diff --git a/.gitattributes b/.gitattributes index 0b43f38a6..f1bf6974a 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,3 +1,6 @@ # Line endings are part of the data: vendored test suites and certdata.txt are # compared byte for byte, so a checkout must never rewrite them to CRLF. * text=auto eol=lf + +# Test262 tests use CR, CRLF, U+2028 and lone line terminators on purpose: store them as they are. +crates/clazel-js-lexer/tests/data/test262/** -text diff --git a/Cargo.lock b/Cargo.lock index 01fabfa7b..657235bb4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -359,6 +359,14 @@ dependencies = [ "vstd", ] +[[package]] +name = "clazel-js-lexer" +version = "0.0.0" + +[[package]] +name = "clazel-js-regexp" +version = "0.0.0" + [[package]] name = "clazel-kernel" version = "0.0.0" @@ -577,6 +585,14 @@ dependencies = [ "vstd", ] +[[package]] +name = "clazel-web" +version = "0.0.0" + +[[package]] +name = "clazel-webidl" +version = "0.0.0" + [[package]] name = "clazel-window" version = "0.0.0" diff --git a/crates/clazel-js-lexer/Cargo.toml b/crates/clazel-js-lexer/Cargo.toml new file mode 100644 index 000000000..05dadcf62 --- /dev/null +++ b/crates/clazel-js-lexer/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "clazel-js-lexer" +version = "0.0.0" +edition.workspace = true +license.workspace = true +publish.workspace = true +description = "The JavaScript lexer for Clazel's Phase 7 browser (phase-7.md item 7.2): ECMA-262 section 12 source text to tokens, the goal symbol an input." + +# Verification tier (docs/VERIFICATION.md). `tier` is what is proven about the +# shipped code today; `target-tier` is what the policy requires, since this +# lexes scripts a page chose (phase-7.md 7.0(a)). Tier 0: this is only the +# skeleton that holds the test data of item 7.1. The contracts come first +# (rule 3), in item 7.2. +[package.metadata.clazel] +tier = 0 +target-tier = 2 + +[lints] +workspace = true diff --git a/crates/clazel-js-lexer/SPEC-PIN.md b/crates/clazel-js-lexer/SPEC-PIN.md new file mode 100644 index 000000000..aa0f5fd3a --- /dev/null +++ b/crates/clazel-js-lexer/SPEC-PIN.md @@ -0,0 +1,23 @@ +# The language spec pin (phase-7.md item 7.1) + +## The language spec: ECMA-262, 2026 edition + +Upstream: https://github.com/tc39/ecma262 +Edition: ES2026, tag `es2026` (an annotated tag, object `f7db29f16c5175a93f0d6e8fb27a8e3cb9b97a9e`, dated 2026-07-02) +Commit: 0248456c758431e4bb8e5d26333ff1865123c9cd +Commit date: 2026-03-31 (the `es2026-candidate-2026-03-31` tag is the same commit) +License: Ecma International's software and document licences (the text is not copied here) + +**The spec text is not vendored.** Nothing reads it: the lexer's spec (item 7.2) is +transcribed by hand with the section and step numbers quoted (CLAUDE.md rule 5, +docs/SPEC-STYLE.md), and its header names this commit. A copy of `spec.html` +(about 3 MB, plus its Unicode property tables) would be a file no tool checks. Vendor +it, with a converter, only if a later item reads it (for example, to check the +transcribed grammar against the spec's own grammar productions). + +The newer tag `es2026-errata` (`d89c03f2db8a597bc915b363a6518d0cc8acdbc0`) holds +editorial fixes made after publication. It is not the edition, so it is not the pin. + + +Test262's pin is in `tests/data/test262/SOURCE.md`, with the subset vendored and why. +It is the last Test262 commit before the commit above. diff --git a/crates/clazel-js-lexer/src/lib.rs b/crates/clazel-js-lexer/src/lib.rs new file mode 100644 index 000000000..971d16068 --- /dev/null +++ b/crates/clazel-js-lexer/src/lib.rs @@ -0,0 +1,7 @@ +//! The JavaScript lexer for Clazel's Phase 7 browser (phase-7.md item 7.2). +//! +//! Empty for now: item 7.1 only creates the crate, so that the test data +//! (`tests/data/`) has a home. The spec and its contracts come first (CLAUDE.md +//! rule 3), then the implementation. +//! +//! Tier: see `[package.metadata.clazel]` in `Cargo.toml` and `docs/VERIFICATION.md`. diff --git a/crates/clazel-js-lexer/tests/data/test262/LICENSE.md b/crates/clazel-js-lexer/tests/data/test262/LICENSE.md new file mode 100644 index 000000000..a56b038f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/LICENSE.md @@ -0,0 +1,28 @@ +Test262: ECMAScript Test Suite ("Software") is protected by copyright and is being +made available under the "BSD License", included below. This Software may be subject to third party rights (rights +from parties other than Ecma International), including patent rights, and no licenses under such third party rights +are granted under this license even if the third party concerned is a member of Ecma International. SEE THE ECMA +CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT https://www.ecma-international.org/ipr FOR +INFORMATION REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA INTERNATIONAL STANDARDS*. + +Copyright (C) 2012 Ecma International +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +following conditions are met: +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following + disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other materials provided with the distribution. +3. Neither the name of the authors nor Ecma International may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT +SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +* Ecma International Standards hereafter means Ecma International Standards as well as Ecma Technical Reports diff --git a/crates/clazel-js-lexer/tests/data/test262/SOURCE.md b/crates/clazel-js-lexer/tests/data/test262/SOURCE.md new file mode 100644 index 000000000..ea62ecc36 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/SOURCE.md @@ -0,0 +1,32 @@ +# Test262, the ECMAScript conformance suite (the syntax subset) + +Upstream: https://github.com/tc39/test262 +Commit: e91219cb6b87865703ce8619b5bc0f7c2bf608e1 +License: BSD-3-Clause (`LICENSE.md`, the repository's `LICENSE`; each test file also carries its own copyright header, kept as it is) +Subset: from `test/language/`, every test whose frontmatter has `negative:` with phase `parse`, `early` or `resolution`, and every test under the lexical directories `asi`, `comments`, `directive-prologue`, `future-reserved-words`, `identifier-resolution`, `identifiers`, `keywords`, `line-terminators`, `literals`, `punctuators`, `reserved-words`, `source-text`, `statementList`, `types` and `white-space`; plus every `*_FIXTURE.js` in a directory that holds a vendored test, all of `harness/`, and `features.txt`. + +The commit is Test262's last before the pinned ECMA-262 2026 commit (2026-03-30; see +`SPEC-PIN.md` in the crate's root). Test262 has no edition tags. + +The files are copied byte for byte, under the same paths as upstream (`test/language/...`, +`harness/...`, `features.txt`). `.gitattributes` stores them without line-ending conversion: some +tests use CR, CRLF and the Unicode line separators on purpose. + +5,422 files, 8,297,553 bytes (LICENSE.md and SOURCE.md not counted): 5,212 tests (and their fixtures), `harness/` and `features.txt`. + +What it is for: items 7.2 and 7.3 (the lexer and the parser) run the tests that parse or +fail to parse; the negative ones carry the early errors. The tests of the rest of +`test/language/` (positive ones in `expressions/` and `statements/`), `test/built-ins/` +and `test/annexB/` are not vendored: they join with the items that record their +results (phase-7.md 7.7 to 7.11). The Intl, Temporal, Atomics and SharedArrayBuffer +directories never will, by 7.0(b). + +`xtask/src/testdata/test262.rs` converts it into `tests/generated/test262.rs`, one row per +test with its frontmatter (`flags`, `features`, `includes`, `negative`) and whether it is an +expected failure, with the reason: a feature excluded by 7.0(b), or newer than the edition +(263 tests). The table also holds a SHA-256 over every vendored file, so an edit to a +harness file or a fixture makes it stale. To update, copy the subset from a newer commit, +change the commit above, and run `cargo xtask testdata`. + +This is an official suite (the language committee's own), so it is rule 7's evidence +for the lexer and the parser. diff --git a/crates/clazel-js-lexer/tests/data/test262/features.txt b/crates/clazel-js-lexer/tests/data/test262/features.txt new file mode 100644 index 000000000..44ed23b15 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/features.txt @@ -0,0 +1,279 @@ +## Proposed language features +# +# This project accepts tests for language proposals that have reached stage 3 +# in TC39's standardization process. Those tests should be annotated with a +# dedicated feature flag so that consumers may more easily omit them as +# necessary. +# +# Generally, feature flags should be per proposal, not per individual API +# that a proposal adds. To filter for specific APIs, use the directory +# structure. +# +# https://github.com/tc39/process-document + +# Intl Era Monthcode +# https://github.com/tc39/proposal-intl-era-monthcode +Intl.Era-monthcode + +# Intl.Locale Info +# https://github.com/tc39/proposal-intl-locale-info +Intl.Locale-info + +# Intl.NumberFormat V3 +# https://github.com/tc39/proposal-intl-numberformat-v3 +Intl.NumberFormat-v3 + +# Legacy RegExp features +# https://github.com/tc39/proposal-regexp-legacy-features +legacy-regexp + +# Temporal +# https://github.com/tc39/proposal-temporal +Temporal + +# ShadowRealm, née Callable Boundary Realms +# https://github.com/tc39/proposal-realms +ShadowRealm + +# Decorators +# https://github.com/tc39/proposal-decorators +decorators + +# Duplicate named capturing groups +# https://github.com/tc39/proposal-duplicate-named-capturing-groups +regexp-duplicate-named-groups + +# Explicit Resource Management +# https://github.com/tc39/proposal-explicit-resource-management +explicit-resource-management + +# Source Phase Imports +## https://github.com/tc39/proposal-source-phase-imports +source-phase-imports +## test262 special specifier +source-phase-imports-module-source + +# Atomics.pause +# https://github.com/tc39/proposal-atomics-microwait +Atomics.pause + +# Deferred import evaluation +# https://tc39.es/proposal-defer-import-eval +import-defer + +# Import Text +# https://github.com/tc39/proposal-import-text +import-text + +# Time Zone Canonicalization +# https://github.com/tc39/proposal-canonical-tz +canonical-tz + +# Immutable Array Buffer +# https://github.com/tc39/proposal-immutable-arraybuffer +immutable-arraybuffer + +# Import Bytes +# https://github.com/tc39/proposal-import-bytes +import-bytes + +# Non-extensible Applies to Private +# https://github.com/tc39/proposal-nonextensible-applies-to-private +nonextensible-applies-to-private + +# Joint Iteration +# https://github.com/tc39/proposal-joint-iteration +joint-iteration + +# Await Dictionary +# https://github.com/tc39/proposal-await-dictionary +await-dictionary + +## Standard language features +# +# Language features that have been included in a published version of the +# ECMA-262 specification. These flags are largely maintained for historical +# reasons, though their use for relatively new features (i.e. prior to +# availability across major implementations) is appreciated. + +AggregateError +align-detached-buffer-semantics-with-web-reality # https://github.com/tc39/ecma262/pull/2164 +arbitrary-module-namespace-names # https://github.com/tc39/ecma262/pull/2154 +ArrayBuffer +array-find-from-last +Array.fromAsync +Array.prototype.at +Array.prototype.flat +Array.prototype.flatMap +Array.prototype.includes +Array.prototype.values +Atomics.waitAsync +array-grouping +arraybuffer-transfer +arrow-function +async-iteration +async-functions +Atomics +BigInt +caller +change-array-by-copy +class +class-fields-private +class-fields-private-in +class-fields-public +class-methods-private +class-static-block +class-static-fields-private +class-static-fields-public +class-static-methods-private +coalesce-expression +computed-property-names +const +cross-realm +DataView +DataView.prototype.getFloat32 +DataView.prototype.getFloat64 +DataView.prototype.getInt16 +DataView.prototype.getInt32 +DataView.prototype.getInt8 +DataView.prototype.getUint16 +DataView.prototype.getUint32 +DataView.prototype.setUint8 +default-parameters +destructuring-assignment +destructuring-binding +dynamic-import +error-cause +Error.isError +exponentiation +export-star-as-namespace-from-module # https://github.com/tc39/ecma262/pull/1174 +FinalizationRegistry +for-in-order +for-of +Float16Array +Float32Array +Float64Array +generators +globalThis +hashbang +import-attributes +import.meta +iterator-helpers +iterator-sequencing +Int8Array +Int16Array +Int32Array +Intl-enumeration +intl-normative-optional # https://tc39.es/ecma402/#legacy-constructor +Intl.DateTimeFormat-datetimestyle +Intl.DateTimeFormat-dayPeriod # https://github.com/tc39/ecma402/pull/346 +Intl.DateTimeFormat-extend-timezonename +Intl.DateTimeFormat-formatRange +Intl.DateTimeFormat-fractionalSecondDigits # https://github.com/tc39/ecma402/pull/347 +Intl.DisplayNames +Intl.DisplayNames-v2 +Intl.DurationFormat +Intl.ListFormat +Intl.Locale +Intl.NumberFormat-unified +Intl.RelativeTimeFormat +Intl.Segmenter +json-modules +json-parse-with-source +json-superset +let +logical-assignment-operators +Map +Math.sumPrecise +new.target +numeric-separator-literal +object-rest +object-spread +Object.fromEntries +Object.hasOwn +Object.is +optional-catch-binding +optional-chaining +Promise +Promise.allSettled +Promise.any +Promise.prototype.finally +promise-with-resolvers +promise-try +Proxy +proxy-missing-checks # https://github.com/tc39/ecma262/pull/666 +Reflect +Reflect.construct +Reflect.set +Reflect.setPrototypeOf +regexp-dotall +RegExp.escape +regexp-lookbehind +regexp-match-indices +regexp-modifiers +regexp-named-groups +regexp-unicode-property-escapes +regexp-v-flag +resizable-arraybuffer +rest-parameters +Set +set-methods +SharedArrayBuffer +stable-array-sort # https://github.com/tc39/ecma262/pull/1340 +stable-typedarray-sort # https://github.com/tc39/ecma262/pull/1433 +string-trimming +String.fromCodePoint +String.prototype.at +String.prototype.endsWith +String.prototype.includes +String.prototype.isWellFormed +String.prototype.matchAll +String.prototype.replaceAll +String.prototype.trimEnd +String.prototype.trimStart +String.prototype.toWellFormed +super +Symbol +symbols-as-weakmap-keys +Symbol.asyncIterator +Symbol.hasInstance +Symbol.isConcatSpreadable +Symbol.iterator +Symbol.match +Symbol.matchAll +Symbol.prototype.description +Symbol.replace +Symbol.search +Symbol.species +Symbol.split +Symbol.toPrimitive +Symbol.toStringTag +Symbol.unscopables +tail-call-optimization +template +top-level-await +TypedArray +TypedArray.prototype.at +u180e +Uint8Array +uint8array-base64 +Uint16Array +Uint32Array +Uint8ClampedArray +upsert +WeakMap +WeakRef +WeakSet +well-formed-json-stringify +__proto__ +__getter__ +__setter__ + +## Test-Harness Features +# +# The rare cases where testing language functionality requires non-standard +# language features, exposed through global-environment functions on the $262 +# object, go here. + +IsHTMLDDA +host-gc-required diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/assert.js b/crates/clazel-js-lexer/tests/data/test262/harness/assert.js new file mode 100644 index 000000000..7ced0cd0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/assert.js @@ -0,0 +1,170 @@ +// Copyright (C) 2017 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Collection of assertion functions used throughout test262 +defines: [assert] +---*/ + + +function assert(mustBeTrue, message) { + if (mustBeTrue === true) { + return; + } + + if (message === undefined) { + message = 'Expected true but got ' + assert._toString(mustBeTrue); + } + throw new Test262Error(message); +} + +assert._isSameValue = function (a, b) { + if (a === b) { + // Handle +/-0 vs. -/+0 + return a !== 0 || 1 / a === 1 / b; + } + + // Handle NaN vs. NaN + return a !== a && b !== b; +}; + +assert.sameValue = function (actual, expected, message) { + try { + if (assert._isSameValue(actual, expected)) { + return; + } + } catch (error) { + throw new Test262Error(message + ' (_isSameValue operation threw) ' + error); + return; + } + + if (message === undefined) { + message = ''; + } else { + message += ' '; + } + + message += 'Expected SameValue(«' + assert._toString(actual) + '», «' + assert._toString(expected) + '») to be true'; + + throw new Test262Error(message); +}; + +assert.notSameValue = function (actual, unexpected, message) { + if (!assert._isSameValue(actual, unexpected)) { + return; + } + + if (message === undefined) { + message = ''; + } else { + message += ' '; + } + + message += 'Expected SameValue(«' + assert._toString(actual) + '», «' + assert._toString(unexpected) + '») to be false'; + + throw new Test262Error(message); +}; + +assert.throws = function (expectedErrorConstructor, func, message) { + var expectedName, actualName; + if (typeof func !== "function") { + throw new Test262Error('assert.throws requires two arguments: the error constructor ' + + 'and a function to run'); + return; + } + if (message === undefined) { + message = ''; + } else { + message += ' '; + } + + try { + func(); + } catch (thrown) { + if (typeof thrown !== 'object' || thrown === null) { + message += 'Thrown value was not an object!'; + throw new Test262Error(message); + } else if (thrown.constructor !== expectedErrorConstructor) { + expectedName = expectedErrorConstructor.name; + actualName = thrown.constructor.name; + if (expectedName === actualName) { + message += 'Expected a ' + expectedName + ' but got a different error constructor with the same name'; + } else { + message += 'Expected a ' + expectedName + ' but got a ' + actualName; + } + throw new Test262Error(message); + } + return; + } + + message += 'Expected a ' + expectedErrorConstructor.name + ' to be thrown but no exception was thrown at all'; + throw new Test262Error(message); +}; + +function isPrimitive(value) { + return !value || (typeof value !== 'object' && typeof value !== 'function'); +} + +assert.compareArray = function (actual, expected, message) { + message = message === undefined ? '' : message; + + if (typeof message === 'symbol') { + message = message.toString(); + } + + if (isPrimitive(actual)) { + assert(false, `Actual argument [${actual}] shouldn't be primitive. ${message}`); + } else if (isPrimitive(expected)) { + assert(false, `Expected argument [${expected}] shouldn't be primitive. ${message}`); + } + var result = compareArray(actual, expected); + if (result) return; + + var format = compareArray.format; + assert(false, `Actual ${format(actual)} and expected ${format(expected)} should have the same contents. ${message}`); +}; + +function compareArray(a, b) { + if (b.length !== a.length) { + return false; + } + for (var i = 0; i < a.length; i++) { + if (!assert._isSameValue(b[i], a[i])) { + return false; + } + } + return true; +} + +compareArray.format = function (arrayLike) { + return `[${Array.prototype.map.call(arrayLike, String).join(', ')}]`; +}; + +assert._formatIdentityFreeValue = function formatIdentityFreeValue(value) { + switch (value === null ? 'null' : typeof value) { + case 'string': + return typeof JSON !== "undefined" ? JSON.stringify(value) : `"${value}"`; + case 'bigint': + return `${value}n`; + case 'number': + if (value === 0 && 1 / value === -Infinity) return '-0'; + // falls through + case 'boolean': + case 'undefined': + case 'null': + return String(value); + } +}; + +assert._toString = function (value) { + var basic = assert._formatIdentityFreeValue(value); + if (basic) return basic; + try { + return String(value); + } catch (err) { + if (err.name === 'TypeError') { + return Object.prototype.toString.call(value); + } + throw err; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/assertRelativeDateMs.js b/crates/clazel-js-lexer/tests/data/test262/harness/assertRelativeDateMs.js new file mode 100644 index 000000000..7535973f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/assertRelativeDateMs.js @@ -0,0 +1,25 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Verify that the given date object's Number representation describes the + correct number of milliseconds since the Unix epoch relative to the local + time zone (as interpreted at the specified date). +defines: [assertRelativeDateMs] +---*/ + +/** + * @param {Date} date + * @param {Number} expectedMs + */ +function assertRelativeDateMs(date, expectedMs) { + var actualMs = date.valueOf(); + var localOffset = date.getTimezoneOffset() * 60000; + + if (actualMs - localOffset !== expectedMs) { + throw new Test262Error( + 'Expected ' + date + ' to be ' + expectedMs + + ' milliseconds from the Unix epoch' + ); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/asyncHelpers.js b/crates/clazel-js-lexer/tests/data/test262/harness/asyncHelpers.js new file mode 100644 index 000000000..163d2b47b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/asyncHelpers.js @@ -0,0 +1,105 @@ +// Copyright (C) 2022 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + A collection of assertion and wrapper functions for testing asynchronous built-ins. +defines: [asyncTest, assert.throwsAsync] +---*/ + +/** + * Defines the **sole** asynchronous test of a file. + * @see {@link ../docs/rfcs/async-helpers.md} for background. + * + * @param {Function} testFunc a callback whose returned promise indicates test results + * (fulfillment for success, rejection for failure) + * @returns {void} + */ +function asyncTest(testFunc) { + if (!Object.prototype.hasOwnProperty.call(globalThis, "$DONE")) { + throw new Test262Error("asyncTest called without async flag"); + } + if (typeof testFunc !== "function") { + $DONE(new Test262Error("asyncTest called with non-function argument")); + return; + } + try { + testFunc().then( + function () { + $DONE(); + }, + function (error) { + $DONE(error); + } + ); + } catch (syncError) { + $DONE(syncError); + } +} + +/** + * Asserts that a callback asynchronously throws an instance of a particular + * error (i.e., returns a promise whose rejection value is an object referencing + * the constructor). + * + * @param {Function} expectedErrorConstructor the expected constructor of the + * rejection value + * @param {Function} func the callback + * @param {string} [message] the prefix to use for failure messages + * @returns {Promise} fulfills if the expected error is thrown, + * otherwise rejects + */ +assert.throwsAsync = function (expectedErrorConstructor, func, message) { + return new Promise(function (resolve) { + var fail = function (detail) { + if (message === undefined) { + throw new Test262Error(detail); + } + throw new Test262Error(message + " " + detail); + }; + if (typeof expectedErrorConstructor !== "function") { + fail("assert.throwsAsync called with an argument that is not an error constructor"); + } + if (typeof func !== "function") { + fail("assert.throwsAsync called with an argument that is not a function"); + } + var expectedName = expectedErrorConstructor.name; + var expectation = "Expected a " + expectedName + " to be thrown asynchronously"; + var res; + try { + res = func(); + } catch (thrown) { + fail(expectation + " but the function threw synchronously"); + } + if (res === null || typeof res !== "object" || typeof res.then !== "function") { + fail(expectation + " but result was not a thenable"); + } + var onResFulfilled, onResRejected; + var resSettlementP = new Promise(function (onFulfilled, onRejected) { + onResFulfilled = onFulfilled; + onResRejected = onRejected; + }); + try { + res.then(onResFulfilled, onResRejected) + } catch (thrown) { + fail(expectation + " but .then threw synchronously"); + } + resolve(resSettlementP.then( + function () { + fail(expectation + " but no exception was thrown at all"); + }, + function (thrown) { + var actualName; + if (thrown === null || typeof thrown !== "object") { + fail(expectation + " but thrown value was not an object"); + } else if (thrown.constructor !== expectedErrorConstructor) { + actualName = thrown.constructor.name; + if (expectedName === actualName) { + fail(expectation + + " but got a different error constructor with the same name"); + } + fail(expectation + " but got a " + actualName); + } + } + )); + }); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/atomicsHelper.js b/crates/clazel-js-lexer/tests/data/test262/harness/atomicsHelper.js new file mode 100644 index 000000000..9828b15c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/atomicsHelper.js @@ -0,0 +1,324 @@ +// Copyright (C) 2017 Mozilla Corporation. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + Collection of functions used to interact with Atomics.* operations across agent boundaries. +defines: + - $262.agent.getReportAsync + - $262.agent.getReport + - $262.agent.safeBroadcastAsync + - $262.agent.safeBroadcast + - $262.agent.setTimeout + - $262.agent.tryYield + - $262.agent.trySleep +---*/ + +/** + * @return {String} A report sent from an agent. + */ +{ + // This is only necessary because the original + // $262.agent.getReport API was insufficient. + // + // All runtimes currently have their own + // $262.agent.getReport which is wrong, so we + // will pave over it with a corrected version. + // + // Binding $262.agent is necessary to prevent + // breaking SpiderMonkey's $262.agent.getReport + let getReport = $262.agent.getReport.bind($262.agent); + + $262.agent.getReport = function() { + var r; + while ((r = getReport()) == null) { + $262.agent.sleep(1); + } + return r; + }; + + if (this.setTimeout === undefined) { + (function(that) { + that.setTimeout = function(callback, delay) { + let p = Promise.resolve(); + let start = Date.now(); + let end = start + delay; + function check() { + if ((end - Date.now()) > 0) { + p.then(check); + } + else { + callback(); + } + } + p.then(check); + } + })(this); + } + + $262.agent.setTimeout = setTimeout; + + $262.agent.getReportAsync = function() { + return new Promise(function(resolve) { + (function loop() { + let result = getReport(); + if (!result) { + setTimeout(loop, 1000); + } else { + resolve(result); + } + })(); + }); + }; +} + +/** + * + * Share a given Int32Array or BigInt64Array to all running agents. Ensure that the + * provided TypedArray is a "shared typed array". + * + * NOTE: Migrating all tests to this API is necessary to prevent tests from hanging + * indefinitely when a SAB is sent to a worker but the code in the worker attempts to + * create a non-sharable TypedArray (something that is not Int32Array or BigInt64Array). + * When that scenario occurs, an exception is thrown and the agent worker can no + * longer communicate with any other threads that control the SAB. If the main + * thread happens to be spinning in the $262.agent.waitUntil() while loop, it will never + * meet its termination condition and the test will hang indefinitely. + * + * Because we've defined $262.agent.broadcast(SAB) in + * https://github.com/tc39/test262/blob/HEAD/INTERPRETING.md, there are host implementations + * that assume compatibility, which must be maintained. + * + * + * $262.agent.safeBroadcast(TA) should not be included in + * https://github.com/tc39/test262/blob/HEAD/INTERPRETING.md + * + * + * @param {(Int32Array|BigInt64Array)} typedArray An Int32Array or BigInt64Array with a SharedArrayBuffer + */ +$262.agent.safeBroadcast = function(typedArray) { + let Constructor = Object.getPrototypeOf(typedArray).constructor; + let temp = new Constructor( + new SharedArrayBuffer(Constructor.BYTES_PER_ELEMENT) + ); + try { + // This will never actually wait, but that's fine because we only + // want to ensure that this typedArray CAN be waited on and is shareable. + Atomics.wait(temp, 0, Constructor === Int32Array ? 1 : BigInt(1)); + } catch (error) { + throw new Test262Error(`${Constructor.name} cannot be used as a shared typed array. (${error})`); + } + + $262.agent.broadcast(typedArray.buffer); +}; + +$262.agent.safeBroadcastAsync = async function(ta, index, expected) { + await $262.agent.broadcast(ta.buffer); + await $262.agent.waitUntil(ta, index, expected); + await $262.agent.tryYield(); + return await Atomics.load(ta, index); +}; + + +/** + * With a given Int32Array or BigInt64Array, wait until the expected number of agents have + * reported themselves by calling: + * + * Atomics.add(typedArray, index, 1); + * + * @param {(Int32Array|BigInt64Array)} typedArray An Int32Array or BigInt64Array with a SharedArrayBuffer + * @param {number} index The index of which all agents will report. + * @param {number} expected The number of agents that are expected to report as active. + */ +$262.agent.waitUntil = function(typedArray, index, expected) { + + var agents = 0; + while ((agents = Atomics.load(typedArray, index)) !== expected) { + /* nothing */ + } + assert.sameValue(agents, expected, "Reporting number of 'agents' equals the value of 'expected'"); +}; + +/** + * Timeout values used throughout the Atomics tests. All timeouts are specified in milliseconds. + * + * @property {number} yield Used for `$262.agent.tryYield`. Must not be used in other functions. + * @property {number} small Used when agents will always timeout and `Atomics.wake` is not part + * of the test semantics. Must be larger than `$262.agent.timeouts.yield`. + * @property {number} long Used when some agents may timeout and `Atomics.wake` is called on some + * agents. The agents are required to wait and this needs to be observable + * by the main thread. + * @property {number} huge Used when `Atomics.wake` is called on all waiting agents. The waiting + * must not timeout. The agents are required to wait and this needs to be + * observable by the main thread. All waiting agents must be woken by the + * main thread. + * + * Usage for `$262.agent.timeouts.small`: + * const WAIT_INDEX = 0; + * const RUNNING = 1; + * const TIMEOUT = $262.agent.timeouts.small; + * const i32a = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2)); + * + * $262.agent.start(` + * $262.agent.receiveBroadcast(function(sab) { + * const i32a = new Int32Array(sab); + * Atomics.add(i32a, ${RUNNING}, 1); + * + * $262.agent.report(Atomics.wait(i32a, ${WAIT_INDEX}, 0, ${TIMEOUT})); + * + * $262.agent.leaving(); + * }); + * `); + * $262.agent.safeBroadcast(i32a.buffer); + * + * // Wait until the agent was started and then try to yield control to increase + * // the likelihood the agent has called `Atomics.wait` and is now waiting. + * $262.agent.waitUntil(i32a, RUNNING, 1); + * $262.agent.tryYield(); + * + * // The agent is expected to time out. + * assert.sameValue($262.agent.getReport(), "timed-out"); + * + * + * Usage for `$262.agent.timeouts.long`: + * const WAIT_INDEX = 0; + * const RUNNING = 1; + * const NUMAGENT = 2; + * const TIMEOUT = $262.agent.timeouts.long; + * const i32a = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2)); + * + * for (let i = 0; i < NUMAGENT; i++) { + * $262.agent.start(` + * $262.agent.receiveBroadcast(function(sab) { + * const i32a = new Int32Array(sab); + * Atomics.add(i32a, ${RUNNING}, 1); + * + * $262.agent.report(Atomics.wait(i32a, ${WAIT_INDEX}, 0, ${TIMEOUT})); + * + * $262.agent.leaving(); + * }); + * `); + * } + * $262.agent.safeBroadcast(i32a.buffer); + * + * // Wait until the agents were started and then try to yield control to increase + * // the likelihood the agents have called `Atomics.wait` and are now waiting. + * $262.agent.waitUntil(i32a, RUNNING, NUMAGENT); + * $262.agent.tryYield(); + * + * // Wake exactly one agent. + * assert.sameValue(Atomics.wake(i32a, WAIT_INDEX, 1), 1); + * + * // When it doesn't matter how many agents were woken at once, a while loop + * // can be used to make the test more resilient against intermittent failures + * // in case even though `tryYield` was called, the agents haven't started to + * // wait. + * // + * // // Repeat until exactly one agent was woken. + * // var woken = 0; + * // while ((woken = Atomics.wake(i32a, WAIT_INDEX, 1)) !== 0) ; + * // assert.sameValue(woken, 1); + * + * // One agent was woken and the other one timed out. + * const reports = [$262.agent.getReport(), $262.agent.getReport()]; + * assert(reports.includes("ok")); + * assert(reports.includes("timed-out")); + * + * + * Usage for `$262.agent.timeouts.huge`: + * const WAIT_INDEX = 0; + * const RUNNING = 1; + * const NUMAGENT = 2; + * const TIMEOUT = $262.agent.timeouts.huge; + * const i32a = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2)); + * + * for (let i = 0; i < NUMAGENT; i++) { + * $262.agent.start(` + * $262.agent.receiveBroadcast(function(sab) { + * const i32a = new Int32Array(sab); + * Atomics.add(i32a, ${RUNNING}, 1); + * + * $262.agent.report(Atomics.wait(i32a, ${WAIT_INDEX}, 0, ${TIMEOUT})); + * + * $262.agent.leaving(); + * }); + * `); + * } + * $262.agent.safeBroadcast(i32a.buffer); + * + * // Wait until the agents were started and then try to yield control to increase + * // the likelihood the agents have called `Atomics.wait` and are now waiting. + * $262.agent.waitUntil(i32a, RUNNING, NUMAGENT); + * $262.agent.tryYield(); + * + * // Wake all agents. + * assert.sameValue(Atomics.wake(i32a, WAIT_INDEX), NUMAGENT); + * + * // When it doesn't matter how many agents were woken at once, a while loop + * // can be used to make the test more resilient against intermittent failures + * // in case even though `tryYield` was called, the agents haven't started to + * // wait. + * // + * // // Repeat until all agents were woken. + * // for (var wokenCount = 0; wokenCount < NUMAGENT; ) { + * // var woken = 0; + * // while ((woken = Atomics.wake(i32a, WAIT_INDEX)) !== 0) ; + * // // Maybe perform an action on the woken agents here. + * // wokenCount += woken; + * // } + * + * // All agents were woken and none timeout. + * for (var i = 0; i < NUMAGENT; i++) { + * assert($262.agent.getReport(), "ok"); + * } + */ +$262.agent.timeouts = { + yield: 100, + small: 200, + long: 1000, + huge: 10000, +}; + +/** + * Try to yield control to the agent threads. + * + * Usage: + * const VALUE = 0; + * const RUNNING = 1; + * const i32a = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2)); + * + * $262.agent.start(` + * $262.agent.receiveBroadcast(function(sab) { + * const i32a = new Int32Array(sab); + * Atomics.add(i32a, ${RUNNING}, 1); + * + * Atomics.store(i32a, ${VALUE}, 1); + * + * $262.agent.leaving(); + * }); + * `); + * $262.agent.safeBroadcast(i32a.buffer); + * + * // Wait until agent was started and then try to yield control. + * $262.agent.waitUntil(i32a, RUNNING, 1); + * $262.agent.tryYield(); + * + * // Note: This result is not guaranteed, but should hold in practice most of the time. + * assert.sameValue(Atomics.load(i32a, VALUE), 1); + * + * The default implementation simply waits for `$262.agent.timeouts.yield` milliseconds. + */ +$262.agent.tryYield = function() { + $262.agent.sleep($262.agent.timeouts.yield); +}; + +/** + * Try to sleep the current agent for the given amount of milliseconds. It is acceptable, + * but not encouraged, to ignore this sleep request and directly continue execution. + * + * The default implementation calls `$262.agent.sleep(ms)`. + * + * @param {number} ms Time to sleep in milliseconds. + */ +$262.agent.trySleep = function(ms) { + $262.agent.sleep(ms); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/byteConversionValues.js b/crates/clazel-js-lexer/tests/data/test262/harness/byteConversionValues.js new file mode 100644 index 000000000..bbec02cda --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/byteConversionValues.js @@ -0,0 +1,654 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Provide a list for original and expected values for different byte + conversions. + This helper is mostly used on tests for TypedArray and DataView, and each + array from the expected values must match the original values array on every + index containing its original value. +defines: [byteConversionValues] +---*/ +var byteConversionValues = { + values: [ + 127, // 2 ** 7 - 1 + 128, // 2 ** 7 + 32767, // 2 ** 15 - 1 + 32768, // 2 ** 15 + 2147483647, // 2 ** 31 - 1 + 2147483648, // 2 ** 31 + 255, // 2 ** 8 - 1 + 256, // 2 ** 8 + 65535, // 2 ** 16 - 1 + 65536, // 2 ** 16 + 4294967295, // 2 ** 32 - 1 + 4294967296, // 2 ** 32 + 9007199254740991, // 2 ** 53 - 1 + 9007199254740992, // 2 ** 53 + 1.1, + 0.1, + 0.5, + 0.50000001, + 0.6, + 0.7, + undefined, + -1, + -0, + -0.1, + -1.1, + NaN, + -127, // - ( 2 ** 7 - 1 ) + -128, // - ( 2 ** 7 ) + -32767, // - ( 2 ** 15 - 1 ) + -32768, // - ( 2 ** 15 ) + -2147483647, // - ( 2 ** 31 - 1 ) + -2147483648, // - ( 2 ** 31 ) + -255, // - ( 2 ** 8 - 1 ) + -256, // - ( 2 ** 8 ) + -65535, // - ( 2 ** 16 - 1 ) + -65536, // - ( 2 ** 16 ) + -4294967295, // - ( 2 ** 32 - 1 ) + -4294967296, // - ( 2 ** 32 ) + Infinity, + -Infinity, + 0, + 2049, // an integer which rounds down under ties-to-even when cast to float16 + 2051, // an integer which rounds up under ties-to-even when cast to float16 + 0.00006103515625, // smallest normal float16 + 0.00006097555160522461, // largest subnormal float16 + 5.960464477539063e-8, // smallest float16 + 2.9802322387695312e-8, // largest double which rounds to 0 when cast to float16 + 2.980232238769532e-8, // smallest double which does not round to 0 when cast to float16 + 8.940696716308594e-8, // a double which rounds up to a subnormal under ties-to-even when cast to float16 + 1.4901161193847656e-7, // a double which rounds down to a subnormal under ties-to-even when cast to float16 + 1.490116119384766e-7, // the next double above the one on the previous line one + 65504, // max finite float16 + 65520, // smallest double which rounds to infinity when cast to float16 + 65519.99999999999, // largest double which does not round to infinity when cast to float16 + 0.000061005353927612305, // smallest double which rounds to a non-subnormal when cast to float16 + 0.0000610053539276123 // largest double which rounds to a subnormal when cast to float16 + ], + + expected: { + Int8: [ + 127, // 127 + -128, // 128 + -1, // 32767 + 0, // 32768 + -1, // 2147483647 + 0, // 2147483648 + -1, // 255 + 0, // 256 + -1, // 65535 + 0, // 65536 + -1, // 4294967295 + 0, // 4294967296 + -1, // 9007199254740991 + 0, // 9007199254740992 + 1, // 1.1 + 0, // 0.1 + 0, // 0.5 + 0, // 0.50000001, + 0, // 0.6 + 0, // 0.7 + 0, // undefined + -1, // -1 + 0, // -0 + 0, // -0.1 + -1, // -1.1 + 0, // NaN + -127, // -127 + -128, // -128 + 1, // -32767 + 0, // -32768 + 1, // -2147483647 + 0, // -2147483648 + 1, // -255 + 0, // -256 + 1, // -65535 + 0, // -65536 + 1, // -4294967295 + 0, // -4294967296 + 0, // Infinity + 0, // -Infinity + 0, // 0 + 1, // 2049 + 3, // 2051 + 0, // 0.00006103515625 + 0, // 0.00006097555160522461 + 0, // 5.960464477539063e-8 + 0, // 2.9802322387695312e-8 + 0, // 2.980232238769532e-8 + 0, // 8.940696716308594e-8 + 0, // 1.4901161193847656e-7 + 0, // 1.490116119384766e-7 + -32, // 65504 + -16, // 65520 + -17, // 65519.99999999999 + 0, // 0.000061005353927612305 + 0 // 0.0000610053539276123 + ], + Uint8: [ + 127, // 127 + 128, // 128 + 255, // 32767 + 0, // 32768 + 255, // 2147483647 + 0, // 2147483648 + 255, // 255 + 0, // 256 + 255, // 65535 + 0, // 65536 + 255, // 4294967295 + 0, // 4294967296 + 255, // 9007199254740991 + 0, // 9007199254740992 + 1, // 1.1 + 0, // 0.1 + 0, // 0.5 + 0, // 0.50000001, + 0, // 0.6 + 0, // 0.7 + 0, // undefined + 255, // -1 + 0, // -0 + 0, // -0.1 + 255, // -1.1 + 0, // NaN + 129, // -127 + 128, // -128 + 1, // -32767 + 0, // -32768 + 1, // -2147483647 + 0, // -2147483648 + 1, // -255 + 0, // -256 + 1, // -65535 + 0, // -65536 + 1, // -4294967295 + 0, // -4294967296 + 0, // Infinity + 0, // -Infinity + 0, // 0 + 1, // 2049 + 3, // 2051 + 0, // 0.00006103515625 + 0, // 0.00006097555160522461 + 0, // 5.960464477539063e-8 + 0, // 2.9802322387695312e-8 + 0, // 2.980232238769532e-8 + 0, // 8.940696716308594e-8 + 0, // 1.4901161193847656e-7 + 0, // 1.490116119384766e-7 + 224, // 65504 + 240, // 65520 + 239, // 65519.99999999999 + 0, // 0.000061005353927612305 + 0 // 0.0000610053539276123 + ], + Uint8Clamped: [ + 127, // 127 + 128, // 128 + 255, // 32767 + 255, // 32768 + 255, // 2147483647 + 255, // 2147483648 + 255, // 255 + 255, // 256 + 255, // 65535 + 255, // 65536 + 255, // 4294967295 + 255, // 4294967296 + 255, // 9007199254740991 + 255, // 9007199254740992 + 1, // 1.1, + 0, // 0.1 + 0, // 0.5 + 1, // 0.50000001, + 1, // 0.6 + 1, // 0.7 + 0, // undefined + 0, // -1 + 0, // -0 + 0, // -0.1 + 0, // -1.1 + 0, // NaN + 0, // -127 + 0, // -128 + 0, // -32767 + 0, // -32768 + 0, // -2147483647 + 0, // -2147483648 + 0, // -255 + 0, // -256 + 0, // -65535 + 0, // -65536 + 0, // -4294967295 + 0, // -4294967296 + 255, // Infinity + 0, // -Infinity + 0, // 0 + 255, // 2049 + 255, // 2051 + 0, // 0.00006103515625 + 0, // 0.00006097555160522461 + 0, // 5.960464477539063e-8 + 0, // 2.9802322387695312e-8 + 0, // 2.980232238769532e-8 + 0, // 8.940696716308594e-8 + 0, // 1.4901161193847656e-7 + 0, // 1.490116119384766e-7 + 255, // 65504 + 255, // 65520 + 255, // 65519.99999999999 + 0, // 0.000061005353927612305 + 0 // 0.0000610053539276123 + ], + Int16: [ + 127, // 127 + 128, // 128 + 32767, // 32767 + -32768, // 32768 + -1, // 2147483647 + 0, // 2147483648 + 255, // 255 + 256, // 256 + -1, // 65535 + 0, // 65536 + -1, // 4294967295 + 0, // 4294967296 + -1, // 9007199254740991 + 0, // 9007199254740992 + 1, // 1.1 + 0, // 0.1 + 0, // 0.5 + 0, // 0.50000001, + 0, // 0.6 + 0, // 0.7 + 0, // undefined + -1, // -1 + 0, // -0 + 0, // -0.1 + -1, // -1.1 + 0, // NaN + -127, // -127 + -128, // -128 + -32767, // -32767 + -32768, // -32768 + 1, // -2147483647 + 0, // -2147483648 + -255, // -255 + -256, // -256 + 1, // -65535 + 0, // -65536 + 1, // -4294967295 + 0, // -4294967296 + 0, // Infinity + 0, // -Infinity + 0, // 0 + 2049, // 2049 + 2051, // 2051 + 0, // 0.00006103515625 + 0, // 0.00006097555160522461 + 0, // 5.960464477539063e-8 + 0, // 2.9802322387695312e-8 + 0, // 2.980232238769532e-8 + 0, // 8.940696716308594e-8 + 0, // 1.4901161193847656e-7 + 0, // 1.490116119384766e-7 + -32, // 65504 + -16, // 65520 + -17, // 65519.99999999999 + 0, // 0.000061005353927612305 + 0 // 0.0000610053539276123 + ], + Uint16: [ + 127, // 127 + 128, // 128 + 32767, // 32767 + 32768, // 32768 + 65535, // 2147483647 + 0, // 2147483648 + 255, // 255 + 256, // 256 + 65535, // 65535 + 0, // 65536 + 65535, // 4294967295 + 0, // 4294967296 + 65535, // 9007199254740991 + 0, // 9007199254740992 + 1, // 1.1 + 0, // 0.1 + 0, // 0.5 + 0, // 0.50000001, + 0, // 0.6 + 0, // 0.7 + 0, // undefined + 65535, // -1 + 0, // -0 + 0, // -0.1 + 65535, // -1.1 + 0, // NaN + 65409, // -127 + 65408, // -128 + 32769, // -32767 + 32768, // -32768 + 1, // -2147483647 + 0, // -2147483648 + 65281, // -255 + 65280, // -256 + 1, // -65535 + 0, // -65536 + 1, // -4294967295 + 0, // -4294967296 + 0, // Infinity + 0, // -Infinity + 0, // 0 + 2049, // 2049 + 2051, // 2051 + 0, // 0.00006103515625 + 0, // 0.00006097555160522461 + 0, // 5.960464477539063e-8 + 0, // 2.9802322387695312e-8 + 0, // 2.980232238769532e-8 + 0, // 8.940696716308594e-8 + 0, // 1.4901161193847656e-7 + 0, // 1.490116119384766e-7 + 65504, // 65504 + 65520, // 65520 + 65519, // 65519.99999999999 + 0, // 0.000061005353927612305 + 0 // 0.0000610053539276123 + ], + Int32: [ + 127, // 127 + 128, // 128 + 32767, // 32767 + 32768, // 32768 + 2147483647, // 2147483647 + -2147483648, // 2147483648 + 255, // 255 + 256, // 256 + 65535, // 65535 + 65536, // 65536 + -1, // 4294967295 + 0, // 4294967296 + -1, // 9007199254740991 + 0, // 9007199254740992 + 1, // 1.1 + 0, // 0.1 + 0, // 0.5 + 0, // 0.50000001, + 0, // 0.6 + 0, // 0.7 + 0, // undefined + -1, // -1 + 0, // -0 + 0, // -0.1 + -1, // -1.1 + 0, // NaN + -127, // -127 + -128, // -128 + -32767, // -32767 + -32768, // -32768 + -2147483647, // -2147483647 + -2147483648, // -2147483648 + -255, // -255 + -256, // -256 + -65535, // -65535 + -65536, // -65536 + 1, // -4294967295 + 0, // -4294967296 + 0, // Infinity + 0, // -Infinity + 0, // 0 + 2049, // 2049 + 2051, // 2051 + 0, // 0.00006103515625 + 0, // 0.00006097555160522461 + 0, // 5.960464477539063e-8 + 0, // 2.9802322387695312e-8 + 0, // 2.980232238769532e-8 + 0, // 8.940696716308594e-8 + 0, // 1.4901161193847656e-7 + 0, // 1.490116119384766e-7 + 65504, // 65504 + 65520, // 65520 + 65519, // 65519.99999999999 + 0, // 0.000061005353927612305 + 0 // 0.0000610053539276123 + ], + Uint32: [ + 127, // 127 + 128, // 128 + 32767, // 32767 + 32768, // 32768 + 2147483647, // 2147483647 + 2147483648, // 2147483648 + 255, // 255 + 256, // 256 + 65535, // 65535 + 65536, // 65536 + 4294967295, // 4294967295 + 0, // 4294967296 + 4294967295, // 9007199254740991 + 0, // 9007199254740992 + 1, // 1.1 + 0, // 0.1 + 0, // 0.5 + 0, // 0.50000001, + 0, // 0.6 + 0, // 0.7 + 0, // undefined + 4294967295, // -1 + 0, // -0 + 0, // -0.1 + 4294967295, // -1.1 + 0, // NaN + 4294967169, // -127 + 4294967168, // -128 + 4294934529, // -32767 + 4294934528, // -32768 + 2147483649, // -2147483647 + 2147483648, // -2147483648 + 4294967041, // -255 + 4294967040, // -256 + 4294901761, // -65535 + 4294901760, // -65536 + 1, // -4294967295 + 0, // -4294967296 + 0, // Infinity + 0, // -Infinity + 0, // 0 + 2049, // 2049 + 2051, // 2051 + 0, // 0.00006103515625 + 0, // 0.00006097555160522461 + 0, // 5.960464477539063e-8 + 0, // 2.9802322387695312e-8 + 0, // 2.980232238769532e-8 + 0, // 8.940696716308594e-8 + 0, // 1.4901161193847656e-7 + 0, // 1.490116119384766e-7 + 65504, // 65504 + 65520, // 65520 + 65519, // 65519.99999999999 + 0, // 0.000061005353927612305 + 0 // 0.0000610053539276123 + ], + Float16: [ + 127, // 127 + 128, // 128 + 32768, // 32767 + 32768, // 32768 + Infinity, // 2147483647 + Infinity, // 2147483648 + 255, // 255 + 256, // 256 + Infinity, // 65535 + Infinity, // 65536 + Infinity, // 4294967295 + Infinity, // 4294967296 + Infinity, // 9007199254740991 + Infinity, // 9007199254740992 + 1.099609375, // 1.1 + 0.0999755859375, // 0.1 + 0.5, // 0.5 + 0.5, // 0.50000001, + 0.60009765625, // 0.6 + 0.7001953125, // 0.7 + NaN, // undefined + -1, // -1 + -0, // -0 + -0.0999755859375, // -0.1 + -1.099609375, // -1.1 + NaN, // NaN + -127, // -127 + -128, // -128 + -32768, // -32767 + -32768, // -32768 + -Infinity, // -2147483647 + -Infinity, // -2147483648 + -255, // -255 + -256, // -256 + -Infinity, // -65535 + -Infinity, // -65536 + -Infinity, // -4294967295 + -Infinity, // -4294967296 + Infinity, // Infinity + -Infinity, // -Infinity + 0, // 0 + 2048, // 2049 + 2052, // 2051 + 0.00006103515625, // 0.00006103515625 + 0.00006097555160522461, // 0.00006097555160522461 + 5.960464477539063e-8, // 5.960464477539063e-8 + 0, // 2.9802322387695312e-8 + 5.960464477539063e-8, // 2.980232238769532e-8 + 1.1920928955078125e-7, // 8.940696716308594e-8 + 1.1920928955078125e-7, // 1.4901161193847656e-7 + 1.7881393432617188e-7, // 1.490116119384766e-7 + 65504, // 65504 + Infinity, // 65520 + 65504, // 65519.99999999999 + 0.00006103515625, // 0.000061005353927612305 + 0.00006097555160522461 // 0.0000610053539276123 + ], + Float32: [ + 127, // 127 + 128, // 128 + 32767, // 32767 + 32768, // 32768 + 2147483648, // 2147483647 + 2147483648, // 2147483648 + 255, // 255 + 256, // 256 + 65535, // 65535 + 65536, // 65536 + 4294967296, // 4294967295 + 4294967296, // 4294967296 + 9007199254740992, // 9007199254740991 + 9007199254740992, // 9007199254740992 + 1.100000023841858, // 1.1 + 0.10000000149011612, // 0.1 + 0.5, // 0.5 + 0.5, // 0.50000001, + 0.6000000238418579, // 0.6 + 0.699999988079071, // 0.7 + NaN, // undefined + -1, // -1 + -0, // -0 + -0.10000000149011612, // -0.1 + -1.100000023841858, // -1.1 + NaN, // NaN + -127, // -127 + -128, // -128 + -32767, // -32767 + -32768, // -32768 + -2147483648, // -2147483647 + -2147483648, // -2147483648 + -255, // -255 + -256, // -256 + -65535, // -65535 + -65536, // -65536 + -4294967296, // -4294967295 + -4294967296, // -4294967296 + Infinity, // Infinity + -Infinity, // -Infinity + 0, // 0 + 2049, // 2049 + 2051, // 2051 + 0.00006103515625, // 0.00006103515625 + 0.00006097555160522461, // 0.00006097555160522461 + 5.960464477539063e-8, // 5.960464477539063e-8 + 2.9802322387695312e-8, // 2.9802322387695312e-8 + 2.9802322387695312e-8, // 2.980232238769532e-8 + 8.940696716308594e-8, // 8.940696716308594e-8 + 1.4901161193847656e-7, // 1.4901161193847656e-7 + 1.4901161193847656e-7, // 1.490116119384766e-7 + 65504, // 65504 + 65520, // 65520 + 65520, // 65519.99999999999 + 0.000061005353927612305, // 0.000061005353927612305 + 0.000061005353927612305 // 0.0000610053539276123 + ], + Float64: [ + 127, // 127 + 128, // 128 + 32767, // 32767 + 32768, // 32768 + 2147483647, // 2147483647 + 2147483648, // 2147483648 + 255, // 255 + 256, // 256 + 65535, // 65535 + 65536, // 65536 + 4294967295, // 4294967295 + 4294967296, // 4294967296 + 9007199254740991, // 9007199254740991 + 9007199254740992, // 9007199254740992 + 1.1, // 1.1 + 0.1, // 0.1 + 0.5, // 0.5 + 0.50000001, // 0.50000001, + 0.6, // 0.6 + 0.7, // 0.7 + NaN, // undefined + -1, // -1 + -0, // -0 + -0.1, // -0.1 + -1.1, // -1.1 + NaN, // NaN + -127, // -127 + -128, // -128 + -32767, // -32767 + -32768, // -32768 + -2147483647, // -2147483647 + -2147483648, // -2147483648 + -255, // -255 + -256, // -256 + -65535, // -65535 + -65536, // -65536 + -4294967295, // -4294967295 + -4294967296, // -4294967296 + Infinity, // Infinity + -Infinity, // -Infinity + 0, // 0 + 2049, // 2049 + 2051, // 2051 + 0.00006103515625, // 0.00006103515625 + 0.00006097555160522461, // 0.00006097555160522461 + 5.960464477539063e-8, // 5.960464477539063e-8 + 2.9802322387695312e-8, // 2.9802322387695312e-8 + 2.980232238769532e-8, // 2.980232238769532e-8 + 8.940696716308594e-8, // 8.940696716308594e-8 + 1.4901161193847656e-7, // 1.4901161193847656e-7 + 1.490116119384766e-7, // 1.490116119384766e-7 + 65504, // 65504 + 65520, // 65520 + 65519.99999999999, // 65519.99999999999 + 0.000061005353927612305, // 0.000061005353927612305 + 0.0000610053539276123 // 0.0000610053539276123 + ] + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/compareArray.js b/crates/clazel-js-lexer/tests/data/test262/harness/compareArray.js new file mode 100644 index 000000000..dfeef3fe6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/compareArray.js @@ -0,0 +1,7 @@ +// Copyright (C) 2017 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Deprecated now that compareArray is defined in assert.js. +defines: [compareArray] +---*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/compareIterator.js b/crates/clazel-js-lexer/tests/data/test262/harness/compareIterator.js new file mode 100644 index 000000000..1a30998c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/compareIterator.js @@ -0,0 +1,35 @@ +// Copyright (C) 2018 Peter Wong. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: Compare the values of an iterator with an array of expected values +defines: [assert.compareIterator] +---*/ + +// Example: +// +// function* numbers() { +// yield 1; +// yield 2; +// yield 3; +// } +// +// assert.compareIterator(numbers(), [ +// v => assert.sameValue(v, 1), +// v => assert.sameValue(v, 2), +// v => assert.sameValue(v, 3), +// ]); +// +assert.compareIterator = function(iter, validators, message) { + message = message || ''; + + var i, result; + for (i = 0; i < validators.length; i++) { + result = iter.next(); + assert(!result.done, 'Expected ' + i + ' values(s). Instead iterator only produced ' + (i - 1) + ' value(s). ' + message); + validators[i](result.value); + } + + result = iter.next(); + assert(result.done, 'Expected only ' + i + ' values(s). Instead iterator produced more. ' + message); + assert.sameValue(result.value, undefined, 'Expected value of `undefined` when iterator completes. ' + message); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/dateConstants.js b/crates/clazel-js-lexer/tests/data/test262/harness/dateConstants.js new file mode 100644 index 000000000..1e728d328 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/dateConstants.js @@ -0,0 +1,29 @@ +// Copyright (C) 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Collection of date-centric values +defines: + - date_1899_end + - date_1900_start + - date_1969_end + - date_1970_start + - date_1999_end + - date_2000_start + - date_2099_end + - date_2100_start + - start_of_time + - end_of_time +---*/ + +var date_1899_end = -2208988800001; +var date_1900_start = -2208988800000; +var date_1969_end = -1; +var date_1970_start = 0; +var date_1999_end = 946684799999; +var date_2000_start = 946684800000; +var date_2099_end = 4102444799999; +var date_2100_start = 4102444800000; + +var start_of_time = -8.64e15; +var end_of_time = 8.64e15; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/decimalToHexString.js b/crates/clazel-js-lexer/tests/data/test262/harness/decimalToHexString.js new file mode 100644 index 000000000..74fb48776 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/decimalToHexString.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Collection of functions used to assert the correctness of various encoding operations. +defines: [decimalToHexString, decimalToPercentHexString] +---*/ + +function decimalToHexString(n) { + var hex = "0123456789ABCDEF"; + n >>>= 0; + var s = ""; + while (n) { + s = hex[n & 0xf] + s; + n >>>= 4; + } + while (s.length < 4) { + s = "0" + s; + } + return s; +} + +function decimalToPercentHexString(n) { + var hex = "0123456789ABCDEF"; + return "%" + hex[(n >> 4) & 0xf] + hex[n & 0xf]; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/deepEqual.js b/crates/clazel-js-lexer/tests/data/test262/harness/deepEqual.js new file mode 100644 index 000000000..181381d2f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/deepEqual.js @@ -0,0 +1,400 @@ +// Copyright 2019 Ron Buckton. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + Compare two values structurally +defines: [assert.deepEqual] +---*/ + +assert.deepEqual = function(actual, expected, message) { + var format = assert.deepEqual.format; + var mustBeTrue = assert.deepEqual._compare(actual, expected); + + // format can be slow when `actual` or `expected` are large objects, like for + // example the global object, so only call it when the assertion will fail. + if (mustBeTrue !== true) { + message = `Expected ${format(actual)} to be structurally equal to ${format(expected)}. ${(message || '')}`; + } + + assert(mustBeTrue, message); +}; + +(function() { +let getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +let join = arr => arr.join(', '); +function stringFromTemplate(strings, subs) { + let parts = strings.map((str, i) => `${i === 0 ? '' : subs[i - 1]}${str}`); + return parts.join(''); +} +function escapeKey(key) { + if (typeof key === 'symbol') return `[${String(key)}]`; + if (/^[a-zA-Z0-9_$]+$/.test(key)) return key; + return assert._formatIdentityFreeValue(key); +} + +assert.deepEqual.format = function(value, seen) { + let basic = assert._formatIdentityFreeValue(value); + if (basic) return basic; + switch (value === null ? 'null' : typeof value) { + case 'string': + case 'bigint': + case 'number': + case 'boolean': + case 'undefined': + case 'null': + assert(false, 'values without identity should use basic formatting'); + break; + case 'symbol': + case 'function': + case 'object': + break; + default: + return typeof value; + } + + if (!seen) { + seen = { + counter: 0, + map: new Map() + }; + } + let usage = seen.map.get(value); + if (usage) { + usage.used = true; + return `ref #${usage.id}`; + } + usage = { id: ++seen.counter, used: false }; + seen.map.set(value, usage); + + // Properly communicating multiple references requires deferred rendering of + // all identity-bearing values until the outermost format call finishes, + // because the current value can also in appear in a not-yet-visited part of + // the object graph (which, when visited, will update the usage object). + // + // To preserve readability of the desired output formatting, we accomplish + // this deferral using tagged template literals. + // Evaluation closes over the usage object and returns a function that accepts + // "mapper" arguments for rendering the corresponding substitution values and + // returns an object with only a toString method which will itself be invoked + // when trying to use the result as a string in assert.deepEqual. + // + // For convenience, any absent mapper is presumed to be `String`, and the + // function itself has a toString method that self-invokes with no mappers + // (allowing returning the function directly when every mapper is `String`). + function lazyResult(strings, ...subs) { + function acceptMappers(...mappers) { + function toString() { + let renderings = subs.map((sub, i) => (mappers[i] || String)(sub)); + let rendered = stringFromTemplate(strings, renderings); + if (usage.used) rendered += ` as #${usage.id}`; + return rendered; + } + + return { toString }; + } + + acceptMappers.toString = () => String(acceptMappers()); + return acceptMappers; + } + + let format = assert.deepEqual.format; + function lazyString(strings, ...subs) { + return { toString: () => stringFromTemplate(strings, subs) }; + } + + if (typeof value === 'function') { + return lazyResult`function${value.name ? ` ${String(value.name)}` : ''}`; + } + if (typeof value !== 'object') { + // probably a symbol + return lazyResult`${value}`; + } + if (Array.isArray ? Array.isArray(value) : value instanceof Array) { + return lazyResult`[${value.map(value => format(value, seen))}]`(join); + } + if (value instanceof Date) { + return lazyResult`Date(${format(value.toISOString(), seen)})`; + } + if (value instanceof Error) { + return lazyResult`error ${value.name || 'Error'}(${format(value.message, seen)})`; + } + if (value instanceof RegExp) { + return lazyResult`${value}`; + } + if (typeof Map !== "undefined" && value instanceof Map) { + let contents = Array.from(value).map(pair => lazyString`${format(pair[0], seen)} => ${format(pair[1], seen)}`); + return lazyResult`Map {${contents}}`(join); + } + if (typeof Set !== "undefined" && value instanceof Set) { + let contents = Array.from(value).map(value => format(value, seen)); + return lazyResult`Set {${contents}}`(join); + } + + let tag = Symbol.toStringTag && Symbol.toStringTag in value + ? value[Symbol.toStringTag] + : Object.getPrototypeOf(value) === null ? '[Object: null prototype]' : 'Object'; + let keys = Reflect.ownKeys(value).filter(key => getOwnPropertyDescriptor(value, key).enumerable); + let contents = keys.map(key => lazyString`${escapeKey(key)}: ${format(value[key], seen)}`); + return lazyResult`${tag ? `${tag} ` : ''}{${contents}}`(String, join); +}; +})(); + +assert.deepEqual._compare = (function () { + var EQUAL = 1; + var NOT_EQUAL = -1; + var UNKNOWN = 0; + + function deepEqual(a, b) { + return compareEquality(a, b) === EQUAL; + } + + function compareEquality(a, b, cache) { + return compareIf(a, b, isOptional, compareOptionality) + || compareIf(a, b, isPrimitiveEquatable, comparePrimitiveEquality) + || compareIf(a, b, isObjectEquatable, compareObjectEquality, cache) + || NOT_EQUAL; + } + + function compareIf(a, b, test, compare, cache) { + return !test(a) + ? !test(b) ? UNKNOWN : NOT_EQUAL + : !test(b) ? NOT_EQUAL : cacheComparison(a, b, compare, cache); + } + + function tryCompareStrictEquality(a, b) { + return a === b ? EQUAL : UNKNOWN; + } + + function tryCompareTypeOfEquality(a, b) { + return typeof a !== typeof b ? NOT_EQUAL : UNKNOWN; + } + + function tryCompareToStringTagEquality(a, b) { + var aTag = Symbol.toStringTag in a ? a[Symbol.toStringTag] : undefined; + var bTag = Symbol.toStringTag in b ? b[Symbol.toStringTag] : undefined; + return aTag !== bTag ? NOT_EQUAL : UNKNOWN; + } + + function isOptional(value) { + return value === undefined + || value === null; + } + + function compareOptionality(a, b) { + return tryCompareStrictEquality(a, b) + || NOT_EQUAL; + } + + function isPrimitiveEquatable(value) { + switch (typeof value) { + case 'string': + case 'number': + case 'bigint': + case 'boolean': + case 'symbol': + return true; + default: + return isBoxed(value); + } + } + + function comparePrimitiveEquality(a, b) { + if (isBoxed(a)) a = a.valueOf(); + if (isBoxed(b)) b = b.valueOf(); + return tryCompareStrictEquality(a, b) + || tryCompareTypeOfEquality(a, b) + || compareIf(a, b, isNaNEquatable, compareNaNEquality) + || NOT_EQUAL; + } + + function isNaNEquatable(value) { + return typeof value === 'number'; + } + + function compareNaNEquality(a, b) { + return isNaN(a) && isNaN(b) ? EQUAL : NOT_EQUAL; + } + + function isObjectEquatable(value) { + return typeof value === 'object' || typeof value === 'function'; + } + + function compareObjectEquality(a, b, cache) { + if (!cache) cache = new Map(); + return getCache(cache, a, b) + || setCache(cache, a, b, EQUAL) // consider equal for now + || cacheComparison(a, b, tryCompareStrictEquality, cache) + || cacheComparison(a, b, tryCompareToStringTagEquality, cache) + || compareIf(a, b, isValueOfEquatable, compareValueOfEquality) + || compareIf(a, b, isToStringEquatable, compareToStringEquality) + || compareIf(a, b, isArrayLikeEquatable, compareArrayLikeEquality, cache) + || compareIf(a, b, isStructurallyEquatable, compareStructuralEquality, cache) + || compareIf(a, b, isIterableEquatable, compareIterableEquality, cache) + || cacheComparison(a, b, fail, cache); + } + + function isBoxed(value) { + return value instanceof String + || value instanceof Number + || value instanceof Boolean + || typeof Symbol === 'function' && value instanceof Symbol + || typeof BigInt === 'function' && value instanceof BigInt; + } + + function isValueOfEquatable(value) { + return value instanceof Date; + } + + function compareValueOfEquality(a, b) { + return compareIf(a.valueOf(), b.valueOf(), isPrimitiveEquatable, comparePrimitiveEquality) + || NOT_EQUAL; + } + + function isToStringEquatable(value) { + return value instanceof RegExp; + } + + function compareToStringEquality(a, b) { + return compareIf(a.toString(), b.toString(), isPrimitiveEquatable, comparePrimitiveEquality) + || NOT_EQUAL; + } + + function isArrayLikeEquatable(value) { + return (Array.isArray ? Array.isArray(value) : value instanceof Array) + || (typeof Uint8Array === 'function' && value instanceof Uint8Array) + || (typeof Uint8ClampedArray === 'function' && value instanceof Uint8ClampedArray) + || (typeof Uint16Array === 'function' && value instanceof Uint16Array) + || (typeof Uint32Array === 'function' && value instanceof Uint32Array) + || (typeof Int8Array === 'function' && value instanceof Int8Array) + || (typeof Int16Array === 'function' && value instanceof Int16Array) + || (typeof Int32Array === 'function' && value instanceof Int32Array) + || (typeof Float32Array === 'function' && value instanceof Float32Array) + || (typeof Float64Array === 'function' && value instanceof Float64Array) + || (typeof BigUint64Array === 'function' && value instanceof BigUint64Array) + || (typeof BigInt64Array === 'function' && value instanceof BigInt64Array); + } + + function compareArrayLikeEquality(a, b, cache) { + if (a.length !== b.length) return NOT_EQUAL; + for (var i = 0; i < a.length; i++) { + if (compareEquality(a[i], b[i], cache) === NOT_EQUAL) { + return NOT_EQUAL; + } + } + return EQUAL; + } + + function isStructurallyEquatable(value) { + return !(typeof Promise === 'function' && value instanceof Promise // only comparable by reference + || typeof WeakMap === 'function' && value instanceof WeakMap // only comparable by reference + || typeof WeakSet === 'function' && value instanceof WeakSet // only comparable by reference + || typeof Map === 'function' && value instanceof Map // comparable via @@iterator + || typeof Set === 'function' && value instanceof Set); // comparable via @@iterator + } + + function compareStructuralEquality(a, b, cache) { + var aKeys = []; + for (var key in a) aKeys.push(key); + + var bKeys = []; + for (var key in b) bKeys.push(key); + + if (aKeys.length !== bKeys.length) { + return NOT_EQUAL; + } + + aKeys.sort(); + bKeys.sort(); + + for (var i = 0; i < aKeys.length; i++) { + var aKey = aKeys[i]; + var bKey = bKeys[i]; + if (compareEquality(aKey, bKey, cache) === NOT_EQUAL) { + return NOT_EQUAL; + } + if (compareEquality(a[aKey], b[bKey], cache) === NOT_EQUAL) { + return NOT_EQUAL; + } + } + + return compareIf(a, b, isIterableEquatable, compareIterableEquality, cache) + || EQUAL; + } + + function isIterableEquatable(value) { + return typeof Symbol === 'function' + && typeof value[Symbol.iterator] === 'function'; + } + + function compareIteratorEquality(a, b, cache) { + if (typeof Map === 'function' && a instanceof Map && b instanceof Map || + typeof Set === 'function' && a instanceof Set && b instanceof Set) { + if (a.size !== b.size) return NOT_EQUAL; // exit early if we detect a difference in size + } + + var ar, br; + while (true) { + ar = a.next(); + br = b.next(); + if (ar.done) { + if (br.done) return EQUAL; + if (b.return) b.return(); + return NOT_EQUAL; + } + if (br.done) { + if (a.return) a.return(); + return NOT_EQUAL; + } + if (compareEquality(ar.value, br.value, cache) === NOT_EQUAL) { + if (a.return) a.return(); + if (b.return) b.return(); + return NOT_EQUAL; + } + } + } + + function compareIterableEquality(a, b, cache) { + return compareIteratorEquality(a[Symbol.iterator](), b[Symbol.iterator](), cache); + } + + function cacheComparison(a, b, compare, cache) { + var result = compare(a, b, cache); + if (cache && (result === EQUAL || result === NOT_EQUAL)) { + setCache(cache, a, b, /** @type {EQUAL | NOT_EQUAL} */(result)); + } + return result; + } + + function fail() { + return NOT_EQUAL; + } + + function setCache(cache, left, right, result) { + var otherCache; + + otherCache = cache.get(left); + if (!otherCache) cache.set(left, otherCache = new Map()); + otherCache.set(right, result); + + otherCache = cache.get(right); + if (!otherCache) cache.set(right, otherCache = new Map()); + otherCache.set(left, result); + } + + function getCache(cache, left, right) { + var otherCache; + var result; + + otherCache = cache.get(left); + result = otherCache && otherCache.get(right); + if (result) return result; + + otherCache = cache.get(right); + result = otherCache && otherCache.get(left); + if (result) return result; + + return UNKNOWN; + } + + return deepEqual; +})(); diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/detachArrayBuffer.js b/crates/clazel-js-lexer/tests/data/test262/harness/detachArrayBuffer.js new file mode 100644 index 000000000..81af99f3b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/detachArrayBuffer.js @@ -0,0 +1,16 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + A function used in the process of asserting correctness of TypedArray objects. + + $262.detachArrayBuffer is defined by a host. +defines: [$DETACHBUFFER] +---*/ + +function $DETACHBUFFER(buffer) { + if (!$262 || typeof $262.detachArrayBuffer !== "function") { + throw new Test262Error("No method available to detach an ArrayBuffer"); + } + $262.detachArrayBuffer(buffer); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/doneprintHandle.js b/crates/clazel-js-lexer/tests/data/test262/harness/doneprintHandle.js new file mode 100644 index 000000000..334d19ec8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/doneprintHandle.js @@ -0,0 +1,22 @@ +// Copyright (C) 2017 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | +defines: [$DONE] +---*/ + +function __consolePrintHandle__(msg) { + print(msg); +} + +function $DONE(error) { + if (error) { + if(typeof error === 'object' && error !== null && 'name' in error) { + __consolePrintHandle__('Test262:AsyncTestFailure:' + error.name + ': ' + error.message); + } else { + __consolePrintHandle__('Test262:AsyncTestFailure:Test262Error: ' + String(error)); + } + } else { + __consolePrintHandle__('Test262:AsyncTestComplete'); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/features.yml b/crates/clazel-js-lexer/tests/data/test262/harness/features.yml new file mode 100644 index 000000000..a58b1ccee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/features.yml @@ -0,0 +1,4 @@ +atomicsHelper: [Atomics] +testAtomics.js: [ArrayBuffer, Atomics, DataView, SharedArrayBuffer, Symbol, TypedArray] +testTypedArray.js: [TypedArray] +isConstructor.js: [Reflect.construct] diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/fnGlobalObject.js b/crates/clazel-js-lexer/tests/data/test262/harness/fnGlobalObject.js new file mode 100644 index 000000000..231897c86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/fnGlobalObject.js @@ -0,0 +1,12 @@ +// Copyright (C) 2017 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Produce a reliable global object +defines: [fnGlobalObject] +---*/ + +var __globalObject = Function("return this;")(); +function fnGlobalObject() { + return __globalObject; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/isConstructor.js b/crates/clazel-js-lexer/tests/data/test262/harness/isConstructor.js new file mode 100644 index 000000000..387c664e1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/isConstructor.js @@ -0,0 +1,22 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: | + Test if a given function is a constructor function. +defines: [isConstructor] +features: [Reflect.construct] +---*/ + +function isConstructor(f) { + if (typeof f !== "function") { + throw new Test262Error("isConstructor invoked with a non-function value"); + } + + try { + Reflect.construct(function(){}, [], f); + } catch (e) { + return false; + } + return true; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/iteratorZipUtils.js b/crates/clazel-js-lexer/tests/data/test262/harness/iteratorZipUtils.js new file mode 100644 index 000000000..d27a90cc2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/iteratorZipUtils.js @@ -0,0 +1,219 @@ +// Copyright (C) 2025 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Utility functions for testing Iterator.prototype.zip and Iterator.prototype.zipKeyed. Requires inclusion of propertyHelper.js. +defines: + - forEachSequenceCombination + - forEachSequenceCombinationKeyed + - assertZipped + - assertZippedKeyed + - assertIteratorResult + - assertIsPackedArray +---*/ + +// Assert |result| is an object created by CreateIteratorResultObject. +function assertIteratorResult(result, value, done, label) { + assert.sameValue( + Object.getPrototypeOf(result), + Object.prototype, + label + ": [[Prototype]] of iterator result is Object.prototype" + ); + + assert(Object.isExtensible(result), label + ": iterator result is extensible"); + + var ownKeys = Reflect.ownKeys(result); + assert.compareArray(ownKeys, ["value", "done"], label + ": iterator result properties"); + + verifyProperty(result, "value", { + value: value, + writable: true, + enumerable: true, + configurable: true, + }); + + verifyProperty(result, "done", { + value: done, + writable: true, + enumerable: true, + configurable: true, + }); +} + +// Assert |array| is a packed array with default property attributes. +function assertIsPackedArray(array, label) { + assert(Array.isArray(array), label + ": array is an array exotic object"); + + assert.sameValue( + Object.getPrototypeOf(array), + Array.prototype, + label + ": [[Prototype]] of array is Array.prototype" + ); + + assert(Object.isExtensible(array), label + ": array is extensible"); + + // Ensure "length" property has its default property attributes. + verifyProperty(array, "length", { + writable: true, + enumerable: false, + configurable: false, + }); + + // Ensure no holes and all elements have the default property attributes. + for (var i = 0; i < array.length; i++) { + verifyProperty(array, i, { + writable: true, + enumerable: true, + configurable: true, + }); + } +} + +// Assert |array| is an extensible null-prototype object with default property attributes. +function _assertIsNullProtoMutableObject(object, label) { + assert.sameValue( + Object.getPrototypeOf(object), + null, + label + ": [[Prototype]] of object is null" + ); + + assert(Object.isExtensible(object), label + ": object is extensible"); + + // Ensure all properties have the default property attributes. + var keys = Object.getOwnPropertyNames(object); + for (var i = 0; i < keys.length; i++) { + verifyProperty(object, keys[i], { + writable: true, + enumerable: true, + configurable: true, + }); + } +} + +// Assert that the `zipped` iterator yields the first `count` outputs of Iterator.zip. +// Assumes `inputs` is an array of arrays, each with length >= `count`. +// Advances `zipped` by `count` steps. +function assertZipped(zipped, inputs, count, label) { + // Last returned elements array. + var last = null; + + for (var i = 0; i < count; i++) { + var itemLabel = label + ", step " + i; + + var result = zipped.next(); + var value = result.value; + + // Test IteratorResult structure. + assertIteratorResult(result, value, false, itemLabel); + + // Ensure value is a new array. + assert.notSameValue(value, last, itemLabel + ": returns a new array"); + last = value; + + // Ensure all array elements have the expected value. + var expected = inputs.map(function (array) { + return array[i]; + }); + assert.compareArray(value, expected, itemLabel + ": values"); + + // Ensure value is a packed array with default data properties. + assertIsPackedArray(value, itemLabel); + } +} + +// Assert that the `zipped` iterator yields the first `count` outputs of Iterator.zipKeyed. +// Assumes `inputs` is an object whose values are arrays, each with length >= `count`. +// Advances `zipped` by `count` steps. +function assertZippedKeyed(zipped, inputs, count, label) { + // Last returned elements array. + var last = null; + + var expectedKeys = Object.keys(inputs); + + for (var i = 0; i < count; i++) { + var itemLabel = label + ", step " + i; + + var result = zipped.next(); + var value = result.value; + + // Test IteratorResult structure. + assertIteratorResult(result, value, false, itemLabel); + + // Ensure resulting object is a new object. + assert.notSameValue(value, last, itemLabel + ": returns a new object"); + last = value; + + // Ensure resulting object has the expected keys and values. + assert.compareArray(Reflect.ownKeys(value), expectedKeys, itemLabel + ": result object keys"); + + var expectedValues = Object.values(inputs).map(function (array) { + return array[i]; + }); + assert.compareArray(Object.values(value), expectedValues, itemLabel + ": result object values"); + + // Ensure resulting object is a null-prototype mutable object with default data properties. + _assertIsNullProtoMutableObject(value, itemLabel); + } +} + +function forEachSequenceCombinationKeyed(callback) { + return forEachSequenceCombination(function(inputs, inputsLabel, min, max) { + var object = {}; + for (var i = 0; i < inputs.length; ++i) { + object["prop_" + i] = inputs[i]; + } + inputsLabel = "inputs = " + JSON.stringify(object); + callback(object, inputsLabel, min, max); + }); +} + +function forEachSequenceCombination(callback) { + function test(inputs) { + if (inputs.length === 0) { + callback(inputs, "inputs = []", 0, 0); + return; + } + + var lengths = inputs.map(function(array) { + return array.length; + }); + + var min = Math.min.apply(null, lengths); + var max = Math.max.apply(null, lengths); + + var inputsLabel = "inputs = " + JSON.stringify(inputs); + + callback(inputs, inputsLabel, min, max); + } + + // Yield all prefixes of the string |s|. + function* prefixes(s) { + for (var i = 0; i <= s.length; ++i) { + yield s.slice(0, i); + } + } + + // Zip an empty iterable. + test([]); + + // Zip a single iterator. + for (var prefix of prefixes("abcd")) { + test([prefix.split("")]); + } + + // Zip two iterators. + for (var prefix1 of prefixes("abcd")) { + for (var prefix2 of prefixes("efgh")) { + test([prefix1.split(""), prefix2.split("")]); + } + } + + // Zip three iterators. + for (var prefix1 of prefixes("abcd")) { + for (var prefix2 of prefixes("efgh")) { + for (var prefix3 of prefixes("ijkl")) { + test([prefix1.split(""), prefix2.split(""), prefix3.split("")]); + } + } + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/nans.js b/crates/clazel-js-lexer/tests/data/test262/harness/nans.js new file mode 100644 index 000000000..521ba9d7a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/nans.js @@ -0,0 +1,22 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + A collection of NaN values produced from expressions that have been observed + to create distinct bit representations on various platforms. These provide a + weak basis for assertions regarding the consistent canonicalization of NaN + values in Array buffers. +defines: [NaNs] +---*/ + +var NaNs = [ + NaN, + Number.NaN, + NaN * 0, + 0/0, + Infinity/Infinity, + -(0/0), + Math.pow(-1, 0.5), + -Math.pow(-1, 0.5), + Number("Not-a-Number"), +]; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/nativeFunctionMatcher.js b/crates/clazel-js-lexer/tests/data/test262/harness/nativeFunctionMatcher.js new file mode 100644 index 000000000..591447b9f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/nativeFunctionMatcher.js @@ -0,0 +1,220 @@ +// Copyright (C) 2016 Michael Ficarra. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: Assert _NativeFunction_ Syntax +info: | + NativeFunction : + function _NativeFunctionAccessor_ opt _IdentifierName_ opt ( _FormalParameters_ ) { [ native code ] } + NativeFunctionAccessor : + get + set +defines: + - assertToStringOrNativeFunction + - assertNativeFunction + - validateNativeFunctionSource +---*/ + +const validateNativeFunctionSource = function(source) { + // These regexes should be kept up to date with Unicode using `regexpu-core`. + // `/\p{ID_Start}/u` + const UnicodeIDStart = /(?:[A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCDF\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD4E\uDEC0-\uDEEB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43\uDD4B]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])/; + // `/\p{ID_Continue}/u` + const UnicodeIDContinue = /(?:[0-9A-Z_a-z\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05EF-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u07FD\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u08D3-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u09FE\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D81-\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1878\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1ABF\u1AC0\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CD0-\u1CD2\u1CD4-\u1CFA\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA827\uA82C\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD27\uDD30-\uDD39\uDE80-\uDEA9\uDEAB\uDEAC\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF50\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD44-\uDD47\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDC9-\uDDCC\uDDCE-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3B-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC5E-\uDC61\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB8\uDEC0-\uDEC9\uDF00-\uDF1A\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDC00-\uDC3A\uDCA0-\uDCE9\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD35\uDD37\uDD38\uDD3B-\uDD43\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD7\uDDDA-\uDDE1\uDDE3\uDDE4\uDE00-\uDE3E\uDE47\uDE50-\uDE99\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD8E\uDD90\uDD91\uDD93-\uDD98\uDDA0-\uDDA9\uDEE0-\uDEF6\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF4F-\uDF87\uDF8F-\uDF9F\uDFE0\uDFE1\uDFE3\uDFE4\uDFF0\uDFF1]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD00-\uDD2C\uDD30-\uDD3D\uDD40-\uDD49\uDD4E\uDEC0-\uDEF9]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4B\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]|\uDB40[\uDD00-\uDDEF])/; + // `/\p{Space_Separator}/u` + const UnicodeSpaceSeparator = /[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/; + + const isNewline = (c) => /[\u000A\u000D\u2028\u2029]/.test(c); + const isWhitespace = (c) => /[\u0009\u000B\u000C\u0020\u00A0\uFEFF]/.test(c) || UnicodeSpaceSeparator.test(c); + + let pos = 0; + + const eatWhitespace = () => { + while (pos < source.length) { + const c = source[pos]; + if (isWhitespace(c) || isNewline(c)) { + pos += 1; + continue; + } + + if (c === '/') { + if (source[pos + 1] === '/') { + while (pos < source.length) { + if (isNewline(source[pos])) { + break; + } + pos += 1; + } + continue; + } + if (source[pos + 1] === '*') { + const end = source.indexOf('*/', pos); + if (end === -1) { + throw new SyntaxError(); + } + pos = end + '*/'.length; + continue; + } + } + + break; + } + }; + + const getIdentifier = () => { + eatWhitespace(); + + const start = pos; + let end = pos; + switch (source[end]) { + case '_': + case '$': + end += 1; + break; + default: + if (UnicodeIDStart.test(source[end])) { + end += 1; + break; + } + return null; + } + while (end < source.length) { + const c = source[end]; + switch (c) { + case '_': + case '$': + end += 1; + break; + default: + if (UnicodeIDContinue.test(c)) { + end += 1; + break; + } + return source.slice(start, end); + } + } + return source.slice(start, end); + }; + + const test = (s) => { + eatWhitespace(); + + if (/\w/.test(s)) { + return getIdentifier() === s; + } + return source.slice(pos, pos + s.length) === s; + }; + + const eat = (s) => { + if (test(s)) { + pos += s.length; + return true; + } + return false; + }; + + const eatIdentifier = () => { + const n = getIdentifier(); + if (n !== null) { + pos += n.length; + return true; + } + return false; + }; + + const expect = (s) => { + if (!eat(s)) { + throw new SyntaxError(); + } + }; + + const eatString = () => { + if (source[pos] === '\'' || source[pos] === '"') { + const match = source[pos]; + pos += 1; + while (pos < source.length) { + if (source[pos] === match && source[pos - 1] !== '\\') { + return; + } + if (isNewline(source[pos])) { + throw new SyntaxError(); + } + pos += 1; + } + throw new SyntaxError(); + } + }; + + // "Stumble" through source text until matching character is found. + // Assumes ECMAScript syntax keeps `[]` and `()` balanced. + const stumbleUntil = (c) => { + const match = { + ']': '[', + ')': '(', + }[c]; + let nesting = 1; + while (pos < source.length) { + eatWhitespace(); + eatString(); // Strings may contain unbalanced characters. + if (source[pos] === match) { + nesting += 1; + } else if (source[pos] === c) { + nesting -= 1; + } + pos += 1; + if (nesting === 0) { + return; + } + } + throw new SyntaxError(); + }; + + // function + expect('function'); + + // NativeFunctionAccessor + eat('get') || eat('set'); + + // PropertyName + if (!eatIdentifier() && eat('[')) { + stumbleUntil(']'); + } + + // ( FormalParameters ) + expect('('); + stumbleUntil(')'); + + // { + expect('{'); + + // [native code] + expect('['); + expect('native'); + expect('code'); + expect(']'); + + // } + expect('}'); + + eatWhitespace(); + if (pos !== source.length) { + throw new SyntaxError(); + } +}; + +const assertToStringOrNativeFunction = function(fn, expected) { + const actual = "" + fn; + try { + assert.sameValue(actual, expected); + } catch (unused) { + assertNativeFunction(fn, expected); + } +}; + +const assertNativeFunction = function(fn, special) { + const actual = "" + fn; + try { + validateNativeFunctionSource(actual); + } catch (unused) { + throw new Test262Error('Conforms to NativeFunction Syntax: ' + JSON.stringify(actual) + (special ? ' (' + special + ')' : '')); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/promiseHelper.js b/crates/clazel-js-lexer/tests/data/test262/harness/promiseHelper.js new file mode 100644 index 000000000..9a8bf627a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/promiseHelper.js @@ -0,0 +1,75 @@ +// Copyright (C) 2017 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Check that an array contains a numeric sequence starting at 1 + and incrementing by 1 for each entry in the array. Used by + Promise tests to assert the order of execution in deep Promise + resolution pipelines. +defines: [checkSequence, checkSettledPromises] +---*/ + +function checkSequence(arr, message) { + arr.forEach(function(e, i) { + if (e !== (i+1)) { + throw new Test262Error((message ? message : "Steps in unexpected sequence:") + + " '" + arr.join(',') + "'"); + } + }); + + return true; +} + +function checkSettledPromises(settleds, expected, message) { + const prefix = message ? `${message}: ` : ''; + + assert.sameValue(Array.isArray(settleds), true, `${prefix}Settled values is an array`); + + assert.sameValue( + settleds.length, + expected.length, + `${prefix}The settled values has a different length than expected` + ); + + settleds.forEach((settled, i) => { + assert.sameValue( + Object.prototype.hasOwnProperty.call(settled, 'status'), + true, + `${prefix}The settled value has a property status` + ); + + assert.sameValue(settled.status, expected[i].status, `${prefix}status for item ${i}`); + + if (settled.status === 'fulfilled') { + assert.sameValue( + Object.prototype.hasOwnProperty.call(settled, 'value'), + true, + `${prefix}The fulfilled promise has a property named value` + ); + + assert.sameValue( + Object.prototype.hasOwnProperty.call(settled, 'reason'), + false, + `${prefix}The fulfilled promise has no property named reason` + ); + + assert.sameValue(settled.value, expected[i].value, `${prefix}value for item ${i}`); + } else { + assert.sameValue(settled.status, 'rejected', `${prefix}Valid statuses are only fulfilled or rejected`); + + assert.sameValue( + Object.prototype.hasOwnProperty.call(settled, 'value'), + false, + `${prefix}The fulfilled promise has no property named value` + ); + + assert.sameValue( + Object.prototype.hasOwnProperty.call(settled, 'reason'), + true, + `${prefix}The fulfilled promise has a property named reason` + ); + + assert.sameValue(settled.reason, expected[i].reason, `${prefix}Reason value for item ${i}`); + } + }); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/propertyHelper.js b/crates/clazel-js-lexer/tests/data/test262/harness/propertyHelper.js new file mode 100644 index 000000000..51cc80c88 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/propertyHelper.js @@ -0,0 +1,371 @@ +// Copyright (C) 2017 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Collection of functions used to safely verify the correctness of + property descriptors. +defines: + - verifyProperty + - verifyCallableProperty + - verifyEqualTo # deprecated + - verifyWritable # deprecated + - verifyNotWritable # deprecated + - verifyEnumerable # deprecated + - verifyNotEnumerable # deprecated + - verifyConfigurable # deprecated + - verifyNotConfigurable # deprecated + - verifyPrimordialProperty + - verifyPrimordialCallableProperty +---*/ + +// @ts-check + +// Capture primordial functions and receiver-uncurried primordial methods that +// are used in verification but might be destroyed *by* that process itself. +var __isArray = Array.isArray; +var __defineProperty = Object.defineProperty; +var __getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +var __getOwnPropertyNames = Object.getOwnPropertyNames; +var __join = Function.prototype.call.bind(Array.prototype.join); +var __push = Function.prototype.call.bind(Array.prototype.push); +var __hasOwnProperty = Function.prototype.call.bind(Object.prototype.hasOwnProperty); +var __propertyIsEnumerable = Function.prototype.call.bind(Object.prototype.propertyIsEnumerable); +var nonIndexNumericPropertyName = Math.pow(2, 32) - 1; + +/** + * @param {object} obj + * @param {string|symbol} name + * @param {PropertyDescriptor|undefined} desc + * @param {object} [options] + * @param {boolean} [options.restore] revert mutations from verifying writable/configurable + */ +function verifyProperty(obj, name, desc, options) { + assert( + arguments.length > 2, + 'verifyProperty should receive at least 3 arguments: obj, name, and descriptor' + ); + + var originalDesc = __getOwnPropertyDescriptor(obj, name); + var nameStr = String(name); + + // Allows checking for undefined descriptor if it's explicitly given. + if (desc === undefined) { + assert.sameValue( + originalDesc, + undefined, + "obj['" + nameStr + "'] descriptor should be undefined" + ); + + // desc and originalDesc are both undefined, problem solved; + return true; + } + + assert( + __hasOwnProperty(obj, name), + "obj should have an own property " + nameStr + ); + + assert.notSameValue( + desc, + null, + "The desc argument should be an object or undefined, null" + ); + + assert.sameValue( + typeof desc, + "object", + "The desc argument should be an object or undefined, " + String(desc) + ); + + var names = __getOwnPropertyNames(desc); + for (var i = 0; i < names.length; i++) { + assert( + names[i] === "value" || + names[i] === "writable" || + names[i] === "enumerable" || + names[i] === "configurable" || + names[i] === "get" || + names[i] === "set", + "Invalid descriptor field: " + names[i], + ); + } + + var failures = []; + + if (__hasOwnProperty(desc, 'value')) { + if (!isSameValue(desc.value, originalDesc.value)) { + __push(failures, "obj['" + nameStr + "'] descriptor value should be " + desc.value); + } + if (!isSameValue(desc.value, obj[name])) { + __push(failures, "obj['" + nameStr + "'] value should be " + desc.value); + } + } + + if (__hasOwnProperty(desc, 'enumerable') && desc.enumerable !== undefined) { + if (desc.enumerable !== originalDesc.enumerable || + desc.enumerable !== isEnumerable(obj, name)) { + __push(failures, "obj['" + nameStr + "'] descriptor should " + (desc.enumerable ? '' : 'not ') + "be enumerable"); + } + } + + // Operations past this point are potentially destructive! + + if (__hasOwnProperty(desc, 'writable') && desc.writable !== undefined) { + if (desc.writable !== originalDesc.writable || + desc.writable !== isWritable(obj, name)) { + __push(failures, "obj['" + nameStr + "'] descriptor should " + (desc.writable ? '' : 'not ') + "be writable"); + } + } + + if (__hasOwnProperty(desc, 'configurable') && desc.configurable !== undefined) { + if (desc.configurable !== originalDesc.configurable || + desc.configurable !== isConfigurable(obj, name)) { + __push(failures, "obj['" + nameStr + "'] descriptor should " + (desc.configurable ? '' : 'not ') + "be configurable"); + } + } + + if (failures.length) { + assert(false, __join(failures, '; ')); + } + + if (options && options.restore) { + __defineProperty(obj, name, originalDesc); + } + + return true; +} + +function isConfigurable(obj, name) { + try { + delete obj[name]; + } catch (e) { + if (!(e instanceof TypeError)) { + throw new Test262Error("Expected TypeError, got " + e); + } + } + return !__hasOwnProperty(obj, name); +} + +function isEnumerable(obj, name) { + var stringCheck = false; + + if (typeof name === "string") { + for (var x in obj) { + if (x === name) { + stringCheck = true; + break; + } + } + } else { + // skip it if name is not string, works for Symbol names. + stringCheck = true; + } + + return stringCheck && __hasOwnProperty(obj, name) && __propertyIsEnumerable(obj, name); +} + +function isSameValue(a, b) { + if (a === 0 && b === 0) return 1 / a === 1 / b; + if (a !== a && b !== b) return true; + + return a === b; +} + +function isWritable(obj, name, verifyProp, value) { + var unlikelyValue = __isArray(obj) && name === "length" ? + nonIndexNumericPropertyName : + "unlikelyValue"; + var newValue = value || unlikelyValue; + var hadValue = __hasOwnProperty(obj, name); + var oldValue = obj[name]; + var writeSucceeded; + + if (arguments.length < 4 && newValue === oldValue) { + newValue = newValue + "2"; + } + + try { + obj[name] = newValue; + } catch (e) { + if (!(e instanceof TypeError)) { + throw new Test262Error("Expected TypeError, got " + e); + } + } + + writeSucceeded = isSameValue(obj[verifyProp || name], newValue); + + // Revert the change only if it was successful (in other cases, reverting + // is unnecessary and may trigger exceptions for certain property + // configurations) + if (writeSucceeded) { + if (hadValue) { + obj[name] = oldValue; + } else { + delete obj[name]; + } + } + + return writeSucceeded; +} + +/** + * Verify that there is a function of specified name, length, and containing + * descriptor associated with `obj[name]` and following the conventions for + * built-in objects. + * + * @param {object} obj + * @param {string|symbol} name + * @param {string} [functionName] defaults to name for strings, `[${name.description}]` for symbols + * @param {number} functionLength + * @param {PropertyDescriptor} [desc] defaults to data property conventions (writable, non-enumerable, configurable) + * @param {object} [options] + * @param {boolean} [options.restore] revert mutations from verifying writable/configurable + */ +function verifyCallableProperty(obj, name, functionName, functionLength, desc, options) { + var value = obj[name]; + + assert.sameValue(typeof value, "function", + "obj['" + String(name) + "'] descriptor should be a function"); + + // Every other data property described in clauses 19 through 28 and in + // Annex B.2 has the attributes { [[Writable]]: true, [[Enumerable]]: false, + // [[Configurable]]: true } unless otherwise specified. + // https://tc39.es/ecma262/multipage/ecmascript-standard-built-in-objects.html + if (desc === undefined) { + desc = { + writable: true, + enumerable: false, + configurable: true, + value: value + }; + } else if (!__hasOwnProperty(desc, "value") && !__hasOwnProperty(desc, "get")) { + desc.value = value; + } + + verifyProperty(obj, name, desc, options); + + if (functionName === undefined) { + if (typeof name === "symbol") { + functionName = "[" + name.description + "]"; + } else { + functionName = name; + } + } + // Unless otherwise specified, the "name" property of a built-in function + // object has the attributes { [[Writable]]: false, [[Enumerable]]: false, + // [[Configurable]]: true }. + // https://tc39.es/ecma262/multipage/ecmascript-standard-built-in-objects.html#sec-ecmascript-standard-built-in-objects + // https://tc39.es/ecma262/multipage/ordinary-and-exotic-objects-behaviours.html#sec-setfunctionname + verifyProperty(value, "name", { + value: functionName, + writable: false, + enumerable: false, + configurable: desc.configurable + }, options); + + // Unless otherwise specified, the "length" property of a built-in function + // object has the attributes { [[Writable]]: false, [[Enumerable]]: false, + // [[Configurable]]: true }. + // https://tc39.es/ecma262/multipage/ecmascript-standard-built-in-objects.html#sec-ecmascript-standard-built-in-objects + // https://tc39.es/ecma262/multipage/ordinary-and-exotic-objects-behaviours.html#sec-setfunctionlength + verifyProperty(value, "length", { + value: functionLength, + writable: false, + enumerable: false, + configurable: desc.configurable + }, options); +} + +/** + * Deprecated; please use `verifyProperty` in new tests. + */ +function verifyEqualTo(obj, name, value) { + if (!isSameValue(obj[name], value)) { + throw new Test262Error("Expected obj[" + String(name) + "] to equal " + value + + ", actually " + obj[name]); + } +} + +/** + * Deprecated; please use `verifyProperty` in new tests. + */ +function verifyWritable(obj, name, verifyProp, value) { + if (!verifyProp) { + assert(__getOwnPropertyDescriptor(obj, name).writable, + "Expected obj[" + String(name) + "] to have writable:true."); + } + if (!isWritable(obj, name, verifyProp, value)) { + throw new Test262Error("Expected obj[" + String(name) + "] to be writable, but was not."); + } +} + +/** + * Deprecated; please use `verifyProperty` in new tests. + */ +function verifyNotWritable(obj, name, verifyProp, value) { + if (!verifyProp) { + assert(!__getOwnPropertyDescriptor(obj, name).writable, + "Expected obj[" + String(name) + "] to have writable:false."); + } + if (isWritable(obj, name, verifyProp)) { + throw new Test262Error("Expected obj[" + String(name) + "] NOT to be writable, but was."); + } +} + +/** + * Deprecated; please use `verifyProperty` in new tests. + */ +function verifyEnumerable(obj, name) { + assert(__getOwnPropertyDescriptor(obj, name).enumerable, + "Expected obj[" + String(name) + "] to have enumerable:true."); + if (!isEnumerable(obj, name)) { + throw new Test262Error("Expected obj[" + String(name) + "] to be enumerable, but was not."); + } +} + +/** + * Deprecated; please use `verifyProperty` in new tests. + */ +function verifyNotEnumerable(obj, name) { + assert(!__getOwnPropertyDescriptor(obj, name).enumerable, + "Expected obj[" + String(name) + "] to have enumerable:false."); + if (isEnumerable(obj, name)) { + throw new Test262Error("Expected obj[" + String(name) + "] NOT to be enumerable, but was."); + } +} + +/** + * Deprecated; please use `verifyProperty` in new tests. + */ +function verifyConfigurable(obj, name) { + assert(__getOwnPropertyDescriptor(obj, name).configurable, + "Expected obj[" + String(name) + "] to have configurable:true."); + if (!isConfigurable(obj, name)) { + throw new Test262Error("Expected obj[" + String(name) + "] to be configurable, but was not."); + } +} + +/** + * Deprecated; please use `verifyProperty` in new tests. + */ +function verifyNotConfigurable(obj, name) { + assert(!__getOwnPropertyDescriptor(obj, name).configurable, + "Expected obj[" + String(name) + "] to have configurable:false."); + if (isConfigurable(obj, name)) { + throw new Test262Error("Expected obj[" + String(name) + "] NOT to be configurable, but was."); + } +} + +/** + * Use this function to verify the properties of a primordial object. + * For non-primordial objects, use verifyProperty. + * See: https://github.com/tc39/how-we-work/blob/main/terminology.md#primordial + */ +var verifyPrimordialProperty = verifyProperty; + +/** + * Use this function to verify the primordial function-valued properties. + * For non-primordial functions, use verifyCallableProperty. + * See: https://github.com/tc39/how-we-work/blob/main/terminology.md#primordial + */ +var verifyPrimordialCallableProperty = verifyCallableProperty; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/proxyTrapsHelper.js b/crates/clazel-js-lexer/tests/data/test262/harness/proxyTrapsHelper.js new file mode 100644 index 000000000..3bd0256b0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/proxyTrapsHelper.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 Jordan Harband. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Used to assert the correctness of object behavior in the presence + and context of Proxy objects. +defines: [allowProxyTraps] +---*/ + +function allowProxyTraps(overrides) { + function throwTest262Error(msg) { + return function () { throw new Test262Error(msg); }; + } + if (!overrides) { overrides = {}; } + return { + getPrototypeOf: overrides.getPrototypeOf || throwTest262Error('[[GetPrototypeOf]] trap called'), + setPrototypeOf: overrides.setPrototypeOf || throwTest262Error('[[SetPrototypeOf]] trap called'), + isExtensible: overrides.isExtensible || throwTest262Error('[[IsExtensible]] trap called'), + preventExtensions: overrides.preventExtensions || throwTest262Error('[[PreventExtensions]] trap called'), + getOwnPropertyDescriptor: overrides.getOwnPropertyDescriptor || throwTest262Error('[[GetOwnProperty]] trap called'), + has: overrides.has || throwTest262Error('[[HasProperty]] trap called'), + get: overrides.get || throwTest262Error('[[Get]] trap called'), + set: overrides.set || throwTest262Error('[[Set]] trap called'), + deleteProperty: overrides.deleteProperty || throwTest262Error('[[Delete]] trap called'), + defineProperty: overrides.defineProperty || throwTest262Error('[[DefineOwnProperty]] trap called'), + enumerate: throwTest262Error('[[Enumerate]] trap called: this trap has been removed'), + ownKeys: overrides.ownKeys || throwTest262Error('[[OwnPropertyKeys]] trap called'), + apply: overrides.apply || throwTest262Error('[[Call]] trap called'), + construct: overrides.construct || throwTest262Error('[[Construct]] trap called') + }; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/regExpUtils.js b/crates/clazel-js-lexer/tests/data/test262/harness/regExpUtils.js new file mode 100644 index 000000000..b397be070 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/regExpUtils.js @@ -0,0 +1,113 @@ +// Copyright (C) 2017 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Collection of functions used to assert the correctness of RegExp objects. +defines: [buildString, testPropertyEscapes, testPropertyOfStrings, testExtendedCharacterClass, matchValidator] +---*/ + +function buildString(args) { + // Use member expressions rather than destructuring `args` for improved + // compatibility with engines that only implement assignment patterns + // partially or not at all. + const loneCodePoints = args.loneCodePoints; + const ranges = args.ranges; + const CHUNK_SIZE = 10000; + let result = String.fromCodePoint.apply(null, loneCodePoints); + for (let i = 0; i < ranges.length; i++) { + let range = ranges[i]; + let start = range[0]; + let end = range[1]; + let codePoints = []; + for (let length = 0, codePoint = start; codePoint <= end; codePoint++) { + codePoints[length++] = codePoint; + if (length === CHUNK_SIZE) { + result += String.fromCodePoint.apply(null, codePoints); + codePoints.length = length = 0; + } + } + result += String.fromCodePoint.apply(null, codePoints); + } + return result; +} + +function printCodePoint(codePoint) { + const hex = codePoint + .toString(16) + .toUpperCase() + .padStart(6, "0"); + return `U+${hex}`; +} + +function printStringCodePoints(string) { + const buf = []; + for (let symbol of string) { + let formatted = printCodePoint(symbol.codePointAt(0)); + buf.push(formatted); + } + return buf.join(' '); +} + +function testPropertyEscapes(regExp, string, expression) { + if (!regExp.test(string)) { + for (let symbol of string) { + let formatted = printCodePoint(symbol.codePointAt(0)); + assert( + regExp.test(symbol), + `\`${ expression }\` should match ${ formatted } (\`${ symbol }\`)` + ); + } + } +} + +function testPropertyOfStrings(args) { + // Use member expressions rather than destructuring `args` for improved + // compatibility with engines that only implement assignment patterns + // partially or not at all. + const regExp = args.regExp; + const expression = args.expression; + const matchStrings = args.matchStrings; + const nonMatchStrings = args.nonMatchStrings; + const allStrings = matchStrings.join(''); + if (!regExp.test(allStrings)) { + for (let string of matchStrings) { + assert( + regExp.test(string), + `\`${ expression }\` should match ${ string } (${ printStringCodePoints(string) })` + ); + } + } + + if (!nonMatchStrings) return; + + const allNonMatchStrings = nonMatchStrings.join(''); + if (regExp.test(allNonMatchStrings)) { + for (let string of nonMatchStrings) { + assert( + !regExp.test(string), + `\`${ expression }\` should not match ${ string } (${ printStringCodePoints(string) })` + ); + } + } +} + +// The exact same logic can be used to test extended character classes +// as enabled through the RegExp `v` flag. This is useful to test not +// just standalone properties of strings, but also string literals, and +// set operations. +const testExtendedCharacterClass = testPropertyOfStrings; + +// Returns a function that validates a RegExp match result. +// +// Example: +// +// var validate = matchValidator(['b'], 1, 'abc'); +// validate(/b/.exec('abc')); +// +function matchValidator(expectedEntries, expectedIndex, expectedInput) { + return function(match) { + assert.compareArray(match, expectedEntries, 'Match entries'); + assert.sameValue(match.index, expectedIndex, 'Match index'); + assert.sameValue(match.input, expectedInput, 'Match input'); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/resizableArrayBufferUtils.js b/crates/clazel-js-lexer/tests/data/test262/harness/resizableArrayBufferUtils.js new file mode 100644 index 000000000..9dad8ccb8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/resizableArrayBufferUtils.js @@ -0,0 +1,152 @@ +// Copyright 2023 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: | + Collection of helper constants and functions for testing resizable array buffers. +defines: + - floatCtors + - ctors + - MyBigInt64Array + - CreateResizableArrayBuffer + - MayNeedBigInt + - Convert + - ToNumbers + - CreateRabForTest + - CollectValuesAndResize + - TestIterationAndResize +features: [BigInt] +---*/ +// Helper to create subclasses without bombing out when `class` isn't supported +function subClass(type) { + try { + return new Function('return class My' + type + ' extends ' + type + ' {}')(); + } catch (e) {} +} + +const MyUint8Array = subClass('Uint8Array'); +const MyFloat32Array = subClass('Float32Array'); +const MyBigInt64Array = subClass('BigInt64Array'); + +const builtinCtors = [ + Uint8Array, + Int8Array, + Uint16Array, + Int16Array, + Uint32Array, + Int32Array, + Float32Array, + Float64Array, + Uint8ClampedArray, +]; + +// Big(U)int64Array and Float16Array are newer features adding them above unconditionally +// would cause implementations lacking it to fail every test which uses it. +if (typeof Float16Array !== 'undefined') { + builtinCtors.push(Float16Array); +} + +if (typeof BigUint64Array !== 'undefined') { + builtinCtors.push(BigUint64Array); +} + +if (typeof BigInt64Array !== 'undefined') { + builtinCtors.push(BigInt64Array); +} + +const floatCtors = [ + Float32Array, + Float64Array, + MyFloat32Array +]; + +if (typeof Float16Array !== 'undefined') { + floatCtors.push(Float16Array); +} + +const ctors = builtinCtors.concat(MyUint8Array, MyFloat32Array); + +if (typeof MyBigInt64Array !== 'undefined') { + ctors.push(MyBigInt64Array); +} + +function CreateResizableArrayBuffer(byteLength, maxByteLength) { + return new ArrayBuffer(byteLength, { maxByteLength: maxByteLength }); +} + +function Convert(item) { + if (typeof item == 'bigint') { + return Number(item); + } + return item; +} + +function ToNumbers(array) { + let result = []; + for (let i = 0; i < array.length; i++) { + let item = array[i]; + result.push(Convert(item)); + } + return result; +} + +function MayNeedBigInt(ta, n) { + assert.sameValue(typeof n, 'number'); + if ((BigInt64Array !== 'undefined' && ta instanceof BigInt64Array) + || (BigUint64Array !== 'undefined' && ta instanceof BigUint64Array)) { + return BigInt(n); + } + return n; +} + +function CreateRabForTest(ctor) { + const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT, 8 * ctor.BYTES_PER_ELEMENT); + // Write some data into the array. + const taWrite = new ctor(rab); + for (let i = 0; i < 4; ++i) { + taWrite[i] = MayNeedBigInt(taWrite, 2 * i); + } + return rab; +} + +function CollectValuesAndResize(n, values, rab, resizeAfter, resizeTo) { + if (typeof n == 'bigint') { + values.push(Number(n)); + } else { + values.push(n); + } + if (values.length == resizeAfter) { + rab.resize(resizeTo); + } + return true; +} + +function TestIterationAndResize(iterable, expected, rab, resizeAfter, newByteLength) { + let values = []; + let resized = false; + var arrayValues = false; + + for (let value of iterable) { + if (Array.isArray(value)) { + arrayValues = true; + values.push([ + value[0], + Number(value[1]) + ]); + } else { + values.push(Number(value)); + } + if (!resized && values.length == resizeAfter) { + rab.resize(newByteLength); + resized = true; + } + } + if (!arrayValues) { + assert.compareArray([].concat(values), expected, "TestIterationAndResize: list of iterated values"); + } else { + for (let i = 0; i < expected.length; i++) { + assert.compareArray(values[i], expected[i], "TestIterationAndResize: list of iterated lists of values"); + } + } + assert(resized, "TestIterationAndResize: resize condition should have been hit"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/assertThrowsValue.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/assertThrowsValue.js new file mode 100644 index 000000000..3058fe4f1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/assertThrowsValue.js @@ -0,0 +1,24 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/*--- +defines: [assertThrowsValue] +---*/ + +function assertThrowsValue(f, val, msg) { + try { + f(); + } catch (exc) { + assert.sameValue(exc, val, msg); + return; + } + + var fullmsg = "Assertion failed: expected exception, no exception thrown"; + if (msg !== void 0) { + fullmsg += " - " + msg; + } + throw new Test262Error(fullmsg); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Date-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Date-shell.js new file mode 100644 index 000000000..e2a67fcd5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Date-shell.js @@ -0,0 +1,129 @@ +/*--- +defines: [runDSTOffsetCachingTestsFraction] +---*/ + +function runDSTOffsetCachingTestsFraction(part, parts) +{ + var BUGNUMBER = 563938; + var summary = 'Cache DST offsets to improve SunSpider score'; + + var MAX_UNIX_TIMET = 2145859200; // "2037-12-31T08:00:00.000Z" (PST8PDT based!) + var RANGE_EXPANSION_AMOUNT = 30 * 24 * 60 * 60; + + /** + * Computes the time zone offset in minutes at the given timestamp. + */ + function tzOffsetFromUnixTimestamp(timestamp) + { + var d = new Date(NaN); + d.setTime(timestamp); // local slot = NaN, UTC slot = timestamp + return d.getTimezoneOffset(); // get UTC, calculate local => diff in minutes + } + + /** + * Clear the DST offset cache, leaving it initialized to include a timestamp + * completely unlike the provided one (i.e. one very, very far away in time + * from it). Thus an immediately following lookup for the provided timestamp + * will cache-miss and compute a clean value. + */ + function clearDSTOffsetCache(undesiredTimestamp) + { + var opposite = (undesiredTimestamp + MAX_UNIX_TIMET / 2) % MAX_UNIX_TIMET; + + // Generic purge to known, but not necessarily desired, state + tzOffsetFromUnixTimestamp(0); + tzOffsetFromUnixTimestamp(MAX_UNIX_TIMET); + + // Purge to desired state. Cycle 2x in case opposite or undesiredTimestamp + // is close to 0 or MAX_UNIX_TIMET. + tzOffsetFromUnixTimestamp(opposite); + tzOffsetFromUnixTimestamp(undesiredTimestamp); + tzOffsetFromUnixTimestamp(opposite); + tzOffsetFromUnixTimestamp(undesiredTimestamp); + } + + function computeCanonicalTZOffset(timestamp) + { + clearDSTOffsetCache(timestamp); + return tzOffsetFromUnixTimestamp(timestamp); + } + + var TEST_TIMESTAMPS_SECONDS = + [ + // Special-ish timestamps + 0, + RANGE_EXPANSION_AMOUNT, + MAX_UNIX_TIMET, + ]; + + var ONE_DAY = 24 * 60 * 60; + var EIGHTY_THREE_HOURS = 83 * 60 * 60; + var NINETY_EIGHT_HOURS = 98 * 60 * 60; + function nextIncrement(i) + { + return i === EIGHTY_THREE_HOURS ? NINETY_EIGHT_HOURS : EIGHTY_THREE_HOURS; + } + + // Now add a long sequence of non-special timestamps, from a fixed range, that + // overlaps a DST change by "a bit" on each side. 67 days should be enough + // displacement that we can occasionally exercise the implementation's + // thirty-day expansion and the DST-offset-change logic. Use two different + // increments just to be safe and catch something a single increment might not. + var DST_CHANGE_DATE = 1268553600; // March 14, 2010 + for (var t = DST_CHANGE_DATE - 67 * ONE_DAY, + i = nextIncrement(NINETY_EIGHT_HOURS), + end = DST_CHANGE_DATE + 67 * ONE_DAY; + t < end; + i = nextIncrement(i), t += i) + { + TEST_TIMESTAMPS_SECONDS.push(t); + } + + var TEST_TIMESTAMPS = + TEST_TIMESTAMPS_SECONDS.map(function(v) { return v * 1000; }); + + /************** + * BEGIN TEST * + **************/ + + // Compute the correct time zone offsets for all timestamps to be tested. + var CORRECT_TZOFFSETS = TEST_TIMESTAMPS.map(computeCanonicalTZOffset); + + // Intentionally and knowingly invoking every single logic path in the cache + // isn't easy for a human to get right (and know he's gotten it right), so + // let's do it the easy way: exhaustively try all possible four-date sequences + // selecting from our array of possible timestamps. + + var sz = TEST_TIMESTAMPS.length; + var start = Math.floor((part - 1) / parts * sz); + var end = Math.floor(part / parts * sz); + + for (var i = start; i < end; i++) + { + var t1 = TEST_TIMESTAMPS[i]; + for (var j = 0; j < sz; j++) + { + var t2 = TEST_TIMESTAMPS[j]; + for (var k = 0; k < sz; k++) + { + var t3 = TEST_TIMESTAMPS[k]; + for (var w = 0; w < sz; w++) + { + var t4 = TEST_TIMESTAMPS[w]; + + clearDSTOffsetCache(t1); + + var tzo1 = tzOffsetFromUnixTimestamp(t1); + var tzo2 = tzOffsetFromUnixTimestamp(t2); + var tzo3 = tzOffsetFromUnixTimestamp(t3); + var tzo4 = tzOffsetFromUnixTimestamp(t4); + + assert.sameValue(tzo1, CORRECT_TZOFFSETS[i]); + assert.sameValue(tzo2, CORRECT_TZOFFSETS[j]); + assert.sameValue(tzo3, CORRECT_TZOFFSETS[k]); + assert.sameValue(tzo4, CORRECT_TZOFFSETS[w]); + } + } + } + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-JSON-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-JSON-shell.js new file mode 100644 index 000000000..6f20467a3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-JSON-shell.js @@ -0,0 +1,63 @@ +/*--- +defines: [testJSON, testJSONSyntaxError] +---*/ + +function testJSON(str) { + // Leading and trailing whitespace never affect parsing, so test the string + // multiple times with and without whitespace around it as it's easy and can + // potentially detect bugs. + + // Try the provided string + try { + JSON.parse(str); + } catch (e) { + throw new Test262Error("string <" + str + "> should have parsed as JSON"); + } + + // Now try the provided string with trailing whitespace + try { + JSON.parse(str + " "); + } catch (e) { + throw new Test262Error("string <" + str + " > should have parsed as JSON"); + } + + // Now try the provided string with leading whitespace + try { + JSON.parse(" " + str); + } catch (e) { + throw new Test262Error("string < " + str + "> should have parsed as JSON"); + } + + // Now try the provided string with whitespace surrounding it + try { + JSON.parse(" " + str + " "); + } catch (e) { + throw new Test262Error("string < " + str + " > should have parsed as JSON"); + } +} + +function testJSONSyntaxError(str) { + // Leading and trailing whitespace never affect parsing, so test the string + // multiple times with and without whitespace around it as it's easy and can + // potentially detect bugs. + + // Try the provided string + assert.throws(SyntaxError, function() { + JSON.parse(str); + }, "string <" + str + "> shouldn't have parsed as JSON"); + + // Now try the provided string with trailing whitespace + assert.throws(SyntaxError, function() { + JSON.parse(str + " "); + }, "string <" + str + " > shouldn't have parsed as JSON"); + + // Now try the provided string with leading whitespace + assert.throws(SyntaxError, function() { + JSON.parse(" " + str); + }, "string < " + str + "> shouldn't have parsed as JSON"); + + // Now try the provided string with whitespace surrounding it + assert.throws(SyntaxError, function() { + JSON.parse(" " + str + " "); + }, "string < " + str + " > shouldn't have parsed as JSON"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Math-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Math-shell.js new file mode 100644 index 000000000..1afea3a1f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Math-shell.js @@ -0,0 +1,88 @@ +/*--- +defines: [assertNear, ONE_PLUS_EPSILON, ONE_MINUS_EPSILON] +---*/ + +// The nearest representable values to +1.0. +const ONE_PLUS_EPSILON = 1 + Math.pow(2, -52); // 0.9999999999999999 +const ONE_MINUS_EPSILON = 1 - Math.pow(2, -53); // 1.0000000000000002 + +{ + const fail = function (msg) { + var exc = new Error(msg); + try { + // Try to improve on exc.fileName and .lineNumber; leave exc.stack + // alone. We skip two frames: fail() and its caller, an assertX() + // function. + var frames = exc.stack.trim().split("\n"); + if (frames.length > 2) { + var m = /@([^@:]*):([0-9]+)$/.exec(frames[2]); + if (m) { + exc.fileName = m[1]; + exc.lineNumber = +m[2]; + } + } + } catch (ignore) { throw ignore;} + throw exc; + }; + + let ENDIAN; // 0 for little-endian, 1 for big-endian. + + // Return the difference between the IEEE 754 bit-patterns for a and b. + // + // This is meaningful when a and b are both finite and have the same + // sign. Then the following hold: + // + // * If a === b, then diff(a, b) === 0. + // + // * If a !== b, then diff(a, b) === 1 + the number of representable values + // between a and b. + // + const f = new Float64Array([0, 0]); + const u = new Uint32Array(f.buffer); + const diff = function (a, b) { + f[0] = a; + f[1] = b; + //print(u[1].toString(16) + u[0].toString(16) + " " + u[3].toString(16) + u[2].toString(16)); + return Math.abs((u[3-ENDIAN] - u[1-ENDIAN]) * 0x100000000 + u[2+ENDIAN] - u[0+ENDIAN]); + }; + + // Set ENDIAN to the platform's endianness. + ENDIAN = 0; // try little-endian first + if (diff(2, 4) === 0x100000) // exact wrong answer we'll get on a big-endian platform + ENDIAN = 1; + // For test262-harness compatibility, + // avoid `assert.sameValue` while still defining functions. + // https://github.com/bocoup/test262-stream/issues/34 + const assertDiffResult = (a, b, expect, detail) => { + const result = diff(a, b); + if (result === expect) return; + throw new Error( + `Expected diff(${a}, ${b}) to be ${expect} but got ${result} [${detail}]` + ); + }; + assertDiffResult(2, 4, 0x10000000000000, "wanted 0x10000000000000"); + assertDiffResult(0, Number.MIN_VALUE, 1, "0 vs. Number.MIN_VALUE"); + assertDiffResult(1, ONE_PLUS_EPSILON, 1, "1 vs. ONE_PLUS_EPSILON"); + assertDiffResult(1, ONE_MINUS_EPSILON, 1, "1 vs. ONE_MINUS_EPSILON"); + + var assertNear = function assertNear(a, b, tolerance=1) { + if (!Number.isFinite(b)) { + fail("second argument to assertNear (expected value) must be a finite number"); + } else if (Number.isNaN(a)) { + fail("got NaN, expected a number near " + b); + } else if (!Number.isFinite(a)) { + if (b * Math.sign(a) < Number.MAX_VALUE) + fail("got " + a + ", expected a number near " + b); + } else { + // When the two arguments do not have the same sign bit, diff() + // returns some huge number. So if b is positive or negative 0, + // make target the zero that has the same sign bit as a. + var target = b === 0 ? a * 0 : b; + var err = diff(a, target); + if (err > tolerance) { + fail("got " + a + ", expected a number near " + b + + " (relative error: " + err + ")"); + } + } + }; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Reflect-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Reflect-shell.js new file mode 100644 index 000000000..d43b8372d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Reflect-shell.js @@ -0,0 +1,13 @@ +/*--- +defines: [SOME_PRIMITIVE_VALUES] +---*/ + +// List of a few values that are not objects. +var SOME_PRIMITIVE_VALUES = [ + undefined, null, + false, + -Infinity, -1.6e99, -1, -0, 0, Math.pow(2, -1074), 1, 4294967295, + Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER + 1, 1.6e99, Infinity, NaN, + "", "Phaedo", + Symbol(), Symbol("iterator"), Symbol.for("iterator"), Symbol.iterator +]; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Set-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Set-shell.js new file mode 100644 index 000000000..448e7d336 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Set-shell.js @@ -0,0 +1,105 @@ +/*--- +defines: [assertSetContainsExactOrderedItems, SetLike, SetIteratorLike, LoggingProxy] +---*/ +(function(global) { + // Save the primordial values. + const {Array, Error, Object, Proxy, Reflect, Set} = global; + + const ArrayIsArray = Array.isArray; + const ReflectApply = Reflect.apply; + const ReflectDefineProperty = Reflect.defineProperty; + const ReflectGet = Reflect.get; + const ReflectGetPrototypeOf = Reflect.getPrototypeOf; + const SetPrototype = Set.prototype; + const SetPrototypeHas = SetPrototype.has; + const SetPrototypeSize = Object.getOwnPropertyDescriptor(SetPrototype, "size").get; + const SetPrototypeKeys = SetPrototype.keys; + const SetIteratorPrototypeNext = new Set().values().next; + + function assertSetContainsExactOrderedItems(actual, expected) { + assert.sameValue(ReflectGetPrototypeOf(actual), SetPrototype, "actual is a native Set object"); + assert.sameValue(ArrayIsArray(expected), true, "expected is an Array object"); + + assert.sameValue(ReflectApply(SetPrototypeSize, actual, []), expected.length); + + let index = 0; + let keys = ReflectApply(SetPrototypeKeys, actual, []); + + while (true) { + let {done, value: item} = ReflectApply(SetIteratorPrototypeNext, keys, []); + if (done) { + break; + } + assert.sameValue(item, expected[index], `Element at index ${index}:`); + index++; + } + } + global.assertSetContainsExactOrderedItems = assertSetContainsExactOrderedItems; + + class SetLike { + #set; + + constructor(values) { + this.#set = new Set(values); + } + + get size() { + return ReflectApply(SetPrototypeSize, this.#set, []); + } + + has(value) { + return ReflectApply(SetPrototypeHas, this.#set, [value]); + } + + keys() { + let keys = ReflectApply(SetPrototypeKeys, this.#set, []); + return new SetIteratorLike(keys); + } + } + global.SetLike = SetLike; + + class SetIteratorLike { + #keys; + + constructor(keys) { + this.#keys = keys; + } + + next() { + return ReflectApply(SetIteratorPrototypeNext, this.#keys, []); + } + + // The |return| method of the iterator protocol is never called. + return() { + throw new Error("Unexpected call to |return| method"); + } + + // The |throw| method of the iterator protocol is never called. + throw() { + throw new Error("Unexpected call to |throw| method"); + } + } + + function LoggingProxy(obj, log) { + assert.sameValue(ArrayIsArray(log), true); + + let handler = new Proxy({ + get(t, pk, r) { + ReflectDefineProperty(log, log.length, { + value: pk, writable: true, enumerable: true, configurable: true, + }); + return ReflectGet(t, pk, r); + } + }, { + get(t, pk, r) { + ReflectDefineProperty(log, log.length, { + value: `[[${pk}]]`, writable: true, enumerable: true, configurable: true, + }); + return ReflectGet(t, pk, r); + } + }); + + return {obj, proxy: new Proxy(obj, handler)}; + } + global.LoggingProxy = LoggingProxy; +})(this); diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Temporal-PlainMonthDay-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Temporal-PlainMonthDay-shell.js new file mode 100644 index 000000000..1ffbf3a54 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-Temporal-PlainMonthDay-shell.js @@ -0,0 +1,48 @@ +/*--- +defines: [ISOFields, assertSameISOFields] +---*/ + +function ISOFields(monthDay) { + let re = /^(?-?\d{4,6})-(?\d{2})-(?\d{2})\[u-ca=(?[\w\-]+)\]$/; + + let str = monthDay.toString({calendarName: "always"}); + let match = str.match(re); + assert.sameValue(match !== null, true, `can't match: ${str}`); + + let {year, month, day, calendar} = match.groups; + let isoYear = Number(year); + let isoMonth = Number(month); + let isoDay = Number(day); + + let date = Temporal.PlainDate.from(str); + let isoDate = date.withCalendar("iso8601"); + + assert.sameValue(calendar, date.calendarId); + assert.sameValue(isoYear, isoDate.year); + assert.sameValue(isoMonth, isoDate.month); + assert.sameValue(isoDay, isoDate.day); + + return { + isoYear, + isoMonth, + isoDay, + calendar, + }; +} + +function assertSameISOFields(actual, expected) { + let actualFields = ISOFields(actual); + let expectedFields = ISOFields(expected); + + assert.sameValue(typeof actualFields.isoYear, "number"); + assert.sameValue(typeof actualFields.isoMonth, "number"); + assert.sameValue(typeof actualFields.isoDay, "number"); + + assert.sameValue(actualFields.isoMonth > 0, true); + assert.sameValue(actualFields.isoDay > 0, true); + + assert.sameValue(actualFields.isoYear, expectedFields.isoYear); + assert.sameValue(actualFields.isoMonth, expectedFields.isoMonth); + assert.sameValue(actualFields.isoDay, expectedFields.isoDay); + assert.sameValue(actualFields.calendar, expectedFields.calendar); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-TypedArray-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-TypedArray-shell.js new file mode 100644 index 000000000..c8bd8b90e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-TypedArray-shell.js @@ -0,0 +1,131 @@ +/*--- +defines: [typedArrayConstructors, sharedTypedArrayConstructors, anyTypedArrayConstructors, isSharedConstructor, isFloatConstructor, isUnsignedConstructor] +---*/ +(function(global) { + "use strict"; + + const { + Float16Array, Float32Array, Float64Array, Object, Reflect, SharedArrayBuffer, WeakMap, + } = global; + const { + apply: Reflect_apply, + construct: Reflect_construct, + } = Reflect; + const { + get: WeakMap_prototype_get, + has: WeakMap_prototype_has, + } = WeakMap.prototype; + + const sharedConstructors = new WeakMap(); + + // Synthesize a constructor for a shared memory array from the constructor + // for unshared memory. This has "good enough" fidelity for many uses. In + // cases where it's not good enough, call isSharedConstructor for local + // workarounds. + function sharedConstructor(baseConstructor) { + // Create SharedTypedArray as a subclass of %TypedArray%, following the + // built-in %TypedArray% subclasses. + class SharedTypedArray extends Object.getPrototypeOf(baseConstructor) { + constructor(...args) { + var array = Reflect_construct(baseConstructor, args); + var {buffer, byteOffset, length} = array; + var sharedBuffer = new SharedArrayBuffer(buffer.byteLength); + var sharedArray = Reflect_construct(baseConstructor, + [sharedBuffer, byteOffset, length], + new.target); + for (var i = 0; i < length; i++) + sharedArray[i] = array[i]; + assert.sameValue(sharedArray.buffer, sharedBuffer); + return sharedArray; + } + } + + // 22.2.5.1 TypedArray.BYTES_PER_ELEMENT + Object.defineProperty(SharedTypedArray, "BYTES_PER_ELEMENT", + {__proto__: null, value: baseConstructor.BYTES_PER_ELEMENT}); + + // 22.2.6.1 TypedArray.prototype.BYTES_PER_ELEMENT + Object.defineProperty(SharedTypedArray.prototype, "BYTES_PER_ELEMENT", + {__proto__: null, value: baseConstructor.BYTES_PER_ELEMENT}); + + // Share the same name with the base constructor to avoid calling + // isSharedConstructor() in multiple places. + Object.defineProperty(SharedTypedArray, "name", + {__proto__: null, value: baseConstructor.name}); + + sharedConstructors.set(SharedTypedArray, baseConstructor); + + return SharedTypedArray; + } + + /** + * All TypedArray constructors for unshared memory. + */ + const typedArrayConstructors = Object.freeze([ + Int8Array, + Uint8Array, + Uint8ClampedArray, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ].concat(Float16Array ?? [])); + + /** + * All TypedArray constructors for shared memory. + */ + const sharedTypedArrayConstructors = Object.freeze( + typeof SharedArrayBuffer === "function" + ? typedArrayConstructors.map(sharedConstructor) + : [] + ); + + /** + * All TypedArray constructors for unshared and shared memory. + */ + const anyTypedArrayConstructors = Object.freeze([ + ...typedArrayConstructors, ...sharedTypedArrayConstructors, + ]); + + /** + * Returns `true` if `constructor` is a TypedArray constructor for shared + * memory. + */ + function isSharedConstructor(constructor) { + return Reflect_apply(WeakMap_prototype_has, sharedConstructors, [constructor]); + } + + /** + * Returns `true` if `constructor` is a TypedArray constructor for shared + * or unshared memory, with an underlying element type of one of Float16, Float32 + * or Float64. + */ + function isFloatConstructor(constructor) { + if (isSharedConstructor(constructor)) + constructor = Reflect_apply(WeakMap_prototype_get, sharedConstructors, [constructor]); + return constructor == Float32Array || constructor == Float64Array || (Float16Array && constructor == Float16Array); + } + + /** + * Returns `true` if `constructor` is a TypedArray constructor for shared + * or unshared memory, with an underlying element type of one of Uint8, + * Uint8Clamped, Uint16, or Uint32. + */ + function isUnsignedConstructor(constructor) { + if (isSharedConstructor(constructor)) + constructor = Reflect_apply(WeakMap_prototype_get, sharedConstructors, [constructor]); + return constructor == Uint8Array || + constructor == Uint8ClampedArray || + constructor == Uint16Array || + constructor == Uint32Array; + } + + global.typedArrayConstructors = typedArrayConstructors; + global.sharedTypedArrayConstructors = sharedTypedArrayConstructors; + global.anyTypedArrayConstructors = anyTypedArrayConstructors; + global.isSharedConstructor = isSharedConstructor; + global.isFloatConstructor = isFloatConstructor; + global.isUnsignedConstructor = isUnsignedConstructor; +})(this); diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-expressions-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-expressions-shell.js new file mode 100644 index 000000000..e8f584e1b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-expressions-shell.js @@ -0,0 +1,190 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/*--- +defines: [testDestructuringArrayDefault] +---*/ + +(function(global) { + function func() { + } + class C { + foo() { + } + static foo() { + } + } + + function test_one(pattern, val, opt) { + var stmts = []; + var i = 0; + var c; + + stmts.push(`var ${pattern} = ${val};`); + + for (var stmt of stmts) { + if (!opt.no_plain) { + eval(` +${stmt} +`); + } + + if (!opt.no_func) { + eval(` +function f${i}() { + ${stmt} +} +f${i}(); +`); + i++; + + eval(` +var f${i} = function foo() { + ${stmt} +}; +f${i}(); +`); + i++; + + eval(` +var f${i} = () => { + ${stmt} +}; +f${i}(); +`); + i++; + } + + if (!opt.no_gen) { + eval(` +function* g${i}() { + ${stmt} +} +[...g${i}()]; +`); + i++; + + eval(` +var g${i} = function* foo() { + ${stmt} +}; +[...g${i}()]; +`); + i++; + } + + if (!opt.no_ctor) { + eval(` +class D${i} { + constructor() { + ${stmt} + } +} +new D${i}(); +`); + i++; + } + + if (!opt.no_derived_ctor) { + if (opt.no_pre_super) { + eval(` +class D${i} extends C { + constructor() { + ${stmt} + try { super(); } catch (e) {} + } +} +new D${i}(); +`); + i++; + } else { + eval(` +class D${i} extends C { + constructor() { + super(); + ${stmt} + } +} +new D${i}(); +`); + i++; + } + } + + if (!opt.no_method) { + eval(` +class D${i} extends C { + method() { + ${stmt} + } + static staticMethod() { + ${stmt} + } +} +new D${i}().method(); +D${i}.staticMethod(); +`); + i++; + } + } + + if (!opt.no_func_arg) { + eval(` +function f${i}(${pattern}) {} +f${i}(${val}); +`); + i++; + + eval(` +var f${i} = function foo(${pattern}) {}; +f${i}(${val}); +`); + i++; + + eval(` +var f${i} = (${pattern}) => {}; +f${i}(${val}); +`); + i++; + } + + if (!opt.no_gen_arg) { + eval(` +function* g${i}(${pattern}) {} +[...g${i}(${val})]; +`); + i++; + + eval(` +var g${i} = function* foo(${pattern}) {}; +[...g${i}(${val})]; +`); + i++; + } + } + + function test(expr, opt={}) { + var pattern = `[a=${expr}, ...c]`; + test_one(pattern, "[]", opt); + test_one(pattern, "[1]", opt); + + pattern = `[,a=${expr}]`; + test_one(pattern, "[]", opt); + test_one(pattern, "[1]", opt); + test_one(pattern, "[1, 2]", opt); + + pattern = `[{x: [a=${expr}]}]`; + test_one(pattern, "[{x: [1]}]", opt); + + pattern = `[x=[a=${expr}]=[]]`; + test_one(pattern, "[]", opt); + test_one(pattern, "[1]", opt); + + pattern = `[x=[a=${expr}]=[1]]`; + test_one(pattern, "[]", opt); + test_one(pattern, "[1]", opt); + } + + global.testDestructuringArrayDefault = test; +})(this); diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-generators-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-generators-shell.js new file mode 100644 index 000000000..24a666ae3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-generators-shell.js @@ -0,0 +1,17 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +/*--- +defines: [assertIteratorResult, assertIteratorNext, assertIteratorDone] +---*/ + +function assertIteratorResult(result, value, done) { + assert.sameValue(result.value, value); + assert.sameValue(result.done, done); +} +function assertIteratorNext(iter, value) { + assertIteratorResult(iter.next(), value, false); +} +function assertIteratorDone(iter, value) { + assertIteratorResult(iter.next(), value, true); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-strict-shell.js b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-strict-shell.js new file mode 100644 index 000000000..68bddea67 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sm/non262-strict-shell.js @@ -0,0 +1,98 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/*--- +defines: [completesNormally, raisesException, testLenientAndStrict, parsesSuccessfully, parseRaisesException, returns] +---*/ +(function(global) { + + /* + * completesNormally(CODE) returns true if evaluating CODE (as eval + * code) completes normally (rather than throwing an exception). + */ + globalThis.completesNormally = function completesNormally(code) { + try { + eval(code); + return true; + } catch (exception) { + return false; + } + } + + /* + * raisesException(EXCEPTION)(CODE) returns true if evaluating CODE (as + * eval code) throws an exception object that is an instance of EXCEPTION, + * and returns false if it throws any other error or evaluates + * successfully. For example: raises(TypeError)("0()") == true. + */ + globalThis.raisesException = function raisesException(exception) { + return function (code) { + try { + eval(code); + return false; + } catch (actual) { + return actual instanceof exception; + } + }; + }; + + /* + * Return true if both of these return true: + * - LENIENT_PRED applied to CODE + * - STRICT_PRED applied to CODE with a use strict directive added to the front + * + * Run STRICT_PRED first, for testing code that affects the global environment + * in loose mode, but fails in strict mode. + */ + global.testLenientAndStrict = function testLenientAndStrict(code, lenient_pred, strict_pred) { + return (strict_pred("'use strict'; " + code) && + lenient_pred(code)); + } + + /* + * parsesSuccessfully(CODE) returns true if CODE parses as function + * code without an error. + */ + global.parsesSuccessfully = function parsesSuccessfully(code) { + try { + Function(code); + return true; + } catch (exception) { + return false; + } + }; + + /* + * parseRaisesException(EXCEPTION)(CODE) returns true if parsing CODE + * as function code raises EXCEPTION. + */ + global.parseRaisesException = function parseRaisesException(exception) { + return function (code) { + try { + Function(code); + return false; + } catch (actual) { + return exception.prototype.isPrototypeOf(actual); + } + }; + }; + + /* + * returns(VALUE)(CODE) returns true if evaluating CODE (as eval code) + * completes normally (rather than throwing an exception), yielding a value + * strictly equal to VALUE. + */ + global.returns = function returns(value) { + return function(code) { + try { + return eval(code) === value; + } catch (exception) { + return false; + } + } + } + +})(this); diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/sta.js b/crates/clazel-js-lexer/tests/data/test262/harness/sta.js new file mode 100644 index 000000000..c95ed7a26 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/sta.js @@ -0,0 +1,27 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Provides both: + + - An error class to avoid false positives when testing for thrown exceptions + - A function to explicitly throw an exception using the Test262Error class +defines: [Test262Error, $DONOTEVALUATE] +---*/ + + +function Test262Error(message) { + this.message = message || ""; +} + +Test262Error.prototype.toString = function () { + return "Test262Error: " + this.message; +}; + +Test262Error.thrower = function (message) { + throw new Test262Error(message); +}; + +function $DONOTEVALUATE() { + throw "Test262: This statement should not be evaluated."; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/tcoHelper.js b/crates/clazel-js-lexer/tests/data/test262/harness/tcoHelper.js new file mode 100644 index 000000000..070ce764b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/tcoHelper.js @@ -0,0 +1,14 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + This defines the number of consecutive recursive function calls that must be + made in order to prove that stack frames are properly destroyed according to + ES2015 tail call optimization semantics. +defines: [$MAX_ITERATIONS] +---*/ + + + + +var $MAX_ITERATIONS = 100000; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/temporalHelpers.js b/crates/clazel-js-lexer/tests/data/test262/harness/temporalHelpers.js new file mode 100644 index 000000000..fb2d3a3fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/temporalHelpers.js @@ -0,0 +1,1268 @@ +// Copyright (C) 2021 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + This defines helper objects and functions for testing Temporal. +defines: [TemporalHelpers] +features: [Symbol.species, Symbol.iterator, Temporal] +---*/ + +const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u; + +function formatPropertyName(propertyKey, objectName = "") { + switch (typeof propertyKey) { + case "symbol": + if (Symbol.keyFor(propertyKey) !== undefined) { + return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`; + } else if (propertyKey.description.startsWith("Symbol.")) { + return `${objectName}[${propertyKey.description}]`; + } else { + return `${objectName}[Symbol('${propertyKey.description}')]`; + } + case "string": + if (propertyKey !== String(Number(propertyKey))) { + if (ASCII_IDENTIFIER.test(propertyKey)) { + return objectName ? `${objectName}.${propertyKey}` : propertyKey; + } + return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`; + } + // fall through + default: + // integer or string integer-index + return `${objectName}[${propertyKey}]`; + } +} + +const SKIP_SYMBOL = Symbol("Skip"); + +var TemporalHelpers = { + /* + * Codes and maximum lengths of months in the ISO 8601 calendar. + */ + ISOMonths: [ + { month: 1, monthCode: "M01", daysInMonth: 31 }, + { month: 2, monthCode: "M02", daysInMonth: 29 }, + { month: 3, monthCode: "M03", daysInMonth: 31 }, + { month: 4, monthCode: "M04", daysInMonth: 30 }, + { month: 5, monthCode: "M05", daysInMonth: 31 }, + { month: 6, monthCode: "M06", daysInMonth: 30 }, + { month: 7, monthCode: "M07", daysInMonth: 31 }, + { month: 8, monthCode: "M08", daysInMonth: 31 }, + { month: 9, monthCode: "M09", daysInMonth: 30 }, + { month: 10, monthCode: "M10", daysInMonth: 31 }, + { month: 11, monthCode: "M11", daysInMonth: 30 }, + { month: 12, monthCode: "M12", daysInMonth: 31 } + ], + + /* + * List of known calendar eras and their possible aliases. + * + * https://tc39.es/proposal-intl-era-monthcode/#table-eras + */ + CalendarEras: { + buddhist: [ + { era: "be" }, + ], + coptic: [ + { era: "am" }, + ], + ethiopic: [ + { era: "aa" }, + { era: "am" }, + ], + ethioaa: [ + { era: "aa" }, + ], + gregory: [ + { era: "bce", aliases: ["bc"] }, + { era: "ce", aliases: ["ad"] }, + ], + hebrew: [ + { era: "am" }, + ], + indian: [ + { era: "shaka" }, + ], + "islamic-civil": [ + { era: "bh" }, + { era: "ah" }, + ], + "islamic-tbla": [ + { era: "bh" }, + { era: "ah" }, + ], + "islamic-umalqura": [ + { era: "bh" }, + { era: "ah" }, + ], + japanese: [ + { era: "bce", aliases: ["bc"] }, + { era: "ce", aliases: ["ad"] }, + { era: "heisei" }, + { era: "meiji" }, + { era: "reiwa" }, + { era: "showa" }, + { era: "taisho" }, + ], + persian: [ + { era: "ap" }, + ], + roc: [ + { era: "roc" }, + { era: "broc" }, + ], + }, + + /* + * Return the canonical era code. + */ + canonicalizeCalendarEra(calendarId, eraName) { + assert.sameValue(typeof calendarId, "string", "calendar must be string in canonicalizeCalendarEra"); + + if (!Object.prototype.hasOwnProperty.call(TemporalHelpers.CalendarEras, calendarId)) { + assert.sameValue(eraName, undefined); + return undefined; + } + + assert.sameValue(typeof eraName, "string", "eraName must be string or undefined in canonicalizeCalendarEra"); + + for (let {era, aliases = []} of TemporalHelpers.CalendarEras[calendarId]) { + if (era === eraName || aliases.includes(eraName)) { + return era; + } + } + throw new Test262Error(`Unsupported era name: ${eraName}`); + }, + + /* + * assertDuration(duration, years, ..., nanoseconds[, description]): + * + * Shorthand for asserting that each field of a Temporal.Duration is equal to + * an expected value. + */ + assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") { + const prefix = description ? `${description}: ` : ""; + assert(duration instanceof Temporal.Duration, `${prefix}instanceof`); + assert.sameValue(duration.years, years, `${prefix}years result:`); + assert.sameValue(duration.months, months, `${prefix}months result:`); + assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`); + assert.sameValue(duration.days, days, `${prefix}days result:`); + assert.sameValue(duration.hours, hours, `${prefix}hours result:`); + assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`); + assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`); + assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`); + assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`); + assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`); + }, + + /* + * assertDateDuration(duration, years, months, weeks, days, [, description]): + * + * Shorthand for asserting that each date field of a Temporal.Duration is + * equal to an expected value. + */ + assertDateDuration(duration, years, months, weeks, days, description = "") { + const prefix = description ? `${description}: ` : ""; + assert(duration instanceof Temporal.Duration, `${prefix}instanceof`); + assert.sameValue(duration.years, years, `${prefix}years result:`); + assert.sameValue(duration.months, months, `${prefix}months result:`); + assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`); + assert.sameValue(duration.days, days, `${prefix}days result:`); + assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`); + assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`); + assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`); + assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`); + assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`); + assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`); + }, + + /* + * assertDurationsEqual(actual, expected[, description]): + * + * Shorthand for asserting that each field of a Temporal.Duration is equal to + * the corresponding field in another Temporal.Duration. + */ + assertDurationsEqual(actual, expected, description = "") { + const prefix = description ? `${description}: ` : ""; + assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`); + TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description); + }, + + /* + * assertInstantsEqual(actual, expected[, description]): + * + * Shorthand for asserting that two Temporal.Instants are of the correct type + * and equal according to their equals() methods. + */ + assertInstantsEqual(actual, expected, description = "") { + const prefix = description ? `${description}: ` : ""; + assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`); + assert(actual instanceof Temporal.Instant, `${prefix}instanceof`); + assert(actual.equals(expected), `${prefix}equals method`); + }, + + /* + * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]): + * + * Shorthand for asserting that each field of a Temporal.PlainDate is equal to + * an expected value. (Except the `calendar` property, since callers may want + * to assert either object equality with an object they put in there, or the + * value of date.calendarId.) + */ + assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) { + const prefix = description ? `${description}: ` : ""; + assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`); + assert.sameValue( + TemporalHelpers.canonicalizeCalendarEra(date.calendarId, date.era), + TemporalHelpers.canonicalizeCalendarEra(date.calendarId, era), + `${prefix}era result:` + ); + assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`); + assert.sameValue(date.year, year, `${prefix}year result:`); + assert.sameValue(date.month, month, `${prefix}month result:`); + assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`); + assert.sameValue(date.day, day, `${prefix}day result:`); + }, + + /* + * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]): + * + * Shorthand for asserting that each field of a Temporal.PlainDateTime is + * equal to an expected value. (Except the `calendar` property, since callers + * may want to assert either object equality with an object they put in there, + * or the value of datetime.calendarId.) + */ + assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) { + const prefix = description ? `${description}: ` : ""; + assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`); + assert.sameValue( + TemporalHelpers.canonicalizeCalendarEra(datetime.calendarId, datetime.era), + TemporalHelpers.canonicalizeCalendarEra(datetime.calendarId, era), + `${prefix}era result:` + ); + assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`); + assert.sameValue(datetime.year, year, `${prefix}year result:`); + assert.sameValue(datetime.month, month, `${prefix}month result:`); + assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`); + assert.sameValue(datetime.day, day, `${prefix}day result:`); + assert.sameValue(datetime.hour, hour, `${prefix}hour result:`); + assert.sameValue(datetime.minute, minute, `${prefix}minute result:`); + assert.sameValue(datetime.second, second, `${prefix}second result:`); + assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`); + assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`); + assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`); + }, + + /* + * assertPlainDatesEqual(actual, expected[, description]): + * + * Shorthand for asserting that two Temporal.PlainDates are of the correct + * type, equal according to their equals() methods, and additionally that + * their calendar internal slots are the same value. + */ + assertPlainDatesEqual(actual, expected, description = "") { + const prefix = description ? `${description}: ` : ""; + assert(expected instanceof Temporal.PlainDate, `${prefix}expected value should be a Temporal.PlainDate`); + assert(actual instanceof Temporal.PlainDate, `${prefix}instanceof`); + assert(actual.equals(expected), `${prefix}equals method`); + assert.sameValue( + actual.calendarId, + expected.calendarId, + `${prefix}calendar same value:` + ); + }, + + /* + * assertPlainDateTimesEqual(actual, expected[, description]): + * + * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct + * type, equal according to their equals() methods, and additionally that + * their calendar internal slots are the same value. + */ + assertPlainDateTimesEqual(actual, expected, description = "") { + const prefix = description ? `${description}: ` : ""; + assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`); + assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`); + assert(actual.equals(expected), `${prefix}equals method`); + assert.sameValue( + actual.calendarId, + expected.calendarId, + `${prefix}calendar same value:` + ); + }, + + /* + * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]): + * + * Shorthand for asserting that each field of a Temporal.PlainMonthDay is + * equal to an expected value. (Except the `calendar` property, since callers + * may want to assert either object equality with an object they put in there, + * or the value of monthDay.calendarId().) + */ + assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) { + const prefix = description ? `${description}: ` : ""; + assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`); + assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`); + assert.sameValue(monthDay.day, day, `${prefix}day result:`); + const isoYear = Number(monthDay.toString({ calendarName: "always" }).split("-")[0]); + assert.sameValue(isoYear, referenceISOYear, `${prefix}referenceISOYear result:`); + }, + + /* + * assertPlainTime(time, hour, ..., nanosecond[, description]): + * + * Shorthand for asserting that each field of a Temporal.PlainTime is equal to + * an expected value. + */ + assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") { + const prefix = description ? `${description}: ` : ""; + assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`); + assert.sameValue(time.hour, hour, `${prefix}hour result:`); + assert.sameValue(time.minute, minute, `${prefix}minute result:`); + assert.sameValue(time.second, second, `${prefix}second result:`); + assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`); + assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`); + assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`); + }, + + /* + * assertPlainTimesEqual(actual, expected[, description]): + * + * Shorthand for asserting that two Temporal.PlainTimes are of the correct + * type and equal according to their equals() methods. + */ + assertPlainTimesEqual(actual, expected, description = "") { + const prefix = description ? `${description}: ` : ""; + assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`); + assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`); + assert(actual.equals(expected), `${prefix}equals method`); + }, + + /* + * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]): + * + * Shorthand for asserting that each field of a Temporal.PlainYearMonth is + * equal to an expected value. (Except the `calendar` property, since callers + * may want to assert either object equality with an object they put in there, + * or the value of yearMonth.calendarId.) + * + * Pass null as the referenceISODay if you don't want to give it explicitly. + * In that case, the expected referenceISODay will be computed using PlainDate + * and only verified for consistency, not for equality with a specific value. + */ + assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) { + const prefix = description ? `${description}: ` : ""; + assert(typeof referenceISODay === "number" || referenceISODay === null, + `TemporalHelpers.assertPlainYearMonth() referenceISODay argument should be a number or null, not ${referenceISODay}`); + assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`); + assert.sameValue( + TemporalHelpers.canonicalizeCalendarEra(yearMonth.calendarId, yearMonth.era), + TemporalHelpers.canonicalizeCalendarEra(yearMonth.calendarId, era), + `${prefix}era result:` + ); + assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`); + assert.sameValue(yearMonth.year, year, `${prefix}year result:`); + assert.sameValue(yearMonth.month, month, `${prefix}month result:`); + assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`); + const isoDay = Number(yearMonth.toString({ calendarName: "always" }).slice(1).split("-")[2].slice(0, 2)); + const expectedISODay = referenceISODay ?? yearMonth.toPlainDate({ day: 1 }).withCalendar("iso8601").day; + assert.sameValue(isoDay, expectedISODay, `${prefix}referenceISODay result:`); + }, + + /* + * assertZonedDateTimesEqual(actual, expected[, description]): + * + * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct + * type, equal according to their equals() methods, and additionally that + * their time zones and calendar internal slots are the same value. + */ + assertZonedDateTimesEqual(actual, expected, description = "") { + const prefix = description ? `${description}: ` : ""; + assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`); + assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`); + assert(actual.equals(expected), `${prefix}equals method`); + assert.sameValue(actual.timeZoneId, expected.timeZoneId, `${prefix}time zone same value:`); + assert.sameValue( + actual.calendarId, + expected.calendarId, + `${prefix}calendar same value:` + ); + }, + + /* + * assertUnreachable(description): + * + * Helper for asserting that code is not executed. + */ + assertUnreachable(description) { + let message = "This code should not be executed"; + if (description) { + message = `${message}: ${description}`; + } + throw new Test262Error(message); + }, + + /* + * checkPlainDateTimeConversionFastPath(func): + * + * ToTemporalDate and ToTemporalTime should both, if given a + * Temporal.PlainDateTime instance, convert to the desired type by reading the + * PlainDateTime's internal slots, rather than calling any getters. + * + * func(datetime) is the actual operation to test, that must + * internally call the abstract operation ToTemporalDate or ToTemporalTime. + * It is passed a Temporal.PlainDateTime instance. + */ + checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") { + const actual = []; + const expected = []; + + const calendar = "iso8601"; + const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar); + const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype); + ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => { + Object.defineProperty(datetime, property, { + get() { + actual.push(`get ${formatPropertyName(property)}`); + const value = prototypeDescrs[property].get.call(this); + return { + toString() { + actual.push(`toString ${formatPropertyName(property)}`); + return value.toString(); + }, + valueOf() { + actual.push(`valueOf ${formatPropertyName(property)}`); + return value; + }, + }; + }, + }); + }); + Object.defineProperty(datetime, "calendar", { + get() { + actual.push("get calendar"); + return calendar; + }, + }); + + func(datetime); + assert.compareArray(actual, expected, `${message}: property getters not called`); + }, + + /* + * Check that an options bag that accepts units written in the singular form, + * also accepts the same units written in the plural form. + * func(unit) should call the method with the appropriate options bag + * containing unit as a value. This will be called twice for each element of + * validSingularUnits, once with singular and once with plural, and the + * results of each pair should be the same (whether a Temporal object or a + * primitive value.) + */ + checkPluralUnitsAccepted(func, validSingularUnits) { + const plurals = { + year: "years", + month: "months", + week: "weeks", + day: "days", + hour: "hours", + minute: "minutes", + second: "seconds", + millisecond: "milliseconds", + microsecond: "microseconds", + nanosecond: "nanoseconds", + }; + + validSingularUnits.forEach((unit) => { + const singularValue = func(unit); + const pluralValue = func(plurals[unit]); + const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`; + if (singularValue instanceof Temporal.Duration) { + TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc); + } else if (singularValue instanceof Temporal.Instant) { + TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc); + } else if (singularValue instanceof Temporal.PlainDateTime) { + TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc); + } else if (singularValue instanceof Temporal.PlainTime) { + TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc); + } else if (singularValue instanceof Temporal.ZonedDateTime) { + TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc); + } else { + assert.sameValue(pluralValue, singularValue); + } + }); + }, + + /* + * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc): + * + * Checks the type handling of the roundingIncrement option. + * checkFunc(roundingIncrement) is a function which takes the value of + * roundingIncrement to test, and calls the method under test with it, + * returning the result. assertTrueResultFunc(result, description) should + * assert that result is the expected result with roundingIncrement: true, and + * assertObjectResultFunc(result, description) should assert that result is + * the expected result with roundingIncrement being an object with a valueOf() + * method. + */ + checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) { + // null converts to 0, which is out of range + assert.throws(RangeError, () => checkFunc(null), "null"); + // Booleans convert to either 0 or 1, and 1 is allowed + const trueResult = checkFunc(true); + assertTrueResultFunc(trueResult, "true"); + assert.throws(RangeError, () => checkFunc(false), "false"); + // Symbols and BigInts cannot convert to numbers + assert.throws(TypeError, () => checkFunc(Symbol()), "symbol"); + assert.throws(TypeError, () => checkFunc(2n), "bigint"); + + // Objects prefer their valueOf() methods when converting to a number + assert.throws(RangeError, () => checkFunc({}), "plain object"); + + const expected = [ + "get roundingIncrement.valueOf", + "call roundingIncrement.valueOf", + ]; + const actual = []; + const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement"); + const objectResult = checkFunc(observer); + assertObjectResultFunc(objectResult, "object with valueOf"); + assert.compareArray(actual, expected, "order of operations"); + }, + + /* + * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc): + * + * Checks the type handling of a string option, of which there are several in + * Temporal. + * propertyName is the name of the option, and value is the value that + * assertFunc should expect it to have. + * checkFunc(value) is a function which takes the value of the option to test, + * and calls the method under test with it, returning the result. + * assertFunc(result, description) should assert that result is the expected + * result with the option value being an object with a toString() method + * which returns the given value. + */ + checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) { + // null converts to the string "null", which is an invalid string value + assert.throws(RangeError, () => checkFunc(null), "null"); + // Booleans convert to the strings "true" or "false", which are invalid + assert.throws(RangeError, () => checkFunc(true), "true"); + assert.throws(RangeError, () => checkFunc(false), "false"); + // Symbols cannot convert to strings + assert.throws(TypeError, () => checkFunc(Symbol()), "symbol"); + // Numbers convert to strings which are invalid + assert.throws(RangeError, () => checkFunc(2), "number"); + // BigInts convert to strings which are invalid + assert.throws(RangeError, () => checkFunc(2n), "bigint"); + + // Objects prefer their toString() methods when converting to a string + assert.throws(RangeError, () => checkFunc({}), "plain object"); + + const expected = [ + `get ${propertyName}.toString`, + `call ${propertyName}.toString`, + ]; + const actual = []; + const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName); + const result = checkFunc(observer); + assertFunc(result, "object with toString"); + assert.compareArray(actual, expected, "order of operations"); + }, + + /* + * checkSubclassingIgnored(construct, constructArgs, method, methodArgs, + * resultAssertions): + * + * Methods of Temporal classes that return a new instance of the same class, + * must not take the constructor of a subclass into account, nor the @@species + * property. This helper runs tests to ensure this. + * + * construct(...constructArgs) must yield a valid instance of the Temporal + * class. instance[method](...methodArgs) is the method call under test, which + * must also yield a valid instance of the same Temporal class, not a + * subclass. See below for the individual tests that this runs. + * resultAssertions() is a function that performs additional assertions on the + * instance returned by the method under test. + */ + checkSubclassingIgnored(...args) { + this.checkSubclassConstructorNotObject(...args); + this.checkSubclassConstructorUndefined(...args); + this.checkSubclassConstructorThrows(...args); + this.checkSubclassConstructorNotCalled(...args); + this.checkSubclassSpeciesInvalidResult(...args); + this.checkSubclassSpeciesNotAConstructor(...args); + this.checkSubclassSpeciesNull(...args); + this.checkSubclassSpeciesUndefined(...args); + this.checkSubclassSpeciesThrows(...args); + }, + + /* + * Checks that replacing the 'constructor' property of the instance with + * various primitive values does not affect the returned new instance. + */ + checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) { + function check(value, description) { + const instance = new construct(...constructArgs); + instance.constructor = value; + const result = instance[method](...methodArgs); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description); + resultAssertions(result); + } + + check(null, "null"); + check(true, "true"); + check("test", "string"); + check(Symbol(), "Symbol"); + check(7, "number"); + check(7n, "bigint"); + }, + + /* + * Checks that replacing the 'constructor' property of the subclass with + * undefined does not affect the returned new instance. + */ + checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) { + let called = 0; + + class MySubclass extends construct { + constructor() { + ++called; + super(...constructArgs); + } + } + + const instance = new MySubclass(); + assert.sameValue(called, 1); + + MySubclass.prototype.constructor = undefined; + + const result = instance[method](...methodArgs); + assert.sameValue(called, 1); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype); + resultAssertions(result); + }, + + /* + * Checks that making the 'constructor' property of the instance throw when + * called does not affect the returned new instance. + */ + checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) { + function CustomError() {} + const instance = new construct(...constructArgs); + Object.defineProperty(instance, "constructor", { + get() { + throw new CustomError(); + } + }); + const result = instance[method](...methodArgs); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype); + resultAssertions(result); + }, + + /* + * Checks that when subclassing, the subclass constructor is not called by + * the method under test. + */ + checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) { + let called = 0; + + class MySubclass extends construct { + constructor() { + ++called; + super(...constructArgs); + } + } + + const instance = new MySubclass(); + assert.sameValue(called, 1); + + const result = instance[method](...methodArgs); + assert.sameValue(called, 1); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype); + resultAssertions(result); + }, + + /* + * Check that the constructor's @@species property is ignored when it's a + * constructor that returns a non-object value. + */ + checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) { + function check(value, description) { + const instance = new construct(...constructArgs); + instance.constructor = { + [Symbol.species]: function() { + return value; + }, + }; + const result = instance[method](...methodArgs); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description); + resultAssertions(result); + } + + check(undefined, "undefined"); + check(null, "null"); + check(true, "true"); + check("test", "string"); + check(Symbol(), "Symbol"); + check(7, "number"); + check(7n, "bigint"); + check({}, "plain object"); + }, + + /* + * Check that the constructor's @@species property is ignored when it's not a + * constructor. + */ + checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) { + function check(value, description) { + const instance = new construct(...constructArgs); + instance.constructor = { + [Symbol.species]: value, + }; + const result = instance[method](...methodArgs); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description); + resultAssertions(result); + } + + check(true, "true"); + check("test", "string"); + check(Symbol(), "Symbol"); + check(7, "number"); + check(7n, "bigint"); + check({}, "plain object"); + }, + + /* + * Check that the constructor's @@species property is ignored when it's null. + */ + checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) { + let called = 0; + + class MySubclass extends construct { + constructor() { + ++called; + super(...constructArgs); + } + } + + const instance = new MySubclass(); + assert.sameValue(called, 1); + + MySubclass.prototype.constructor = { + [Symbol.species]: null, + }; + + const result = instance[method](...methodArgs); + assert.sameValue(called, 1); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype); + resultAssertions(result); + }, + + /* + * Check that the constructor's @@species property is ignored when it's + * undefined. + */ + checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) { + let called = 0; + + class MySubclass extends construct { + constructor() { + ++called; + super(...constructArgs); + } + } + + const instance = new MySubclass(); + assert.sameValue(called, 1); + + MySubclass.prototype.constructor = { + [Symbol.species]: undefined, + }; + + const result = instance[method](...methodArgs); + assert.sameValue(called, 1); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype); + resultAssertions(result); + }, + + /* + * Check that the constructor's @@species property is ignored when it throws, + * i.e. it is not called at all. + */ + checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) { + function CustomError() {} + + const instance = new construct(...constructArgs); + instance.constructor = { + get [Symbol.species]() { + throw new CustomError(); + }, + }; + + const result = instance[method](...methodArgs); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype); + }, + + /* + * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions): + * + * Static methods of Temporal classes that return a new instance of the class, + * must not use the this-value as a constructor. This helper runs tests to + * ensure this. + * + * construct[method](...methodArgs) is the static method call under test, and + * must yield a valid instance of the Temporal class, not a subclass. See + * below for the individual tests that this runs. + * resultAssertions() is a function that performs additional assertions on the + * instance returned by the method under test. + */ + checkSubclassingIgnoredStatic(...args) { + this.checkStaticInvalidReceiver(...args); + this.checkStaticReceiverNotCalled(...args); + this.checkThisValueNotCalled(...args); + }, + + /* + * Check that calling the static method with a receiver that's not callable, + * still calls the intrinsic constructor. + */ + checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) { + function check(value, description) { + const result = construct[method].apply(value, methodArgs); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype); + resultAssertions(result); + } + + check(undefined, "undefined"); + check(null, "null"); + check(true, "true"); + check("test", "string"); + check(Symbol(), "symbol"); + check(7, "number"); + check(7n, "bigint"); + check({}, "Non-callable object"); + }, + + /* + * Check that calling the static method with a receiver that returns a value + * that's not callable, still calls the intrinsic constructor. + */ + checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) { + function check(value, description) { + const receiver = function () { + return value; + }; + const result = construct[method].apply(receiver, methodArgs); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype); + resultAssertions(result); + } + + check(undefined, "undefined"); + check(null, "null"); + check(true, "true"); + check("test", "string"); + check(Symbol(), "symbol"); + check(7, "number"); + check(7n, "bigint"); + check({}, "Non-callable object"); + }, + + /* + * Check that the receiver isn't called. + */ + checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) { + let called = false; + + class MySubclass extends construct { + constructor(...args) { + called = true; + super(...args); + } + } + + const result = MySubclass[method](...methodArgs); + assert.sameValue(called, false); + assert.sameValue(Object.getPrototypeOf(result), construct.prototype); + resultAssertions(result); + }, + + /* + * Check that any calendar-carrying Temporal object has its [[Calendar]] + * internal slot read by ToTemporalCalendar, and does not fetch the calendar + * by calling getters. + */ + checkToTemporalCalendarFastPath(func) { + const plainDate = new Temporal.PlainDate(2000, 5, 2, "iso8601"); + const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, "iso8601"); + const plainMonthDay = new Temporal.PlainMonthDay(5, 2, "iso8601"); + const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, "iso8601"); + const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", "iso8601"); + + [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => { + Object.defineProperty(temporalObject, "calendar", { + get() { + throw new Test262Error("should not get 'calendar' property"); + }, + }); + Object.defineProperty(temporalObject, "calendarId", { + get() { + throw new Test262Error("should not get 'calendarId' property"); + }, + }); + + func(temporalObject); + }); + }, + + checkToTemporalInstantFastPath(func) { + const actual = []; + const expected = []; + + const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC"); + Object.defineProperty(datetime, "toString", { + get() { + actual.push("get toString"); + return function (options) { + actual.push("call toString"); + return Temporal.ZonedDateTime.prototype.toString.call(this, options); + }; + }, + }); + + func(datetime); + assert.compareArray(actual, expected, "toString not called"); + }, + + checkToTemporalPlainDateTimeFastPath(func) { + const actual = []; + const expected = []; + + const date = new Temporal.PlainDate(2000, 5, 2, "iso8601"); + const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype); + ["year", "month", "monthCode", "day"].forEach((property) => { + Object.defineProperty(date, property, { + get() { + actual.push(`get ${formatPropertyName(property)}`); + const value = prototypeDescrs[property].get.call(this); + return TemporalHelpers.toPrimitiveObserver(actual, value, property); + }, + }); + }); + ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => { + Object.defineProperty(date, property, { + get() { + actual.push(`get ${formatPropertyName(property)}`); + return undefined; + }, + }); + }); + Object.defineProperty(date, "calendar", { + get() { + actual.push("get calendar"); + return "iso8601"; + }, + }); + + func(date); + assert.compareArray(actual, expected, "property getters not called"); + }, + + /* + * observeProperty(calls, object, propertyName, value): + * + * Defines an own property @object.@propertyName with value @value, that + * will log any calls to its accessors to the array @calls. + */ + observeProperty(calls, object, propertyName, value, objectName = "") { + Object.defineProperty(object, propertyName, { + get() { + calls.push(`get ${formatPropertyName(propertyName, objectName)}`); + return value; + }, + set() { + calls.push(`set ${formatPropertyName(propertyName, objectName)}`); + } + }); + }, + + /* + * observeMethod(calls, object, propertyName, value): + * + * Defines an own property @object.@propertyName with value @value, that + * will log any calls of @value to the array @calls. + */ + observeMethod(calls, object, propertyName, objectName = "") { + const method = object[propertyName]; + object[propertyName] = function () { + calls.push(`call ${formatPropertyName(propertyName, objectName)}`); + return method.apply(object, arguments); + }; + }, + + /* + * Used for substituteMethod to indicate default behavior instead of a + * substituted value + */ + SUBSTITUTE_SKIP: SKIP_SYMBOL, + + /* + * substituteMethod(object, propertyName, values): + * + * Defines an own property @object.@propertyName that will, for each + * subsequent call to the method previously defined as + * @object.@propertyName: + * - Call the method, if no more values remain + * - Call the method, if the value in @values for the corresponding call + * is SUBSTITUTE_SKIP + * - Otherwise, return the corresponding value in @value + */ + substituteMethod(object, propertyName, values) { + let calls = 0; + const method = object[propertyName]; + object[propertyName] = function () { + if (calls >= values.length) { + return method.apply(object, arguments); + } else if (values[calls] === SKIP_SYMBOL) { + calls++; + return method.apply(object, arguments); + } else { + return values[calls++]; + } + }; + }, + + /* + * propertyBagObserver(): + * Returns an object that behaves like the given propertyBag but tracks Get + * and Has operations on any of its properties, by appending messages to an + * array. If the value of a property in propertyBag is a primitive, the value + * of the returned object's property will additionally be a + * TemporalHelpers.toPrimitiveObserver that will track calls to its toString + * and valueOf methods in the same array. This is for the purpose of testing + * order of operations that are observable from user code. objectName is used + * in the log. + * If skipToPrimitive is given, it must be an array of property keys. Those + * properties will not have a TemporalHelpers.toPrimitiveObserver returned, + * and instead just be returned directly. + */ + propertyBagObserver(calls, propertyBag, objectName, skipToPrimitive) { + return new Proxy(propertyBag, { + ownKeys(target) { + calls.push(`ownKeys ${objectName}`); + return Reflect.ownKeys(target); + }, + getOwnPropertyDescriptor(target, key) { + calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`); + return Reflect.getOwnPropertyDescriptor(target, key); + }, + get(target, key, receiver) { + calls.push(`get ${formatPropertyName(key, objectName)}`); + const result = Reflect.get(target, key, receiver); + if (result === undefined) { + return undefined; + } + if ((result !== null && typeof result === "object") || typeof result === "function") { + return result; + } + if (skipToPrimitive && skipToPrimitive.indexOf(key) >= 0) { + return result; + } + return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`); + }, + has(target, key) { + calls.push(`has ${formatPropertyName(key, objectName)}`); + return Reflect.has(target, key); + }, + }); + }, + + /* + * Returns an object that will append logs of any Gets or Calls of its valueOf + * or toString properties to the array calls. Both valueOf and toString will + * return the actual primitiveValue. propertyName is used in the log. + */ + toPrimitiveObserver(calls, primitiveValue, propertyName) { + return { + get valueOf() { + calls.push(`get ${propertyName}.valueOf`); + return function () { + calls.push(`call ${propertyName}.valueOf`); + return primitiveValue; + }; + }, + get toString() { + calls.push(`get ${propertyName}.toString`); + return function () { + calls.push(`call ${propertyName}.toString`); + if (primitiveValue === undefined) return undefined; + return primitiveValue.toString(); + }; + }, + }; + }, + + /* + * An object containing further methods that return arrays of ISO strings, for + * testing parsers. + */ + ISO: { + /* + * PlainMonthDay strings that are not valid. + */ + plainMonthDayStringsInvalid() { + return [ + "11-18junk", + "11-18[u-ca=gregory]", + "11-18[u-ca=hebrew]", + "11-18[U-CA=iso8601]", + "11-18[u-CA=iso8601]", + "11-18[FOO=bar]", + "-999999-01-01[u-ca=gregory]", + "-999999-01-01[u-ca=chinese]", + "+999999-01-01[u-ca=gregory]", + "+999999-01-01[u-ca=chinese]", + ]; + }, + + /* + * PlainMonthDay strings that are valid and that should produce October 1st. + */ + plainMonthDayStringsValid() { + return [ + "10-01", + "1001", + "1965-10-01", + "1976-10-01T152330.1+00:00", + "19761001T15:23:30.1+00:00", + "1976-10-01T15:23:30.1+0000", + "1976-10-01T152330.1+0000", + "19761001T15:23:30.1+0000", + "19761001T152330.1+00:00", + "19761001T152330.1+0000", + "+001976-10-01T152330.1+00:00", + "+0019761001T15:23:30.1+00:00", + "+001976-10-01T15:23:30.1+0000", + "+001976-10-01T152330.1+0000", + "+0019761001T15:23:30.1+0000", + "+0019761001T152330.1+00:00", + "+0019761001T152330.1+0000", + "1976-10-01T15:23:00", + "1976-10-01T15:23", + "1976-10-01T15", + "1976-10-01", + "--10-01", + "--1001", + "-999999-10-01", + "-999999-10-01[u-ca=iso8601]", + "+999999-10-01", + "+999999-10-01[u-ca=iso8601]", + ]; + }, + + /* + * PlainTime strings that may be mistaken for PlainMonthDay or + * PlainYearMonth strings, and so require a time designator. + */ + plainTimeStringsAmbiguous() { + const ambiguousStrings = [ + "2021-12", // ambiguity between YYYY-MM and HHMM-UU + "2021-12[-12:00]", // ditto, TZ does not disambiguate + "1214", // ambiguity between MMDD and HHMM + "0229", // ditto, including MMDD that doesn't occur every year + "1130", // ditto, including DD that doesn't occur in every month + "12-14", // ambiguity between MM-DD and HH-UU + "12-14[-14:00]", // ditto, TZ does not disambiguate + "202112", // ambiguity between YYYYMM and HHMMSS + "202112[UTC]", // ditto, TZ does not disambiguate + ]; + // Adding a calendar annotation to one of these strings must not cause + // disambiguation in favour of time. + const stringsWithCalendar = ambiguousStrings.map((s) => s + "[u-ca=iso8601]"); + return ambiguousStrings.concat(stringsWithCalendar); + }, + + /* + * PlainTime strings that are of similar form to PlainMonthDay and + * PlainYearMonth strings, but are not ambiguous due to components that + * aren't valid as months or days. + */ + plainTimeStringsUnambiguous() { + return [ + "2021-13", // 13 is not a month + "202113", // ditto + "2021-13[-13:00]", // ditto + "202113[-13:00]", // ditto + "0000-00", // 0 is not a month + "000000", // ditto + "0000-00[UTC]", // ditto + "000000[UTC]", // ditto + "1314", // 13 is not a month + "13-14", // ditto + "1232", // 32 is not a day + "0230", // 30 is not a day in February + "0631", // 31 is not a day in June + "0000", // 0 is neither a month nor a day + "00-00", // ditto + ]; + }, + + /* + * PlainYearMonth-like strings that are not valid. + */ + plainYearMonthStringsInvalid() { + return [ + "2020-13", + "1976-11[u-ca=gregory]", + "1976-11[u-ca=hebrew]", + "1976-11[U-CA=iso8601]", + "1976-11[u-CA=iso8601]", + "1976-11[FOO=bar]", + "+999999-01", + "-999999-01", + ]; + }, + + /* + * PlainYearMonth-like strings that are valid and should produce November + * 1976 in the ISO 8601 calendar. + */ + plainYearMonthStringsValid() { + return [ + "1976-11", + "1976-11-10", + "1976-11-01T09:00:00+00:00", + "1976-11-01T00:00:00+05:00", + "197611", + "+00197611", + "1976-11-18T15:23:30.1-02:00", + "1976-11-18T152330.1+00:00", + "19761118T15:23:30.1+00:00", + "1976-11-18T15:23:30.1+0000", + "1976-11-18T152330.1+0000", + "19761118T15:23:30.1+0000", + "19761118T152330.1+00:00", + "19761118T152330.1+0000", + "+001976-11-18T152330.1+00:00", + "+0019761118T15:23:30.1+00:00", + "+001976-11-18T15:23:30.1+0000", + "+001976-11-18T152330.1+0000", + "+0019761118T15:23:30.1+0000", + "+0019761118T152330.1+00:00", + "+0019761118T152330.1+0000", + "1976-11-18T15:23", + "1976-11-18T15", + "1976-11-18", + ]; + }, + + /* + * PlainYearMonth-like strings that are valid and should produce November of + * the ISO year -9999. + */ + plainYearMonthStringsValidNegativeYear() { + return [ + "-009999-11", + ]; + }, + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/testAtomics.js b/crates/clazel-js-lexer/tests/data/test262/harness/testAtomics.js new file mode 100644 index 000000000..cf605445c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/testAtomics.js @@ -0,0 +1,123 @@ +// Copyright (C) 2017 Mozilla Corporation. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Collection of functions used to assert the correctness of SharedArrayBuffer objects. +defines: + - testWithAtomicsOutOfBoundsIndices + - testWithAtomicsInBoundsIndices + - testWithAtomicsNonViewValues +---*/ + + +/** + * Calls the provided function for a each bad index that should throw a + * RangeError when passed to an Atomics method on a SAB-backed view where + * index 125 is out of range. + * + * @param f - the function to call for each bad index. + */ +function testWithAtomicsOutOfBoundsIndices(f) { + var bad_indices = [ + function(view) { return -1; }, + function(view) { return view.length; }, + function(view) { return view.length * 2; }, + function(view) { return Number.POSITIVE_INFINITY; }, + function(view) { return Number.NEGATIVE_INFINITY; }, + function(view) { return { valueOf: function() { return 125; } }; }, + function(view) { return { toString: function() { return '125'; }, valueOf: false }; }, // non-callable valueOf triggers invocation of toString + ]; + + for (var i = 0; i < bad_indices.length; ++i) { + var IdxGen = bad_indices[i]; + try { + f(IdxGen); + } catch (e) { + e.message += ' (Testing with index gen ' + IdxGen + '.)'; + throw e; + } + } +} + +/** + * Calls the provided function for each good index that should not throw when + * passed to an Atomics method on a SAB-backed view. + * + * The view must have length greater than zero. + * + * @param f - the function to call for each good index. + */ +function testWithAtomicsInBoundsIndices(f) { + // Most of these are eventually coerced to +0 by ToIndex. + var good_indices = [ + function(view) { return 0/-1; }, + function(view) { return '-0'; }, + function(view) { return undefined; }, + function(view) { return NaN; }, + function(view) { return 0.5; }, + function(view) { return '0.5'; }, + function(view) { return -0.9; }, + function(view) { return { password: 'qumquat' }; }, + function(view) { return view.length - 1; }, + function(view) { return { valueOf: function() { return 0; } }; }, + function(view) { return { toString: function() { return '0'; }, valueOf: false }; }, // non-callable valueOf triggers invocation of toString + ]; + + for (var i = 0; i < good_indices.length; ++i) { + var IdxGen = good_indices[i]; + try { + f(IdxGen); + } catch (e) { + e.message += ' (Testing with index gen ' + IdxGen + '.)'; + throw e; + } + } +} + +/** + * Calls the provided function for each value that should throw a TypeError + * when passed to an Atomics method as a view. + * + * @param f - the function to call for each non-view value. + */ + +function testWithAtomicsNonViewValues(f) { + var values = [ + null, + undefined, + true, + false, + new Boolean(true), + 10, + 3.14, + new Number(4), + 'Hi there', + new Date, + /a*utomaton/g, + { password: 'qumquat' }, + new DataView(new ArrayBuffer(10)), + new ArrayBuffer(128), + new SharedArrayBuffer(128), + new Error('Ouch'), + [1,1,2,3,5,8], + function(x) { return -x; }, + Symbol('halleluja'), + // TODO: Proxy? + Object, + Int32Array, + Date, + Math, + Atomics + ]; + + for (var i = 0; i < values.length; ++i) { + var nonView = values[i]; + try { + f(nonView); + } catch (e) { + e.message += ' (Testing with non-view value ' + nonView + '.)'; + throw e; + } + } +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/testIntl.js b/crates/clazel-js-lexer/tests/data/test262/harness/testIntl.js new file mode 100644 index 000000000..ee4d43d98 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/testIntl.js @@ -0,0 +1,2781 @@ +// Copyright (C) 2011 2012 Norbert Lindenberg. All rights reserved. +// Copyright (C) 2012 2013 Mozilla Corporation. All rights reserved. +// Copyright (C) 2020 Apple Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + This file contains shared functions for the tests in the conformance test + suite for the ECMAScript Internationalization API. +author: Norbert Lindenberg +defines: + - testWithIntlConstructors + - taintDataProperty + - taintMethod + - taintProperties + - taintArray + - getLocaleSupportInfo + - getInvalidLanguageTags + - isCanonicalizedStructurallyValidLanguageTag + - getInvalidLocaleArguments + - testOption + - testForUnwantedRegExpChanges + - allCalendars + - allCollations + - allNumberingSystems + - isValidNumberingSystem + - numberingSystemDigits + - allSimpleSanctionedUnits + - testNumberFormat + - getDateTimeComponents + - getDateTimeComponentValues + - isCanonicalizedStructurallyValidTimeZoneName + - partitionDurationFormatPattern + - formatDurationFormatPattern +---*/ +/** + */ + + +/** + * @description Calls the provided function for every service constructor in + * the Intl object. + * @param {Function} f the function to call for each service constructor in + * the Intl object. + * @param {Function} Constructor the constructor object to test with. + */ +function testWithIntlConstructors(f) { + var constructors = ["Collator", "NumberFormat", "DateTimeFormat"]; + + // Optionally supported Intl constructors. + // NB: Intl.Locale isn't an Intl service constructor! + // Intl.DisplayNames cannot be called without type in options. + ["PluralRules", "RelativeTimeFormat", "ListFormat"].forEach(function(constructor) { + if (typeof Intl[constructor] === "function") { + constructors[constructors.length] = constructor; + } + }); + + constructors.forEach(function (constructor) { + var Constructor = Intl[constructor]; + try { + f(Constructor); + } catch (e) { + e.message += " (Testing with " + constructor + ".)"; + throw e; + } + }); +} + + +/** + * Taints a named data property of the given object by installing + * a setter that throws an exception. + * @param {object} obj the object whose data property to taint + * @param {string} property the property to taint + */ +function taintDataProperty(obj, property) { + Object.defineProperty(obj, property, { + set: function(value) { + throw new Test262Error("Client code can adversely affect behavior: setter for " + property + "."); + }, + enumerable: false, + configurable: true + }); +} + + +/** + * Taints a named method of the given object by replacing it with a function + * that throws an exception. + * @param {object} obj the object whose method to taint + * @param {string} property the name of the method to taint + */ +function taintMethod(obj, property) { + Object.defineProperty(obj, property, { + value: function() { + throw new Test262Error("Client code can adversely affect behavior: method " + property + "."); + }, + writable: true, + enumerable: false, + configurable: true + }); +} + + +/** + * Taints the given properties (and similarly named properties) by installing + * setters on Object.prototype that throw exceptions. + * @param {Array} properties an array of property names to taint + */ +function taintProperties(properties) { + properties.forEach(function (property) { + var adaptedProperties = [property, "__" + property, "_" + property, property + "_", property + "__"]; + adaptedProperties.forEach(function (property) { + taintDataProperty(Object.prototype, property); + }); + }); +} + + +/** + * Taints the Array object by creating a setter for the property "0" and + * replacing some key methods with functions that throw exceptions. + */ +function taintArray() { + taintDataProperty(Array.prototype, "0"); + taintMethod(Array.prototype, "indexOf"); + taintMethod(Array.prototype, "join"); + taintMethod(Array.prototype, "push"); + taintMethod(Array.prototype, "slice"); + taintMethod(Array.prototype, "sort"); +} + + +/** + * Gets locale support info for the given constructor object, which must be one + * of Intl constructors. + * @param {object} Constructor the constructor for which to get locale support info + * @param {object} options the options while calling the constructor + * @return {object} locale support info with the following properties: + * supported: array of fully supported language tags + * byFallback: array of language tags that are supported through fallbacks + * unsupported: array of unsupported language tags + */ +function getLocaleSupportInfo(Constructor, options) { + var languages = ["zh", "es", "en", "hi", "ur", "ar", "ja", "pa"]; + var scripts = ["Latn", "Hans", "Deva", "Arab", "Jpan", "Hant", "Guru"]; + var countries = ["CN", "IN", "US", "PK", "JP", "TW", "HK", "SG", "419"]; + + var allTags = []; + var i, j, k; + var language, script, country; + for (i = 0; i < languages.length; i++) { + language = languages[i]; + allTags.push(language); + for (j = 0; j < scripts.length; j++) { + script = scripts[j]; + allTags.push(language + "-" + script); + for (k = 0; k < countries.length; k++) { + country = countries[k]; + allTags.push(language + "-" + script + "-" + country); + } + } + for (k = 0; k < countries.length; k++) { + country = countries[k]; + allTags.push(language + "-" + country); + } + } + + var supported = []; + var byFallback = []; + var unsupported = []; + for (i = 0; i < allTags.length; i++) { + var request = allTags[i]; + var result = new Constructor([request], options).resolvedOptions().locale; + if (request === result) { + supported.push(request); + } else if (request.indexOf(result) === 0) { + byFallback.push(request); + } else { + unsupported.push(request); + } + } + + return { + supported: supported, + byFallback: byFallback, + unsupported: unsupported + }; +} + + +/** + * Returns an array of strings for which IsStructurallyValidLanguageTag() returns false + */ +function getInvalidLanguageTags() { + var invalidLanguageTags = [ + "", // empty tag + "i", // singleton alone + "x", // private use without subtag + "u", // extension singleton in first place + "419", // region code in first place + "u-nu-latn-cu-bob", // extension sequence without language + "hans-cmn-cn", // "hans" could theoretically be a 4-letter language code, + // but those can't be followed by extlang codes. + "cmn-hans-cn-u-u", // duplicate singleton + "cmn-hans-cn-t-u-ca-u", // duplicate singleton + "de-gregory-gregory", // duplicate variant + "*", // language range + "de-*", // language range + "中文", // non-ASCII letters + "en-ß", // non-ASCII letters + "ıd", // non-ASCII letters + "es-Latn-latn", // two scripts + "pl-PL-pl", // two regions + "u-ca-gregory", // extension in first place + "de-1996-1996", // duplicate numeric variant + "pt-u-ca-gregory-u-nu-latn", // duplicate singleton subtag + + // Invalid tags starting with: https://github.com/tc39/ecma402/pull/289 + "no-nyn", // regular grandfathered in BCP47, but invalid in UTS35 + "i-klingon", // irregular grandfathered in BCP47, but invalid in UTS35 + "zh-hak-CN", // language with extlang in BCP47, but invalid in UTS35 + "sgn-ils", // language with extlang in BCP47, but invalid in UTS35 + "x-foo", // privateuse-only in BCP47, but invalid in UTS35 + "x-en-US-12345", // more privateuse-only variants. + "x-12345-12345-en-US", + "x-en-US-12345-12345", + "x-en-u-foo", + "x-en-u-foo-u-bar", + "x-u-foo", + + // underscores in different parts of the language tag + "de_DE", + "DE_de", + "cmn_Hans", + "cmn-hans_cn", + "es_419", + "es-419-u-nu-latn-cu_bob", + "i_klingon", + "cmn-hans-cn-t-ca-u-ca-x_t-u", + "enochian_enochian", + "de-gregory_u-ca-gregory", + + "en\u0000", // null-terminator sequence + " en", // leading whitespace + "en ", // trailing whitespace + "it-IT-Latn", // country before script tag + "de-u", // incomplete Unicode extension sequences + "de-u-", + "de-u-ca-", + "de-u-ca-gregory-", + "si-x", // incomplete private-use tags + "x-", + "x-y-", + ]; + + // make sure the data above is correct + for (var i = 0; i < invalidLanguageTags.length; ++i) { + var invalidTag = invalidLanguageTags[i]; + assert( + !isCanonicalizedStructurallyValidLanguageTag(invalidTag), + "Test data \"" + invalidTag + "\" is a canonicalized and structurally valid language tag." + ); + } + + return invalidLanguageTags; +} + + +/** + * @description Tests whether locale is a String value representing a + * structurally valid and canonicalized BCP 47 language tag, as defined in + * sections 6.2.2 and 6.2.3 of the ECMAScript Internationalization API + * Specification. + * @param {String} locale the string to be tested. + * @result {Boolean} whether the test succeeded. + */ +function isCanonicalizedStructurallyValidLanguageTag(locale) { + + /** + * Regular expression defining Unicode BCP 47 Locale Identifiers. + * + * Spec: https://unicode.org/reports/tr35/#Unicode_locale_identifier + */ + var alpha = "[a-z]", + digit = "[0-9]", + alphanum = "[a-z0-9]", + variant = "(" + alphanum + "{5,8}|(?:" + digit + alphanum + "{3}))", + region = "(" + alpha + "{2}|" + digit + "{3})", + script = "(" + alpha + "{4})", + language = "(" + alpha + "{2,3}|" + alpha + "{5,8})", + privateuse = "(x(-[a-z0-9]{1,8})+)", + singleton = "(" + digit + "|[a-wy-z])", + attribute= "(" + alphanum + "{3,8})", + keyword = "(" + alphanum + alpha + "(-" + alphanum + "{3,8})*)", + unicode_locale_extensions = "(u((-" + keyword + ")+|((-" + attribute + ")+(-" + keyword + ")*)))", + tlang = "(" + language + "(-" + script + ")?(-" + region + ")?(-" + variant + ")*)", + tfield = "(" + alpha + digit + "(-" + alphanum + "{3,8})+)", + transformed_extensions = "(t((-" + tlang + "(-" + tfield + ")*)|(-" + tfield + ")+))", + other_singleton = "(" + digit + "|[a-sv-wy-z])", + other_extensions = "(" + other_singleton + "(-" + alphanum + "{2,8})+)", + extension = "(" + unicode_locale_extensions + "|" + transformed_extensions + "|" + other_extensions + ")", + locale_id = language + "(-" + script + ")?(-" + region + ")?(-" + variant + ")*(-" + extension + ")*(-" + privateuse + ")?", + languageTag = "^(" + locale_id + ")$", + languageTagRE = new RegExp(languageTag, "i"); + + var duplicateSingleton = "-" + singleton + "-(.*-)?\\1(?!" + alphanum + ")", + duplicateSingletonRE = new RegExp(duplicateSingleton, "i"), + duplicateVariant = "(" + alphanum + "{2,8}-)+" + variant + "-(" + alphanum + "{2,8}-)*\\2(?!" + alphanum + ")", + duplicateVariantRE = new RegExp(duplicateVariant, "i"); + + var transformKeyRE = new RegExp("^" + alpha + digit + "$", "i"); + + /** + * Verifies that the given string is a well-formed Unicode BCP 47 Locale Identifier + * with no duplicate variant or singleton subtags. + * + * Spec: ECMAScript Internationalization API Specification, draft, 6.2.2. + */ + function isStructurallyValidLanguageTag(locale) { + if (!languageTagRE.test(locale)) { + return false; + } + locale = locale.split(/-x-/)[0]; + return !duplicateSingletonRE.test(locale) && !duplicateVariantRE.test(locale); + } + + + /** + * Mappings from complete tags to preferred values. + * + * Spec: http://unicode.org/reports/tr35/#Identifiers + * Version: CLDR, version 36.1 + */ + var __tagMappings = { + // property names must be in lower case; values in canonical form + + "art-lojban": "jbo", + "cel-gaulish": "xtg", + "zh-guoyu": "zh", + "zh-hakka": "hak", + "zh-xiang": "hsn", + }; + + + /** + * Mappings from language subtags to preferred values. + * + * Spec: http://unicode.org/reports/tr35/#Identifiers + * Version: CLDR, version 36.1 + */ + var __languageMappings = { + // property names and values must be in canonical case + + "aam": "aas", + "aar": "aa", + "abk": "ab", + "adp": "dz", + "afr": "af", + "aju": "jrb", + "aka": "ak", + "alb": "sq", + "als": "sq", + "amh": "am", + "ara": "ar", + "arb": "ar", + "arg": "an", + "arm": "hy", + "asd": "snz", + "asm": "as", + "aue": "ktz", + "ava": "av", + "ave": "ae", + "aym": "ay", + "ayr": "ay", + "ayx": "nun", + "aze": "az", + "azj": "az", + "bak": "ba", + "bam": "bm", + "baq": "eu", + "bcc": "bal", + "bcl": "bik", + "bel": "be", + "ben": "bn", + "bgm": "bcg", + "bh": "bho", + "bih": "bho", + "bis": "bi", + "bjd": "drl", + "bod": "bo", + "bos": "bs", + "bre": "br", + "bul": "bg", + "bur": "my", + "bxk": "luy", + "bxr": "bua", + "cat": "ca", + "ccq": "rki", + "ces": "cs", + "cha": "ch", + "che": "ce", + "chi": "zh", + "chu": "cu", + "chv": "cv", + "cjr": "mom", + "cka": "cmr", + "cld": "syr", + "cmk": "xch", + "cmn": "zh", + "cor": "kw", + "cos": "co", + "coy": "pij", + "cqu": "quh", + "cre": "cr", + "cwd": "cr", + "cym": "cy", + "cze": "cs", + "dan": "da", + "deu": "de", + "dgo": "doi", + "dhd": "mwr", + "dik": "din", + "diq": "zza", + "dit": "dif", + "div": "dv", + "drh": "mn", + "dut": "nl", + "dzo": "dz", + "ekk": "et", + "ell": "el", + "emk": "man", + "eng": "en", + "epo": "eo", + "esk": "ik", + "est": "et", + "eus": "eu", + "ewe": "ee", + "fao": "fo", + "fas": "fa", + "fat": "ak", + "fij": "fj", + "fin": "fi", + "fra": "fr", + "fre": "fr", + "fry": "fy", + "fuc": "ff", + "ful": "ff", + "gav": "dev", + "gaz": "om", + "gbo": "grb", + "geo": "ka", + "ger": "de", + "gfx": "vaj", + "ggn": "gvr", + "gla": "gd", + "gle": "ga", + "glg": "gl", + "glv": "gv", + "gno": "gon", + "gre": "el", + "grn": "gn", + "gti": "nyc", + "gug": "gn", + "guj": "gu", + "guv": "duz", + "gya": "gba", + "hat": "ht", + "hau": "ha", + "hdn": "hai", + "hea": "hmn", + "heb": "he", + "her": "hz", + "him": "srx", + "hin": "hi", + "hmo": "ho", + "hrr": "jal", + "hrv": "hr", + "hun": "hu", + "hye": "hy", + "ibi": "opa", + "ibo": "ig", + "ice": "is", + "ido": "io", + "iii": "ii", + "ike": "iu", + "iku": "iu", + "ile": "ie", + "ilw": "gal", + "in": "id", + "ina": "ia", + "ind": "id", + "ipk": "ik", + "isl": "is", + "ita": "it", + "iw": "he", + "jav": "jv", + "jeg": "oyb", + "ji": "yi", + "jpn": "ja", + "jw": "jv", + "kal": "kl", + "kan": "kn", + "kas": "ks", + "kat": "ka", + "kau": "kr", + "kaz": "kk", + "kgc": "tdf", + "kgh": "kml", + "khk": "mn", + "khm": "km", + "kik": "ki", + "kin": "rw", + "kir": "ky", + "kmr": "ku", + "knc": "kr", + "kng": "kg", + "knn": "kok", + "koj": "kwv", + "kom": "kv", + "kon": "kg", + "kor": "ko", + "kpv": "kv", + "krm": "bmf", + "ktr": "dtp", + "kua": "kj", + "kur": "ku", + "kvs": "gdj", + "kwq": "yam", + "kxe": "tvd", + "kzj": "dtp", + "kzt": "dtp", + "lao": "lo", + "lat": "la", + "lav": "lv", + "lbk": "bnc", + "lii": "raq", + "lim": "li", + "lin": "ln", + "lit": "lt", + "llo": "ngt", + "lmm": "rmx", + "ltz": "lb", + "lub": "lu", + "lug": "lg", + "lvs": "lv", + "mac": "mk", + "mah": "mh", + "mal": "ml", + "mao": "mi", + "mar": "mr", + "may": "ms", + "meg": "cir", + "mhr": "chm", + "mkd": "mk", + "mlg": "mg", + "mlt": "mt", + "mnk": "man", + "mo": "ro", + "mol": "ro", + "mon": "mn", + "mri": "mi", + "msa": "ms", + "mst": "mry", + "mup": "raj", + "mwj": "vaj", + "mya": "my", + "myd": "aog", + "myt": "mry", + "nad": "xny", + "nau": "na", + "nav": "nv", + "nbl": "nr", + "ncp": "kdz", + "nde": "nd", + "ndo": "ng", + "nep": "ne", + "nld": "nl", + "nno": "nn", + "nns": "nbr", + "nnx": "ngv", + "no": "nb", + "nob": "nb", + "nor": "nb", + "npi": "ne", + "nts": "pij", + "nya": "ny", + "oci": "oc", + "ojg": "oj", + "oji": "oj", + "ori": "or", + "orm": "om", + "ory": "or", + "oss": "os", + "oun": "vaj", + "pan": "pa", + "pbu": "ps", + "pcr": "adx", + "per": "fa", + "pes": "fa", + "pli": "pi", + "plt": "mg", + "pmc": "huw", + "pmu": "phr", + "pnb": "lah", + "pol": "pl", + "por": "pt", + "ppa": "bfy", + "ppr": "lcq", + "pry": "prt", + "pus": "ps", + "puz": "pub", + "que": "qu", + "quz": "qu", + "rmy": "rom", + "roh": "rm", + "ron": "ro", + "rum": "ro", + "run": "rn", + "rus": "ru", + "sag": "sg", + "san": "sa", + "sca": "hle", + "scc": "sr", + "scr": "hr", + "sin": "si", + "skk": "oyb", + "slk": "sk", + "slo": "sk", + "slv": "sl", + "sme": "se", + "smo": "sm", + "sna": "sn", + "snd": "sd", + "som": "so", + "sot": "st", + "spa": "es", + "spy": "kln", + "sqi": "sq", + "src": "sc", + "srd": "sc", + "srp": "sr", + "ssw": "ss", + "sun": "su", + "swa": "sw", + "swe": "sv", + "swh": "sw", + "tah": "ty", + "tam": "ta", + "tat": "tt", + "tdu": "dtp", + "tel": "te", + "tgk": "tg", + "tgl": "fil", + "tha": "th", + "thc": "tpo", + "thx": "oyb", + "tib": "bo", + "tie": "ras", + "tir": "ti", + "tkk": "twm", + "tl": "fil", + "tlw": "weo", + "tmp": "tyj", + "tne": "kak", + "ton": "to", + "tsf": "taj", + "tsn": "tn", + "tso": "ts", + "ttq": "tmh", + "tuk": "tk", + "tur": "tr", + "tw": "ak", + "twi": "ak", + "uig": "ug", + "ukr": "uk", + "umu": "del", + "uok": "ema", + "urd": "ur", + "uzb": "uz", + "uzn": "uz", + "ven": "ve", + "vie": "vi", + "vol": "vo", + "wel": "cy", + "wln": "wa", + "wol": "wo", + "xba": "cax", + "xho": "xh", + "xia": "acn", + "xkh": "waw", + "xpe": "kpe", + "xsj": "suj", + "xsl": "den", + "ybd": "rki", + "ydd": "yi", + "yid": "yi", + "yma": "lrr", + "ymt": "mtm", + "yor": "yo", + "yos": "zom", + "yuu": "yug", + "zai": "zap", + "zha": "za", + "zho": "zh", + "zsm": "ms", + "zul": "zu", + "zyb": "za", + }; + + + /** + * Mappings from region subtags to preferred values. + * + * Spec: http://unicode.org/reports/tr35/#Identifiers + * Version: CLDR, version 36.1 + */ + var __regionMappings = { + // property names and values must be in canonical case + + "004": "AF", + "008": "AL", + "010": "AQ", + "012": "DZ", + "016": "AS", + "020": "AD", + "024": "AO", + "028": "AG", + "031": "AZ", + "032": "AR", + "036": "AU", + "040": "AT", + "044": "BS", + "048": "BH", + "050": "BD", + "051": "AM", + "052": "BB", + "056": "BE", + "060": "BM", + "062": "034", + "064": "BT", + "068": "BO", + "070": "BA", + "072": "BW", + "074": "BV", + "076": "BR", + "084": "BZ", + "086": "IO", + "090": "SB", + "092": "VG", + "096": "BN", + "100": "BG", + "104": "MM", + "108": "BI", + "112": "BY", + "116": "KH", + "120": "CM", + "124": "CA", + "132": "CV", + "136": "KY", + "140": "CF", + "144": "LK", + "148": "TD", + "152": "CL", + "156": "CN", + "158": "TW", + "162": "CX", + "166": "CC", + "170": "CO", + "174": "KM", + "175": "YT", + "178": "CG", + "180": "CD", + "184": "CK", + "188": "CR", + "191": "HR", + "192": "CU", + "196": "CY", + "203": "CZ", + "204": "BJ", + "208": "DK", + "212": "DM", + "214": "DO", + "218": "EC", + "222": "SV", + "226": "GQ", + "230": "ET", + "231": "ET", + "232": "ER", + "233": "EE", + "234": "FO", + "238": "FK", + "239": "GS", + "242": "FJ", + "246": "FI", + "248": "AX", + "249": "FR", + "250": "FR", + "254": "GF", + "258": "PF", + "260": "TF", + "262": "DJ", + "266": "GA", + "268": "GE", + "270": "GM", + "275": "PS", + "276": "DE", + "278": "DE", + "280": "DE", + "288": "GH", + "292": "GI", + "296": "KI", + "300": "GR", + "304": "GL", + "308": "GD", + "312": "GP", + "316": "GU", + "320": "GT", + "324": "GN", + "328": "GY", + "332": "HT", + "334": "HM", + "336": "VA", + "340": "HN", + "344": "HK", + "348": "HU", + "352": "IS", + "356": "IN", + "360": "ID", + "364": "IR", + "368": "IQ", + "372": "IE", + "376": "IL", + "380": "IT", + "384": "CI", + "388": "JM", + "392": "JP", + "398": "KZ", + "400": "JO", + "404": "KE", + "408": "KP", + "410": "KR", + "414": "KW", + "417": "KG", + "418": "LA", + "422": "LB", + "426": "LS", + "428": "LV", + "430": "LR", + "434": "LY", + "438": "LI", + "440": "LT", + "442": "LU", + "446": "MO", + "450": "MG", + "454": "MW", + "458": "MY", + "462": "MV", + "466": "ML", + "470": "MT", + "474": "MQ", + "478": "MR", + "480": "MU", + "484": "MX", + "492": "MC", + "496": "MN", + "498": "MD", + "499": "ME", + "500": "MS", + "504": "MA", + "508": "MZ", + "512": "OM", + "516": "NA", + "520": "NR", + "524": "NP", + "528": "NL", + "531": "CW", + "533": "AW", + "534": "SX", + "535": "BQ", + "540": "NC", + "548": "VU", + "554": "NZ", + "558": "NI", + "562": "NE", + "566": "NG", + "570": "NU", + "574": "NF", + "578": "NO", + "580": "MP", + "581": "UM", + "583": "FM", + "584": "MH", + "585": "PW", + "586": "PK", + "591": "PA", + "598": "PG", + "600": "PY", + "604": "PE", + "608": "PH", + "612": "PN", + "616": "PL", + "620": "PT", + "624": "GW", + "626": "TL", + "630": "PR", + "634": "QA", + "638": "RE", + "642": "RO", + "643": "RU", + "646": "RW", + "652": "BL", + "654": "SH", + "659": "KN", + "660": "AI", + "662": "LC", + "663": "MF", + "666": "PM", + "670": "VC", + "674": "SM", + "678": "ST", + "682": "SA", + "686": "SN", + "688": "RS", + "690": "SC", + "694": "SL", + "702": "SG", + "703": "SK", + "704": "VN", + "705": "SI", + "706": "SO", + "710": "ZA", + "716": "ZW", + "720": "YE", + "724": "ES", + "728": "SS", + "729": "SD", + "732": "EH", + "736": "SD", + "740": "SR", + "744": "SJ", + "748": "SZ", + "752": "SE", + "756": "CH", + "760": "SY", + "762": "TJ", + "764": "TH", + "768": "TG", + "772": "TK", + "776": "TO", + "780": "TT", + "784": "AE", + "788": "TN", + "792": "TR", + "795": "TM", + "796": "TC", + "798": "TV", + "800": "UG", + "804": "UA", + "807": "MK", + "818": "EG", + "826": "GB", + "830": "JE", + "831": "GG", + "832": "JE", + "833": "IM", + "834": "TZ", + "840": "US", + "850": "VI", + "854": "BF", + "858": "UY", + "860": "UZ", + "862": "VE", + "876": "WF", + "882": "WS", + "886": "YE", + "887": "YE", + "891": "RS", + "894": "ZM", + "958": "AA", + "959": "QM", + "960": "QN", + "962": "QP", + "963": "QQ", + "964": "QR", + "965": "QS", + "966": "QT", + "967": "EU", + "968": "QV", + "969": "QW", + "970": "QX", + "971": "QY", + "972": "QZ", + "973": "XA", + "974": "XB", + "975": "XC", + "976": "XD", + "977": "XE", + "978": "XF", + "979": "XG", + "980": "XH", + "981": "XI", + "982": "XJ", + "983": "XK", + "984": "XL", + "985": "XM", + "986": "XN", + "987": "XO", + "988": "XP", + "989": "XQ", + "990": "XR", + "991": "XS", + "992": "XT", + "993": "XU", + "994": "XV", + "995": "XW", + "996": "XX", + "997": "XY", + "998": "XZ", + "999": "ZZ", + "BU": "MM", + "CS": "RS", + "CT": "KI", + "DD": "DE", + "DY": "BJ", + "FQ": "AQ", + "FX": "FR", + "HV": "BF", + "JT": "UM", + "MI": "UM", + "NH": "VU", + "NQ": "AQ", + "PU": "UM", + "PZ": "PA", + "QU": "EU", + "RH": "ZW", + "TP": "TL", + "UK": "GB", + "VD": "VN", + "WK": "UM", + "YD": "YE", + "YU": "RS", + "ZR": "CD", + }; + + + /** + * Complex mappings from language subtags to preferred values. + * + * Spec: http://unicode.org/reports/tr35/#Identifiers + * Version: CLDR, version 36.1 + */ + var __complexLanguageMappings = { + // property names and values must be in canonical case + + "cnr": {language: "sr", region: "ME"}, + "drw": {language: "fa", region: "AF"}, + "hbs": {language: "sr", script: "Latn"}, + "prs": {language: "fa", region: "AF"}, + "sh": {language: "sr", script: "Latn"}, + "swc": {language: "sw", region: "CD"}, + "tnf": {language: "fa", region: "AF"}, + }; + + + /** + * Complex mappings from region subtags to preferred values. + * + * Spec: http://unicode.org/reports/tr35/#Identifiers + * Version: CLDR, version 36.1 + */ + var __complexRegionMappings = { + // property names and values must be in canonical case + + "172": { + default: "RU", + "ab": "GE", + "az": "AZ", + "be": "BY", + "crh": "UA", + "gag": "MD", + "got": "UA", + "hy": "AM", + "ji": "UA", + "ka": "GE", + "kaa": "UZ", + "kk": "KZ", + "ku-Yezi": "GE", + "ky": "KG", + "os": "GE", + "rue": "UA", + "sog": "UZ", + "tg": "TJ", + "tk": "TM", + "tkr": "AZ", + "tly": "AZ", + "ttt": "AZ", + "ug-Cyrl": "KZ", + "uk": "UA", + "und-Armn": "AM", + "und-Chrs": "UZ", + "und-Geor": "GE", + "und-Goth": "UA", + "und-Sogd": "UZ", + "und-Sogo": "UZ", + "und-Yezi": "GE", + "uz": "UZ", + "xco": "UZ", + "xmf": "GE", + }, + "200": { + default: "CZ", + "sk": "SK", + }, + "530": { + default: "CW", + "vic": "SX", + }, + "532": { + default: "CW", + "vic": "SX", + }, + "536": { + default: "SA", + "akk": "IQ", + "ckb": "IQ", + "ku-Arab": "IQ", + "mis": "IQ", + "syr": "IQ", + "und-Hatr": "IQ", + "und-Syrc": "IQ", + "und-Xsux": "IQ", + }, + "582": { + default: "FM", + "mh": "MH", + "pau": "PW", + }, + "810": { + default: "RU", + "ab": "GE", + "az": "AZ", + "be": "BY", + "crh": "UA", + "et": "EE", + "gag": "MD", + "got": "UA", + "hy": "AM", + "ji": "UA", + "ka": "GE", + "kaa": "UZ", + "kk": "KZ", + "ku-Yezi": "GE", + "ky": "KG", + "lt": "LT", + "ltg": "LV", + "lv": "LV", + "os": "GE", + "rue": "UA", + "sgs": "LT", + "sog": "UZ", + "tg": "TJ", + "tk": "TM", + "tkr": "AZ", + "tly": "AZ", + "ttt": "AZ", + "ug-Cyrl": "KZ", + "uk": "UA", + "und-Armn": "AM", + "und-Chrs": "UZ", + "und-Geor": "GE", + "und-Goth": "UA", + "und-Sogd": "UZ", + "und-Sogo": "UZ", + "und-Yezi": "GE", + "uz": "UZ", + "vro": "EE", + "xco": "UZ", + "xmf": "GE", + }, + "890": { + default: "RS", + "bs": "BA", + "hr": "HR", + "mk": "MK", + "sl": "SI", + }, + "AN": { + default: "CW", + "vic": "SX", + }, + "NT": { + default: "SA", + "akk": "IQ", + "ckb": "IQ", + "ku-Arab": "IQ", + "mis": "IQ", + "syr": "IQ", + "und-Hatr": "IQ", + "und-Syrc": "IQ", + "und-Xsux": "IQ", + }, + "PC": { + default: "FM", + "mh": "MH", + "pau": "PW", + }, + "SU": { + default: "RU", + "ab": "GE", + "az": "AZ", + "be": "BY", + "crh": "UA", + "et": "EE", + "gag": "MD", + "got": "UA", + "hy": "AM", + "ji": "UA", + "ka": "GE", + "kaa": "UZ", + "kk": "KZ", + "ku-Yezi": "GE", + "ky": "KG", + "lt": "LT", + "ltg": "LV", + "lv": "LV", + "os": "GE", + "rue": "UA", + "sgs": "LT", + "sog": "UZ", + "tg": "TJ", + "tk": "TM", + "tkr": "AZ", + "tly": "AZ", + "ttt": "AZ", + "ug-Cyrl": "KZ", + "uk": "UA", + "und-Armn": "AM", + "und-Chrs": "UZ", + "und-Geor": "GE", + "und-Goth": "UA", + "und-Sogd": "UZ", + "und-Sogo": "UZ", + "und-Yezi": "GE", + "uz": "UZ", + "vro": "EE", + "xco": "UZ", + "xmf": "GE", + }, + }; + + + /** + * Mappings from variant subtags to preferred values. + * + * Spec: http://unicode.org/reports/tr35/#Identifiers + * Version: CLDR, version 36.1 + */ + var __variantMappings = { + // property names and values must be in canonical case + + "aaland": {type: "region", replacement: "AX"}, + "arevela": {type: "language", replacement: "hy"}, + "arevmda": {type: "language", replacement: "hyw"}, + "heploc": {type: "variant", replacement: "alalc97"}, + "polytoni": {type: "variant", replacement: "polyton"}, + }; + + + /** + * Mappings from Unicode extension subtags to preferred values. + * + * Spec: http://unicode.org/reports/tr35/#Identifiers + * Version: CLDR, version 36.1 + */ + var __unicodeMappings = { + // property names and values must be in canonical case + + "ca": { + "ethiopic-amete-alem": "ethioaa", + "islamicc": "islamic-civil", + }, + "kb": { + "yes": "true", + }, + "kc": { + "yes": "true", + }, + "kh": { + "yes": "true", + }, + "kk": { + "yes": "true", + }, + "kn": { + "yes": "true", + }, + "ks": { + "primary": "level1", + "tertiary": "level3", + }, + "ms": { + "imperial": "uksystem", + }, + "rg": { + "cn11": "cnbj", + "cn12": "cntj", + "cn13": "cnhe", + "cn14": "cnsx", + "cn15": "cnmn", + "cn21": "cnln", + "cn22": "cnjl", + "cn23": "cnhl", + "cn31": "cnsh", + "cn32": "cnjs", + "cn33": "cnzj", + "cn34": "cnah", + "cn35": "cnfj", + "cn36": "cnjx", + "cn37": "cnsd", + "cn41": "cnha", + "cn42": "cnhb", + "cn43": "cnhn", + "cn44": "cngd", + "cn45": "cngx", + "cn46": "cnhi", + "cn50": "cncq", + "cn51": "cnsc", + "cn52": "cngz", + "cn53": "cnyn", + "cn54": "cnxz", + "cn61": "cnsn", + "cn62": "cngs", + "cn63": "cnqh", + "cn64": "cnnx", + "cn65": "cnxj", + "cz10a": "cz110", + "cz10b": "cz111", + "cz10c": "cz112", + "cz10d": "cz113", + "cz10e": "cz114", + "cz10f": "cz115", + "cz611": "cz663", + "cz612": "cz632", + "cz613": "cz633", + "cz614": "cz634", + "cz615": "cz635", + "cz621": "cz641", + "cz622": "cz642", + "cz623": "cz643", + "cz624": "cz644", + "cz626": "cz646", + "cz627": "cz647", + "czjc": "cz31", + "czjm": "cz64", + "czka": "cz41", + "czkr": "cz52", + "czli": "cz51", + "czmo": "cz80", + "czol": "cz71", + "czpa": "cz53", + "czpl": "cz32", + "czpr": "cz10", + "czst": "cz20", + "czus": "cz42", + "czvy": "cz63", + "czzl": "cz72", + "fra": "frges", + "frb": "frnaq", + "frc": "frara", + "frd": "frbfc", + "fre": "frbre", + "frf": "frcvl", + "frg": "frges", + "frh": "frcor", + "fri": "frbfc", + "frj": "fridf", + "frk": "frocc", + "frl": "frnaq", + "frm": "frges", + "frn": "frocc", + "fro": "frhdf", + "frp": "frnor", + "frq": "frnor", + "frr": "frpdl", + "frs": "frhdf", + "frt": "frnaq", + "fru": "frpac", + "frv": "frara", + "laxn": "laxs", + "lud": "lucl", + "lug": "luec", + "lul": "luca", + "mrnkc": "mr13", + "no23": "no50", + "nzn": "nzauk", + "nzs": "nzcan", + "omba": "ombj", + "omsh": "omsj", + "plds": "pl02", + "plkp": "pl04", + "pllb": "pl08", + "plld": "pl10", + "pllu": "pl06", + "plma": "pl12", + "plmz": "pl14", + "plop": "pl16", + "plpd": "pl20", + "plpk": "pl18", + "plpm": "pl22", + "plsk": "pl26", + "plsl": "pl24", + "plwn": "pl28", + "plwp": "pl30", + "plzp": "pl32", + "tteto": "tttob", + "ttrcm": "ttmrc", + "ttwto": "tttob", + "twkhq": "twkhh", + "twtnq": "twtnn", + "twtpq": "twnwt", + "twtxq": "twtxg", + }, + "sd": { + "cn11": "cnbj", + "cn12": "cntj", + "cn13": "cnhe", + "cn14": "cnsx", + "cn15": "cnmn", + "cn21": "cnln", + "cn22": "cnjl", + "cn23": "cnhl", + "cn31": "cnsh", + "cn32": "cnjs", + "cn33": "cnzj", + "cn34": "cnah", + "cn35": "cnfj", + "cn36": "cnjx", + "cn37": "cnsd", + "cn41": "cnha", + "cn42": "cnhb", + "cn43": "cnhn", + "cn44": "cngd", + "cn45": "cngx", + "cn46": "cnhi", + "cn50": "cncq", + "cn51": "cnsc", + "cn52": "cngz", + "cn53": "cnyn", + "cn54": "cnxz", + "cn61": "cnsn", + "cn62": "cngs", + "cn63": "cnqh", + "cn64": "cnnx", + "cn65": "cnxj", + "cz10a": "cz110", + "cz10b": "cz111", + "cz10c": "cz112", + "cz10d": "cz113", + "cz10e": "cz114", + "cz10f": "cz115", + "cz611": "cz663", + "cz612": "cz632", + "cz613": "cz633", + "cz614": "cz634", + "cz615": "cz635", + "cz621": "cz641", + "cz622": "cz642", + "cz623": "cz643", + "cz624": "cz644", + "cz626": "cz646", + "cz627": "cz647", + "czjc": "cz31", + "czjm": "cz64", + "czka": "cz41", + "czkr": "cz52", + "czli": "cz51", + "czmo": "cz80", + "czol": "cz71", + "czpa": "cz53", + "czpl": "cz32", + "czpr": "cz10", + "czst": "cz20", + "czus": "cz42", + "czvy": "cz63", + "czzl": "cz72", + "fra": "frges", + "frb": "frnaq", + "frc": "frara", + "frd": "frbfc", + "fre": "frbre", + "frf": "frcvl", + "frg": "frges", + "frh": "frcor", + "fri": "frbfc", + "frj": "fridf", + "frk": "frocc", + "frl": "frnaq", + "frm": "frges", + "frn": "frocc", + "fro": "frhdf", + "frp": "frnor", + "frq": "frnor", + "frr": "frpdl", + "frs": "frhdf", + "frt": "frnaq", + "fru": "frpac", + "frv": "frara", + "laxn": "laxs", + "lud": "lucl", + "lug": "luec", + "lul": "luca", + "mrnkc": "mr13", + "no23": "no50", + "nzn": "nzauk", + "nzs": "nzcan", + "omba": "ombj", + "omsh": "omsj", + "plds": "pl02", + "plkp": "pl04", + "pllb": "pl08", + "plld": "pl10", + "pllu": "pl06", + "plma": "pl12", + "plmz": "pl14", + "plop": "pl16", + "plpd": "pl20", + "plpk": "pl18", + "plpm": "pl22", + "plsk": "pl26", + "plsl": "pl24", + "plwn": "pl28", + "plwp": "pl30", + "plzp": "pl32", + "tteto": "tttob", + "ttrcm": "ttmrc", + "ttwto": "tttob", + "twkhq": "twkhh", + "twtnq": "twtnn", + "twtpq": "twnwt", + "twtxq": "twtxg", + }, + "tz": { + "aqams": "nzakl", + "cnckg": "cnsha", + "cnhrb": "cnsha", + "cnkhg": "cnurc", + "cuba": "cuhav", + "egypt": "egcai", + "eire": "iedub", + "est": "utcw05", + "gmt0": "gmt", + "hongkong": "hkhkg", + "hst": "utcw10", + "iceland": "isrey", + "iran": "irthr", + "israel": "jeruslm", + "jamaica": "jmkin", + "japan": "jptyo", + "libya": "lytip", + "mst": "utcw07", + "navajo": "usden", + "poland": "plwaw", + "portugal": "ptlis", + "prc": "cnsha", + "roc": "twtpe", + "rok": "krsel", + "turkey": "trist", + "uct": "utc", + "usnavajo": "usden", + "zulu": "utc", + }, + }; + + + /** + * Mappings from Unicode extension subtags to preferred values. + * + * Spec: http://unicode.org/reports/tr35/#Identifiers + * Version: CLDR, version 36.1 + */ + var __transformMappings = { + // property names and values must be in canonical case + + "d0": { + "name": "charname", + }, + "m0": { + "names": "prprname", + }, + }; + + /** + * Canonicalizes the given well-formed BCP 47 language tag, including regularized case of subtags. + * + * Spec: ECMAScript Internationalization API Specification, draft, 6.2.3. + * Spec: RFC 5646, section 4.5. + */ + function canonicalizeLanguageTag(locale) { + + // start with lower case for easier processing, and because most subtags will need to be lower case anyway + locale = locale.toLowerCase(); + + // handle mappings for complete tags + if (__tagMappings.hasOwnProperty(locale)) { + return __tagMappings[locale]; + } + + var subtags = locale.split("-"); + var i = 0; + + // handle standard part: all subtags before first variant or singleton subtag + var language; + var script; + var region; + while (i < subtags.length) { + var subtag = subtags[i]; + if (i === 0) { + language = subtag; + } else if (subtag.length === 2 || subtag.length === 3) { + region = subtag.toUpperCase(); + } else if (subtag.length === 4 && !("0" <= subtag[0] && subtag[0] <= "9")) { + script = subtag[0].toUpperCase() + subtag.substring(1).toLowerCase(); + } else { + break; + } + i++; + } + + if (__languageMappings.hasOwnProperty(language)) { + language = __languageMappings[language]; + } else if (__complexLanguageMappings.hasOwnProperty(language)) { + var mapping = __complexLanguageMappings[language]; + + language = mapping.language; + if (script === undefined && mapping.hasOwnProperty("script")) { + script = mapping.script; + } + if (region === undefined && mapping.hasOwnProperty("region")) { + region = mapping.region; + } + } + + if (region !== undefined) { + if (__regionMappings.hasOwnProperty(region)) { + region = __regionMappings[region]; + } else if (__complexRegionMappings.hasOwnProperty(region)) { + var mapping = __complexRegionMappings[region]; + + var mappingKey = language; + if (script !== undefined) { + mappingKey += "-" + script; + } + + if (mapping.hasOwnProperty(mappingKey)) { + region = mapping[mappingKey]; + } else { + region = mapping.default; + } + } + } + + // handle variants + var variants = []; + while (i < subtags.length && subtags[i].length > 1) { + var variant = subtags[i]; + + if (__variantMappings.hasOwnProperty(variant)) { + var mapping = __variantMappings[variant]; + switch (mapping.type) { + case "language": + language = mapping.replacement; + break; + + case "region": + region = mapping.replacement; + break; + + case "variant": + variants.push(mapping.replacement); + break; + + default: + throw new Error("illegal variant mapping type"); + } + } else { + variants.push(variant); + } + + i += 1; + } + variants.sort(); + + // handle extensions + var extensions = []; + while (i < subtags.length && subtags[i] !== "x") { + var extensionStart = i; + i++; + while (i < subtags.length && subtags[i].length > 1) { + i++; + } + + var extension; + var extensionKey = subtags[extensionStart]; + if (extensionKey === "u") { + var j = extensionStart + 1; + + // skip over leading attributes + while (j < i && subtags[j].length > 2) { + j++; + } + + extension = subtags.slice(extensionStart, j).join("-"); + + while (j < i) { + var keyStart = j; + j++; + + while (j < i && subtags[j].length > 2) { + j++; + } + + var key = subtags[keyStart]; + var value = subtags.slice(keyStart + 1, j).join("-"); + + if (__unicodeMappings.hasOwnProperty(key)) { + var mapping = __unicodeMappings[key]; + if (mapping.hasOwnProperty(value)) { + value = mapping[value]; + } + } + + extension += "-" + key; + if (value !== "" && value !== "true") { + extension += "-" + value; + } + } + } else if (extensionKey === "t") { + var j = extensionStart + 1; + + while (j < i && !transformKeyRE.test(subtags[j])) { + j++; + } + + extension = "t"; + + var transformLanguage = subtags.slice(extensionStart + 1, j).join("-"); + if (transformLanguage !== "") { + extension += "-" + canonicalizeLanguageTag(transformLanguage).toLowerCase(); + } + + while (j < i) { + var keyStart = j; + j++; + + while (j < i && subtags[j].length > 2) { + j++; + } + + var key = subtags[keyStart]; + var value = subtags.slice(keyStart + 1, j).join("-"); + + if (__transformMappings.hasOwnProperty(key)) { + var mapping = __transformMappings[key]; + if (mapping.hasOwnProperty(value)) { + value = mapping[value]; + } + } + + extension += "-" + key + "-" + value; + } + } else { + extension = subtags.slice(extensionStart, i).join("-"); + } + + extensions.push(extension); + } + extensions.sort(); + + // handle private use + var privateUse; + if (i < subtags.length) { + privateUse = subtags.slice(i).join("-"); + } + + // put everything back together + var canonical = language; + if (script !== undefined) { + canonical += "-" + script; + } + if (region !== undefined) { + canonical += "-" + region; + } + if (variants.length > 0) { + canonical += "-" + variants.join("-"); + } + if (extensions.length > 0) { + canonical += "-" + extensions.join("-"); + } + if (privateUse !== undefined) { + if (canonical.length > 0) { + canonical += "-" + privateUse; + } else { + canonical = privateUse; + } + } + + return canonical; + } + + return typeof locale === "string" && isStructurallyValidLanguageTag(locale) && + canonicalizeLanguageTag(locale) === locale; +} + + +/** + * Returns an array of error cases handled by CanonicalizeLocaleList(). + */ +function getInvalidLocaleArguments() { + function CustomError() {} + + var topLevelErrors = [ + // fails ToObject + [null, TypeError], + + // fails Get + [{ get length() { throw new CustomError(); } }, CustomError], + + // fail ToLength + [{ length: Symbol.toPrimitive }, TypeError], + [{ length: { get [Symbol.toPrimitive]() { throw new CustomError(); } } }, CustomError], + [{ length: { [Symbol.toPrimitive]() { throw new CustomError(); } } }, CustomError], + [{ length: { get valueOf() { throw new CustomError(); } } }, CustomError], + [{ length: { valueOf() { throw new CustomError(); } } }, CustomError], + [{ length: { get toString() { throw new CustomError(); } } }, CustomError], + [{ length: { toString() { throw new CustomError(); } } }, CustomError], + + // fail type check + [[undefined], TypeError], + [[null], TypeError], + [[true], TypeError], + [[Symbol.toPrimitive], TypeError], + [[1], TypeError], + [[0.1], TypeError], + [[NaN], TypeError], + ]; + + var invalidLanguageTags = [ + "", // empty tag + "i", // singleton alone + "x", // private use without subtag + "u", // extension singleton in first place + "419", // region code in first place + "u-nu-latn-cu-bob", // extension sequence without language + "hans-cmn-cn", // "hans" could theoretically be a 4-letter language code, + // but those can't be followed by extlang codes. + "abcdefghi", // overlong language + "cmn-hans-cn-u-u", // duplicate singleton + "cmn-hans-cn-t-u-ca-u", // duplicate singleton + "de-gregory-gregory", // duplicate variant + "*", // language range + "de-*", // language range + "中文", // non-ASCII letters + "en-ß", // non-ASCII letters + "ıd" // non-ASCII letters + ]; + + return topLevelErrors.concat( + invalidLanguageTags.map(tag => [tag, RangeError]), + invalidLanguageTags.map(tag => [[tag], RangeError]), + invalidLanguageTags.map(tag => [["en", tag], RangeError]), + ) +} + +/** + * Tests whether the named options property is correctly handled by the given constructor. + * @param {object} Constructor the constructor to test. + * @param {string} property the name of the options property to test. + * @param {string} type the type that values of the property are expected to have + * @param {Array} [values] an array of allowed values for the property. Not needed for boolean. + * @param {any} fallback the fallback value that the property assumes if not provided. + * @param {object} testOptions additional options: + * @param {boolean} isOptional whether support for this property is optional for implementations. + * @param {boolean} noReturn whether the resulting value of the property is not returned. + * @param {boolean} isILD whether the resulting value of the property is implementation and locale dependent. + * @param {object} extra additional option to pass along, properties are value -> {option: value}. + */ +function testOption(Constructor, property, type, values, fallback, testOptions) { + var isOptional = testOptions !== undefined && testOptions.isOptional === true; + var noReturn = testOptions !== undefined && testOptions.noReturn === true; + var isILD = testOptions !== undefined && testOptions.isILD === true; + + function addExtraOptions(options, value, testOptions) { + if (testOptions !== undefined && testOptions.extra !== undefined) { + var extra; + if (value !== undefined && testOptions.extra[value] !== undefined) { + extra = testOptions.extra[value]; + } else if (testOptions.extra.any !== undefined) { + extra = testOptions.extra.any; + } + if (extra !== undefined) { + Object.getOwnPropertyNames(extra).forEach(function (prop) { + options[prop] = extra[prop]; + }); + } + } + } + + var testValues, options, obj, expected, actual, error; + + // test that the specified values are accepted. Also add values that convert to specified values. + if (type === "boolean") { + if (values === undefined) { + values = [true, false]; + } + testValues = values.slice(0); + testValues.push(888); + testValues.push(0); + } else if (type === "string") { + testValues = values.slice(0); + testValues.push({toString: function () { return values[0]; }}); + } + testValues.forEach(function (value) { + options = {}; + options[property] = value; + addExtraOptions(options, value, testOptions); + obj = new Constructor(undefined, options); + if (noReturn) { + if (obj.resolvedOptions().hasOwnProperty(property)) { + throw new Test262Error("Option property " + property + " is returned, but shouldn't be."); + } + } else { + actual = obj.resolvedOptions()[property]; + if (isILD) { + if (actual !== undefined && values.indexOf(actual) === -1) { + throw new Test262Error("Invalid value " + actual + " returned for property " + property + "."); + } + } else { + if (type === "boolean") { + expected = Boolean(value); + } else if (type === "string") { + expected = String(value); + } + if (actual !== expected && !(isOptional && actual === undefined)) { + throw new Test262Error("Option value " + value + " for property " + property + + " was not accepted; got " + actual + " instead."); + } + } + } + }); + + // test that invalid values are rejected + if (type === "string") { + var invalidValues = ["invalidValue", -1, null]; + // assume that we won't have values in caseless scripts + if (values[0].toUpperCase() !== values[0]) { + invalidValues.push(values[0].toUpperCase()); + } else { + invalidValues.push(values[0].toLowerCase()); + } + invalidValues.forEach(function (value) { + options = {}; + options[property] = value; + addExtraOptions(options, value, testOptions); + error = undefined; + try { + obj = new Constructor(undefined, options); + } catch (e) { + error = e; + } + if (error === undefined) { + throw new Test262Error("Invalid option value " + value + " for property " + property + " was not rejected."); + } else if (error.name !== "RangeError") { + throw new Test262Error("Invalid option value " + value + " for property " + property + " was rejected with wrong error " + error.name + "."); + } + }); + } + + // test that fallback value or another valid value is used if no options value is provided + if (!noReturn) { + options = {}; + addExtraOptions(options, undefined, testOptions); + obj = new Constructor(undefined, options); + actual = obj.resolvedOptions()[property]; + if (!(isOptional && actual === undefined)) { + if (fallback !== undefined) { + if (actual !== fallback) { + throw new Test262Error("Option fallback value " + fallback + " for property " + property + + " was not used; got " + actual + " instead."); + } + } else { + if (values.indexOf(actual) === -1 && !(isILD && actual === undefined)) { + throw new Test262Error("Invalid value " + actual + " returned for property " + property + "."); + } + } + } + } +} + + +/** + * Properties of the RegExp constructor that may be affected by use of regular + * expressions, and the default values of these properties. Properties are from + * https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Deprecated_and_obsolete_features#RegExp_Properties + */ +var regExpProperties = ["$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$9", + "$_", "$*", "$&", "$+", "$`", "$'", + "input", "lastMatch", "lastParen", "leftContext", "rightContext" +]; + +var regExpPropertiesDefaultValues = (function () { + var values = Object.create(null); + (/(?:)/).test(""); + regExpProperties.forEach(function (property) { + values[property] = RegExp[property]; + }); + return values; +}()); + + +/** + * Tests that executing the provided function (which may use regular expressions + * in its implementation) does not create or modify unwanted properties on the + * RegExp constructor. + */ +function testForUnwantedRegExpChanges(testFunc) { + (/(?:)/).test(""); + testFunc(); + regExpProperties.forEach(function (property) { + if (RegExp[property] !== regExpPropertiesDefaultValues[property]) { + throw new Test262Error("RegExp has unexpected property " + property + " with value " + + RegExp[property] + "."); + } + }); +} + + +/** + * Returns an array of all known calendars. + */ +function allCalendars() { + // source: CLDR file common/bcp47/number.xml; version CLDR 39. + // https://github.com/unicode-org/cldr/blob/master/common/bcp47/calendar.xml + return [ + "buddhist", + "chinese", + "coptic", + "dangi", + "ethioaa", + "ethiopic", + "gregory", + "hebrew", + "indian", + "islamic", + "islamic-umalqura", + "islamic-tbla", + "islamic-civil", + "islamic-rgsa", + "iso8601", + "japanese", + "persian", + "roc", + ]; +} + + +/** + * Returns an array of all known collations. + */ +function allCollations() { + // source: CLDR file common/bcp47/collation.xml; version CLDR 39. + // https://github.com/unicode-org/cldr/blob/master/common/bcp47/collation.xml + return [ + "big5han", + "compat", + "dict", + "direct", + "ducet", + "emoji", + "eor", + "gb2312", + "phonebk", + "phonetic", + "pinyin", + "reformed", + "search", + "searchjl", + "standard", + "stroke", + "trad", + "unihan", + "zhuyin", + ]; +} + + +/** + * Returns an array of all known numbering systems. + */ +function allNumberingSystems() { + // source: CLDR file common/bcp47/number.xml; version CLDR 48 & new in Unicode 17.0 + // https://github.com/unicode-org/cldr/blob/master/common/bcp47/number.xml + return [ + "adlm", + "ahom", + "arab", + "arabext", + "armn", + "armnlow", + "bali", + "beng", + "bhks", + "brah", + "cakm", + "cham", + "cyrl", + "deva", + "diak", + "ethi", + "finance", + "fullwide", + "gara", + "geor", + "gong", + "gonm", + "grek", + "greklow", + "gujr", + "gukh", + "guru", + "hanidays", + "hanidec", + "hans", + "hansfin", + "hant", + "hantfin", + "hebr", + "hmng", + "hmnp", + "java", + "jpan", + "jpanfin", + "jpanyear", + "kali", + "kawi", + "khmr", + "knda", + "krai", + "lana", + "lanatham", + "laoo", + "latn", + "lepc", + "limb", + "mathbold", + "mathdbl", + "mathmono", + "mathsanb", + "mathsans", + "mlym", + "modi", + "mong", + "mroo", + "mtei", + "mymr", + "mymrepka", + "mymrpao", + "mymrshan", + "mymrtlng", + "nagm", + "native", + "newa", + "nkoo", + "olck", + "onao", + "orya", + "osma", + "outlined", + "rohg", + "roman", + "romanlow", + "saur", + "segment", + "shrd", + "sind", + "sinh", + "sora", + "sund", + "sunu", + "takr", + "talu", + "taml", + "tamldec", + "tnsa", + "telu", + "thai", + "tirh", + "tibt", + "tols", + "traditio", + "vaii", + "wara", + "wcho", + ]; +} + + +/** + * Tests whether name is a valid BCP 47 numbering system name + * and not excluded from use in the ECMAScript Internationalization API. + * @param {string} name the name to be tested. + * @return {boolean} whether name is a valid BCP 47 numbering system name and + * allowed for use in the ECMAScript Internationalization API. + */ + +function isValidNumberingSystem(name) { + + var numberingSystems = allNumberingSystems(); + + var excluded = [ + "finance", + "native", + "traditio" + ]; + + + return numberingSystems.indexOf(name) !== -1 && excluded.indexOf(name) === -1; +} + + +/** + * Provides the digits of numbering systems with simple digit mappings, + * as specified in . + */ + +var numberingSystemDigits = { + adlm: "𞥐𞥑𞥒𞥓𞥔𞥕𞥖𞥗𞥘𞥙", + ahom: "𑜰𑜱𑜲𑜳𑜴𑜵𑜶𑜷𑜸𑜹", + arab: "٠١٢٣٤٥٦٧٨٩", + arabext: "۰۱۲۳۴۵۶۷۸۹", + bali: "\u1B50\u1B51\u1B52\u1B53\u1B54\u1B55\u1B56\u1B57\u1B58\u1B59", + beng: "০১২৩৪৫৬৭৮৯", + bhks: "𑱐𑱑𑱒𑱓𑱔𑱕𑱖𑱗𑱘𑱙", + brah: "𑁦𑁧𑁨𑁩𑁪𑁫𑁬𑁭𑁮𑁯", + cakm: "𑄶𑄷𑄸𑄹𑄺𑄻𑄼𑄽𑄾𑄿", + cham: "꩐꩑꩒꩓꩔꩕꩖꩗꩘꩙", + deva: "०१२३४५६७८९", + diak: "𑥐𑥑𑥒𑥓𑥔𑥕𑥖𑥗𑥘𑥙", + fullwide: "0123456789", + gara: "\u{10D40}\u{10D41}\u{10D42}\u{10D43}\u{10D44}\u{10D45}\u{10D46}\u{10D47}\u{10D48}\u{10D49}", + gong: "𑶠𑶡𑶢𑶣𑶤𑶥𑶦𑶧𑶨𑶩", + gonm: "𑵐𑵑𑵒𑵓𑵔𑵕𑵖𑵗𑵘𑵙", + gujr: "૦૧૨૩૪૫૬૭૮૯", + gukh: "\u{16130}\u{16131}\u{16132}\u{16133}\u{16134}\u{16135}\u{16136}\u{16137}\u{16138}\u{16139}", + guru: "੦੧੨੩੪੫੬੭੮੯", + hanidec: "〇一二三四五六七八九", + hmng: "𖭐𖭑𖭒𖭓𖭔𖭕𖭖𖭗𖭘𖭙", + hmnp: "𞅀𞅁𞅂𞅃𞅄𞅅𞅆𞅇𞅈𞅉", + java: "꧐꧑꧒꧓꧔꧕꧖꧗꧘꧙", + kali: "꤀꤁꤂꤃꤄꤅꤆꤇꤈꤉", + kawi: "\u{11F50}\u{11F51}\u{11F52}\u{11F53}\u{11F54}\u{11F55}\u{11F56}\u{11F57}\u{11F58}\u{11F59}", + khmr: "០១២៣៤៥៦៧៨៩", + knda: "೦೧೨೩೪೫೬೭೮೯", + krai: "\u{16D70}\u{16D71}\u{16D72}\u{16D73}\u{16D74}\u{16D75}\u{16D76}\u{16D77}\u{16D78}\u{16D79}", + lana: "᪀᪁᪂᪃᪄᪅᪆᪇᪈᪉", + lanatham: "᪐᪑᪒᪓᪔᪕᪖᪗᪘᪙", + laoo: "໐໑໒໓໔໕໖໗໘໙", + latn: "0123456789", + lepc: "᱀᱁᱂᱃᱄᱅᱆᱇᱈᱉", + limb: "\u1946\u1947\u1948\u1949\u194A\u194B\u194C\u194D\u194E\u194F", + mathbold: "𝟎𝟏𝟐𝟑𝟒𝟓𝟔𝟕𝟖𝟗", + mathdbl: "𝟘𝟙𝟚𝟛𝟜𝟝𝟞𝟟𝟠𝟡", + mathmono: "𝟶𝟷𝟸𝟹𝟺𝟻𝟼𝟽𝟾𝟿", + mathsanb: "𝟬𝟭𝟮𝟯𝟰𝟱𝟲𝟳𝟴𝟵", + mathsans: "𝟢𝟣𝟤𝟥𝟦𝟧𝟨𝟩𝟪𝟫", + mlym: "൦൧൨൩൪൫൬൭൮൯", + modi: "𑙐𑙑𑙒𑙓𑙔𑙕𑙖𑙗𑙘𑙙", + mong: "᠐᠑᠒᠓᠔᠕᠖᠗᠘᠙", + mroo: "𖩠𖩡𖩢𖩣𖩤𖩥𖩦𖩧𖩨𖩩", + mtei: "꯰꯱꯲꯳꯴꯵꯶꯷꯸꯹", + mymr: "၀၁၂၃၄၅၆၇၈၉", + mymrepka: "\u{116DA}\u{116DB}\u{116DC}\u{116DD}\u{116DE}\u{116DF}\u{116E0}\u{116E1}\u{116E2}\u{116E3}", + mymrpao: "\u{116D0}\u{116D1}\u{116D2}\u{116D3}\u{116D4}\u{116D5}\u{116D6}\u{116D7}\u{116D8}\u{116D9}", + mymrshan: "႐႑႒႓႔႕႖႗႘႙", + mymrtlng: "꧰꧱꧲꧳꧴꧵꧶꧷꧸꧹", + nagm: "\u{1E4F0}\u{1E4F1}\u{1E4F2}\u{1E4F3}\u{1E4F4}\u{1E4F5}\u{1E4F6}\u{1E4F7}\u{1E4F8}\u{1E4F9}", + newa: "𑑐𑑑𑑒𑑓𑑔𑑕𑑖𑑗𑑘𑑙", + nkoo: "߀߁߂߃߄߅߆߇߈߉", + olck: "᱐᱑᱒᱓᱔᱕᱖᱗᱘᱙", + onao: "\u{1E5F1}\u{1E5F2}\u{1E5F3}\u{1E5F4}\u{1E5F5}\u{1E5F6}\u{1E5F7}\u{1E5F8}\u{1E5F9}\u{1E5FA}", + orya: "୦୧୨୩୪୫୬୭୮୯", + osma: "𐒠𐒡𐒢𐒣𐒤𐒥𐒦𐒧𐒨𐒩", + outlined: "\u{1CCF0}\u{1CCF1}\u{1CCF2}\u{1CCF3}\u{1CCF4}\u{1CCF5}\u{1CCF6}\u{1CCF7}\u{1CCF8}\u{1CCF9}", + rohg: "𐴰𐴱𐴲𐴳𐴴𐴵𐴶𐴷𐴸𐴹", + saur: "꣐꣑꣒꣓꣔꣕꣖꣗꣘꣙", + segment: "🯰🯱🯲🯳🯴🯵🯶🯷🯸🯹", + shrd: "𑇐𑇑𑇒𑇓𑇔𑇕𑇖𑇗𑇘𑇙", + sind: "𑋰𑋱𑋲𑋳𑋴𑋵𑋶𑋷𑋸𑋹", + sinh: "෦෧෨෩෪෫෬෭෮෯", + sora: "𑃰𑃱𑃲𑃳𑃴𑃵𑃶𑃷𑃸𑃹", + sund: "᮰᮱᮲᮳᮴᮵᮶᮷᮸᮹", + sunu: "\u{11BF0}\u{11BF1}\u{11BF2}\u{11BF3}\u{11BF4}\u{11BF5}\u{11BF6}\u{11BF7}\u{11BF8}\u{11BF9}", + takr: "𑛀𑛁𑛂𑛃𑛄𑛅𑛆𑛇𑛈𑛉", + talu: "᧐᧑᧒᧓᧔᧕᧖᧗᧘᧙", + tamldec: "௦௧௨௩௪௫௬௭௮௯", + telu: "౦౧౨౩౪౫౬౭౮౯", + thai: "๐๑๒๓๔๕๖๗๘๙", + tibt: "༠༡༢༣༤༥༦༧༨༩", + tirh: "𑓐𑓑𑓒𑓓𑓔𑓕𑓖𑓗𑓘𑓙", + tnsa: "\u{16AC0}\u{16AC1}\u{16AC2}\u{16AC3}\u{16AC4}\u{16AC5}\u{16AC6}\u{16AC7}\u{16AC8}\u{16AC9}", + tols: "\u{11DE0}\u{11DE1}\u{11DE2}\u{11DE3}\u{11DE4}\u{11DE5}\u{11DE6}\u{11DE7}\u{11DE8}\u{11DE9}", + vaii: "꘠꘡꘢꘣꘤꘥꘦꘧꘨꘩", + wara: "𑣠𑣡𑣢𑣣𑣤𑣥𑣦𑣧𑣨𑣩", + wcho: "𞋰𞋱𞋲𞋳𞋴𞋵𞋶𞋷𞋸𞋹", +}; + + +/** + * Returns an array of all simple, sanctioned unit identifiers. + */ +function allSimpleSanctionedUnits() { + // https://tc39.es/ecma402/#table-sanctioned-simple-unit-identifiers + return [ + "acre", + "bit", + "byte", + "celsius", + "centimeter", + "day", + "degree", + "fahrenheit", + "fluid-ounce", + "foot", + "gallon", + "gigabit", + "gigabyte", + "gram", + "hectare", + "hour", + "inch", + "kilobit", + "kilobyte", + "kilogram", + "kilometer", + "liter", + "megabit", + "megabyte", + "meter", + "microsecond", + "mile", + "mile-scandinavian", + "milliliter", + "millimeter", + "millisecond", + "minute", + "month", + "nanosecond", + "ounce", + "percent", + "petabyte", + "pound", + "second", + "stone", + "terabit", + "terabyte", + "week", + "yard", + "year", + ]; +} + + +/** + * Tests that number formatting is handled correctly. The function checks that the + * digit sequences in formatted output are as specified, converted to the + * selected numbering system, and embedded in consistent localized patterns. + * @param {Array} locales the locales to be tested. + * @param {Array} numberingSystems the numbering systems to be tested. + * @param {Object} options the options to pass to Intl.NumberFormat. Options + * must include {useGrouping: false}, and must cause 1.1 to be formatted + * pre- and post-decimal digits. + * @param {Object} testData maps input data (in ES5 9.3.1 format) to expected output strings + * in unlocalized format with Western digits. + */ + +function testNumberFormat(locales, numberingSystems, options, testData) { + locales.forEach(function (locale) { + numberingSystems.forEach(function (numbering) { + var digits = numberingSystemDigits[numbering]; + var format = new Intl.NumberFormat([locale + "-u-nu-" + numbering], options); + + function getPatternParts(positive) { + var n = positive ? 1.1 : -1.1; + var formatted = format.format(n); + var oneoneRE = "([^" + digits + "]*)[" + digits + "]+([^" + digits + "]+)[" + digits + "]+([^" + digits + "]*)"; + var match = formatted.match(new RegExp(oneoneRE)); + if (match === null) { + throw new Test262Error("Unexpected formatted " + n + " for " + + format.resolvedOptions().locale + " and options " + + JSON.stringify(options) + ": " + formatted); + } + return match; + } + + function toNumbering(raw) { + return raw.replace(/[0-9]/g, function (digit) { + return digits[digit.charCodeAt(0) - "0".charCodeAt(0)]; + }); + } + + function buildExpected(raw, patternParts) { + var period = raw.indexOf("."); + if (period === -1) { + return patternParts[1] + toNumbering(raw) + patternParts[3]; + } else { + return patternParts[1] + + toNumbering(raw.substring(0, period)) + + patternParts[2] + + toNumbering(raw.substring(period + 1)) + + patternParts[3]; + } + } + + if (format.resolvedOptions().numberingSystem === numbering) { + // figure out prefixes, infixes, suffixes for positive and negative values + var posPatternParts = getPatternParts(true); + var negPatternParts = getPatternParts(false); + + Object.getOwnPropertyNames(testData).forEach(function (input) { + var rawExpected = testData[input]; + var patternParts; + if (rawExpected[0] === "-") { + patternParts = negPatternParts; + rawExpected = rawExpected.substring(1); + } else { + patternParts = posPatternParts; + } + var expected = buildExpected(rawExpected, patternParts); + var actual = format.format(input); + if (actual !== expected) { + throw new Test262Error("Formatted value for " + input + ", " + + format.resolvedOptions().locale + " and options " + + JSON.stringify(options) + " is " + actual + "; expected " + expected + "."); + } + }); + } + }); + }); +} + + +/** + * Return the components of date-time formats. + * @return {Array} an array with all date-time components. + */ + +function getDateTimeComponents() { + return ["weekday", "era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"]; +} + + +/** + * Return the valid values for the given date-time component, as specified + * by the table in section 12.1.1. + * @param {string} component a date-time component. + * @return {Array} an array with the valid values for the component. + */ + +function getDateTimeComponentValues(component) { + + var components = { + weekday: ["narrow", "short", "long"], + era: ["narrow", "short", "long"], + year: ["2-digit", "numeric"], + month: ["2-digit", "numeric", "narrow", "short", "long"], + day: ["2-digit", "numeric"], + hour: ["2-digit", "numeric"], + minute: ["2-digit", "numeric"], + second: ["2-digit", "numeric"], + timeZoneName: ["short", "long"] + }; + + var result = components[component]; + if (result === undefined) { + throw new Test262Error("Internal error: No values defined for date-time component " + component + "."); + } + return result; +} + + +/** + * @description Tests whether timeZone is a String value representing a + * structurally valid and canonicalized time zone name, as defined in + * sections 6.4.1 and 6.4.2 of the ECMAScript Internationalization API + * Specification. + * @param {String} timeZone the string to be tested. + * @result {Boolean} whether the test succeeded. + */ + +function isCanonicalizedStructurallyValidTimeZoneName(timeZone) { + /** + * Regular expression defining IANA Time Zone names. + * + * Spec: IANA Time Zone Database, Theory file + */ + var fileNameComponent = "(?:[A-Za-z_]|\\.(?!\\.?(?:/|$)))[A-Za-z.\\-_]{0,13}"; + var fileName = fileNameComponent + "(?:/" + fileNameComponent + ")*"; + var etcName = "(?:Etc/)?GMT[+-]\\d{1,2}"; + var systemVName = "SystemV/[A-Z]{3}\\d{1,2}(?:[A-Z]{3})?"; + var legacyName = etcName + "|" + systemVName + "|CST6CDT|EST5EDT|MST7MDT|PST8PDT|NZ"; + var zoneNamePattern = new RegExp("^(?:" + fileName + "|" + legacyName + ")$"); + + if (typeof timeZone !== "string") { + return false; + } + // 6.4.2 CanonicalizeTimeZoneName (timeZone), step 3 + if (timeZone === "UTC") { + return true; + } + // 6.4.2 CanonicalizeTimeZoneName (timeZone), step 3 + if (timeZone === "Etc/UTC" || timeZone === "Etc/GMT") { + return false; + } + return zoneNamePattern.test(timeZone); +} + + +/** + * @description Simplified PartitionDurationFormatPattern implementation which + * only supports the "en" locale. + * @param {Object} durationFormat the duration format object + * @param {Object} duration the duration record + * @result {Array} an array with formatted duration parts + */ + +function partitionDurationFormatPattern(durationFormat, duration) { + function durationToFractional(duration, exponent) { + let { + seconds = 0, + milliseconds = 0, + microseconds = 0, + nanoseconds = 0, + } = duration; + + // Directly return the duration amount when no sub-seconds are present. + switch (exponent) { + case 9: { + if (milliseconds === 0 && microseconds === 0 && nanoseconds === 0) { + return seconds; + } + break; + } + case 6: { + if (microseconds === 0 && nanoseconds === 0) { + return milliseconds; + } + break; + } + case 3: { + if (nanoseconds === 0) { + return microseconds; + } + break; + } + } + + // Otherwise compute the overall amount of nanoseconds using BigInt to avoid + // loss of precision. + let ns = BigInt(nanoseconds); + switch (exponent) { + case 9: + ns += BigInt(seconds) * 1_000_000_000n; + // fallthrough + case 6: + ns += BigInt(milliseconds) * 1_000_000n; + // fallthrough + case 3: + ns += BigInt(microseconds) * 1_000n; + // fallthrough + } + + let e = BigInt(10 ** exponent); + + // Split the nanoseconds amount into an integer and its fractional part. + let q = ns / e; + let r = ns % e; + + // Pad fractional part, without any leading negative sign, to |exponent| digits. + if (r < 0) { + r = -r; + } + r = String(r).padStart(exponent, "0"); + + // Return the result as a decimal string. + return `${q}.${r}`; + } + + const units = [ + "years", + "months", + "weeks", + "days", + "hours", + "minutes", + "seconds", + "milliseconds", + "microseconds", + "nanoseconds", + ]; + + let options = durationFormat.resolvedOptions(); + + // Only "en" is supported. + const locale = "en"; + const numberingSystem = "latn"; + const timeSeparator = ":"; + + let result = []; + let needSeparator = false; + let displayNegativeSign = true; + + for (let unit of units) { + // Absent units default to zero. + let value = duration[unit] ?? 0; + + let style = options[unit]; + let display = options[unit + "Display"]; + + // NumberFormat requires singular unit names. + let numberFormatUnit = unit.slice(0, -1); + + // Compute the matching NumberFormat options. + let nfOpts = Object.create(null); + + // Numeric seconds and sub-seconds are combined into a single value. + let done = false; + if (unit === "seconds" || unit === "milliseconds" || unit === "microseconds") { + let nextStyle = options[units[units.indexOf(unit) + 1]]; + if (nextStyle === "numeric") { + if (unit === "seconds") { + value = durationToFractional(duration, 9); + } else if (unit === "milliseconds") { + value = durationToFractional(duration, 6); + } else { + value = durationToFractional(duration, 3); + } + + nfOpts.maximumFractionDigits = options.fractionalDigits ?? 9; + nfOpts.minimumFractionDigits = options.fractionalDigits ?? 0; + nfOpts.roundingMode = "trunc"; + + done = true; + } + } + + // Display zero numeric minutes when seconds will be displayed. + let displayRequired = false; + if (unit === "minutes" && needSeparator) { + displayRequired = options.secondsDisplay === "always" || + (duration.seconds ?? 0) !== 0 || + (duration.milliseconds ?? 0) !== 0 || + (duration.microseconds ?? 0) !== 0 || + (duration.nanoseconds ?? 0) !== 0; + } + + // "auto" display omits zero units. + if (value !== 0 || display !== "auto" || displayRequired) { + // Display only the first negative value. + if (displayNegativeSign) { + displayNegativeSign = false; + + // Set to negative zero to ensure the sign is displayed. + if (value === 0) { + let negative = units.some(unit => (duration[unit] ?? 0) < 0); + if (negative) { + value = -0; + } + } + } else { + nfOpts.signDisplay = "never"; + } + + nfOpts.numberingSystem = options.numberingSystem; + + // If the value is formatted as a 2-digit numeric value. + if (style === "2-digit") { + nfOpts.minimumIntegerDigits = 2; + } + + // If the value is formatted as a standalone unit. + if (style !== "numeric" && style !== "2-digit") { + nfOpts.style = "unit"; + nfOpts.unit = numberFormatUnit; + nfOpts.unitDisplay = style; + } else { + nfOpts.useGrouping = false; + } + + let nf = new Intl.NumberFormat(locale, nfOpts); + + let list; + if (!needSeparator) { + list = []; + } else { + list = result[result.length - 1]; + + // Prepend the time separator before the formatted number. + list.push({ + type: "literal", + value: timeSeparator, + }); + } + + // Format the numeric value. + let parts = nf.formatToParts(value); + + // Add |numberFormatUnit| to the formatted number. + for (let {value, type} of parts) { + list.push({type, value, unit: numberFormatUnit}); + } + + if (!needSeparator) { + // Prepend the separator before the next numeric unit. + if (style === "2-digit" || style === "numeric") { + needSeparator = true; + } + + // Append the formatted number to |result|. + result.push(list); + } + } + + if (done) { + break; + } + } + + let listStyle = options.style; + if (listStyle === "digital") { + listStyle = "short"; + } + + let lf = new Intl.ListFormat(locale, { + type: "unit", + style: listStyle, + }); + + // Collect all formatted units into a list of strings. + let strings = []; + for (let parts of result) { + let string = ""; + for (let {value} of parts) { + string += value; + } + strings.push(string); + } + + // Format the list of strings and compute the overall result. + let flattened = []; + for (let {type, value} of lf.formatToParts(strings)) { + if (type === "element") { + flattened.push(...result.shift()); + } else { + flattened.push({type, value}); + } + } + return flattened; +} + + +/** + * @description Return the formatted string from partitionDurationFormatPattern. + * @param {Object} durationFormat the duration format object + * @param {Object} duration the duration record + * @result {String} a string containing the formatted duration + */ + +function formatDurationFormatPattern(durationFormat, duration) { + let parts = partitionDurationFormatPattern(durationFormat, duration); + return parts.reduce((acc, e) => acc + e.value, ""); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/testTypedArray.js b/crates/clazel-js-lexer/tests/data/test262/harness/testTypedArray.js new file mode 100644 index 000000000..e55e62621 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/testTypedArray.js @@ -0,0 +1,399 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Collection of functions used to assert the correctness of TypedArray objects. +defines: + - floatArrayConstructors + - nonClampedIntArrayConstructors + - intArrayConstructors + - typedArrayConstructors + - TypedArray + - testWithAllTypedArrayConstructors + - testWithTypedArrayConstructors + - testWithBigIntTypedArrayConstructors + - nonAtomicsFriendlyTypedArrayConstructors + - testWithAtomicsFriendlyTypedArrayConstructors + - testWithNonAtomicsFriendlyTypedArrayConstructors + - testTypedArrayConversions +---*/ + +var floatArrayConstructors = [ + Float64Array, + Float32Array +]; + +var nonClampedIntArrayConstructors = [ + Int32Array, + Int16Array, + Int8Array, + Uint32Array, + Uint16Array, + Uint8Array +]; + +var intArrayConstructors = nonClampedIntArrayConstructors.concat([Uint8ClampedArray]); + +// Float16Array is a newer feature +// adding it to this list unconditionally would cause implementations lacking it to fail every test which uses it +if (typeof Float16Array !== "undefined") { + floatArrayConstructors.push(Float16Array); +} + +var bigIntArrayConstructors = []; +if (typeof BigInt64Array !== "undefined") { + bigIntArrayConstructors.push(BigInt64Array); +} +if (typeof BigUint64Array !== "undefined") { + bigIntArrayConstructors.push(BigUint64Array); +} + +/** + * Array containing every non-bigint typed array constructor. + */ +var typedArrayConstructors = floatArrayConstructors.concat(intArrayConstructors); + +/** + * Array containing every typed array constructor, including those with bigint values. + */ +var allTypedArrayConstructors = typedArrayConstructors.concat(bigIntArrayConstructors); + +/** + * The %TypedArray% intrinsic constructor function. + */ +var TypedArray = Object.getPrototypeOf(Int8Array); + +function isPrimitive(val) { + return !val || (typeof val !== "object" && typeof val !== "function"); +} + +function makePassthrough(TA, primitiveOrIterable) { + return primitiveOrIterable; +} + +function makeArray(TA, primitiveOrIterable) { + if (isPrimitive(primitiveOrIterable)) { + var n = Number(primitiveOrIterable); + // Only values between 0 and 2**53 - 1 inclusive can get mapped into TA contents. + if (!(n >= 0 && n < 9007199254740992)) return primitiveOrIterable; + return Array.from({ length: n }, function() { return "0"; }); + } + return Array.from(primitiveOrIterable); +} + +function makeArrayLike(TA, primitiveOrIterable) { + var arr = makeArray(TA, primitiveOrIterable); + if (isPrimitive(arr)) return arr; + var obj = { length: arr.length }; + for (var i = 0; i < obj.length; i++) obj[i] = arr[i]; + return obj; +} + +var makeIterable; +if (typeof Symbol !== "undefined" && Symbol.iterator) { + makeIterable = function makeIterable(TA, primitiveOrIterable) { + var src = makeArray(TA, primitiveOrIterable); + if (isPrimitive(src)) return src; + var obj = {}; + obj[Symbol.iterator] = function() { return src[Symbol.iterator](); }; + return obj; + }; +} + +function makeArrayBuffer(TA, primitiveOrIterable) { + var arr = makeArray(TA, primitiveOrIterable); + if (isPrimitive(arr)) return arr; + return new TA(arr).buffer; +} + +var makeResizableArrayBuffer, makeGrownArrayBuffer, makeShrunkArrayBuffer; +if (ArrayBuffer.prototype.resize) { + var copyIntoArrayBuffer = function(destBuffer, srcBuffer) { + var destView = new Uint8Array(destBuffer); + var srcView = new Uint8Array(srcBuffer); + for (var i = 0; i < srcView.length; i++) destView[i] = srcView[i]; + return destBuffer; + }; + + makeResizableArrayBuffer = function makeResizableArrayBuffer(TA, primitiveOrIterable) { + if (isPrimitive(primitiveOrIterable)) { + var n = Number(primitiveOrIterable) * TA.BYTES_PER_ELEMENT; + if (!(n >= 0 && n < 9007199254740992)) return primitiveOrIterable; + return new ArrayBuffer(n, { maxByteLength: n * 2 }); + } + var fixed = makeArrayBuffer(TA, primitiveOrIterable); + var byteLength = fixed.byteLength; + var resizable = new ArrayBuffer(byteLength, { maxByteLength: byteLength * 2 }); + return copyIntoArrayBuffer(resizable, fixed); + }; + + makeGrownArrayBuffer = function makeGrownArrayBuffer(TA, primitiveOrIterable) { + if (isPrimitive(primitiveOrIterable)) { + var n = Number(primitiveOrIterable) * TA.BYTES_PER_ELEMENT; + if (!(n >= 0 && n < 9007199254740992)) return primitiveOrIterable; + var grown = new ArrayBuffer(Math.floor(n / 2), { maxByteLength: n }); + grown.resize(n); + } + var fixed = makeArrayBuffer(TA, primitiveOrIterable); + var byteLength = fixed.byteLength; + var grown = new ArrayBuffer(Math.floor(byteLength / 2), { maxByteLength: byteLength }); + grown.resize(byteLength); + return copyIntoArrayBuffer(grown, fixed); + }; + + makeShrunkArrayBuffer = function makeShrunkArrayBuffer(TA, primitiveOrIterable) { + if (isPrimitive(primitiveOrIterable)) { + var n = Number(primitiveOrIterable) * TA.BYTES_PER_ELEMENT; + if (!(n >= 0 && n < 9007199254740992)) return primitiveOrIterable; + var shrunk = new ArrayBuffer(n * 2, { maxByteLength: n * 2 }); + shrunk.resize(n); + } + var fixed = makeArrayBuffer(TA, primitiveOrIterable); + var byteLength = fixed.byteLength; + var shrunk = new ArrayBuffer(byteLength * 2, { maxByteLength: byteLength * 2 }); + copyIntoArrayBuffer(shrunk, fixed); + shrunk.resize(byteLength); + return shrunk; + }; +} + +var typedArrayCtorArgFactories = [makePassthrough, makeArray, makeArrayLike]; +if (makeIterable) typedArrayCtorArgFactories.push(makeIterable); +typedArrayCtorArgFactories.push(makeArrayBuffer); +if (makeResizableArrayBuffer) typedArrayCtorArgFactories.push(makeResizableArrayBuffer); +if (makeGrownArrayBuffer) typedArrayCtorArgFactories.push(makeGrownArrayBuffer); +if (makeShrunkArrayBuffer) typedArrayCtorArgFactories.push(makeShrunkArrayBuffer); + +/** + * @typedef {"passthrough" | "arraylike" | "iterable" | "arraybuffer" | "resizable"} typedArrayArgFactoryFeature + */ + +/** + * A predicate for testing whether a TypedArray argument factory from this file + * matches any of the provided features. + * + * @param {Function} argFactory + * @param {typedArrayArgFactoryFeature[]} features + * @returns {boolean} + */ +function ctorArgFactoryMatchesSome(argFactory, features) { + for (var i = 0; i < features.length; ++i) { + switch (features[i]) { + case "passthrough": + if (argFactory === makePassthrough) return true; + break; + case "arraylike": + if (argFactory === makeArray || argFactory === makeArrayLike) return true; + break; + case "iterable": + if (argFactory === makeIterable) return true; + break; + case "arraybuffer": + if ( + argFactory === makeArrayBuffer || + argFactory === makeResizableArrayBuffer || + argFactory === makeGrownArrayBuffer || + argFactory === makeShrunkArrayBuffer + ) { + return true; + } + break; + case "resizable": + if ( + argFactory === makeResizableArrayBuffer || + argFactory === makeGrownArrayBuffer || + argFactory === makeShrunkArrayBuffer + ) { + return true; + } + break; + default: + throw Test262Error("unknown feature: " + features[i]); + } + } + return false; +} + +/** + * Callback for testing a typed array constructor. + * + * @callback typedArrayConstructorCallback + * @param {Function} TypedArrayConstructor the constructor object to test with + * @param {Function} [TypedArrayConstructorArgFactory] a function for making + * a TypedArrayConstructor argument from a primitive (usually a number) or + * iterable (usually an array) + */ + +/** + * Calls the provided function with (typedArrayCtor, typedArrayCtorArgFactory) + * pairs, where typedArrayCtor is Uint8Array/Int8Array/BigInt64Array/etc. and + * typedArrayCtorArgFactory is a function for mapping a primitive (usually a + * number) or iterable (usually an array) into a value suitable as the first + * argument of typedArrayCtor (an Array, arraylike, iterable, or ArrayBuffer). + * + * @param {typedArrayConstructorCallback} f - the function to call + * @param {Array} [constructors] - an explicit list of TypedArray constructors + * @param {typedArrayArgFactoryFeature[]} [includeArgFactories] - for selecting + * initial constructor argument factory functions, rather than starting with + * all argument factories + * @param {typedArrayArgFactoryFeature[]} [excludeArgFactories] - for excluding + * constructor argument factory functions, after an initial selection + */ +function testWithAllTypedArrayConstructors(f, constructors, includeArgFactories, excludeArgFactories) { + var ctors = constructors || allTypedArrayConstructors; + var ctorArgFactories = typedArrayCtorArgFactories; + if (includeArgFactories) { + ctorArgFactories = []; + for (var i = 0; i < typedArrayCtorArgFactories.length; ++i) { + if (ctorArgFactoryMatchesSome(typedArrayCtorArgFactories[i], includeArgFactories)) { + ctorArgFactories.push(typedArrayCtorArgFactories[i]); + } + } + } + if (excludeArgFactories) { + ctorArgFactories = ctorArgFactories.slice(); + for (var i = ctorArgFactories.length - 1; i >= 0; --i) { + if (ctorArgFactoryMatchesSome(ctorArgFactories[i], excludeArgFactories)) { + ctorArgFactories.splice(i, 1); + } + } + } + if (ctorArgFactories.length === 0) { + throw Test262Error("no arg factories match include " + includeArgFactories + " and exclude " + excludeArgFactories); + } + for (var k = 0; k < ctorArgFactories.length; ++k) { + var argFactory = ctorArgFactories[k]; + for (var i = 0; i < ctors.length; ++i) { + var constructor = ctors[i]; + var boundArgFactory = argFactory.bind(undefined, constructor); + try { + f(constructor, boundArgFactory); + } catch (e) { + e.message += " (Testing with " + constructor.name + " and " + argFactory.name + ".)"; + throw e; + } + } + } +} + +/** + * Calls the provided function with (typedArrayCtor, typedArrayCtorArgFactory) + * pairs, where typedArrayCtor is Uint8Array/Int8Array/BigInt64Array/etc. and + * typedArrayCtorArgFactory is a function for mapping a primitive (usually a + * number) or iterable (usually an array) into a value suitable as the first + * argument of typedArrayCtor (an Array, arraylike, iterable, or ArrayBuffer). + * + * typedArrayCtor will not be BigInt64Array or BigUint64Array unless one or both + * of those are explicitly provided. + * + * @param {typedArrayConstructorCallback} f - the function to call + * @param {Array} [constructors] - an explicit list of TypedArray constructors + * @param {typedArrayArgFactoryFeature[]} [includeArgFactories] - for selecting + * initial constructor argument factory functions, rather than starting with + * all argument factories + * @param {typedArrayArgFactoryFeature[]} [excludeArgFactories] - for excluding + * constructor argument factory functions, after an initial selection + */ +function testWithTypedArrayConstructors(f, constructors, includeArgFactories, excludeArgFactories) { + var ctors = constructors || typedArrayConstructors; + testWithAllTypedArrayConstructors(f, ctors, includeArgFactories, excludeArgFactories); +} + +/** + * Calls the provided function for every BigInt typed array constructor. + * + * @param {typedArrayConstructorCallback} f - the function to call + * @param {Array} [constructors] - an explicit list of TypedArray constructors + * @param {typedArrayArgFactoryFeature[]} [includeArgFactories] - for selecting + * initial constructor argument factory functions, rather than starting with + * all argument factories + * @param {typedArrayArgFactoryFeature[]} [excludeArgFactories] - for excluding + * constructor argument factory functions, after an initial selection + */ +function testWithBigIntTypedArrayConstructors(f, constructors, includeArgFactories, excludeArgFactories) { + var ctors = constructors || [BigInt64Array, BigUint64Array]; + testWithAllTypedArrayConstructors(f, ctors, includeArgFactories, excludeArgFactories); +} + +var nonAtomicsFriendlyTypedArrayConstructors = floatArrayConstructors.concat([Uint8ClampedArray]); +/** + * Calls the provided function for every non-"Atomics Friendly" typed array constructor. + * + * @param {typedArrayConstructorCallback} f - the function to call for each typed array constructor. + * @param {Array} selected - An optional Array with filtered typed arrays + */ +function testWithNonAtomicsFriendlyTypedArrayConstructors(f) { + testWithTypedArrayConstructors(f, nonAtomicsFriendlyTypedArrayConstructors); +} + +/** + * Calls the provided function for every "Atomics Friendly" typed array constructor. + * + * @param {typedArrayConstructorCallback} f - the function to call for each typed array constructor. + * @param {Array} selected - An optional Array with filtered typed arrays + */ +function testWithAtomicsFriendlyTypedArrayConstructors(f) { + testWithTypedArrayConstructors(f, [ + Int32Array, + Int16Array, + Int8Array, + Uint32Array, + Uint16Array, + Uint8Array, + ]); +} + +/** + * Helper for conversion operations on TypedArrays, the expected values + * properties are indexed in order to match the respective value for each + * TypedArray constructor + * @param {Function} fn - the function to call for each constructor and value. + * will be called with the constructor, value, expected + * value, and a initial value that can be used to avoid + * a false positive with an equivalent expected value. + */ +function testTypedArrayConversions(byteConversionValues, fn) { + var values = byteConversionValues.values; + var expected = byteConversionValues.expected; + + testWithTypedArrayConstructors(function(TA) { + var name = TA.name.slice(0, -5); + + return values.forEach(function(value, index) { + var exp = expected[name][index]; + var initial = 0; + if (exp === 0) { + initial = 1; + } + fn(TA, value, exp, initial); + }); + }); +} + +/** + * Checks if the given argument is one of the float-based TypedArray constructors. + * + * @param {constructor} ctor - the value to check + * @returns {boolean} + */ +function isFloatTypedArrayConstructor(arg) { + return floatArrayConstructors.indexOf(arg) !== -1; +} + +/** + * Determines the precision of the given float-based TypedArray constructor. + * + * @param {constructor} ctor - the value to check + * @returns {string} "half", "single", or "double" for Float16Array, Float32Array, and Float64Array respectively. + */ +function floatTypedArrayConstructorPrecision(FA) { + if (typeof Float16Array !== "undefined" && FA === Float16Array) { + return "half"; + } else if (FA === Float32Array) { + return "single"; + } else if (FA === Float64Array) { + return "double"; + } else { + throw new Error("Malformed test - floatTypedArrayConstructorPrecision called with non-float TypedArray"); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/typeCoercion.js b/crates/clazel-js-lexer/tests/data/test262/harness/typeCoercion.js new file mode 100644 index 000000000..09b3d54b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/typeCoercion.js @@ -0,0 +1,469 @@ +// Copyright (C) 2017 Josh Wolfe. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + Functions to help generate test cases for testing type coercion abstract + operations like ToNumber. +defines: + - testCoercibleToIndexZero + - testCoercibleToIndexOne + - testCoercibleToIndexFromIndex + - testCoercibleToIntegerZero + - testCoercibleToIntegerOne + - testCoercibleToNumberZero + - testCoercibleToNumberNan + - testCoercibleToNumberOne + - testCoercibleToIntegerFromInteger + - testPrimitiveWrappers + - testCoercibleToPrimitiveWithMethod + - testNotCoercibleToIndex + - testNotCoercibleToInteger + - testNotCoercibleToNumber + - testNotCoercibleToPrimitive + - testCoercibleToString + - testNotCoercibleToString + - testCoercibleToBooleanTrue + - testCoercibleToBooleanFalse + - testCoercibleToBigIntZero + - testCoercibleToBigIntOne + - testCoercibleToBigIntFromBigInt + - testNotCoercibleToBigInt +---*/ + +function testCoercibleToIndexZero(test) { + testCoercibleToIntegerZero(test); +} + +function testCoercibleToIndexOne(test) { + testCoercibleToIntegerOne(test); +} + +function testCoercibleToIndexFromIndex(nominalIndex, test) { + assert(Number.isInteger(nominalIndex)); + assert(0 <= nominalIndex && nominalIndex <= 2**53 - 1); + testCoercibleToIntegerFromInteger(nominalIndex, test); +} + +function testCoercibleToIntegerZero(test) { + testCoercibleToNumberZero(test); + + testCoercibleToIntegerFromInteger(0, test); + + // NaN -> +0 + testCoercibleToNumberNan(test); + + // When toString() returns a string that parses to NaN: + test({}); + test([]); +} + +function testCoercibleToIntegerOne(test) { + testCoercibleToNumberOne(test); + + testCoercibleToIntegerFromInteger(1, test); + + // When toString() returns "1" + test([1]); + test(["1"]); +} + +function testCoercibleToNumberZero(test) { + function testPrimitiveValue(value) { + test(value); + // ToPrimitive + testPrimitiveWrappers(value, "number", test); + } + + testPrimitiveValue(null); + testPrimitiveValue(false); + testPrimitiveValue(0); + testPrimitiveValue("0"); +} + +function testCoercibleToNumberNan(test) { + function testPrimitiveValue(value) { + test(value); + // ToPrimitive + testPrimitiveWrappers(value, "number", test); + } + + testPrimitiveValue(undefined); + testPrimitiveValue(NaN); + testPrimitiveValue(""); + testPrimitiveValue("foo"); + testPrimitiveValue("true"); +} + +function testCoercibleToNumberOne(test) { + function testPrimitiveValue(value) { + test(value); + // ToPrimitive + testPrimitiveWrappers(value, "number", test); + } + + testPrimitiveValue(true); + testPrimitiveValue(1); + testPrimitiveValue("1"); +} + +function testCoercibleToIntegerFromInteger(nominalInteger, test) { + assert(Number.isInteger(nominalInteger)); + + function testPrimitiveValue(value) { + test(value); + // ToPrimitive + testPrimitiveWrappers(value, "number", test); + + // Non-primitive values that coerce to the nominal integer: + // toString() returns a string that parsers to a primitive value. + test([value]); + } + + function testPrimitiveNumber(number) { + testPrimitiveValue(number); + // ToNumber: String -> Number + testPrimitiveValue(number.toString()); + } + + testPrimitiveNumber(nominalInteger); + + // ToInteger: floor(abs(number)) + if (nominalInteger >= 0) { + testPrimitiveNumber(nominalInteger + 0.9); + } + if (nominalInteger <= 0) { + testPrimitiveNumber(nominalInteger - 0.9); + } +} + +function testPrimitiveWrappers(primitiveValue, hint, test) { + if (primitiveValue != null) { + // null and undefined result in {} rather than a proper wrapper, + // so skip this case for those values. + test(Object(primitiveValue)); + } + + testCoercibleToPrimitiveWithMethod(hint, function() { + return primitiveValue; + }, test); +} + +function testCoercibleToPrimitiveWithMethod(hint, method, test) { + var supportsToPrimitive = typeof Symbol !== "undefined" && !!Symbol.toPrimitive; + + var methodNames; + if (hint === "number") { + methodNames = ["valueOf", "toString"]; + } else if (hint === "string") { + methodNames = ["toString", "valueOf"]; + } else { + throw new Test262Error(); + } + // precedence order + if (supportsToPrimitive) { + test({ + [Symbol.toPrimitive]: method, + [methodNames[0]]: function() { throw new Test262Error(); }, + [methodNames[1]]: function() { throw new Test262Error(); }, + }); + } + test({ + [methodNames[0]]: method, + [methodNames[1]]: function() { throw new Test262Error(); }, + }); + if (hint === "number") { + // The default valueOf returns an object, which is unsuitable. + // The default toString returns a String, which is suitable. + // Therefore this test only works for valueOf falling back to toString. + test({ + // this is toString: + [methodNames[1]]: method, + }); + } + + // GetMethod: if func is undefined or null, return undefined. + if (supportsToPrimitive) { + test({ + [Symbol.toPrimitive]: undefined, + [methodNames[0]]: method, + [methodNames[1]]: method, + }); + test({ + [Symbol.toPrimitive]: null, + [methodNames[0]]: method, + [methodNames[1]]: method, + }); + } + + // if methodNames[0] is not callable, fallback to methodNames[1] + test({ + [methodNames[0]]: null, + [methodNames[1]]: method, + }); + test({ + [methodNames[0]]: 1, + [methodNames[1]]: method, + }); + test({ + [methodNames[0]]: {}, + [methodNames[1]]: method, + }); + + // if methodNames[0] returns an object, fallback to methodNames[1] + test({ + [methodNames[0]]: function() { return {}; }, + [methodNames[1]]: method, + }); + test({ + [methodNames[0]]: function() { return Object(1); }, + [methodNames[1]]: method, + }); +} + +function testNotCoercibleToIndex(test) { + function testPrimitiveValue(value) { + test(RangeError, value); + // ToPrimitive + testPrimitiveWrappers(value, "number", function(value) { + test(RangeError, value); + }); + } + + // Let integerIndex be ? ToInteger(value). + testNotCoercibleToInteger(test); + + // If integerIndex < 0, throw a RangeError exception. + testPrimitiveValue(-1); + testPrimitiveValue(-2.5); + testPrimitiveValue("-2.5"); + testPrimitiveValue(-Infinity); + + // Let index be ! ToLength(integerIndex). + // If SameValueZero(integerIndex, index) is false, throw a RangeError exception. + testPrimitiveValue(2 ** 53); + testPrimitiveValue(Infinity); +} + +function testNotCoercibleToInteger(test) { + // ToInteger only throws from ToNumber. + testNotCoercibleToNumber(test); +} + +function testNotCoercibleToNumber(test) { + function testPrimitiveValue(value) { + test(TypeError, value); + // ToPrimitive + testPrimitiveWrappers(value, "number", function(value) { + test(TypeError, value); + }); + } + + // ToNumber: Symbol -> TypeError + if (typeof Symbol !== "undefined") { + testPrimitiveValue(Symbol("1")); + } + + if (typeof BigInt !== "undefined") { + // ToNumber: BigInt -> TypeError + testPrimitiveValue(BigInt(0)); + } + + // ToPrimitive + testNotCoercibleToPrimitive("number", test); +} + +function testNotCoercibleToPrimitive(hint, test) { + var supportsToPrimitive = typeof Symbol !== "undefined" && !!Symbol.toPrimitive; + + function MyError() {} + + // ToPrimitive: input[@@toPrimitive] is not callable (and non-null) + if (supportsToPrimitive) { + test(TypeError, {[Symbol.toPrimitive]: 1}); + test(TypeError, {[Symbol.toPrimitive]: {}}); + + // ToPrimitive: input[@@toPrimitive] returns object + test(TypeError, {[Symbol.toPrimitive]: function() { return Object(1); }}); + test(TypeError, {[Symbol.toPrimitive]: function() { return {}; }}); + + // ToPrimitive: input[@@toPrimitive] throws + test(MyError, {[Symbol.toPrimitive]: function() { throw new MyError(); }}); + } + + // OrdinaryToPrimitive: method throws + testCoercibleToPrimitiveWithMethod(hint, function() { + throw new MyError(); + }, function(value) { + test(MyError, value); + }); + + // OrdinaryToPrimitive: both methods are unsuitable + function testUnsuitableMethod(method) { + test(TypeError, {valueOf:method, toString:method}); + } + // not callable: + testUnsuitableMethod(null); + testUnsuitableMethod(1); + testUnsuitableMethod({}); + // returns object: + testUnsuitableMethod(function() { return Object(1); }); + testUnsuitableMethod(function() { return {}; }); +} + +function testCoercibleToString(test) { + function testPrimitiveValue(value, expectedString) { + test(value, expectedString); + // ToPrimitive + testPrimitiveWrappers(value, "string", function(value) { + test(value, expectedString); + }); + } + + testPrimitiveValue(undefined, "undefined"); + testPrimitiveValue(null, "null"); + testPrimitiveValue(true, "true"); + testPrimitiveValue(false, "false"); + testPrimitiveValue(0, "0"); + testPrimitiveValue(-0, "0"); + testPrimitiveValue(Infinity, "Infinity"); + testPrimitiveValue(-Infinity, "-Infinity"); + testPrimitiveValue(123.456, "123.456"); + testPrimitiveValue(-123.456, "-123.456"); + testPrimitiveValue("", ""); + testPrimitiveValue("foo", "foo"); + + if (typeof BigInt !== "undefined") { + // BigInt -> TypeError + testPrimitiveValue(BigInt(0), "0"); + } + + // toString of a few objects + test([], ""); + test(["foo", "bar"], "foo,bar"); + test({}, "[object Object]"); +} + +function testNotCoercibleToString(test) { + function testPrimitiveValue(value) { + test(TypeError, value); + // ToPrimitive + testPrimitiveWrappers(value, "string", function(value) { + test(TypeError, value); + }); + } + + // Symbol -> TypeError + if (typeof Symbol !== "undefined") { + testPrimitiveValue(Symbol("1")); + } + + // ToPrimitive + testNotCoercibleToPrimitive("string", test); +} + +function testCoercibleToBooleanTrue(test) { + test(true); + test(1); + test("string"); + if (typeof Symbol !== "undefined") { + test(Symbol("1")); + } + test({}); +} + +function testCoercibleToBooleanFalse(test) { + test(undefined); + test(null); + test(false); + test(0); + test(-0); + test(NaN); + test(""); +} + +function testCoercibleToBigIntZero(test) { + function testPrimitiveValue(value) { + test(value); + // ToPrimitive + testPrimitiveWrappers(value, "number", test); + } + + testCoercibleToBigIntFromBigInt(BigInt(0), test); + testPrimitiveValue(-BigInt(0)); + testPrimitiveValue("-0"); + testPrimitiveValue(false); + testPrimitiveValue(""); + testPrimitiveValue(" "); + + // toString() returns "" + test([]); + + // toString() returns "0" + test([0]); +} + +function testCoercibleToBigIntOne(test) { + function testPrimitiveValue(value) { + test(value); + // ToPrimitive + testPrimitiveWrappers(value, "number", test); + } + + testCoercibleToBigIntFromBigInt(BigInt(1), test); + testPrimitiveValue(true); + + // toString() returns "1" + test([1]); +} + +function testCoercibleToBigIntFromBigInt(nominalBigInt, test) { + function testPrimitiveValue(value) { + test(value); + // ToPrimitive + testPrimitiveWrappers(value, "number", test); + } + + testPrimitiveValue(nominalBigInt); + testPrimitiveValue(nominalBigInt.toString()); + testPrimitiveValue("0b" + nominalBigInt.toString(2)); + testPrimitiveValue("0o" + nominalBigInt.toString(8)); + testPrimitiveValue("0x" + nominalBigInt.toString(16)); + testPrimitiveValue(" " + nominalBigInt.toString() + " "); + + // toString() returns the decimal string representation + test([nominalBigInt]); + test([nominalBigInt.toString()]); +} + +function testNotCoercibleToBigInt(test) { + function testPrimitiveValue(error, value) { + test(error, value); + // ToPrimitive + testPrimitiveWrappers(value, "number", function(value) { + test(error, value); + }); + } + + // Undefined, Null, Number, Symbol -> TypeError + testPrimitiveValue(TypeError, undefined); + testPrimitiveValue(TypeError, null); + testPrimitiveValue(TypeError, 0); + testPrimitiveValue(TypeError, NaN); + testPrimitiveValue(TypeError, Infinity); + if (typeof Symbol !== "undefined") { + testPrimitiveValue(TypeError, Symbol("1")); + } + + // when a String parses to NaN -> SyntaxError + function testStringValue(string) { + testPrimitiveValue(SyntaxError, string); + testPrimitiveValue(SyntaxError, " " + string); + testPrimitiveValue(SyntaxError, string + " "); + testPrimitiveValue(SyntaxError, " " + string + " "); + } + testStringValue("a"); + testStringValue("0b2"); + testStringValue("0o8"); + testStringValue("0xg"); + testStringValue("1n"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/harness/wellKnownIntrinsicObjects.js b/crates/clazel-js-lexer/tests/data/test262/harness/wellKnownIntrinsicObjects.js new file mode 100644 index 000000000..382fdaf5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/harness/wellKnownIntrinsicObjects.js @@ -0,0 +1,403 @@ +// Copyright (C) 2018 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + An Array of all representable Well-Known Intrinsic Objects +defines: [WellKnownIntrinsicObjects, getWellKnownIntrinsicObject] +---*/ + +const WellKnownIntrinsicObjects = [ + { + name: '%AggregateError%', + source: 'AggregateError', + }, + { + name: '%Array%', + source: 'Array', + }, + { + name: '%ArrayBuffer%', + source: 'ArrayBuffer', + }, + { + name: '%ArrayIteratorPrototype%', + source: 'Object.getPrototypeOf([][Symbol.iterator]())', + }, + { + // Not currently accessible to ECMAScript user code + name: '%AsyncFromSyncIteratorPrototype%', + source: '', + }, + { + name: '%AsyncFunction%', + source: '(async function() {}).constructor', + }, + { + name: '%AsyncGeneratorFunction%', + source: '(async function* () {}).constructor', + }, + { + name: '%AsyncGeneratorPrototype%', + source: 'Object.getPrototypeOf(async function* () {}).prototype', + }, + { + name: '%AsyncIteratorPrototype%', + source: 'Object.getPrototypeOf(Object.getPrototypeOf(async function* () {}).prototype)', + }, + { + name: '%Atomics%', + source: 'Atomics', + }, + { + name: '%BigInt%', + source: 'BigInt', + }, + { + name: '%BigInt64Array%', + source: 'BigInt64Array', + }, + { + name: '%BigUint64Array%', + source: 'BigUint64Array', + }, + { + name: '%Boolean%', + source: 'Boolean', + }, + { + name: '%DataView%', + source: 'DataView', + }, + { + name: '%Date%', + source: 'Date', + }, + { + name: '%decodeURI%', + source: 'decodeURI', + }, + { + name: '%decodeURIComponent%', + source: 'decodeURIComponent', + }, + { + name: '%encodeURI%', + source: 'encodeURI', + }, + { + name: '%encodeURIComponent%', + source: 'encodeURIComponent', + }, + { + name: '%Error%', + source: 'Error', + }, + { + name: '%eval%', + source: 'eval', + }, + { + name: '%EvalError%', + source: 'EvalError', + }, + { + name: '%FinalizationRegistry%', + source: 'FinalizationRegistry', + }, + { + name: '%Float32Array%', + source: 'Float32Array', + }, + { + name: '%Float64Array%', + source: 'Float64Array', + }, + { + // Not currently accessible to ECMAScript user code + name: '%ForInIteratorPrototype%', + source: '', + }, + { + name: '%Function%', + source: 'Function', + }, + { + name: '%GeneratorFunction%', + source: '(function* () {}).constructor', + }, + { + name: '%GeneratorPrototype%', + source: 'Object.getPrototypeOf(function * () {}).prototype', + }, + { + name: '%Int8Array%', + source: 'Int8Array', + }, + { + name: '%Int16Array%', + source: 'Int16Array', + }, + { + name: '%Int32Array%', + source: 'Int32Array', + }, + { + name: '%isFinite%', + source: 'isFinite', + }, + { + name: '%isNaN%', + source: 'isNaN', + }, + { + name: '%Iterator%', + source: 'typeof Iterator !== "undefined" ? Iterator : Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())).constructor', + }, + { + name: '%IteratorHelperPrototype%', + source: 'Object.getPrototypeOf(Iterator.from([]).drop(0))', + }, + { + name: '%JSON%', + source: 'JSON', + }, + { + name: '%Map%', + source: 'Map', + }, + { + name: '%MapIteratorPrototype%', + source: 'Object.getPrototypeOf(new Map()[Symbol.iterator]())', + }, + { + name: '%Math%', + source: 'Math', + }, + { + name: '%Number%', + source: 'Number', + }, + { + name: '%Object%', + source: 'Object', + }, + { + name: '%parseFloat%', + source: 'parseFloat', + }, + { + name: '%parseInt%', + source: 'parseInt', + }, + { + name: '%Promise%', + source: 'Promise', + }, + { + name: '%Proxy%', + source: 'Proxy', + }, + { + name: '%RangeError%', + source: 'RangeError', + }, + { + name: '%ReferenceError%', + source: 'ReferenceError', + }, + { + name: '%Reflect%', + source: 'Reflect', + }, + { + name: '%RegExp%', + source: 'RegExp', + }, + { + name: '%RegExpStringIteratorPrototype%', + source: 'Object.getPrototypeOf(RegExp.prototype[Symbol.matchAll](""))', + }, + { + name: '%Set%', + source: 'Set', + }, + { + name: '%SetIteratorPrototype%', + source: 'Object.getPrototypeOf(new Set()[Symbol.iterator]())', + }, + { + name: '%SharedArrayBuffer%', + source: 'SharedArrayBuffer', + }, + { + name: '%String%', + source: 'String', + }, + { + name: '%StringIteratorPrototype%', + source: 'Object.getPrototypeOf(new String()[Symbol.iterator]())', + }, + { + name: '%Symbol%', + source: 'Symbol', + }, + { + name: '%SyntaxError%', + source: 'SyntaxError', + }, + { + name: '%ThrowTypeError%', + source: '(function() { "use strict"; return Object.getOwnPropertyDescriptor(arguments, "callee").get })()', + }, + { + name: '%TypedArray%', + source: 'Object.getPrototypeOf(Uint8Array)', + }, + { + name: '%TypeError%', + source: 'TypeError', + }, + { + name: '%Uint8Array%', + source: 'Uint8Array', + }, + { + name: '%Uint8ClampedArray%', + source: 'Uint8ClampedArray', + }, + { + name: '%Uint16Array%', + source: 'Uint16Array', + }, + { + name: '%Uint32Array%', + source: 'Uint32Array', + }, + { + name: '%URIError%', + source: 'URIError', + }, + { + name: '%WeakMap%', + source: 'WeakMap', + }, + { + name: '%WeakRef%', + source: 'WeakRef', + }, + { + name: '%WeakSet%', + source: 'WeakSet', + }, + { + name: '%WrapForValidIteratorPrototype%', + source: 'Object.getPrototypeOf(Iterator.from({ [Symbol.iterator](){ return {}; } }))', + }, + + // Extensions to well-known intrinsic objects. + // + // https://tc39.es/ecma262/#sec-additional-properties-of-the-global-object + { + name: "%escape%", + source: "escape", + }, + { + name: "%unescape%", + source: "unescape", + }, + + // Extensions to well-known intrinsic objects. + // + // https://tc39.es/ecma402/#sec-402-well-known-intrinsic-objects + { + name: "%Intl%", + source: "Intl", + }, + { + name: "%Intl.Collator%", + source: "Intl.Collator", + }, + { + name: "%Intl.DateTimeFormat%", + source: "Intl.DateTimeFormat", + }, + { + name: "%Intl.DisplayNames%", + source: "Intl.DisplayNames", + }, + { + name: "%Intl.DurationFormat%", + source: "Intl.DurationFormat", + }, + { + name: "%Intl.ListFormat%", + source: "Intl.ListFormat", + }, + { + name: "%Intl.Locale%", + source: "Intl.Locale", + }, + { + name: "%Intl.NumberFormat%", + source: "Intl.NumberFormat", + }, + { + name: "%Intl.PluralRules%", + source: "Intl.PluralRules", + }, + { + name: "%Intl.RelativeTimeFormat%", + source: "Intl.RelativeTimeFormat", + }, + { + name: "%Intl.Segmenter%", + source: "Intl.Segmenter", + }, + { + name: "%IntlSegmentIteratorPrototype%", + source: "Object.getPrototypeOf(new Intl.Segmenter().segment()[Symbol.iterator]())", + }, + { + name: "%IntlSegmentsPrototype%", + source: "Object.getPrototypeOf(new Intl.Segmenter().segment())", + }, + + // Extensions to well-known intrinsic objects. + // + // https://tc39.es/proposal-temporal/#sec-well-known-intrinsic-objects + { + name: "%Temporal%", + source: "Temporal", + }, +]; + +WellKnownIntrinsicObjects.forEach((wkio) => { + var actual; + + try { + actual = new Function("return " + wkio.source)(); + } catch (exception) { + // Nothing to do here. + } + + wkio.value = actual; +}); + +/** + * Returns a well-known intrinsic object, if the implementation provides it. + * Otherwise, throws. + * @param {string} key - the specification's name for the intrinsic, for example + * "%Array%" + * @returns {object} the well-known intrinsic object. + */ +function getWellKnownIntrinsicObject(key) { + for (var ix = 0; ix < WellKnownIntrinsicObjects.length; ix++) { + if (WellKnownIntrinsicObjects[ix].name === key) { + var value = WellKnownIntrinsicObjects[ix].value; + if (value !== undefined) + return value; + throw new Test262Error('this implementation could not obtain ' + key); + } + } + throw new Test262Error('unknown well-known intrinsic ' + key); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/arguments-object/10.5-1gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/arguments-object/10.5-1gs.js new file mode 100644 index 000000000..ef4554347 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/arguments-object/10.5-1gs.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.5-1gs +description: Strict Mode - arguments cannot be assigned to in a strict function +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + + +function f_10_5_1_gs(){ + arguments = 7; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T1.js new file mode 100644 index 000000000..514c8eb88 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T1.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check examples for automatic semicolon insertion from the standard +es5id: 7.9.2_A1_T1 +description: "{ 1 2 } 3 is not a valid sentence in the ECMAScript grammar" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +{ 1 2 } 3 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T2.js new file mode 100644 index 000000000..f8d103689 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T2.js @@ -0,0 +1,14 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check examples for automatic semicolon insertion from the standard +es5id: 7.9.2_A1_T2 +description: > + { 1 \n 2 } 3 is a valid sentence in the ECMAScript grammar with + automatic semicolon insertion +---*/ + +//CHECK#1 +{ 1 +2 } 3 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T3.js new file mode 100644 index 000000000..2ed562a7f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T3.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check examples for automatic semicolon insertion from the standard +es5id: 7.9.2_A1_T3 +description: for( a ; b \n ) is not a valid sentence in the ECMAScript grammar +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( a ; b +) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T4.js new file mode 100644 index 000000000..90f72da47 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T4.js @@ -0,0 +1,19 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check examples for automatic semicolon insertion from the standard +es5id: 7.9.2_A1_T4 +description: > + return \n a+b is a valid sentence in the ECMAScript grammar with + automatic semicolon insertion, but returned undefined +---*/ + +//CHECK#1 +var a=1,b=2; +function test(){ + return + a+b +} +var x=test(); +if (x!==undefined) throw new Test262Error('#1: Automatic semicolon insertion not work with return'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T5.js new file mode 100644 index 000000000..9ab51629c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T5.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check examples for automatic semicolon insertion from the standard +es5id: 7.9.2_A1_T5 +description: > + a=b \n ++c is a valid sentence in the ECMAScript grammar with + automatic semicolon insertion, but a!==b++c +---*/ + +//CHECK#1 +var a=1,b=2,c=3; +a=b +++c + +if (a!==b) throw new Test262Error('#1: Automatic semicolon insertion not work with ++'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T6.js new file mode 100644 index 000000000..4342057ba --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T6.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check examples for automatic semicolon insertion from the standard +es5id: 7.9.2_A1_T6 +description: > + if(a>b) \n else c=d is not a valid sentence in the ECMAScript + grammar +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +var a=1,b=2,c=3,d; +if(a>b) +else c=d diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T7.js new file mode 100644 index 000000000..1e404189d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9.2_A1_T7.js @@ -0,0 +1,22 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check examples for automatic semicolon insertion from the standard +es5id: 7.9.2_A1_T7 +description: > + a=b+c \n (d+e).print() is a valid sentence in the ECMAScript + grammar, and automatic semicolon insertion not run +---*/ + +//CHECK#1 +function c (a){ + return 2*a; +} + +var a=1,b=2,d=4,e=5; + +a=b+c +(d+e) + +if (a !== 20) throw new Test262Error('#1: Automatic semicolon insertion work wrong'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A1.js new file mode 100644 index 000000000..b7733ad16 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A1.js @@ -0,0 +1,36 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Continue Statement for automatic semicolon insertion +es5id: 7.9_A1 +description: Try use continue \n Label construction +---*/ + +//CHECK#1 +label1: for (var i = 0; i <= 0; i++) { + for (var j = 0; j <= 1; j++) { + if (j === 0) { + continue label1; + } else { + throw new Test262Error('#1: Check continue statement for automatic semicolon insertion'); + } + } +} + +//CHECK#2 +var result = false; +label2: for (var i = 0; i <= 1; i++) { + for (var j = 0; j <= 1; j++) { + if (j === 0) { + continue + label2; + } else { + result = true; + } + } +} + +if (result !== true) { + throw new Test262Error('#2: Check continue statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T1.js new file mode 100644 index 000000000..b5f291023 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T1.js @@ -0,0 +1,11 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T1 +description: Checking if execution of "1 * {}" passes +---*/ + +//CHECK#1 +1 * {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T10.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T10.js new file mode 100644 index 000000000..6e2808217 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T10.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T10 +description: "Checking if execution of \"{a:1 \\n} 3\" passes" +---*/ + +//CHECK#1 +{a:1 +} 3 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T11.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T11.js new file mode 100644 index 000000000..137eb88c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T11.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T11 +description: "Checking if execution of \"{a:1 \\n} \\n 3\" passes" +---*/ + +//CHECK#1 +{a:1 +} +3 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T12.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T12.js new file mode 100644 index 000000000..58ce4c594 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T12.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T12 +description: "Checking if execution of \"{ \\n a: \\n 1 \\n } \\n 3\" passes" +---*/ + +//CHECK#1 +{ +a: +1 +} +3 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T2.js new file mode 100644 index 000000000..4c84b0908 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T2.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T2 +description: Checking if execution of "{}*1" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +{} * 1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T3.js new file mode 100644 index 000000000..432b952e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T3.js @@ -0,0 +1,11 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T3 +description: Checking if execution of "({}) * 1" passes +---*/ + +//CHECK#1 +({}) * 1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T4.js new file mode 100644 index 000000000..59e86113f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T4.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T4 +description: Checking if execution of "({};)*1" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +({};) * 1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T5.js new file mode 100644 index 000000000..80e1a0ba4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T5.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T5 +description: Checking if execution of "( \n {} \n ) * 1" passes +---*/ + +//CHECK#1 +( + {} +) * 1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T6.js new file mode 100644 index 000000000..3dba58172 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T6.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T6 +description: Checking if execution of "{} \n * 1" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +{} + * 1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T7.js new file mode 100644 index 000000000..dba768216 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T7.js @@ -0,0 +1,11 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T7 +description: Checking if execution of "{1} 2" passes +---*/ + +//CHECK#1 +{1} 2 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T8.js new file mode 100644 index 000000000..0623d4850 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T8.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T8 +description: Checking if execution of "{1 2} 3" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +{1 2} 3 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T9.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T9.js new file mode 100644 index 000000000..144d41173 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A10_T9.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check {} for automatic semicolon insertion +es5id: 7.9_A10_T9 +description: Checking if execution of "{1 \n 2} 3" passes +---*/ + +//CHECK#1 +{1 +2} 3 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T1.js new file mode 100644 index 000000000..c198a44c4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T1.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T1 +description: Use if (false) x = 1 (without semicolon) and check x +---*/ + +//CHECK#1 +var x = 0; +if (false) x = 1 +if (x !== 0) { + throw new Test262Error('#1: Check If Statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T10.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T10.js new file mode 100644 index 000000000..98c4e2d45 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T10.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T10 +description: Use if (false) {x = 1} else {x=-1} and check x +---*/ + +//CHECK#1 +var x = 0; +if (false) {x = 1} else {x = -1} +if (x !== -1) { + throw new Test262Error('#1: Check If Statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T11.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T11.js new file mode 100644 index 000000000..757ff7912 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T11.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T11 +description: Use if (false) {{x = 1};} \n else x=-1 and check x +---*/ + +//CHECK#1 +var x = 0; +if (false) {{x = 1};} +else x = -1 +if (x !== -1) { + throw new Test262Error('#1: Check If Statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T2.js new file mode 100644 index 000000000..3bf9cbd85 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T2.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T2 +description: Use if (false) \n x = 1 and check x +---*/ + +//CHECK#1 +var x = 0; +if (false) +x = 1 +if (x !== 0) { + throw new Test262Error('#1: Check If Statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T3.js new file mode 100644 index 000000000..5536573bb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T3.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T3 +description: Use if (false);\n x = 1 and check x +---*/ + +//CHECK#1 +var x = 0; +if (false); +x = 1 +if (x !== 1) { + throw new Test262Error('#1: Check If Statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T4.js new file mode 100644 index 000000000..f99f2a611 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T4.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T4 +description: Checking if execution of "if (false) x = 1 else x = -1" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +var x = 0; +if (false) x = 1 else x = -1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T5.js new file mode 100644 index 000000000..66b2f962d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T5.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T5 +description: Use if (false) x = 1; else x=-1 and check x +---*/ + +//CHECK#1 +var x = 0; +if (false) x = 1; else x = -1 +if (x !== -1) { + throw new Test262Error('#1: Check If Statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T6.js new file mode 100644 index 000000000..da0f72fee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T6.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T6 +description: Use if (false) x = 1 \n else x=-1 and check x +---*/ + +//CHECK#1 +var x = 0; +if (false) x = 1 +else x = -1 +if (x !== -1) { + throw new Test262Error('#1: Check If Statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T7.js new file mode 100644 index 000000000..782fdafa9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T7.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T7 +description: Use if (false) x = 1; \n else x=-1 and check x +---*/ + +//CHECK#1 +var x = 0; +if (false) x = 1; +else x = -1 +if (x !== -1) { + throw new Test262Error('#1: Check If Statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T8.js new file mode 100644 index 000000000..f021a018e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T8.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T8 +description: Use if (false) {x = 1}; \n else x=-1 and check x +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +if (false) {}; +else {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T9.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T9.js new file mode 100644 index 000000000..3337ffd26 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A11_T9.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check If Statement for automatic semicolon insertion +es5id: 7.9_A11_T9 +description: Use if (false) {x = 1} \n else x=-1 and check x +---*/ + +//CHECK#1 +var x = 0; +if (false) {x = 1} +else x = -1 +if (x !== -1) { + throw new Test262Error('#1: Check If Statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A2.js new file mode 100644 index 000000000..5be2d3ef3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A2.js @@ -0,0 +1,30 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Break Statement for automatic semicolon insertion +es5id: 7.9_A2 +description: Try use break \n Label construction +---*/ + +//CHECK#1 +label1: for (var i = 0; i <= 0; i++) { + for (var j = 0; j <= 0; j++) { + break label1; + } + throw new Test262Error('#1: Check break statement for automatic semicolon insertion'); +} + +//CHECK#2 +var result = false; +label2: for (var i = 0; i <= 0; i++) { + for (var j = 0; j <= 0; j++) { + break + label2; + } + result = true; +} + +if (result !== true) { + throw new Test262Error('#2: Check break statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A3.js new file mode 100644 index 000000000..9df01a191 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A3.js @@ -0,0 +1,27 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Return Statement for automatic semicolon insertion +es5id: 7.9_A3 +description: Try use return \n Expression construction +---*/ + +//CHECK#1 +function f1() +{ + return 1; +} +if (f1() !== 1) { + throw new Test262Error('#1: Check return statement for automatic semicolon insertion'); +} + +//CHECK#2 +function f2() +{ + return + 1; +} +if (f2() !== undefined) { + throw new Test262Error('#2: Check return statement for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A4.js new file mode 100644 index 000000000..a4148c6ce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A4.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Throw Statement for automatic semicolon insertion +es5id: 7.9_A4 +description: Try use Throw \n Expression construction +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +try { + throw + 1; +} catch(e) { +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.1_T1.js new file mode 100644 index 000000000..38f7a6c0c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.1_T1.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Postfix Increment Operator for automatic semicolon insertion +es5id: 7.9_A5.1_T1 +description: Try use Variable \n ++ construction +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var x = 0; +x +++; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.2_T1.js new file mode 100644 index 000000000..65968e7f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.2_T1.js @@ -0,0 +1,21 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Prefix Increment Operator for automatic semicolon insertion +es5id: 7.9_A5.2_T1 +description: Try use Variable1 \n ++Variable2 construction +---*/ + +//CHECK#1 +var x = 0; +var y = 0; +x +++y +if (x !== 0) { + throw new Test262Error('#1: Check Prefix Increment Operator for automatic semicolon insertion'); +} else { + if (y !== 1) { + throw new Test262Error('#2: Check Prefix Increment Operator for automatic semicolon insertion'); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.3_T1.js new file mode 100644 index 000000000..86665927e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.3_T1.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Postfix Decrement Operator for automatic semicolon insertion +es5id: 7.9_A5.3_T1 +description: Try use Variable \n -- construction +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +var x = 1; +x +--; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.4_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.4_T1.js new file mode 100644 index 000000000..1384038b5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.4_T1.js @@ -0,0 +1,21 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Prefix Decrement Operator for automatic semicolon insertion +es5id: 7.9_A5.4_T1 +description: Try use Variable1 \n --Variable2 construction +---*/ + +//CHECK#1 +var x = 1; +var y = 1; +x +--y +if (x !== 1) { + throw new Test262Error('#1: Check Prefix Decrement Operator for automatic semicolon insertion'); +} else { + if (y !== 0) { + throw new Test262Error('#1: Check Prefix Decrement Operator for automatic semicolon insertion'); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T1.js new file mode 100644 index 000000000..55a4873c0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T1.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Function Expression for automatic semicolon insertion +es5id: 7.9_A5.5_T1 +description: Try use 1 + function_name\n(2 + 3) construction +---*/ + +//CHECK#1 +function f(t) { + return t; +} +var x = 1 + f +(2 + 3) +if (x !== 6) { + throw new Test262Error('#1: Check Function Expression for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T2.js new file mode 100644 index 000000000..aa9ec0cca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T2.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Function Expression for automatic semicolon insertion +es5id: 7.9_A5.5_T2 +description: > + Try use function f(o) {o.x = 1; return o;}; \n (new Object()).x; + construction +---*/ + +//CHECK#1 +var result = function f(o) {o.x = 1; return o;}; +(new Object()).x; +if (typeof result !== "function") { + throw new Test262Error('#1: Check Function Expression for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T3.js new file mode 100644 index 000000000..bee86321a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T3.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Function Expression for automatic semicolon insertion +es5id: 7.9_A5.5_T3 +description: > + Try use function f(o) {o.x = 1; return o;} \n (new Object()).x; + construction +---*/ + +//CHECK#1 +var result = function f(o) {o.x = 1; return o;} +(new Object()).x; +if (result !== 1) { + throw new Test262Error('#1: Check Function Expression for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T4.js new file mode 100644 index 000000000..933885494 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T4.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Function Expression for automatic semicolon insertion +es5id: 7.9_A5.5_T4 +description: Insert some LineTerminators into function body +---*/ + +//CHECK#1 +var x = +1 + (function (t){return {a:t +} +}) +(2 + 3). +a + +if (x !== 6) { + throw new Test262Error('#1: Check Function Expression for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T5.js new file mode 100644 index 000000000..0bdb99ea6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.5_T5.js @@ -0,0 +1,28 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Function Expression for automatic semicolon insertion +es5id: 7.9_A5.5_T5 +description: Insert some LineTerminators into rerutn expression; +---*/ + +//CHECK#1 +var x = +1 + (function f +(t){ +return { +a: +function(){ +return t + 1 +} +} +} +) +(2 + 3). +a +() + +if (x !== 7) { + throw new Test262Error('#1: Check Function Expression for automatic semicolon insertion'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.6_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.6_T1.js new file mode 100644 index 000000000..354c6b030 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.6_T1.js @@ -0,0 +1,35 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Since LineTerminator between Postfix Increment/Decrement Operator(I/DO) and operand is not allowed but + between Prefix I/DO and operand admitted, Postfix I/DO in combination with prefix I/DO after automatic semicolon insertion gives valid result +es5id: 7.9_A5.6_T1 +description: Try use Variable1 \n ++ \n Variable2 construction +---*/ + +var x=0, y=0; + +x +++ +y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#1 +if ((x!==0)&(y!==1)) { + throw new Test262Error('#1: Check Postfix Increment Operator for automatic semicolon insertion'); +} +// +////////////////////////////////////////////////////////////////////////////// + +x +++y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#2 +if ((x!==0)&(y!==2)) { + throw new Test262Error('#2: Check Postfix Increment Operator for automatic semicolon insertion'); +} +// +////////////////////////////////////////////////////////////////////////////// diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.6_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.6_T2.js new file mode 100644 index 000000000..5403fed5f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.6_T2.js @@ -0,0 +1,35 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Since LineTerminator between Postfix Increment/Decrement Operator(I/DO) and operand is not allowed but + between Prefix I/DO and operand admitted, Postfix I/DO in combination with prefix I/DO after automatic semicolon insertion gives valid result +es5id: 7.9_A5.6_T2 +description: Try use Variable1 \n -- \n Variable2 construction +---*/ + +var x=0, y=2; + +x +-- +y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#1 +if ((x!==0)&(y!==1)) { + throw new Test262Error('#1: Check Postfix Increment Operator for automatic semicolon insertion'); +} +// +////////////////////////////////////////////////////////////////////////////// + +x +--y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#2 +if ((x!==0)&(y!==0)) { + throw new Test262Error('#2: Check Postfix Increment Operator for automatic semicolon insertion'); +} +// +////////////////////////////////////////////////////////////////////////////// diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.7_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.7_T1.js new file mode 100644 index 000000000..7d7741268 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.7_T1.js @@ -0,0 +1,25 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Since LineTerminator(LT) between Postfix Increment/Decrement + Operator(I/DO) and operand is not allowed, two IO(just as two DO + and their combination) between two references separated by [LT] + after automatic semicolon insertion lead to syntax error + +es5id: 7.9_A5.7_T1 +description: Try use Variable1 \n ++ \n ++ \n Variable2 construction +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var x=0, y=0; +var z= +x +++ +++ +y diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.8_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.8_T1.js new file mode 100644 index 000000000..a56aebbb9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.8_T1.js @@ -0,0 +1,51 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Since LineTerminator(LT) between Postfix Increment/Decrement Operator(I/DO) and operand is admitted, + Additive/Substract Operator(A/SO) in combination with I/DO separated by LT or white spaces after automatic semicolon insertion gives valid result +es5id: 7.9_A5.8_T1 +description: Try use Variable1 \n + \n ++ \n Variable2 construction +---*/ + +var x=0, y=0; +var z= +x ++ +++ +y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#1 +if ((z!==1)&&(y!==1)&&(x!==0)) { + throw new Test262Error('#1: '); +} +// +////////////////////////////////////////////////////////////////////////////// + +z= +x ++ ++ +y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#2 +if ((z!==2)&&(y!==2)&&(x!==0)) { + throw new Test262Error(''); +} +// +////////////////////////////////////////////////////////////////////////////// + +z= +x ++ ++ +y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#3 +if ((z!==3)&&(y!==3)&&(x!==0)) { + throw new Test262Error(''); +} +// +////////////////////////////////////////////////////////////////////////////// diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.9_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.9_T1.js new file mode 100644 index 000000000..3257769b4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A5.9_T1.js @@ -0,0 +1,53 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Additive/Substract Operator(A/SO) in combination with itself separated by LT or white spaces + after automatic semicolon insertion gives valid result +es5id: 7.9_A5.9_T1 +description: > + Try use Variable1 (different combinations of three +) Variable2 + construction +---*/ + +var x=1, y=1; +var z= +x ++ ++ ++ +y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#1 +if ((z!==2)&&(y!==1)&&(x!==1)) { + throw new Test262Error('#1: '); +} +// +////////////////////////////////////////////////////////////////////////////// + +z= +x + + + y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#2 +if ((z!==2)&&(y!==1)&&(x!==1)) { + throw new Test262Error(''); +} +// +////////////////////////////////////////////////////////////////////////////// + +z= +x ++ + ++ + +y + +////////////////////////////////////////////////////////////////////////////// +//CHECK#3 +if ((z!==2)&&(y!==1)&&(x!==1)) { + throw new Test262Error(''); +} +// +////////////////////////////////////////////////////////////////////////////// diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T1.js new file mode 100644 index 000000000..dfb77fa0d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T1.js @@ -0,0 +1,14 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T1 +description: for( Empty two semicolons and \n) +---*/ + +//CHECK#1 +for(;; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T10.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T10.js new file mode 100644 index 000000000..fb8ae56e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T10.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T10 +description: for (false \n two semicolons false \n) +---*/ + +//CHECK#1 +for(false + ;;false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T11.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T11.js new file mode 100644 index 000000000..32d0ae6a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T11.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T11 +description: for (false \n semicolon \n semicolon \n) +---*/ + +//CHECK#1 +for(false + ; + ; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T12.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T12.js new file mode 100644 index 000000000..41581acd5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T12.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T12 +description: for (false \n semicolon false \n semicolon \n) +---*/ + +//CHECK#1 +for(false + ;false + ; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T13.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T13.js new file mode 100644 index 000000000..002896645 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T13.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T13 +description: for (false \n semicolon false \n semicolon false \n) +---*/ + +//CHECK#1 +for(false + ;false + ;false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T2.js new file mode 100644 index 000000000..c3b9b6af9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T2.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T2 +description: for (semicolon \n semicolon \n) +---*/ + +//CHECK#1 +for(; + ; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T3.js new file mode 100644 index 000000000..4a8a27107 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T3.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T3 +description: for (\n two semicolons \n) +---*/ + +//CHECK#1 +for( + ;; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T4.js new file mode 100644 index 000000000..23a89775a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T4.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T4 +description: for( \n semicolon \n semicolon \n) +---*/ + +//CHECK#1 +for( + ; + ; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T5.js new file mode 100644 index 000000000..77c703e62 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T5.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T5 +description: for ( \n semicolon \n\n semicolon \n) +---*/ + +//CHECK#1 +for( + ; + + ; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T6.js new file mode 100644 index 000000000..9a4a57231 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T6.js @@ -0,0 +1,14 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T6 +description: for(false semicolon false semicolon false \n) +---*/ + +//CHECK#1 +for(false;false;false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T7.js new file mode 100644 index 000000000..699933370 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T7.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T7 +description: for (false semicolon false \n semicolon \n) +---*/ + +//CHECK#1 +for(false;false + ; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T8.js new file mode 100644 index 000000000..bb722f6ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T8.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T8 +description: for (false semicolon false \n semicolon false \n) +---*/ + +//CHECK#1 +for(false;false + ;false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T9.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T9.js new file mode 100644 index 000000000..0d0b1ee99 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.1_T9.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.1_T9 +description: for (false \n two semicolons \n) +---*/ + +//CHECK#1 +for(false + ;; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T1.js new file mode 100644 index 000000000..38aa9436c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T1.js @@ -0,0 +1,22 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T1 +description: For header is (semicolon \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for(; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T10.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T10.js new file mode 100644 index 000000000..0951c46c5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T10.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T10 +description: For header is (\n false \n semicolon) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( + false +;) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T2.js new file mode 100644 index 000000000..e2cbfac50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T2.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T2 +description: For header is (\n semicolon \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( + ; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T3.js new file mode 100644 index 000000000..21f30a4fc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T3.js @@ -0,0 +1,22 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T3 +description: For header is (\n semicolon) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( +;) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T4.js new file mode 100644 index 000000000..b3c98ca53 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T4.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T4 +description: For header is (\n \n semicolon) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( + +;) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T5.js new file mode 100644 index 000000000..e70a91ed4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T5.js @@ -0,0 +1,22 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T5 +description: For header is (false semicolon false\n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for(false;false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T6.js new file mode 100644 index 000000000..7665aeaf1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T6.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T6 +description: For header is (false semicolon \n false) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for(false; +false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T7.js new file mode 100644 index 000000000..0136b60ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T7.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T7 +description: For header is (false \n semicolon \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for(false + ; +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T8.js new file mode 100644 index 000000000..91421ad7f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T8.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T8 +description: For header is (false \n semicolon false \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for(false + ;false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T9.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T9.js new file mode 100644 index 000000000..dafeb590b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.2_T9.js @@ -0,0 +1,22 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Use one semicolon +es5id: 7.9_A6.2_T9 +description: For header is (\n semicolon false) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( +;false) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T1.js new file mode 100644 index 000000000..dd6ad4edc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T1.js @@ -0,0 +1,22 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Don`t use semicolons +es5id: 7.9_A6.3_T1 +description: For header is (\n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T2.js new file mode 100644 index 000000000..94c53e242 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T2.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Don`t use semicolons +es5id: 7.9_A6.3_T2 +description: For header is (\n \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( + +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T3.js new file mode 100644 index 000000000..9d37a2311 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T3.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Don`t use semicolons +es5id: 7.9_A6.3_T3 +description: For header is (\n \n \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( + + +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T4.js new file mode 100644 index 000000000..a94a45c6d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T4.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Don`t use semicolons +es5id: 7.9_A6.3_T4 +description: For header is (\n false \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( + false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T5.js new file mode 100644 index 000000000..3b6bbbb43 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T5.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Don`t use semicolons +es5id: 7.9_A6.3_T5 +description: For header is (false \n false \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for(false + false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T6.js new file mode 100644 index 000000000..4bab0d81d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T6.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Don`t use semicolons +es5id: 7.9_A6.3_T6 +description: For header is (\n false \n false \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( + false + false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T7.js new file mode 100644 index 000000000..08cf8babe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.3_T7.js @@ -0,0 +1,25 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Check For Statement for automatic semicolon insertion. + If automatic insertion semicolon would become one of the two semicolons in the header of a For Statement. + Don`t use semicolons +es5id: 7.9_A6.3_T7 +description: For header is (\n false \n false \n false \n) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for( + false + false + false +) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.4_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.4_T1.js new file mode 100644 index 000000000..4fa465fae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.4_T1.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.4_T1 +description: > + Three semicolons. For header is (false semicolon false semicolon + false semicolon) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for(false;false;false;) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.4_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.4_T2.js new file mode 100644 index 000000000..1bcde233a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A6.4_T2.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check For Statement for automatic semicolon insertion +es5id: 7.9_A6.4_T2 +description: > + Three semicolons. For header is (false semicolon false two + semicolons false) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +for(false;false;;false) { + break; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T1.js new file mode 100644 index 000000000..7f07f49a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T1.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Var Statement for automatic semicolon insertion +es5id: 7.9_A7_T1 +description: Checking if execution of "var x \n = 1" passes +---*/ + +//CHECK#1 +var x += 1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T2.js new file mode 100644 index 000000000..336700564 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T2.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Var Statement for automatic semicolon insertion +es5id: 7.9_A7_T2 +description: Checking if execution of "var x = \n 1" passes +---*/ + +//CHECK#1 +var x = +1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T3.js new file mode 100644 index 000000000..b9932771c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T3.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Var Statement for automatic semicolon insertion +es5id: 7.9_A7_T3 +description: Checking if execution of "var x \n x = 1" passes +---*/ + +//CHECK#1 +var x +x = 1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T4.js new file mode 100644 index 000000000..97335dd86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T4.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Var Statement for automatic semicolon insertion +es5id: 7.9_A7_T4 +description: Checking if execution of "var \n x" passes +---*/ + +//CHECK#1 +var +x diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T5.js new file mode 100644 index 000000000..f8847257e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T5.js @@ -0,0 +1,14 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Var Statement for automatic semicolon insertion +es5id: 7.9_A7_T5 +description: Checking if execution of "var \n x \n = \n 1" passes +---*/ + +//CHECK#1 +var +x += +1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T6.js new file mode 100644 index 000000000..770eddab3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T6.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Var Statement for automatic semicolon insertion +es5id: 7.9_A7_T6 +description: Checking if execution of "var x, \n y" passes +---*/ + +//CHECK#1 +var x, +y diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T7.js new file mode 100644 index 000000000..f7d01e253 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T7.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Var Statement for automatic semicolon insertion +es5id: 7.9_A7_T7 +description: Checking if execution of "var x \n y" passes +---*/ + +assert.throws(ReferenceError, function() { +var x +y +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T8.js new file mode 100644 index 000000000..6a6cc87bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T8.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Var Statement for automatic semicolon insertion +es5id: 7.9_A7_T8 +description: Checking if execution of "var x \n ,y" passes +---*/ + +//CHECK#1 +var x +,y diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T9.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T9.js new file mode 100644 index 000000000..ddfab1f15 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A7_T9.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Var Statement for automatic semicolon insertion +es5id: 7.9_A7_T9 +description: Checking if execution of "var x \n ,y = 1" passes +---*/ + +//CHECK#1 +var +x +,y = 1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T1.js new file mode 100644 index 000000000..2d95a1f7e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T1.js @@ -0,0 +1,11 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Empty Statement for automatic semicolon insertion +es5id: 7.9_A8_T1 +description: Checking if execution of one semicolon passes +---*/ + +//CHECK#1 +; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T2.js new file mode 100644 index 000000000..280e19783 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T2.js @@ -0,0 +1,14 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Empty Statement for automatic semicolon insertion +es5id: 7.9_A8_T2 +description: Checking if execution of some semicolons with LineTerminators pases +---*/ + +//CHECK#1 +; +; +; +; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T3.js new file mode 100644 index 000000000..64079b91a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T3.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Empty Statement for automatic semicolon insertion +es5id: 7.9_A8_T3 +description: > + Checking if execution of some semicolons without LineTerminators + passes +---*/ + +//CHECK#1 +;;;; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T4.js new file mode 100644 index 000000000..b1f9ddeb4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T4.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Empty Statement for automatic semicolon insertion +es5id: 7.9_A8_T4 +description: > + Checking if execution of some semicolons with LineTerminators and + numbers passes +---*/ + +//CHECK#1 +;1; +;1 +;1; +;1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T5.js new file mode 100644 index 000000000..dcabbf506 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A8_T5.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Empty Statement for automatic semicolon insertion +es5id: 7.9_A8_T5 +description: > + Checking if execution of some semicolons without LineTerminators + but with numbers passes +---*/ + +//CHECK#1 +;;1;;1;;1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T1.js new file mode 100644 index 000000000..1556a5f84 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T1.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Do-While Statement for automatic semicolon insertion +es5id: 7.9_A9_T1 +description: Execute do { \n }while(false) +---*/ + +//CHECK#1 +do { +} while (false) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T2.js new file mode 100644 index 000000000..36ada6dfd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T2.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Do-While Statement for automatic semicolon insertion +es5id: 7.9_A9_T2 +description: Execute do; while(false) \n true +---*/ + +//CHECK#1 +do ; while (false) +true diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T5.js new file mode 100644 index 000000000..5658f8d66 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T5.js @@ -0,0 +1,14 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Do-While Statement for automatic semicolon insertion +es5id: 7.9_A9_T5 +description: Execute do { \n ; \n }while((false) \n ) +---*/ + +//CHECK#1 +do { + ; +} while ((false) +) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T6.js new file mode 100644 index 000000000..198e4e9fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T6.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Do-While Statement for automatic semicolon insertion +es5id: 7.9_A9_T6 +description: Execute do \n while(false) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +do +while (false) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T7.js new file mode 100644 index 000000000..b49fb8507 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T7.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Do-While Statement for automatic semicolon insertion +es5id: 7.9_A9_T7 +description: Execute do \n\n while(false) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +do + +while (false) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T8.js new file mode 100644 index 000000000..bd9333f6f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T8.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Do-While Statement for automatic semicolon insertion +es5id: 7.9_A9_T8 +description: Execute do {}; \n while(false) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +do {}; +while (false) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T9.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T9.js new file mode 100644 index 000000000..5626037e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/S7.9_A9_T9.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Check Do-While Statement for automatic semicolon insertion +es5id: 7.9_A9_T9 +description: Execute do {} \n while(false) +---*/ + +//CHECK#1 +do {} +while (false) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/asi/do-while-same-line.js b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/do-while-same-line.js new file mode 100644 index 000000000..9ad1605b5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/asi/do-while-same-line.js @@ -0,0 +1,24 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-rules-of-automatic-semicolon-insertion +description: ASI at the end of a do-while statement without a new line terminator +info: | + 1. When, as the source text is parsed from left to right, a token (called the offending token) is + encountered that is not allowed by any production of the grammar, then a semicolon is + automatically inserted before the offending token if one or more of the following conditions is + true: + + ... + - The previous token is ) and the inserted semicolon would then be parsed as the terminating + semicolon of a do-while statement (13.7.2). +---*/ + +var x; +do break ; while (0) x = 42; +assert.sameValue(x, 42); + +x = 0; +do do do ; while (x) while (x) while (x) x = 39; +assert.sameValue(x, 39); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-initialization-assignment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-initialization-assignment.js new file mode 100644 index 000000000..26aa30a1b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-initialization-assignment.js @@ -0,0 +1,15 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + for declaration: + disallow initialization assignment +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +for (let x = 3 in {}) { } + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-and-without-initializer.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-and-without-initializer.js new file mode 100644 index 000000000..60e6085d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-and-without-initializer.js @@ -0,0 +1,15 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + for declaration: + disallow multiple lexical bindings, with and without initializer +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +for (let x = 3, y in {}) { } + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-initializer.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-initializer.js new file mode 100644 index 000000000..8801dab22 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-with-initializer.js @@ -0,0 +1,15 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + for declaration: + disallow multiple lexical bindings, with initializer +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +for (let x = 3, y = 4 in {}) { } + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-without-and-with-initializer.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-without-and-with-initializer.js new file mode 100644 index 000000000..7b99b3a96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings-without-and-with-initializer.js @@ -0,0 +1,15 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + for declaration: + disallow multiple lexical bindings, without and with initializer +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +for (let x, y = 4 in {}) { } + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings.js new file mode 100644 index 000000000..da37179df --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/for-in/disallow-multiple-lexical-bindings.js @@ -0,0 +1,15 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + for declaration: + disallow multiple lexical bindings +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +for (let x, y in {}) { } + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-do-statement-while-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-do-statement-while-expression.js new file mode 100644 index 000000000..c9f35f2ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-do-statement-while-expression.js @@ -0,0 +1,15 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + function declarations in statement position: + do Statement while ( Expression ) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +do function g() {} while (false) + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-for-statement.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-for-statement.js new file mode 100644 index 000000000..bd5d9fb7d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-for-statement.js @@ -0,0 +1,15 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + function declarations in statement position: + for ( ;;) Statement +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +for (;false;) function g() {} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement-else-statement.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement-else-statement.js new file mode 100644 index 000000000..4b6f7cc89 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement-else-statement.js @@ -0,0 +1,16 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + function declarations in statement position in strict mode: + if ( Expression ) Statement else Statement +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +if (true) {} else function g() {} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement.js new file mode 100644 index 000000000..7d4538fb3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-if-expression-statement.js @@ -0,0 +1,16 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + function declarations in statement position in strict mode: + if ( Expression ) Statement +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +if (true) function g() {} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-while-expression-statement.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-while-expression-statement.js new file mode 100644 index 000000000..740bf874f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/function-declarations/in-statement-position-while-expression-statement.js @@ -0,0 +1,15 @@ +// Copyright (C) 2011 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 13.1 +description: > + function declarations in statement position: + while ( Expression ) Statement +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +while (false) function g() {} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..70768839f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-function-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (AsyncFunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {} async function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..57e8439d8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-function-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (AsyncFunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {} async function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..d6dfaf55f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-class.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-function-declaration.template +/*--- +description: redeclaration with ClassDeclaration (AsyncFunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {} class f {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..81abd90ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-const.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-function-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (AsyncFunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {} const f = 0 } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..22a8bf0a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-async-function-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (AsyncFunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {} function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..454719b94 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-function-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (AsyncFunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {} function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..1e1a9c0c5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-let.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-function-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (AsyncFunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {} let f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-var.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-var.js new file mode 100644 index 000000000..6d58d4fa0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-function-name-redeclaration-attempt-with-var.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/var.case +// - src/declarations/redeclare-allow-var/block-attempt-to-redeclare-async-function-declaration.template +/*--- +description: redeclaration with VariableDeclaration (AsyncFunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {} var f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..3f9be5f54 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-generator-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (AsyncGeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {} async function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..6ac3b9c43 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-generator-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (AsyncGeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {} async function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..7fbf6e2ac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-class.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-generator-declaration.template +/*--- +description: redeclaration with ClassDeclaration (AsyncGeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {} class f {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..3a70e5691 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-const.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-generator-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (AsyncGeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {} const f = 0 } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..ae4a8d562 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-async-generator-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (AsyncGeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {} function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..198b7c5a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-generator-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (AsyncGeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {} function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..7378d8154 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-let.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-async-generator-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (AsyncGeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {} let f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-var.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-var.js new file mode 100644 index 000000000..b52a4fe83 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/async-generator-name-redeclaration-attempt-with-var.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/var.case +// - src/declarations/redeclare-allow-var/block-attempt-to-redeclare-async-generator-declaration.template +/*--- +description: redeclaration with VariableDeclaration (AsyncGeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {} var f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..58a58a87a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-class-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (ClassDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {} async function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..614460249 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-class-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (ClassDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {} async function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..583ea3ead --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-class.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-class-declaration.template +/*--- +description: redeclaration with ClassDeclaration (ClassDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {} class f {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..d2aa0256f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-const.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-class-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (ClassDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {} const f = 0 } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..bba8cc353 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-function.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-class-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (ClassDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {} function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..f9ec35390 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-class-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (ClassDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {} function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..f84d52260 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-let.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-class-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (ClassDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {} let f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-var.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-var.js new file mode 100644 index 000000000..7de9c0fb8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/class-name-redeclaration-attempt-with-var.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/var.case +// - src/declarations/redeclare-allow-var/block-attempt-to-redeclare-class-declaration.template +/*--- +description: redeclaration with VariableDeclaration (ClassDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {} var f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..acafe8cc0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-const-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (LexicalDeclaration (const) in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; async function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..c806aec01 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-const-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (LexicalDeclaration (const) in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; async function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..5ffef47d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-class.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-const-declaration.template +/*--- +description: redeclaration with ClassDeclaration (LexicalDeclaration (const) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; class f {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..83b2f906e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-const.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-const-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (LexicalDeclaration (const) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; const f = 0 } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..8d04baa45 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-function.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-const-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (LexicalDeclaration (const) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..d241d9fbc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-const-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (LexicalDeclaration (const) in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..ec9d3c314 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-let.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-const-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (LexicalDeclaration (const) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; let f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-var.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-var.js new file mode 100644 index 000000000..71d12c571 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/const-name-redeclaration-attempt-with-var.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/var.case +// - src/declarations/redeclare-allow-var/block-attempt-to-redeclare-const-declaration.template +/*--- +description: redeclaration with VariableDeclaration (LexicalDeclaration (const) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; var f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..6dde22bb4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/fn-block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (VariableDeclaration in BlockStatement inside a function) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +function x() { + { async function f() {}; var f; } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..25f480d3e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/fn-block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (VariableDeclaration in BlockStatement inside a function) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +function x() { + { async function* f() {}; var f; } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..2a8a416ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-class.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/fn-block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with ClassDeclaration (VariableDeclaration in BlockStatement inside a function) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +function x() { + { class f {}; var f; } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..54dd9b63f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-const.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/fn-block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (VariableDeclaration in BlockStatement inside a function) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +function x() { + { const f = 0; var f; } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..6bf489887 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-function.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/fn-block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (VariableDeclaration in BlockStatement inside a function) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +function x() { + { function f() {}; var f; } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..0f3a5a1d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/fn-block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (VariableDeclaration in BlockStatement inside a function) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +function x() { + { function* f() {}; var f; } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..bb8edb65b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/fn-scope-var-name-redeclaration-attempt-with-let.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/fn-block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (VariableDeclaration in BlockStatement inside a function) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +function x() { + { let f; var f; } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-declaration-attempt-to-redeclare-with-var-declaration-nested-in-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-declaration-attempt-to-redeclare-with-var-declaration-nested-in-function.js new file mode 100644 index 000000000..8963e8452 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-declaration-attempt-to-redeclare-with-var-declaration-nested-in-function.js @@ -0,0 +1,31 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-block-static-semantics-early-errors +description: > + Redeclaration with VariableDeclaration (FunctionDeclaration in BlockStatement) +info: | + 13.2.1 Static Semantics: Early Errors + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function g() { + // Create an outer block-statement. + { + // A lexically declared function declaration. + function f() {} + + // An inner block-statement with a variable-declared name. + { + var f; + } + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..92e30355e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-function-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (FunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {} async function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..4ba5d9906 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-function-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (FunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {} async function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..b597b8922 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-class.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-function-declaration.template +/*--- +description: redeclaration with ClassDeclaration (FunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {} class f {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..cbcd8d8bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-const.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-function-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (FunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {} const f = 0 } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..4f7d8a286 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-function.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-function-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (FunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {} function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..674ecc75c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-function-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (FunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {} function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..13d0913c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-let.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-function-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (FunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {} let f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-var.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-var.js new file mode 100644 index 000000000..1e2c1279e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/function-name-redeclaration-attempt-with-var.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/var.case +// - src/declarations/redeclare-allow-var/block-attempt-to-redeclare-function-declaration.template +/*--- +description: redeclaration with VariableDeclaration (FunctionDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {} var f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..723e5a625 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-generator-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (GeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {} async function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..81b95f7ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-generator-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (GeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {} async function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..6a6ba72d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-class.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-generator-declaration.template +/*--- +description: redeclaration with ClassDeclaration (GeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {} class f {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..508b0737e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-const.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-generator-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (GeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {} const f = 0 } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..a675b8cf5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-generator-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (GeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {} function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..783dc3c44 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-generator-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (GeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {} function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..f7959e3a4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-let.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-generator-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (GeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {} let f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-var.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-var.js new file mode 100644 index 000000000..52a377ab0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/generator-name-redeclaration-attempt-with-var.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/var.case +// - src/declarations/redeclare-allow-var/block-attempt-to-redeclare-generator-declaration.template +/*--- +description: redeclaration with VariableDeclaration (GeneratorDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {} var f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..bd659d5b3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ { var f; } async function f() {}; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..175658db5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ { var f; } async function* f() {}; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..5f93752ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-class.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration.template +/*--- +description: redeclaration with ClassDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ { var f; } class f {}; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..e49072423 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-const.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ { var f; } const f = 0; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..36eb41cbf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-function.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-inner-block-var-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ { var f; } function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..45f3de214 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ { var f; } function* f() {}; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..13fe7e4f1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-name-redeclaration-attempt-with-let.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ { var f; } let f; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-function.js new file mode 100644 index 000000000..b36721b3d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-function.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration-after.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {}; { var f; } } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-generator.js new file mode 100644 index 000000000..fb1d140ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-async-generator.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration-after.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {}; { var f; } } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-class.js new file mode 100644 index 000000000..7c5c179c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-class.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration-after.template +/*--- +description: redeclaration with ClassDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {}; { var f; } } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-const.js new file mode 100644 index 000000000..10ff104d2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-const.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration-after.template +/*--- +description: redeclaration with const-LexicalDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; { var f; } } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-function.js new file mode 100644 index 000000000..99c65d0eb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-function.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-inner-block-var-declaration-after.template +/*--- +description: redeclaration with FunctionDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {} { var f; } } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-generator.js new file mode 100644 index 000000000..2211f0ce2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-generator.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration-after.template +/*--- +description: redeclaration with GeneratorDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {}; { var f; } } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-let.js new file mode 100644 index 000000000..c0b537f2e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/inner-block-var-redeclaration-attempt-after-let.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-inner-block-var-declaration-after.template +/*--- +description: redeclaration with let-LexicalDeclaration (VariableDeclaration in a BlockStatement inside a BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + + Static Semantics: VarDeclaredNames + + Block : { } + + 1. Return a new empty List. + + StatementList : StatementList StatementListItem + + 1. Let names be VarDeclaredNames of StatementList. + 2. Append to names the elements of the VarDeclaredNames of StatementListItem. + 3. Return names. + + StatementListItem : Declaration + + 1. Return a new empty List. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; { var f; } } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..fcd29298f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-let-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (LexicalDeclaration (let) in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; async function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..9fa415432 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-let-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (LexicalDeclaration (let) in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; async function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..f44a789d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-class.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-let-declaration.template +/*--- +description: redeclaration with ClassDeclaration (LexicalDeclaration (let) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; class f {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..737db517e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-const.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-let-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (LexicalDeclaration (let) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; const f = 0 } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..f226dbdac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-function.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-let-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (LexicalDeclaration (let) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..7a9639046 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-let-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (LexicalDeclaration (let) in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..a332e9cf2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-let.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-let-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (LexicalDeclaration (let) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains + any duplicate entries. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; let f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-var.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-var.js new file mode 100644 index 000000000..7ab6a776c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/let-name-redeclaration-attempt-with-var.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/var.case +// - src/declarations/redeclare-allow-var/block-attempt-to-redeclare-let-declaration.template +/*--- +description: redeclaration with VariableDeclaration (LexicalDeclaration (let) in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; var f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-function.js new file mode 100644 index 000000000..23e4499f1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ var f; async function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-generator.js new file mode 100644 index 000000000..df9d2efdf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-async-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ var f; async function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-class.js new file mode 100644 index 000000000..3b80ef422 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-class.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with ClassDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ var f; class f {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-const.js new file mode 100644 index 000000000..f9758ba3c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-const.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with const-LexicalDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ var f; const f = 0 } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-function.js new file mode 100644 index 000000000..7e324b403 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-function.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with FunctionDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ var f; function f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-generator.js new file mode 100644 index 000000000..1db5e83a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with GeneratorDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ var f; function* f() {} } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-let.js new file mode 100644 index 000000000..63f3cb6fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-name-redeclaration-attempt-with-let.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration.template +/*--- +description: redeclaration with let-LexicalDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ var f; let f } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-function.js new file mode 100644 index 000000000..c28769779 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-function.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-function.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration-after.template +/*--- +description: redeclaration with AsyncFunctionDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ async function f() {}; var f; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-generator.js new file mode 100644 index 000000000..c56398ba3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-async-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/async-generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration-after.template +/*--- +description: redeclaration with AsyncGeneratorDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ async function* f() {}; var f; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-class.js new file mode 100644 index 000000000..b2a77d26c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-class.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/class.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration-after.template +/*--- +description: redeclaration with ClassDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ class f {}; var f; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-const.js new file mode 100644 index 000000000..696cea7a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-const.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/const.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration-after.template +/*--- +description: redeclaration with const-LexicalDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ const f = 0; var f; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-function.js new file mode 100644 index 000000000..6bd084d2e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-function.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/function.case +// - src/declarations/redeclare-allow-sloppy-function/block-attempt-to-redeclare-var-declaration-after.template +/*--- +description: redeclaration with FunctionDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ function f() {}; var f; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-generator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-generator.js new file mode 100644 index 000000000..4bf5382d8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-generator.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/generator.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration-after.template +/*--- +description: redeclaration with GeneratorDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ function* f() {}; var f; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-let.js new file mode 100644 index 000000000..91ea87922 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/block-scope/syntax/redeclaration/var-redeclaration-attempt-after-let.js @@ -0,0 +1,22 @@ +// This file was procedurally generated from the following sources: +// - src/declarations/let.case +// - src/declarations/redeclare/block-attempt-to-redeclare-var-declaration-after.template +/*--- +description: redeclaration with let-LexicalDeclaration (VariableDeclaration in BlockStatement) +esid: sec-block-static-semantics-early-errors +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Block : { StatementList } + + It is a Syntax Error if any element of the LexicallyDeclaredNames of + StatementList also occurs in the VarDeclaredNames of StatementList. + +---*/ + + +$DONOTEVALUATE(); + +{ let f; var f; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A1_T1.js new file mode 100644 index 000000000..12427b5f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A1_T1.js @@ -0,0 +1,34 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of single line comments +es5id: 7.4_A1_T1 +description: Create comments with any code +---*/ + +//CHECK#1 +// Test262Error.thrower('#1: Correct interpretation single line comments'); + +//CHECK#2 +var x = 0; +assert.sameValue(x, 0, 'The value of `x` is 0'); + +//CHECK#3 +var // y = 1; +y; +assert.sameValue(y, undefined, 'The value of `y` is expected to equal `undefined`'); + +//CHECK#4 +//Test262Error.thrower('#4: Correct interpretation single line comments') //Test262Error.thrower('#4: Correct interpretation single line comments'); // + +////CHECK#5 +//var x = 1; +//if (x === 1) { +// Test262Error.thrower('#5: Correct interpretation single line comments'); +//} + +//CHECK#6 +//var this.y = 1; +this.y++; +assert.sameValue(isNaN(y), true, 'isNaN(y) returns true'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A1_T2.js new file mode 100644 index 000000000..eed3ce9a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A1_T2.js @@ -0,0 +1,11 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of single line comments +es5id: 7.4_A1_T2 +description: "Simple test, create empty comment: ///" +---*/ + +//CHECK#1 +/// diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A2_T1.js new file mode 100644 index 000000000..51598ef05 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A2_T1.js @@ -0,0 +1,63 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of multi line comments +es5id: 7.4_A2_T1 +description: Create comments with any code +---*/ + +/*CHECK#1*/ +/* Test262Error.thrower('#1: Correct interpretation multi line comments'); +*/ + +/*CHECK#2*/ +var x = 0; +/* x = 1;*/ +assert.sameValue(x, 0, 'The value of `x` is 0'); + +//CHECK#3 +var /* y = 1;*/ +y; +assert.sameValue(y, undefined, 'The value of `y` is expected to equal `undefined`'); + +//CHECK#4 +var /* y = 1;*/ y; +assert.sameValue(y, undefined, 'The value of `y` is expected to equal `undefined`'); + +/*CHECK#5*/ +/*var x = 1; +if (x === 1) { + Test262Error.thrower('#5: Correct interpretation multi line comments'); +} +*/ + +/*CHECK#6*/ +/*var this.y = 1;*/ +this.y++; +assert.sameValue(isNaN(y), true, 'isNaN(y) returns true'); + +//CHECK#7 +var string = "/*var y = 0*/" /* y = 1;*/ +assert.sameValue(string, "/*var y = 0*/", 'The value of `string` is "/*var y = 0*/"'); + +//CHECK#8 +var string = "/*var y = 0" /* y = 1;*/ +assert.sameValue(string, "/*var y = 0", 'The value of `string` is "/*var y = 0"'); + +/*CHECK#9*/ +/** Test262Error.thrower('#9: Correct interpretation multi line comments'); +*/ + +/*CHECK#10*/ +/* Test262Error.thrower('#10: Correct interpretation multi line comments'); +**/ + +/*CHECK#11*/ +/****** Test262Error.thrower('#11: Correct interpretation multi line comments');********* +*********** +* + + +********** +**/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A2_T2.js new file mode 100644 index 000000000..1df05201e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A2_T2.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of multi line comments +es5id: 7.4_A2_T2 +description: Try use /*CHECK#1/. This is not closed multi line comment +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/*CHECK#1/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A3.js new file mode 100644 index 000000000..0ebfeb4fc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A3.js @@ -0,0 +1,22 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Multi line comments cannot nest +es5id: 7.4_A3 +description: Try use nested comments +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/*CHECK#1*/ + +/* +var + +/* x */ += 1; +*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T1.js new file mode 100644 index 000000000..785bdfa0e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T1.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single and Multi line comments are used together +es5id: 7.4_A4_T1 +description: Try use 2 close comment tags +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/*CHECK#1*/ + +/* var*/ +x*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T2.js new file mode 100644 index 000000000..79119ab14 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T2.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single and Multi line comments are used together +es5id: 7.4_A4_T2 +description: Fist Multi line comment, then Single line comment +---*/ + +/*CHECK#1*/ + +/* var +*///x*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T3.js new file mode 100644 index 000000000..de3ac7ff6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T3.js @@ -0,0 +1,14 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single and Multi line comments are used together +es5id: 7.4_A4_T3 +description: Insert Single line comment into Multi line comment +---*/ + +/*CHECK#1*/ + +/* var +//x +*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T4.js new file mode 100644 index 000000000..8d5b5cd81 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T4.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single and Multi line comments are used together +es5id: 7.4_A4_T4 +description: Try to open Multi line comment at the end of Single comment +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/*CHECK#1*/ + +// var /* +x*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T5.js new file mode 100644 index 000000000..4af1135ce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T5.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single and Multi line comments are used together +es5id: 7.4_A4_T5 +description: Insert Multi line comment into Single line comment +---*/ + +/*CHECK#1*/ + +// var /* x */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T6.js new file mode 100644 index 000000000..d82b64f10 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T6.js @@ -0,0 +1,14 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single and Multi line comments are used together +es5id: 7.4_A4_T6 +description: > + Insert Multi line comment with two closed tags into Single line + comment +---*/ + +/*CHECK#1*/ + +// var /* x / = */ 1 */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T7.js new file mode 100644 index 000000000..cb5a14c3b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A4_T7.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single and Multi line comments are used together +es5id: 7.4_A4_T7 +description: Insert Multi line comment into Single line comments +---*/ + +/*CHECK#1*/ + +// var /* +// x +// = +// 1*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A5.js new file mode 100644 index 000000000..9bb6a6148 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A5.js @@ -0,0 +1,40 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Single line comments can contain any Unicode character without Line + Terminators +es5id: 7.4_A5 +description: > + //var " + xx + "yy = -1", insert instead of xx all Unicode + characters +---*/ + +var hex = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]; +for (var i1 = 0; i1 < 16; i1++) { + for (var i2 = 0; i2 < 16; i2++) { + for (var i3 = 0; i3 < 16; i3++) { + for (var i4 = 0; i4 < 16; i4++) { + try { + var uu = hex[i1] + hex[i2] + hex[i3] + hex[i4]; + var xx = String.fromCharCode("0x" + uu); + var LineTerminators = ((uu === "000A") || (uu === "000D") || (uu === "2028") || (uu === "2029")); + var yy = 0; + eval("//var " + xx + "yy = -1"); + if (LineTerminators !== true) { + if (yy !== 0) { + throw new Test262Error('#' + uu + ' '); + } + } else { + if (yy !== -1) { + throw new Test262Error('#' + uu + ' '); + } + } + } catch (e){ + throw new Test262Error('#' + uu + ' '); + } + } + } + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A6.js new file mode 100644 index 000000000..1502fd735 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/S7.4_A6.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + If multi line comments csn not nest, they can contain any Unicode + character +es5id: 7.4_A6 +description: "\"var\"+ yy+ \"xx = 1\", insert instead of yy all Unicode characters" +includes: [decimalToHexString.js] +---*/ + +for (var indexI = 0; indexI <= 65535; indexI++) { + try { + var xx = 0; + eval("/*var " + String.fromCharCode(indexI) + "xx = 1*/"); + var differs = xx !== 0; + } catch (e){ + throw new Test262Error('#' + decimalToHexString(indexI) + ' throws'); + } + if (differs) { + throw new Test262Error('#' + decimalToHexString(indexI) + ' differs'); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-041.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-041.js new file mode 100644 index 000000000..c232decb8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-041.js @@ -0,0 +1,20 @@ +#\041 + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed to have encoded characters \041 +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-u0021.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-u0021.js new file mode 100644 index 000000000..52b012bff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-u0021.js @@ -0,0 +1,20 @@ +#\u0021 + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed to have encoded characters \u0021 +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-u21.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-u21.js new file mode 100644 index 000000000..75f7e4d5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-u21.js @@ -0,0 +1,20 @@ +#\u{21} + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed to have encoded characters \u{21} +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-x21.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-x21.js new file mode 100644 index 000000000..f6233833d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-bang-x21.js @@ -0,0 +1,20 @@ +#\x21 + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed to have encoded characters \x21 +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-043.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-043.js new file mode 100644 index 000000000..0c9e27d0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-043.js @@ -0,0 +1,20 @@ +\043! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed to have encoded characters \043 +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-u0023.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-u0023.js new file mode 100644 index 000000000..2cb370a63 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-u0023.js @@ -0,0 +1,20 @@ +\u0023! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed to have encoded characters \u0023 +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-u23.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-u23.js new file mode 100644 index 000000000..96859b568 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-u23.js @@ -0,0 +1,20 @@ +\u{23}! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed to have encoded characters \u{23} +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-x23.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-x23.js new file mode 100644 index 000000000..82ae6c48c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hash-x23.js @@ -0,0 +1,20 @@ +\x23! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed to have encoded characters \x23 +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hashbang.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hashbang.js new file mode 100644 index 000000000..9cfe30afc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/escaped-hashbang.js @@ -0,0 +1,20 @@ +\u0023\u0021 + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed to have encoded characters +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/eval-indirect.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/eval-indirect.js new file mode 100644 index 000000000..2c68fc07a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/eval-indirect.js @@ -0,0 +1,16 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should be available in Script evaluator contexts. (indirect eval) +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +features: [hashbang] +---*/ + +assert.sameValue((0, eval)('#!\n'), undefined); +assert.sameValue((0, eval)('#!\n1'), 1) +assert.sameValue((0, eval)('#!2\n'), undefined); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/eval.js new file mode 100644 index 000000000..dc963a20c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/eval.js @@ -0,0 +1,16 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should be available in Script evaluator contexts. (direct eval) +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +features: [hashbang] +---*/ + +assert.sameValue(eval('#!\n'), undefined); +assert.sameValue(eval('#!\n1'), 1) +assert.sameValue(eval('#!2\n'), undefined); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/function-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/function-body.js new file mode 100644 index 000000000..4e4aa9137 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/function-body.js @@ -0,0 +1,20 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should only be allowed at the start of source texts and should not be allowed within function bodies. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +$DONOTEVALUATE(); + +function fn() {#! +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/function-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/function-constructor.js new file mode 100644 index 000000000..f4bc44618 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/function-constructor.js @@ -0,0 +1,27 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be allowed in function evaluator contexts. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +features: [hashbang] +---*/ + +const AsyncFunction = (async function (){}).constructor; +const GeneratorFunction = (function *(){}).constructor; +const AsyncGeneratorFunction = (async function *(){}).constructor; +for (const ctor of [ + Function, + AsyncFunction, + GeneratorFunction, + AsyncGeneratorFunction, +]) { + assert.throws(SyntaxError, () => ctor('#!\n_', ''), `${ctor.name} Call argument`); + assert.throws(SyntaxError, () => ctor('#!\n_'), `${ctor.name} Call body`); + assert.throws(SyntaxError, () => new ctor('#!\n_', ''), `${ctor.name} Construct argument`); + assert.throws(SyntaxError, () => new ctor('#!\n_'), `${ctor.name} Construct body`); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/line-terminator-carriage-return.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/line-terminator-carriage-return.js new file mode 100644 index 000000000..f8cc382a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/line-terminator-carriage-return.js @@ -0,0 +1,28 @@ +#! this comment ends with a Carriage Return (U+000D) { +} + +// Copyright (C) 2019 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments are terminated by the first LineTerminator: Carriage Return +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] + + SingleLineCommentChars:: + SingleLineCommentChar SingleLineCommentChars[opt] + + SingleLineCommentChar:: + SourceCharacter but not LineTerminator + + LineTerminator:: + + + + +flags: [raw] +features: [hashbang] +---*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/line-terminator-line-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/line-terminator-line-separator.js new file mode 100644 index 000000000..20d917be6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/line-terminator-line-separator.js @@ -0,0 +1,28 @@ +#! this comment ends with a Line Separator (U+2028)
{ +} + +// Copyright (C) 2019 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments are terminated by the first LineTerminator: Line Separator +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] + + SingleLineCommentChars:: + SingleLineCommentChar SingleLineCommentChars[opt] + + SingleLineCommentChar:: + SourceCharacter but not LineTerminator + + LineTerminator:: + + + + +flags: [raw] +features: [hashbang] +---*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/line-terminator-paragraph-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/line-terminator-paragraph-separator.js new file mode 100644 index 000000000..abfa4f6da --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/line-terminator-paragraph-separator.js @@ -0,0 +1,28 @@ +#! this comment ends with a Paragraph Separator (U+2029)
{ +} + +// Copyright (C) 2019 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments are terminated by the first LineTerminator: Paragraph Separator +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] + + SingleLineCommentChars:: + SingleLineCommentChar SingleLineCommentChars[opt] + + SingleLineCommentChar:: + SourceCharacter but not LineTerminator + + LineTerminator:: + + + + +flags: [raw] +features: [hashbang] +---*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/module.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/module.js new file mode 100644 index 000000000..373475edc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/module.js @@ -0,0 +1,15 @@ +#! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should be allowed in Modules. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [module, raw] +features: [hashbang] +---*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/multi-line-comment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/multi-line-comment.js new file mode 100644 index 000000000..c6956b334 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/multi-line-comment.js @@ -0,0 +1,21 @@ +#!/* +throw "Test262: This statement should not be evaluated."; +these characters should not be considered within a comment +*/ + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not interpret multi-line comments. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/no-line-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/no-line-separator.js new file mode 100644 index 000000000..93dbb019e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/no-line-separator.js @@ -0,0 +1,14 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not require a newline afterwards +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +features: [hashbang] +---*/ + +assert.sameValue(eval('#!'), undefined); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/not-empty.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/not-empty.js new file mode 100644 index 000000000..d8a4c98f1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/not-empty.js @@ -0,0 +1,15 @@ +#! these characters should be treated as a comment + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should be allowed in Scripts and should not be required to be empty. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +features: [hashbang] +---*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-directive-prologue-sc.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-directive-prologue-sc.js new file mode 100644 index 000000000..bc010e721 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-directive-prologue-sc.js @@ -0,0 +1,21 @@ +"use strict"; +#! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should only be allowed at start of source texts and should not be preceded by DirectivePrologues. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-directive-prologue.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-directive-prologue.js new file mode 100644 index 000000000..42cae8422 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-directive-prologue.js @@ -0,0 +1,21 @@ +"use strict" +#! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should only be allowed at start of source texts and should not be preceded by DirectivePrologues. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-empty-statement.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-empty-statement.js new file mode 100644 index 000000000..7a6692237 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-empty-statement.js @@ -0,0 +1,20 @@ +;#! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should only be allowed at the start of source texts and should not be preceded by empty statements. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-hashbang.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-hashbang.js new file mode 100644 index 000000000..166457f37 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-hashbang.js @@ -0,0 +1,21 @@ +#! +#! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should only be allowed at the start of source texts and should not be preceded by Hashbang comments. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-line-comment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-line-comment.js new file mode 100644 index 000000000..f30e60948 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-line-comment.js @@ -0,0 +1,21 @@ +// +#! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should only be allowed at the start of source texts and should not be preceded by line comments. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-multi-line-comment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-multi-line-comment.js new file mode 100644 index 000000000..f582e2999 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-multi-line-comment.js @@ -0,0 +1,21 @@ +/* +*/#! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should only be allowed at the start of source texts and should not be preceded by multi-line comments. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-whitespace.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-whitespace.js new file mode 100644 index 000000000..03afd1b87 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/preceding-whitespace.js @@ -0,0 +1,20 @@ + #! + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should only be allowed at the start of source texts and should not be preceded by whitespace. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +throw "Test262: This statement should not be evaluated."; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/statement-block.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/statement-block.js new file mode 100644 index 000000000..dbed2a15f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/statement-block.js @@ -0,0 +1,21 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should only be allowed at the start of source texts and should not be allowed within blocks. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +negative: + phase: parse + type: SyntaxError +features: [hashbang] +---*/ + +$DONOTEVALUATE(); + +{ + #! +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/use-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/use-strict.js new file mode 100644 index 000000000..962614c0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/hashbang/use-strict.js @@ -0,0 +1,17 @@ +#!"use strict" + +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: pending +description: > + Hashbang comments should not be interpreted and should not generate DirectivePrologues. +info: | + HashbangComment:: + #! SingleLineCommentChars[opt] +flags: [raw] +features: [hashbang] +---*/ + +with ({}) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/mongolian-vowel-separator-multi.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/mongolian-vowel-separator-multi.js new file mode 100644 index 000000000..687fd9f3d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/mongolian-vowel-separator-multi.js @@ -0,0 +1,26 @@ +// Copyright (C) 2016 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-unicode-format-control-characters +description: > + Mongolian Vowel Separator can appear in multi-line comments. +info: | + 11.1 Unicode Format-Control Characters + + The Unicode format-control characters (i.e., the characters in category “Cf” + in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT + MARK) are control codes used to control the formatting of a range of text in + the absence of higher-level protocols for this (such as mark-up languages). + + It is useful to allow format-control characters in source text to facilitate + editing and display. All format control characters may be used within comments, + and within string literals, template literals, and regular expression literals. +features: [u180e] +---*/ + +// U+180E in comments; UTF8(0x180E) = 0xE1 0xA0 0x8E +assert.sameValue( + 0, /*᠎ multi-line comment with U+180E */ + 0 +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/mongolian-vowel-separator-single-eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/mongolian-vowel-separator-single-eval.js new file mode 100644 index 000000000..a6e4495cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/mongolian-vowel-separator-single-eval.js @@ -0,0 +1,22 @@ +// Copyright (C) 2016 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-unicode-format-control-characters +description: > + Mongolian Vowel Separator can appear in single-line comments (eval code). +info: | + 11.1 Unicode Format-Control Characters + + The Unicode format-control characters (i.e., the characters in category “Cf” + in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT + MARK) are control codes used to control the formatting of a range of text in + the absence of higher-level protocols for this (such as mark-up languages). + + It is useful to allow format-control characters in source text to facilitate + editing and display. All format control characters may be used within comments, + and within string literals, template literals, and regular expression literals. +features: [u180e] +---*/ + +assert.sameValue(eval("0 //\u180E"), 0); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/mongolian-vowel-separator-single.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/mongolian-vowel-separator-single.js new file mode 100644 index 000000000..c27dfe935 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/mongolian-vowel-separator-single.js @@ -0,0 +1,26 @@ +// Copyright (C) 2016 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-unicode-format-control-characters +description: > + Mongolian Vowel Separator can appear in single-line comments. +info: | + 11.1 Unicode Format-Control Characters + + The Unicode format-control characters (i.e., the characters in category “Cf” + in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT + MARK) are control codes used to control the formatting of a range of text in + the absence of higher-level protocols for this (such as mark-up languages). + + It is useful to allow format-control characters in source text to facilitate + editing and display. All format control characters may be used within comments, + and within string literals, template literals, and regular expression literals. +features: [u180e] +---*/ + +// U+180E in comments; UTF8(0x180E) = 0xE1 0xA0 0x8E +assert.sameValue( + 0, //᠎ single-line comment with U+180E + 0 +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-carriage-return.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-carriage-return.js new file mode 100644 index 000000000..e8b6c9750 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-carriage-return.js @@ -0,0 +1,17 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.4 +esid: sec-comments +description: > + A multi-line comment containing a carriage return should be considered a + LineTerminator +info: > + Comments behave like white space and are discarded except that, if a + MultiLineComment contains a line terminator code point, then the entire + comment is considered to be a LineTerminator for purposes of parsing by the + syntactic grammar. +---*/ + +''/* */'' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-line-feed.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-line-feed.js new file mode 100644 index 000000000..d253f837f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-line-feed.js @@ -0,0 +1,18 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.4 +esid: sec-comments +description: > + A multi-line comment containing a line feed should be considered a + LineTerminator +info: > + Comments behave like white space and are discarded except that, if a + MultiLineComment contains a line terminator code point, then the entire + comment is considered to be a LineTerminator for purposes of parsing by the + syntactic grammar. +---*/ + +''/* +*/'' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-line-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-line-separator.js new file mode 100644 index 000000000..a7c102929 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-line-separator.js @@ -0,0 +1,17 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.4 +esid: sec-comments +description: > + A multi-line comment containing a line separator should be considered a + LineTerminator +info: > + Comments behave like white space and are discarded except that, if a + MultiLineComment contains a line terminator code point, then the entire + comment is considered to be a LineTerminator for purposes of parsing by the + syntactic grammar. +---*/ + +''/*
*/'' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-paragraph-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-paragraph-separator.js new file mode 100644 index 000000000..4b1c0ed53 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-asi-paragraph-separator.js @@ -0,0 +1,17 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.4 +esid: sec-comments +description: > + A multi-line comment containing a paragrah separator should be considered a + LineTerminator +info: > + Comments behave like white space and are discarded except that, if a + MultiLineComment contains a line terminator code point, then the entire + comment is considered to be a LineTerminator for purposes of parsing by the + syntactic grammar. +---*/ + +''/*
*/'' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-html-close-extra.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-html-close-extra.js new file mode 100644 index 000000000..8e6de7708 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/multi-line-html-close-extra.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-html-like-comments +description: > + Arbitrary character sequence not permitted before HTMLCloseComment token +info: | + Comment :: + MultiLineComment + SingleLineComment + SingleLineHTMLOpenComment + SingleLineHTMLCloseComment + SingleLineDelimitedComment + + MultiLineComment :: + /* FirstCommentLine[opt] LineTerminator MultiLineCommentChars[opt] * / HTMLCloseComment[opt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/* +*/ the comment should not include these characters, regardless of AnnexB extensions --> diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/comments/single-line-html-close-without-lt.js b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/single-line-html-close-without-lt.js new file mode 100644 index 000000000..c050aaf08 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/comments/single-line-html-close-without-lt.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-html-like-comments +description: An HTMLCloseComment must be preceded by a LineTerminator +info: | + Comment :: + MultiLineComment + SingleLineComment + SingleLineHTMLOpenComment + SingleLineHTMLCloseComment + SingleLineDelimitedComment + + HTMLCloseComment :: + WhiteSpaceSequence[opt] SingleLineDelimitedCommentSequence[opt] --> SingleLineCommentChars[opt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +;--> diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-1-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-1-s.js new file mode 100644 index 000000000..cd5d28a26 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-1-s.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-1-s +description: > + Strict Mode - Use Strict Directive Prologue is 'use strict'; + which contains two space between 'use' and 'strict' +flags: [noStrict] +---*/ + +function testcase() { + "use strict"; + var public = 1; + + assert.sameValue(public, 1); + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-10-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-10-s.js new file mode 100644 index 000000000..cf724969a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-10-s.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-10-s +description: > + Strict Mode - Use Strict Directive Prologue is ''USE STRICT';' in + which all characters are uppercase +flags: [noStrict] +---*/ + +function testcase() { + "USE STRICT"; + var public = 1; + + assert.sameValue(public, 1); + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-11-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-11-s.js new file mode 100644 index 000000000..edc43e312 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-11-s.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-11-s +description: > + Strict Mode - Eval code is strict code with a Use Strict Directive + at the beginning of the block +flags: [noStrict] +---*/ + +var err = null; + + try { + eval("'use strict'; var public = 1; var anotherVariableNotReserveWord = 2;"); + } catch (e) { + err = e; + } + +assert(err instanceof SyntaxError, 'err instanceof SyntaxError'); +assert.sameValue(typeof public, "undefined", 'typeof public'); +assert.sameValue(typeof anotherVariableNotReserveWord, "undefined", 'typeof anotherVariableNotReserveWord'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-12-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-12-s.js new file mode 100644 index 000000000..7cc4eb0cb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-12-s.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-12-s +description: > + Strict Mode - Eval code is strict eval code with a Use Strict + Directive in the middle of the block +flags: [noStrict] +---*/ + + eval("var public = 1; 'use strict'; var anotherVariableNotReserveWord = 2;"); + +assert.sameValue(public, 1, 'public'); +assert.sameValue(anotherVariableNotReserveWord, 2, 'anotherVariableNotReserveWord'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-13-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-13-s.js new file mode 100644 index 000000000..72d739190 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-13-s.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-13-s +description: > + Strict Mode - Eval code is strict eval code with a Use Strict + Directive at the end of the block +flags: [noStrict] +---*/ + + eval("var public = 1; var anotherVariableNotReserveWord = 2; 'use strict';"); + +assert.sameValue(public, 1, 'public'); +assert.sameValue(anotherVariableNotReserveWord, 2, 'anotherVariableNotReserveWord'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-14-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-14-s.js new file mode 100644 index 000000000..77f4c4c76 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-14-s.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-14-s +description: > + Strict Mode - The call to eval function is contained in a Strict + Mode block +flags: [noStrict] +---*/ + +assert.throws(SyntaxError, function() { + 'use strict'; + + eval("var public = 1;"); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-28-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-28-s.js new file mode 100644 index 000000000..eb5fcbf29 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-28-s.js @@ -0,0 +1,25 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-28-s +description: > + Strict Mode - Function code of Accessor PropertyAssignment + contains Use Strict Directive which appears at the end of the + block(setter) +flags: [noStrict] +---*/ + + var obj = {}; + var data; + + Object.defineProperty(obj, "accProperty", { + set: function (value) { + var _10_1_1_28_s = {a:1, a:2}; + data = value; + "use strict"; + } + }); + obj.accProperty = "overrideData"; + +assert.sameValue(data, "overrideData", 'data'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-29-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-29-s.js new file mode 100644 index 000000000..93258bdf7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-29-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-29-s +description: > + Strict Mode - The built-in Function constructor is contained in + use strict code +flags: [noStrict] +---*/ + +function testcase() { + "use strict"; + var funObj = new Function("a", "eval('public = 1;');"); + funObj(); + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-2gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-2gs.js new file mode 100644 index 000000000..df4b4bcce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-2gs.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-2gs +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict'' + which lost the last character ';' +negative: + phase: parse + type: SyntaxError +flags: [raw] +---*/ + +"use strict" +throw "Test262: This statement should not be evaluated."; +var public = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-3-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-3-s.js new file mode 100644 index 000000000..8794cfe84 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-3-s.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-3-s +description: > + Strict Mode - Use Strict Directive Prologue is '' use strict';' + which the first character is space +flags: [noStrict] +---*/ + +function testcase() { + " use strict"; + var public = 1; + + assert.sameValue(public, 1); + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-30-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-30-s.js new file mode 100644 index 000000000..cd5b01f0a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-30-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-30-s +description: > + Strict Mode - Function code of built-in Function constructor + contains Use Strict Directive which appears at the start of the + block +flags: [noStrict] +---*/ + + +assert.throws(SyntaxError, function() { + var funObj = new Function("a", "'use strict'; eval('public = 1;');"); + funObj(); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-31-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-31-s.js new file mode 100644 index 000000000..5509baf70 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-31-s.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-31-s +description: > + Strict Mode - Function code of built-in Function constructor + contains Use Strict Directive which appears in the middle of the + block +flags: [noStrict] +---*/ + + + var funObj = new Function("a", "eval('public = 1;'); 'use strict'; anotherVariable = 2;"); + funObj(); + +assert.sameValue(public, 1, 'public'); +assert.sameValue(anotherVariable, 2, 'anotherVariable'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-32-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-32-s.js new file mode 100644 index 000000000..15d1de726 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-32-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-32-s +description: > + Strict Mode - Function code of built-in Function constructor + contains Use Strict Directive which appears at the end of the block +flags: [noStrict] +---*/ + + + var funObj = new Function("a", "eval('public = 1;'); anotherVariable = 2; 'use strict';"); + funObj(); + +assert.sameValue(public, 1, 'public'); +assert.sameValue(anotherVariable, 2, 'anotherVariable'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-4-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-4-s.js new file mode 100644 index 000000000..08e6ca7d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-4-s.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-4-s +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict ';' + which the last character is space +flags: [noStrict] +---*/ + +function testcase() { + "use strict "; + var public = 1; + + assert.sameValue(public, 1); + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-5-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-5-s.js new file mode 100644 index 000000000..d2a16af86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-5-s.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-5-s +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict';' + which appears at the beginning of the block +flags: [noStrict] +---*/ + +assert.throws(SyntaxError, function() { + "use strict"; + + eval("var public = 1;"); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-5gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-5gs.js new file mode 100644 index 000000000..f3f8e2acf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-5gs.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-5gs +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict';' + which appears at the start of the code +negative: + phase: parse + type: SyntaxError +flags: [raw] +---*/ + +"use strict"; +throw "Test262: This statement should not be evaluated."; +var public = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-6-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-6-s.js new file mode 100644 index 000000000..a11b7ab9b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-6-s.js @@ -0,0 +1,20 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-6-s +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict';' + which appears in the middle of the block +flags: [noStrict] +---*/ + +function testcase() { + var interface = 2; + "use strict"; + var public = 1; + + assert.sameValue(public, 1, 'public'); + assert.sameValue(interface, 2, 'interface'); + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-7-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-7-s.js new file mode 100644 index 000000000..d4a0d545b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-7-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-7-s +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict';' + which appears at the end of the block +flags: [noStrict] +---*/ + +function testcase() { + var public = 1; + assert.sameValue(public, 1); + "use strict"; + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-8-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-8-s.js new file mode 100644 index 000000000..1aada2657 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-8-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-8-s +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict';' + which appears twice in the directive prologue +flags: [noStrict] +---*/ + +assert.throws(SyntaxError, function() { + "use strict"; + "use strict"; + + eval("var public = 1;"); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-8gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-8gs.js new file mode 100644 index 000000000..33f979ef0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-8gs.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-8gs +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict';' + which appears twice in the code +negative: + phase: parse + type: SyntaxError +flags: [raw] +---*/ + +"use strict"; +"use strict"; +throw "Test262: This statement should not be evaluated."; +var public = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-9-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-9-s.js new file mode 100644 index 000000000..1612c9696 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/10.1.1-9-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.1.1-9-s +description: > + Strict Mode - Use Strict Directive Prologue is ''Use strict';' in + which the first character is uppercase +flags: [noStrict] +---*/ + +function testcase() { + "Use strict"; + var public = 1; + assert.sameValue(public, 1); + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-1-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-1-s.js new file mode 100644 index 000000000..9c7da4d6c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-1-s.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-1-s +description: "'use strict' directive - correct usage" +flags: [noStrict] +---*/ + + function foo() + { + 'use strict'; + return(this === undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-10-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-10-s.js new file mode 100644 index 000000000..eb6948b59 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-10-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-10-s +description: other directives - may follow 'use strict' directive +flags: [noStrict] +---*/ + + function foo() + { + "use strict"; + "bogus directive"; + return (this === undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-11-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-11-s.js new file mode 100644 index 000000000..291685273 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-11-s.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-11-s +description: comments may precede 'use strict' directive +flags: [noStrict] +---*/ + + function foo() + { + // comment + /* comment */ "use strict"; + + return(this === undefined); + + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-12-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-12-s.js new file mode 100644 index 000000000..40733e29e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-12-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-12-s +description: comments may follow 'use strict' directive +flags: [noStrict] +---*/ + + function foo() + { + "use strict"; /* comment */ // comment + + return (this === undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-13-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-13-s.js new file mode 100644 index 000000000..a846589a3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-13-s.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-13-s +description: semicolon insertion works for'use strict' directive +flags: [noStrict] +---*/ + + function foo() + { + "use strict" + return (this === undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-14-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-14-s.js new file mode 100644 index 000000000..0070258c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-14-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-14-s +description: semicolon insertion may come before 'use strict' directive +flags: [noStrict] +---*/ + + function foo() + { + "another directive" + "use strict" ; + return (this === undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-15-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-15-s.js new file mode 100644 index 000000000..65bd4bbca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-15-s.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-15-s +description: blank lines may come before 'use strict' directive +flags: [noStrict] +---*/ + + function foo() + { + + + + + + + "use strict" ; + return (this === undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-16-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-16-s.js new file mode 100644 index 000000000..5174141a9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-16-s.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-16-s +description: > + 'use strict' directive - not recognized if it follow an empty + statement +flags: [noStrict] +---*/ + + function foo() + { + ; 'use strict'; + return (this !== undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-17-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-17-s.js new file mode 100644 index 000000000..cf3623e08 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-17-s.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-17-s +description: > + 'use strict' directive - not recognized if it follow some other + statment empty statement +flags: [noStrict] +---*/ + + function foo() + { + var x; + 'use strict'; + return (this !== undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-2-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-2-s.js new file mode 100644 index 000000000..ec8078c0d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-2-s.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-2-s +description: "\"use strict\" directive - correct usage double quotes" +flags: [noStrict] +---*/ + + function foo() + { + "use strict"; + return (this === undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-3-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-3-s.js new file mode 100644 index 000000000..a1b7531f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-3-s.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-3-s +description: > + 'use strict' directive - not recognized if it contains extra + whitespace +flags: [noStrict] +---*/ + + function foo() + { + ' use strict '; + return (this !== undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-4-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-4-s.js new file mode 100644 index 000000000..6946de41c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-4-s.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-4-s +description: > + 'use strict' directive - not recognized if contains Line + Continuation +flags: [noStrict] +---*/ + + function foo() + { + 'use str\ +ict'; + return (this !== undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-4gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-4gs.js new file mode 100644 index 000000000..d401a5192 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-4gs.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-4gs +description: > + StrictMode - a Use Strict Directive followed by a strict mode + violation +negative: + phase: parse + type: SyntaxError +flags: [raw] +---*/ + +"use strict"; +throw "Test262: This statement should not be evaluated."; +eval = 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-5-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-5-s.js new file mode 100644 index 000000000..f89d35995 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-5-s.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-5-s +description: > + 'use strict' directive - not recognized if contains a + EscapeSequence +flags: [noStrict] +---*/ + + function foo() + { + 'use\u0020strict'; + return(this !== undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-5gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-5gs.js new file mode 100644 index 000000000..e1f2977e7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-5gs.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-5gs +description: > + StrictMode - a Use Strict Directive embedded in a directive + prologue followed by a strict mode violation +negative: + phase: parse + type: SyntaxError +flags: [raw] +---*/ + +"a"; +"use strict"; +"c"; +throw "Test262: This statement should not be evaluated."; +eval = 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-6-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-6-s.js new file mode 100644 index 000000000..e51fff117 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-6-s.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-6-s +description: > + 'use strict' directive - not recognized if contains a + instead of a space +flags: [noStrict] +---*/ + + function foo() + { + 'use strict'; + return (this !== undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-7-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-7-s.js new file mode 100644 index 000000000..428cc3ebb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-7-s.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-7-s +description: "'use strict' directive - not recognized if upper case" +flags: [noStrict] +---*/ + + function foo() + { + 'Use Strict'; + return (this !== undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-8-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-8-s.js new file mode 100644 index 000000000..094354890 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-8-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-8-s +description: "'use strict' directive - may follow other directives" +flags: [noStrict] +---*/ + + function foo() + { + "bogus directive"; + "use strict"; + return (this === undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-9-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-9-s.js new file mode 100644 index 000000000..50ba36c42 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/14.1-9-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 14.1-9-s +description: "'use strict' directive - may occur multiple times" +flags: [noStrict] +---*/ + + function foo() + { + 'use strict'; + "use strict"; + return (this === undefined); + } + +assert(foo.call(undefined)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-final-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-final-runtime.js new file mode 100644 index 000000000..9cbc74314 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-final-runtime.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-21-s +description: > + Strict Mode - Function code of a FunctionDeclaration contains Use + Strict Directive which appears at the end of the block +flags: [noStrict] +---*/ + function fun() { + test262unresolvable = null; + assert.sameValue(test262unresolvable, null); + "use strict"; + } + fun(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-inside-func-decl-parse.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-inside-func-decl-parse.js new file mode 100644 index 000000000..ab240cd75 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-inside-func-decl-parse.js @@ -0,0 +1,24 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-15-s +description: > + Strict Mode - Function code that is part of a FunctionDeclaration + is strict function code if FunctionDeclaration is contained in use + strict +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +function testcase() { + "use strict"; + function fun() { + var static; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-inside-func-decl-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-inside-func-decl-runtime.js new file mode 100644 index 000000000..59313153f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-inside-func-decl-runtime.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-15-s +description: > + Strict Mode - Function code that is part of a FunctionDeclaration + is strict function code if FunctionDeclaration is contained in use + strict +flags: [noStrict] +---*/ + +function testcase() { + "use strict"; + function fun() { + test262unresolvable = null; + } + + assert.throws(ReferenceError, function() { + fun(); + }); + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-no-semi-parse.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-no-semi-parse.js new file mode 100644 index 000000000..be56d0d14 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-no-semi-parse.js @@ -0,0 +1,21 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-2-s +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict'' + which lost the last character ';' +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +function fun() { + "use strict" + var static; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-no-semi-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-no-semi-runtime.js new file mode 100644 index 000000000..240626716 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-no-semi-runtime.js @@ -0,0 +1,20 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-2-s +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict'' + which lost the last character ';' +flags: [noStrict] +---*/ + +function fun() { + "use strict" + test262unresolvable = null; +} + +assert.throws(ReferenceError, function() { + fun(); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-not-first-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-not-first-runtime.js new file mode 100644 index 000000000..d6504be25 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-not-first-runtime.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-20-s +description: > + Strict Mode - Function code of a FunctionDeclaration contains Use + Strict Directive which appears in the middle of the block +flags: [noStrict] +---*/ + + function fun() { + test262unresolvable = null; + "use strict"; + assert.sameValue(test262unresolvable, null); + } + fun(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-parse.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-parse.js new file mode 100644 index 000000000..6d347d644 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-parse.js @@ -0,0 +1,21 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-19-s +description: > + Strict Mode - Function code of a FunctionDeclaration contains Use + Strict Directive which appears at the start of the block +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +function fun() { + "use strict"; + var static; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-runtime.js new file mode 100644 index 000000000..d3dbfb611 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-decl-runtime.js @@ -0,0 +1,21 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-19-s +description: > + Strict Mode - Function code of a FunctionDeclaration contains Use + Strict Directive which appears at the start of the block +flags: [noStrict] +---*/ + + function fun() { + "use strict"; + + test262unresolvable = null; + } + +assert.throws(ReferenceError, function() { + fun(); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-final-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-final-runtime.js new file mode 100644 index 000000000..b5fa0a49f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-final-runtime.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-24-s +description: > + Strict Mode - Function code of a FunctionExpression contains Use + Strict Directive which appears at the end of the block +flags: [noStrict] +---*/ + + (function () { + test262unresolvable = null; + "use strict"; + + assert.sameValue(test262unresolvable, null); + }) (); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-inside-func-decl-parse.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-inside-func-decl-parse.js new file mode 100644 index 000000000..e24e978f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-inside-func-decl-parse.js @@ -0,0 +1,22 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-16-s +description: > + Strict Mode - Function code that is part of a FunctionExpression + is strict function code if FunctionExpression is contained in use + strict +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +function testcase() { + "use strict"; + var static; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-inside-func-decl-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-inside-func-decl-runtime.js new file mode 100644 index 000000000..467fb5d65 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-inside-func-decl-runtime.js @@ -0,0 +1,21 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-16-s +description: > + Strict Mode - Function code that is part of a FunctionExpression + is strict function code if FunctionExpression is contained in use + strict +flags: [noStrict] +---*/ + +function testcase() { + "use strict"; + + assert.throws(ReferenceError, function() { + test262unresolvable = null; + }); + } +testcase(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-no-semi-parse.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-no-semi-parse.js new file mode 100644 index 000000000..0d901f9dc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-no-semi-parse.js @@ -0,0 +1,22 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-2-s +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict'' + which lost the last character ';' +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +(function() { + "use strict" + + var static; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-no-semi-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-no-semi-runtime.js new file mode 100644 index 000000000..3885d3194 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-no-semi-runtime.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-2-s +description: > + Strict Mode - Use Strict Directive Prologue is ''use strict'' + which lost the last character ';' +flags: [noStrict] +---*/ + +assert.throws(ReferenceError, function() { + "use strict" + + test262unresolvable = null; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-not-first-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-not-first-runtime.js new file mode 100644 index 000000000..4aae5cc8a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-not-first-runtime.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-23-s +description: > + Strict Mode - Function code of a FunctionExpression contains Use + Strict Directive which appears in the middle of the block +flags: [noStrict] +---*/ + + (function () { + test262unresolvable = null; + assert.sameValue(test262unresolvable, null); + "use strict"; + }) (); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-parse.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-parse.js new file mode 100644 index 000000000..e27c32dd7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-parse.js @@ -0,0 +1,22 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-22-s +description: > + Strict Mode - Function code of a FunctionExpression contains Use + Strict Directive which appears at the start of the block +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +(function() { + "use strict"; + + var static; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-runtime.js new file mode 100644 index 000000000..9ad085997 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/func-expr-runtime.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-22-s +description: > + Strict Mode - Function code of a FunctionExpression contains Use + Strict Directive which appears at the start of the block +flags: [noStrict] +---*/ + +assert.throws(ReferenceError, function () { + "use strict"; + + test262unresolvable = null; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/get-accsr-inside-func-expr-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/get-accsr-inside-func-expr-runtime.js new file mode 100644 index 000000000..11e4628d8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/get-accsr-inside-func-expr-runtime.js @@ -0,0 +1,25 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-17-s +description: > + Strict Mode - Function code that is part of a Accessor + PropertyAssignment is in Strict Mode if Accessor + PropertyAssignment is contained in use strict(getter) +flags: [noStrict] +---*/ + +assert.throws(ReferenceError, function() { + "use strict"; + var obj = {}; + Object.defineProperty(obj, "accProperty", { + get: function () { + test262unresolvable = null; + return 11; + } + }); + + var temp = obj.accProperty === 11; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/get-accsr-not-first-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/get-accsr-not-first-runtime.js new file mode 100644 index 000000000..8f2d9bc5f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/get-accsr-not-first-runtime.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-27-s +description: > + Strict Mode - Function code of Accessor PropertyAssignment + contains Use Strict Directive which appears in the middle of the + block(getter) +flags: [noStrict] +---*/ + + var obj = {}; + Object.defineProperty(obj, "accProperty", { + get: function () { + test262unresolvable = null; + "use strict"; + return 11; + } + }); + +assert.sameValue(obj.accProperty, 11, 'obj.accProperty'); +assert.sameValue(test262unresolvable, null); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/get-accsr-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/get-accsr-runtime.js new file mode 100644 index 000000000..47e6893b8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/get-accsr-runtime.js @@ -0,0 +1,25 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-25-s +description: > + Strict Mode - Function code of Accessor PropertyAssignment + contains Use Strict Directive which appears at the start of the + block(getter) +flags: [noStrict] +---*/ + + +assert.throws(ReferenceError, function() { + var obj = {}; + Object.defineProperty(obj, "accProperty", { + get: function () { + "use strict"; + test262unresolvable = null; + return 11; + } + }); + var temp = obj.accProperty === 11; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/set-accsr-inside-func-expr-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/set-accsr-inside-func-expr-runtime.js new file mode 100644 index 000000000..1038aa058 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/set-accsr-inside-func-expr-runtime.js @@ -0,0 +1,30 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-18-s +description: > + Strict Mode - Function code that is part of a Accessor + PropertyAssignment is in Strict Mode if Accessor + PropertyAssignment is contained in use strict(setter) +flags: [noStrict] +---*/ + +var data = "data"; + +assert.throws(ReferenceError, function() { + "use strict"; + + var obj = {}; + Object.defineProperty(obj, "accProperty", { + set: function (value) { + test262unresolvable = null; + data = value; + } + }); + + obj.accProperty = "overrideData"; +}); + +assert.sameValue(data, "data", 'data unchanged'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/set-accsr-not-first-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/set-accsr-not-first-runtime.js new file mode 100644 index 000000000..3a4606562 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/set-accsr-not-first-runtime.js @@ -0,0 +1,29 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-26-s +description: > + Strict Mode - Function code of Accessor PropertyAssignment + contains Use Strict Directive which appears at the start of the + block(setter) +flags: [noStrict] +---*/ + +var data = "data"; + +assert.throws(ReferenceError, function() { + var obj = {}; + Object.defineProperty(obj, "accProperty", { + set: function (value) { + "use strict"; + test262unresolvable = null; + data = value; + } + }); + + obj.accProperty = "overrideData"; +}); + +assert.sameValue(data, "data", 'data unchanged'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/set-accsr-runtime.js b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/set-accsr-runtime.js new file mode 100644 index 000000000..e282c89ec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/directive-prologue/set-accsr-runtime.js @@ -0,0 +1,25 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: use-strict-directive +es5id: 10.1.1-25-s +description: > + Strict Mode - Function code of Accessor PropertyAssignment + contains Use Strict Directive which appears at the start of the + block(getter) +flags: [noStrict] +---*/ + + +assert.throws(ReferenceError, function() { + var obj = {}; + Object.defineProperty(obj, "accProperty", { + set: function () { + "use strict"; + test262unresolvable = null; + return 11; + } + }); + obj.accProperty = "overrideData"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/eval-code/direct/strict-caller-global.js b/crates/clazel-js-lexer/tests/data/test262/test/language/eval-code/direct/strict-caller-global.js new file mode 100644 index 000000000..7ef2c1c3d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/eval-code/direct/strict-caller-global.js @@ -0,0 +1,23 @@ +// Copyright (C) 2020 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-performeval +description: Script will be script if strictCaller is true +info: | + ... + 10. If strictCaller is true, let strictEval be true. + ... + 12. Let runningContext be the running execution context. + ... +negative: + phase: runtime + type: SyntaxError +flags: [onlyStrict] +---*/ + +// Although the `try` statement is a more precise mechanism for detecting +// runtime errors, the behavior under test is only observable for a direct eval +// call when the call is made from the global scope. This forces the use of +// the more coarse-grained `negative` frontmatter to assert the expected error. + +eval('var public = 1;'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/eval-code/direct/var-env-global-lex-non-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/eval-code/direct/var-env-global-lex-non-strict.js new file mode 100644 index 000000000..5b87d9ed5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/eval-code/direct/var-env-global-lex-non-strict.js @@ -0,0 +1,30 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-evaldeclarationinstantiation +description: Variable collision with global lexical binding +info: | + [...] + 5. If strict is false, then + a. If varEnvRec is a global Environment Record, then + i. For each name in varNames, do + 1. If varEnvRec.HasLexicalDeclaration(name) is true, throw a + SyntaxError exception. + 2. NOTE: eval will not create a global var declaration that would + be shadowed by a global lexical declaration. + [...] +negative: + phase: runtime + type: SyntaxError +flags: [noStrict] +features: [let] +---*/ + +let x; + +// Although the `try` statement is a more precise mechanism for detecting +// runtime errors, the behavior under test is only observable for a direct eval +// call when the call is made from the global scope. This forces the use of +// the more coarse-grained `negative` frontmatter to assert the expected error. + +eval('var x;'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/eval-code/indirect/parse-failure-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/eval-code/indirect/parse-failure-2.js new file mode 100644 index 000000000..e15f39dce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/eval-code/indirect/parse-failure-2.js @@ -0,0 +1,14 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +info: If the parse fails, throw a SyntaxError exception (but see also clause 16) +esid: sec-performeval +es5id: 15.1.2.1_A2_T2 +description: Checking if execution of "(0,eval)("x = 1; x\u000A++")" fails +negative: + phase: runtime + type: SyntaxError +---*/ + +var x; +(0,eval)("x = 1; x\u000A++"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/export/escaped-as-export-specifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/export/escaped-as-export-specifier.js new file mode 100644 index 000000000..3d376d87b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/export/escaped-as-export-specifier.js @@ -0,0 +1,25 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `as` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +export var a = 0; +export {a \u0061s b} from "./escaped-as-export-specifier.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/export/escaped-default.js b/crates/clazel-js-lexer/tests/data/test262/test/language/export/escaped-default.js new file mode 100644 index 000000000..1e3e1b95e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/export/escaped-default.js @@ -0,0 +1,24 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `default` keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +export d\u0065fault 0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/export/escaped-from.js b/crates/clazel-js-lexer/tests/data/test262/test/language/export/escaped-from.js new file mode 100644 index 000000000..1d235f9a2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/export/escaped-from.js @@ -0,0 +1,24 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `from` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +export {} \u0066rom "./escaped-from.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..93f5ec1bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/array-destructuring-param-strict-body.js @@ -0,0 +1,131 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/arrow-function.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, ([element]) => { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dflt-params-duplicates.js new file mode 100644 index 000000000..8ac9c4a50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dflt-params-duplicates.js @@ -0,0 +1,60 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/arrow-function.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, (x = 0, x) => { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dflt-params-rest.js new file mode 100644 index 000000000..8c2ca36d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dflt-params-rest.js @@ -0,0 +1,64 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/arrow-function.template +/*--- +description: RestParameter does not support an initializer (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, (...x = []) => { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..3a01921c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-init-ary.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/arrow-function.template +/*--- +description: Rest element (nested array pattern) does not support initializer (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...[ x ] = []]) => { + + callCount = callCount + 1; +}; + +f([]); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..e931a2f7c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-init-id.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/arrow-function.template +/*--- +description: Rest element (identifier) does not support initializer (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...x = []]) => { + + callCount = callCount + 1; +}; + +f([]); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..9295e7706 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-init-obj.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/arrow-function.template +/*--- +description: Rest element (nested object pattern) does not support initializer (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...{ x } = []]) => { + + callCount = callCount + 1; +}; + +f([]); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..6905fb0bd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/arrow-function.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...[x], y]) => { + + callCount = callCount + 1; +}; + +f([1, 2, 3]); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..f736c20da --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-id.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/arrow-function.template +/*--- +description: Rest element (identifier) may not be followed by any element (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...x, y]) => { + + callCount = callCount + 1; +}; + +f([1, 2, 3]); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..15cd45066 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/arrow-function.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...{ x }, y]) => { + + callCount = callCount + 1; +}; + +f([1, 2, 3]); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..54916eb32 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/arrow-function-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (arrow function expression (default parameter)) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...[ x ] = []] = []) => { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..a9584c064 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/arrow-function-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (arrow function expression (default parameter)) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...x = []] = []) => { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..67a8e898a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/arrow-function-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (arrow function expression (default parameter)) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...{ x } = []] = []) => { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..279b47988 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/arrow-function-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (arrow function expression (default parameter)) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...[x], y] = [1, 2, 3]) => { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..1d00fb18f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/arrow-function-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (arrow function expression (default parameter)) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...x, y] = [1, 2, 3]) => { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..eefceba94 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/arrow-function-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (arrow function expression (default parameter)) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = ([...{ x }, y] = [1, 2, 3]) => { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'arrow function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-break-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-break-escaped.js new file mode 100644 index 000000000..9ba6cea53 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-break-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/break-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: break is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ bre\u0061k }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-case-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-case-escaped.js new file mode 100644 index 000000000..e1b41863c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-case-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/case-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: case is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ c\u0061se }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-catch-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-catch-escaped.js new file mode 100644 index 000000000..4a6ee32e1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-catch-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/catch-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: catch is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ c\u0061tch }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-class-escaped.js new file mode 100644 index 000000000..5ba47be62 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-class-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/class-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: class is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ cl\u0061ss }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-const-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-const-escaped.js new file mode 100644 index 000000000..6c0ed61a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-const-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/const-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: const is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0063onst }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-continue-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-continue-escaped.js new file mode 100644 index 000000000..23d9d5d4d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-continue-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/continue-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: continue is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0063ontinue }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-debugger-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-debugger-escaped.js new file mode 100644 index 000000000..4fbae26a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-debugger-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/debugger-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: debugger is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0064ebugger }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped-ext.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped-ext.js new file mode 100644 index 000000000..f44f6a9c2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped-ext.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/default-escaped-ext.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: default is a valid identifier name, using extended escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ def\u{61}ult }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped.js new file mode 100644 index 000000000..2000c9518 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-default-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/default-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: default is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ def\u0061ult }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-default.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-default.js new file mode 100644 index 000000000..baf609e0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-default.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/default.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: default is a valid identifier name (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ default }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-delete-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-delete-escaped.js new file mode 100644 index 000000000..461c0c9a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-delete-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/delete-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: delete is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0064elete }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-do-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-do-escaped.js new file mode 100644 index 000000000..8d318c7b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-do-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/do-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: do is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0064o }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-else-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-else-escaped.js new file mode 100644 index 000000000..a52c241c6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-else-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/else-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: else is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0065lse }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-enum-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-enum-escaped.js new file mode 100644 index 000000000..1c7b878bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-enum-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/enum-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: enum is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0065num }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-export-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-export-escaped.js new file mode 100644 index 000000000..a4e41bd07 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-export-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/export-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: export is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0065xport }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped-ext.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped-ext.js new file mode 100644 index 000000000..927399b25 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped-ext.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/extends-escaped-ext.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: extends is a valid identifier name, using extended escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u{65}xtends }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped.js new file mode 100644 index 000000000..3c288258d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/extends-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: extends is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0065xtends }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends.js new file mode 100644 index 000000000..03eeb53e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-extends.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/extends.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: extends is a valid identifier name (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ extends }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-finally-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-finally-escaped.js new file mode 100644 index 000000000..000340586 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-finally-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/finally-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: finally is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0066inally }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-for-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-for-escaped.js new file mode 100644 index 000000000..8ee85c235 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-for-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/for-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: for is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0066or }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-function-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-function-escaped.js new file mode 100644 index 000000000..8d8a4d7bb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-function-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/function-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: function is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0066unction }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-if-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-if-escaped.js new file mode 100644 index 000000000..2002a0b3f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-if-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/if-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: if is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ i\u0066 }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-implements-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-implements-escaped.js new file mode 100644 index 000000000..121ae247b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-implements-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/implements-escaped.case +// - src/identifier-names/future-reserved-words/arrow-fn-assignment-identifier.template +/*--- +description: implements is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0069mplements }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-import-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-import-escaped.js new file mode 100644 index 000000000..65a830d23 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-import-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/import-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: import is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0069mport }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-in-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-in-escaped.js new file mode 100644 index 000000000..1315fc820 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-in-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/in-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: in is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0069n }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-instanceof-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-instanceof-escaped.js new file mode 100644 index 000000000..5ad7e9d3b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-instanceof-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/instanceof-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: instanceof is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ \u0069nstanceof }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-interface-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-interface-escaped.js new file mode 100644 index 000000000..4cfb87883 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-interface-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/interface-escaped.case +// - src/identifier-names/future-reserved-words/arrow-fn-assignment-identifier.template +/*--- +description: interface is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ interf\u0061ce }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-let-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-let-escaped.js new file mode 100644 index 000000000..c3394f44a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-let-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/let-escaped.case +// - src/identifier-names/future-reserved-words/arrow-fn-assignment-identifier.template +/*--- +description: let is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ l\u0065t }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-new-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-new-escaped.js new file mode 100644 index 000000000..7405404a1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-new-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/new-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: new is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ n\u0065w }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-package-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-package-escaped.js new file mode 100644 index 000000000..2572e2863 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-package-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/package-escaped.case +// - src/identifier-names/future-reserved-words/arrow-fn-assignment-identifier.template +/*--- +description: package is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ p\u0061ckage }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-private-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-private-escaped.js new file mode 100644 index 000000000..77f4a2e5f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-private-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/private-escaped.case +// - src/identifier-names/future-reserved-words/arrow-fn-assignment-identifier.template +/*--- +description: private is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ privat\u0065 }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-protected-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-protected-escaped.js new file mode 100644 index 000000000..6e88462c4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-protected-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/protected-escaped.case +// - src/identifier-names/future-reserved-words/arrow-fn-assignment-identifier.template +/*--- +description: protected is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ prot\u0065cted }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-public-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-public-escaped.js new file mode 100644 index 000000000..662eba7cf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-public-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/public-escaped.case +// - src/identifier-names/future-reserved-words/arrow-fn-assignment-identifier.template +/*--- +description: public is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ pu\u0062lic }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-return-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-return-escaped.js new file mode 100644 index 000000000..ede5f3637 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-return-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/return-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: return is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ r\u0065turn }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-static-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-static-escaped.js new file mode 100644 index 000000000..80f4cf371 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-static-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/static-escaped.case +// - src/identifier-names/future-reserved-words/arrow-fn-assignment-identifier.template +/*--- +description: static is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ st\u0061tic }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-super-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-super-escaped.js new file mode 100644 index 000000000..dd77fa19c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-super-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/super-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: super is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ sup\u0065r }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-switch-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-switch-escaped.js new file mode 100644 index 000000000..6455609bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-switch-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/switch-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: switch is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ sw\u0069tch }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-this-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-this-escaped.js new file mode 100644 index 000000000..26953fe6e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-this-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/this-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: this is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ th\u0069s }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-throw-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-throw-escaped.js new file mode 100644 index 000000000..7564c5a40 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-throw-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/throw-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: throw is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ t\u0068row }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-try-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-try-escaped.js new file mode 100644 index 000000000..af1a6d881 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-try-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/try-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: try is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ tr\u0079 }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-typeof-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-typeof-escaped.js new file mode 100644 index 000000000..1e0abf68c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-typeof-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/typeof-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: typeof is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ typ\u0065of }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-var-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-var-escaped.js new file mode 100644 index 000000000..a467dd3e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-var-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/var-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: var is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ v\u0061r }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-void-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-void-escaped.js new file mode 100644 index 000000000..017ea5e66 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-void-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/void-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: void is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ voi\u0064 }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-while-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-while-escaped.js new file mode 100644 index 000000000..19e9b3283 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-while-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/while-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: while is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ whil\u0065 }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-with-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-with-escaped.js new file mode 100644 index 000000000..cf4dde5c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/dstr/syntax-error-ident-ref-with-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/with-escaped.case +// - src/identifier-names/default/arrow-fn-assignment-identifier.template +/*--- +description: with is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern (Arrow Function) cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [arrow-function, destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = ({ w\u0069th }) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..30c6ecbbc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/object-destructuring-param-strict-body.js @@ -0,0 +1,131 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/arrow-function.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, ({property}) => { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/param-dflt-yield-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/param-dflt-yield-expr.js new file mode 100644 index 000000000..55f17d50e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/param-dflt-yield-expr.js @@ -0,0 +1,28 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-arrow-function-definitions +es6id: 14.2 +description: > + The `yield` token is interpreted contextually outside of strict mode +info: | + ArrowFunction[In, Yield] : + + ArrowParameters[?Yield] [no LineTerminator here] => ConciseBody[?In] + + 14.2.1 Static Semantics: Early Errors# + + ArrowFunction : ArrowParameters=>ConciseBody + + - It is a Syntax Error if ArrowParameters Contains YieldExpression is true. +features: [generators, default-parameters] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function *g() { + (x = yield) => {}; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/param-dflt-yield-id-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/param-dflt-yield-id-strict.js new file mode 100644 index 000000000..3503621b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/param-dflt-yield-id-strict.js @@ -0,0 +1,21 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-arrow-function-definitions +es6id: 14.2 +description: > + The `yield` token is interpreted as a FutureReservedWord within strict mode +info: | + ArrowFunction[In, Yield] : + + ArrowParameters[?Yield] [no LineTerminator here] => ConciseBody[?In] +features: [default-parameters] +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(x = yield) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/params-duplicate.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/params-duplicate.js new file mode 100644 index 000000000..14fde6fbd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/params-duplicate.js @@ -0,0 +1,33 @@ +// Copyright 2019 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-arrow-function-definitions +description: Formal parameters may not contain duplicates +info: | + # 14.2 Arrow Function Definitions + + When the production + + ArrowParameters:CoverParenthesizedExpressionAndArrowParameterList + + is recognized the following grammar is used to refine the interpretation + of CoverParenthesizedExpressionAndArrowParameterList: + + ArrowFormalParameters[Yield, Await]: + (UniqueFormalParameters[?Yield, ?Await]) + + # 14.1.2 Static Semantics: Early Errors + + UniqueFormalParameters:FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, (a, a) => { }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/rest-param-strict-body.js new file mode 100644 index 000000000..81f4beac1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/rest-param-strict-body.js @@ -0,0 +1,131 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/arrow-function.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, (a,...rest) => { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..9a7293a73 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/rest-params-trailing-comma-early-error.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/arrow-function.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (arrow function expression) +esid: sec-arrow-function-definitions-runtime-semantics-evaluation +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ArrowFunction : ArrowParameters => ConciseBody + + [...] + 4. Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, (...a,) => { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/static-init-await-binding.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/static-init-await-binding.js new file mode 100644 index 000000000..c83c3a3c5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/static-init-await-binding.js @@ -0,0 +1,18 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-class-definitions-static-semantics-early-errors +description: The `await` keyword is disallowed in the BindingIdentifier position +features: [class-static-block] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +class C { + static { + (await => 0); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/static-init-await-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/static-init-await-reference.js new file mode 100644 index 000000000..8b20af7e0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/static-init-await-reference.js @@ -0,0 +1,18 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-class-definitions-static-semantics-early-errors +description: The `await` keyword is disallowed in the IdentifierReference position +features: [class-static-block] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +class C { + static { + ((x = await) => 0); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-futurereservedword.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-futurereservedword.js new file mode 100644 index 000000000..ca60471aa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-futurereservedword.js @@ -0,0 +1,24 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2 +description: > + ArrowParameters[Yield] : + BindingIdentifier[?Yield] + + (12.1) + BindingIdentifier[Yield] : + Identifier[~Yield] yield + + Identifier : + IdentifierName but not ReservedWord + + ReservedWord : FutureReservedWord + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = enum => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-strict-futurereservedword.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-strict-futurereservedword.js new file mode 100644 index 000000000..c4ac74f92 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier-strict-futurereservedword.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2 +description: > + ArrowParameters[Yield] : + BindingIdentifier[?Yield] + + (12.1) + BindingIdentifier[Yield] : + Identifier[~Yield] yield + + Identifier : + IdentifierName but not ReservedWord + + ReservedWord : FutureReservedWord + + Strict Mode + +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +var af = package => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier.js new file mode 100644 index 000000000..a2014de36 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-identifier.js @@ -0,0 +1,24 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2 +description: > + ArrowParameters[Yield] : + BindingIdentifier[?Yield] + + (12.1) + BindingIdentifier[Yield] : + Identifier[~Yield] yield + + Identifier : + IdentifierName but not ReservedWord + + ReservedWord : Keyword + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = switch => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-arguments.js new file mode 100644 index 000000000..e55afd234 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-arguments.js @@ -0,0 +1,19 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + BindingIdentifier[?Yield] + ... + + No parameter named "arguments" + +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +var af = arguments => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-eval.js new file mode 100644 index 000000000..ee991a563 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-eval.js @@ -0,0 +1,20 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + BindingIdentifier[?Yield] + ... + + + No parameter named "eval" + +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +var af = eval => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-yield.js new file mode 100644 index 000000000..e8ad72a74 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-no-yield.js @@ -0,0 +1,20 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + BindingIdentifier[?Yield] + ... + + + No parameter named "yield" + +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +var af = yield => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-rest.js new file mode 100644 index 000000000..bf980f45a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-bindingidentifier-rest.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2 +description: > + ArrowParameters : BindingIdentifier[?Yield] + + Includes ...rest + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = ...x => x; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-arguments.js new file mode 100644 index 000000000..ca95b215f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-arguments.js @@ -0,0 +1,24 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + No parameters named "arguments" + +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +var af = (arguments) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-1.js new file mode 100644 index 000000000..de2ae6786 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-1.js @@ -0,0 +1,25 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + ArrayBindingPattern + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = (x, [x]) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-2.js new file mode 100644 index 000000000..ff429de6b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-2.js @@ -0,0 +1,25 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + ArrayBindingPattern + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = ([x, x]) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-3.js new file mode 100644 index 000000000..c7282d82a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-array-3.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + ArrayBindingPattern + + BindingRestElement + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = ([x], ...x) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-1.js new file mode 100644 index 000000000..242c59b45 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-1.js @@ -0,0 +1,25 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + ObjectBindingPattern + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = (x, {x}) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-2.js new file mode 100644 index 000000000..f79b71f4f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-2.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + ObjectBindingPattern + + BindingPropertyList + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = (x, {y: x}) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-3.js new file mode 100644 index 000000000..2485761cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-3.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + ObjectBindingPattern + + BindingPropertyList + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = ({x}, {y: x}) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-4.js new file mode 100644 index 000000000..3d25c8610 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-4.js @@ -0,0 +1,29 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + ObjectBindingPattern + + BindingPropertyList + + BindingRestElement + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = ({x}, ...x) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-5.js new file mode 100644 index 000000000..a1993a489 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-5.js @@ -0,0 +1,29 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + ObjectBindingPattern + + BindingPropertyList + + BindingRestElement + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = ({y: x}, ...x) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-6.js new file mode 100644 index 000000000..bc6c47d86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-binding-object-6.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + ObjectBindingPattern + + BindingPropertyList + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = ({y: x, x}) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-rest.js new file mode 100644 index 000000000..bdd315c24 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates-rest.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + No duplicates, rest + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = (x, ...x) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates.js new file mode 100644 index 000000000..11990e825 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-duplicates.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + No duplicates + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = (x, x) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-eval.js new file mode 100644 index 000000000..19ac3d310 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-eval.js @@ -0,0 +1,24 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + CoverParenthesizedExpressionAndArrowParameterList, refined by: + + ArrowFormalParameters[Yield, GeneratorParameter] : + ( StrictFormalParameters[?Yield, ?GeneratorParameter] ) + + No parameters named "eval" + +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +var af = (eval) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-yield.js new file mode 100644 index 000000000..6c9ce9543 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/arrowparameters-cover-no-yield.js @@ -0,0 +1,19 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2.1 +description: > + ArrowParameters[Yield] : + ... + CoverParenthesizedExpressionAndArrowParameterList[?Yield] + + No parameter named "yield" + +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +var af = (yield) => 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters-expression-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters-expression-body.js new file mode 100644 index 000000000..c1533356d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters-expression-body.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2 +description: > + ArrowFunction[In, Yield] : + ArrowParameters[?Yield] [no LineTerminator here] => ConciseBody[?In] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = x +=> x; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters.js new file mode 100644 index 000000000..0409c47fd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid-parenless-parameters.js @@ -0,0 +1,18 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2 +description: > + ArrowFunction[In, Yield] : + ArrowParameters[?Yield] [no LineTerminator here] => ConciseBody[?In] + + No parens around ArrowParameters + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = x +=> {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid.js new file mode 100644 index 000000000..60c8891f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/asi-restriction-invalid.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 14.2 +description: > + ArrowFunction[In, Yield] : + ArrowParameters[?Yield] [no LineTerminator here] => ConciseBody[?In] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +var af = () +=> {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/use-strict-with-non-simple-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/use-strict-with-non-simple-param.js new file mode 100644 index 000000000..0bd9bdcff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/arrow-function/syntax/early-errors/use-strict-with-non-simple-param.js @@ -0,0 +1,21 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-arrow-function-definitions-static-semantics-early-errors +description: > + A SyntaxError is thrown if an arrow function contains a non-simple parameter list and a UseStrict directive. +info: | + Static Semantics: Early Errors + + It is a Syntax Error if ContainsUseStrict of ConciseBody is true and IsSimpleParameterList of ArrowParameters is false. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var f = (a = 0) => { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-init-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-init-yield-ident-invalid.js new file mode 100644 index 000000000..5df6dd1a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-init-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-elem-init-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the Initializer of an AssignmentElement outside of a generator function body, it behaves as an IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [ x = yield ] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-array-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-array-invalid.js new file mode 100644 index 000000000..d1d77d432 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-array-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-elem-nested-array-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression cannot be parsed with no tokens left over using AssignmentPattern as the goal symbol. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [[(x, y)]] = [[]]; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-array-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-array-yield-ident-invalid.js new file mode 100644 index 000000000..95d589cfc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-array-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-elem-nested-array-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment outside of strict mode, it behaves as an IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [[x[yield]]] = [[]]; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-memberexpr-optchain-prop-ref-init.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-memberexpr-optchain-prop-ref-init.js new file mode 100644 index 000000000..e30260c7f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-memberexpr-optchain-prop-ref-init.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-elem-nested-memberexpr-optchain-prop-ref-init.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression of an DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral and AssignmentTargetType(LeftHandSideExpression) is not simple Using Object (MemberExpression OptionalChain .IdentifierName Initializer) (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [optional-chaining, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. + + Syntax + + AssignmentElement : DestructuringAssignmentTarget Initializer_opt + DestructuringAssignmentTarget : LeftHandSideExpression + + Static Semantics: Early Errors + + OptionalExpression: + MemberExpression OptionalChain + CallExpression OptionalChain + OptionalExpression OptionalChain + + OptionalChain: + ?. [ Expression ] + ?. IdentifierName + ?. Arguments + ?. TemplateLiteral + OptionalChain [ Expression ] + OptionalChain .IdentifierName + OptionalChain Arguments + OptionalChain TemplateLiteral + + DestructuringAssignmentTarget : LeftHandSideExpression + + - It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral and IsValidSimpleAssignmentTarget(LeftHandSideExpression) is not true. + + Static Semantics: IsValidSimpleAssignmentTarget + + LeftHandSideExpression : OptionalExpression + 1. Return false. + +---*/ +$DONOTEVALUATE(); +var x = {}; + +0, [x?.y = 42] = [23]; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-obj-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-obj-invalid.js new file mode 100644 index 000000000..2bce48e1a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-obj-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-elem-nested-obj-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression cannot be parsed with no tokens left over using AssignmentPattern as the goal symbol. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [{ get x() {} }] = [{}]; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-obj-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-obj-yield-ident-invalid.js new file mode 100644 index 000000000..8b4b59697 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-nested-obj-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-elem-nested-obj-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the Initializer of a nested destructuring assignment outside of a generator function body, it behaves as a IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [{ x = yield }] = [{}]; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-put-obj-literal-optchain-prop-ref-init.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-put-obj-literal-optchain-prop-ref-init.js new file mode 100644 index 000000000..967ace537 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-put-obj-literal-optchain-prop-ref-init.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-elem-put-obj-literal-optchain-prop-ref-init.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression of an DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral and AssignmentTargetType(LeftHandSideExpression) is not simple Using Object (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [optional-chaining, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. + + Syntax + + AssignmentElement : DestructuringAssignmentTarget Initializer_opt + DestructuringAssignmentTarget : LeftHandSideExpression + + Static Semantics: Early Errors + + OptionalExpression: + MemberExpression OptionalChain + CallExpression OptionalChain + OptionalExpression OptionalChain + + OptionalChain: + ?. [ Expression ] + ?. IdentifierName + ?. Arguments + ?. TemplateLiteral + OptionalChain [ Expression ] + OptionalChain .IdentifierName + OptionalChain Arguments + OptionalChain TemplateLiteral + + DestructuringAssignmentTarget : LeftHandSideExpression + + - It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral and IsValidSimpleAssignmentTarget(LeftHandSideExpression) is not true. + + Static Semantics: IsValidSimpleAssignmentTarget + + LeftHandSideExpression : OptionalExpression + 1. Return false. + +---*/ +$DONOTEVALUATE(); + +0, [{ + set y(val) { + throw new Test262Error('The property should not be accessed.'); + } +}?.y = 42] = [23]; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-target-simple-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-target-simple-strict.js new file mode 100644 index 000000000..87703057b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-target-simple-strict.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-elem-target-simple-strict.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral and IsValidSimpleAssignmentTarget(LeftHandSideExpression) is false. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [arguments] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-target-yield-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-target-yield-invalid.js new file mode 100644 index 000000000..0e40bf0fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-elem-target-yield-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-elem-target-yield-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement and outside of a generator function body, it behaves as an IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [ x[yield] ] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-before-element.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-before-element.js new file mode 100644 index 000000000..011e1c127 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-before-element.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-before-element.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: An AssignmentElement may not follow an AssignmentRestElement in an AssignmentElementList. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [...x, y] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-before-elision.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-before-elision.js new file mode 100644 index 000000000..df7bf9d9c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-before-elision.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-before-elision.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: An elision may not follow an AssignmentRestElement in an AssignmentElementList. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [...x,] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-before-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-before-rest.js new file mode 100644 index 000000000..df829f855 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-before-rest.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-before-rest.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: An AssignmentRestElement may not follow another AssignmentRestElement in an AssignmentElementList. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [...x, ...y] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-elision-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-elision-invalid.js new file mode 100644 index 000000000..bd7efd0c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-elision-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-elision-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: ArrayAssignmentPattern may not include elisions following an AssignmentRestElement in a AssignmentElementList. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [...x,] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-init.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-init.js new file mode 100644 index 000000000..e63928fa8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-init.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-init.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: The AssignmentRestElement does not support an initializer. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); +var x; + +0, [...x = 1] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-array-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-array-invalid.js new file mode 100644 index 000000000..409a8f87c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-array-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-nested-array-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression cannot be parsed with no tokens left over using AssignmentPattern as the goal symbol. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [...[(x, y)]] = [[]]; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-array-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-array-yield-ident-invalid.js new file mode 100644 index 000000000..270a630a8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-array-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-nested-array-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierExpression. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [...[x[yield]]] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-obj-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-obj-invalid.js new file mode 100644 index 000000000..87cbe616f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-obj-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-nested-obj-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression cannot be parsed with no tokens left over using AssignmentPattern as the goal symbol. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [...{ get x() {} }] = [[]]; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-obj-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-obj-yield-ident-invalid.js new file mode 100644 index 000000000..a93bc6a54 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-nested-obj-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-nested-obj-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the Initializer of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierExpression. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, [...{ x = yield }] = [{}]; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-yield-ident-invalid.js new file mode 100644 index 000000000..5dd5d9e36 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/array-rest-yield-ident-invalid.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/array-rest-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentRestElement and outside of a generator function body, it should behave as an IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); +var x = {}; + +0, [...x[yield]] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-identifier-yield-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-identifier-yield-expr.js new file mode 100644 index 000000000..8f54015c5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-identifier-yield-expr.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-id-identifier-yield-expr.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: yield is not a valid IdentifierReference in an AssignmentProperty within generator function bodies. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); +(function*() { + +0, { yield } = {}; + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-identifier-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-identifier-yield-ident-invalid.js new file mode 100644 index 000000000..fab8be9f2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-identifier-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-id-identifier-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: yield is not a valid IdentifierReference in an AssignmentProperty within strict mode code. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { yield } = {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-init-simple-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-init-simple-strict.js new file mode 100644 index 000000000..53b142bf2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-init-simple-strict.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-id-init-simple-strict.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if IsValidSimpleAssignmentTarget of IdentifierReference is false. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { eval = 0 } = {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-init-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-init-yield-ident-invalid.js new file mode 100644 index 000000000..e3dd048d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-init-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-id-init-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the Initializer of an AssignmentProperty and outside of a generator function body, it should behave as an IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { x = yield } = {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-simple-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-simple-strict.js new file mode 100644 index 000000000..c81c4033d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-id-simple-strict.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-id-simple-strict.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if IsValidSimpleAssignmentTarget of IdentifierReference is false. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { eval } = {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-init-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-init-yield-ident-invalid.js new file mode 100644 index 000000000..c1197b2a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-init-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-prop-elem-init-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the Initializer of an AssignmentElement and outside of a generator function body, it should behave as an IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { x: x = yield } = {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-target-memberexpr-optchain-prop-ref-init.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-target-memberexpr-optchain-prop-ref-init.js new file mode 100644 index 000000000..81d3923ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-target-memberexpr-optchain-prop-ref-init.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-prop-elem-target-memberexpr-optchain-prop-ref-init.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression of an DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral and AssignmentTargetType(LeftHandSideExpression) is not simple Using Object (MemberExpression OptionalChain .IdentifierName Initializer) (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [optional-chaining, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. + + Syntax + + AssignmentElement : DestructuringAssignmentTarget Initializer_opt + DestructuringAssignmentTarget : LeftHandSideExpression + + Static Semantics: Early Errors + + OptionalExpression: + MemberExpression OptionalChain + CallExpression OptionalChain + OptionalExpression OptionalChain + + OptionalChain: + ?. [ Expression ] + ?. IdentifierName + ?. Arguments + ?. TemplateLiteral + OptionalChain [ Expression ] + OptionalChain .IdentifierName + OptionalChain Arguments + OptionalChain TemplateLiteral + + DestructuringAssignmentTarget : LeftHandSideExpression + + - It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral and IsValidSimpleAssignmentTarget(LeftHandSideExpression) is not true. + + Static Semantics: IsValidSimpleAssignmentTarget + + LeftHandSideExpression : OptionalExpression + 1. Return false. + +---*/ +$DONOTEVALUATE(); +var y = {}; + +0, { x: y?.z = 42 } = { x: 23 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-target-obj-literal-optchain-prop-ref-init.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-target-obj-literal-optchain-prop-ref-init.js new file mode 100644 index 000000000..c1dbb369f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-target-obj-literal-optchain-prop-ref-init.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-prop-elem-target-obj-literal-optchain-prop-ref-init.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression of an DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral and AssignmentTargetType(LeftHandSideExpression) is not simple Using Object (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [optional-chaining, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. + + Syntax + + AssignmentElement : DestructuringAssignmentTarget Initializer_opt + DestructuringAssignmentTarget : LeftHandSideExpression + + Static Semantics: Early Errors + + OptionalExpression: + MemberExpression OptionalChain + CallExpression OptionalChain + OptionalExpression OptionalChain + + OptionalChain: + ?. [ Expression ] + ?. IdentifierName + ?. Arguments + ?. TemplateLiteral + OptionalChain [ Expression ] + OptionalChain .IdentifierName + OptionalChain Arguments + OptionalChain TemplateLiteral + + DestructuringAssignmentTarget : LeftHandSideExpression + + - It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral and IsValidSimpleAssignmentTarget(LeftHandSideExpression) is not true. + + Static Semantics: IsValidSimpleAssignmentTarget + + LeftHandSideExpression : OptionalExpression + 1. Return false. + +---*/ +$DONOTEVALUATE(); + +0, { x: { + set y(val) { + throw new Test262Error('The property should not be accessed.'); + } +}?.y = 42} = {x: 42}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-target-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-target-yield-ident-invalid.js new file mode 100644 index 000000000..6e22bd5f4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-elem-target-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-prop-elem-target-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement and outside of a generator function body, it should behave as an IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { x: x[yield] } = {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-array-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-array-invalid.js new file mode 100644 index 000000000..29c0d4aad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-array-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-prop-nested-array-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression cannot be parsed with no tokens left over using AssignmentPattern as the goal symbol. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { x: [(x, y)] } = { x: [] }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-array-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-array-yield-ident-invalid.js new file mode 100644 index 000000000..31337c561 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-array-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-prop-nested-array-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the Initializer of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { x: [x = yield] } = { x: [] }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-obj-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-obj-invalid.js new file mode 100644 index 000000000..7317ccd70 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-obj-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-prop-nested-obj-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression cannot be parsed with no tokens left over using AssignmentPattern as the goal symbol. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { x: { get x() {} } } = { x: {} }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-obj-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-obj-yield-ident-invalid.js new file mode 100644 index 000000000..2c88b0590 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-prop-nested-obj-yield-ident-invalid.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-prop-nested-obj-yield-ident-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: When a `yield` token appears within the Initializer of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierReference. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); + +0, { x: { x = yield } } = { x: {} }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-rest-not-last-element-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-rest-not-last-element-invalid.js new file mode 100644 index 000000000..4c59914ef --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/obj-rest-not-last-element-invalid.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-assignment/obj-rest-not-last-element-invalid.case +// - src/dstr-assignment/syntax/assignment-expr.template +/*--- +description: Object rest element needs to be the last AssignmenProperty in ObjectAssignmentPattern. (AssignmentExpression) +esid: sec-variable-statement-runtime-semantics-evaluation +features: [object-rest, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +---*/ +$DONOTEVALUATE(); +var rest, b; + +0, {...rest, b} = {} +; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-break-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-break-escaped.js new file mode 100644 index 000000000..0d902c64b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-break-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/break-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: break is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { bre\u0061k } = { break: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-case-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-case-escaped.js new file mode 100644 index 000000000..77d30ba91 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-case-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/case-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: case is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { c\u0061se } = { case: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-catch-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-catch-escaped.js new file mode 100644 index 000000000..0ed031929 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-catch-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/catch-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: catch is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { c\u0061tch } = { catch: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-class-escaped.js new file mode 100644 index 000000000..a3f7644ac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-class-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/class-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: class is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { cl\u0061ss } = { class: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-const-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-const-escaped.js new file mode 100644 index 000000000..123dd99cf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-const-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/const-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: const is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0063onst } = { const: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-continue-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-continue-escaped.js new file mode 100644 index 000000000..0e6a4c36d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-continue-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/continue-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: continue is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0063ontinue } = { continue: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-debugger-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-debugger-escaped.js new file mode 100644 index 000000000..6c84b67aa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-debugger-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/debugger-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: debugger is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0064ebugger } = { debugger: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped-ext.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped-ext.js new file mode 100644 index 000000000..5f9008ca3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped-ext.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/default-escaped-ext.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: default is a valid identifier name, using extended escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { def\u{61}ult } = { default: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped.js new file mode 100644 index 000000000..e60088b06 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-default-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/default-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: default is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { def\u0061ult } = { default: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-default.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-default.js new file mode 100644 index 000000000..e2b08d544 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-default.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/default.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: default is a valid identifier name (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { default } = { default: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-delete-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-delete-escaped.js new file mode 100644 index 000000000..6304679b5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-delete-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/delete-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: delete is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0064elete } = { delete: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-do-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-do-escaped.js new file mode 100644 index 000000000..8533d10ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-do-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/do-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: do is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0064o } = { do: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-else-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-else-escaped.js new file mode 100644 index 000000000..09f7b3238 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-else-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/else-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: else is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0065lse } = { else: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-enum-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-enum-escaped.js new file mode 100644 index 000000000..b9ace0261 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-enum-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/enum-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: enum is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0065num } = { enum: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-export-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-export-escaped.js new file mode 100644 index 000000000..da5290bc7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-export-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/export-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: export is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0065xport } = { export: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped-ext.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped-ext.js new file mode 100644 index 000000000..83cb17960 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped-ext.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/extends-escaped-ext.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: extends is a valid identifier name, using extended escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u{65}xtends } = { extends: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped.js new file mode 100644 index 000000000..6389193fa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-extends-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/extends-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: extends is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0065xtends } = { extends: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-extends.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-extends.js new file mode 100644 index 000000000..7b473db33 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-extends.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/extends.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: extends is a valid identifier name (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { extends } = { extends: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-finally-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-finally-escaped.js new file mode 100644 index 000000000..42ce33aa0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-finally-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/finally-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: finally is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0066inally } = { finally: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-for-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-for-escaped.js new file mode 100644 index 000000000..be937bbed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-for-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/for-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: for is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0066or } = { for: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-function-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-function-escaped.js new file mode 100644 index 000000000..cdaad0abb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-function-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/function-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: function is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0066unction } = { function: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-if-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-if-escaped.js new file mode 100644 index 000000000..e0a407152 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-if-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/if-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: if is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { i\u0066 } = { if: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-implements-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-implements-escaped.js new file mode 100644 index 000000000..4c6cc7998 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-implements-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/implements-escaped.case +// - src/identifier-names/future-reserved-words/obj-assignment-identifier.template +/*--- +description: implements is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0069mplements } = { implements: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-import-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-import-escaped.js new file mode 100644 index 000000000..e1f98785f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-import-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/import-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: import is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0069mport } = { import: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-in-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-in-escaped.js new file mode 100644 index 000000000..925ed2536 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-in-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/in-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: in is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0069n } = { in: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-instanceof-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-instanceof-escaped.js new file mode 100644 index 000000000..5d3fb33ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-instanceof-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/instanceof-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: instanceof is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { \u0069nstanceof } = { instanceof: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-interface-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-interface-escaped.js new file mode 100644 index 000000000..f17fd5ad0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-interface-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/interface-escaped.case +// - src/identifier-names/future-reserved-words/obj-assignment-identifier.template +/*--- +description: interface is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { interf\u0061ce } = { interface: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-let-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-let-escaped.js new file mode 100644 index 000000000..1e841d9f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-let-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/let-escaped.case +// - src/identifier-names/future-reserved-words/obj-assignment-identifier.template +/*--- +description: let is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { l\u0065t } = { let: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-new-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-new-escaped.js new file mode 100644 index 000000000..4b3ea2ced --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-new-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/new-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: new is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { n\u0065w } = { new: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-package-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-package-escaped.js new file mode 100644 index 000000000..7a4abb44c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-package-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/package-escaped.case +// - src/identifier-names/future-reserved-words/obj-assignment-identifier.template +/*--- +description: package is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { p\u0061ckage } = { package: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-private-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-private-escaped.js new file mode 100644 index 000000000..66d73b85e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-private-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/private-escaped.case +// - src/identifier-names/future-reserved-words/obj-assignment-identifier.template +/*--- +description: private is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { privat\u0065 } = { private: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-protected-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-protected-escaped.js new file mode 100644 index 000000000..05e8b688b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-protected-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/protected-escaped.case +// - src/identifier-names/future-reserved-words/obj-assignment-identifier.template +/*--- +description: protected is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { prot\u0065cted } = { protected: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-public-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-public-escaped.js new file mode 100644 index 000000000..f3f2247af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-public-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/public-escaped.case +// - src/identifier-names/future-reserved-words/obj-assignment-identifier.template +/*--- +description: public is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { pu\u0062lic } = { public: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-return-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-return-escaped.js new file mode 100644 index 000000000..3b66ad286 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-return-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/return-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: return is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { r\u0065turn } = { return: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-static-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-static-escaped.js new file mode 100644 index 000000000..34ef93cdd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-static-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/static-escaped.case +// - src/identifier-names/future-reserved-words/obj-assignment-identifier.template +/*--- +description: static is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { st\u0061tic } = { static: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-super-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-super-escaped.js new file mode 100644 index 000000000..833f26ba0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-super-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/super-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: super is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { sup\u0065r } = { super: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-switch-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-switch-escaped.js new file mode 100644 index 000000000..3efc45684 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-switch-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/switch-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: switch is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { sw\u0069tch } = { switch: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-this-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-this-escaped.js new file mode 100644 index 000000000..affcc456a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-this-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/this-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: this is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { th\u0069s } = { this: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-throw-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-throw-escaped.js new file mode 100644 index 000000000..23406c452 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-throw-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/throw-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: throw is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { t\u0068row } = { throw: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-try-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-try-escaped.js new file mode 100644 index 000000000..347b437b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-try-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/try-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: try is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { tr\u0079 } = { try: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-typeof-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-typeof-escaped.js new file mode 100644 index 000000000..d9513c0e7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-typeof-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/typeof-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: typeof is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { typ\u0065of } = { typeof: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-var-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-var-escaped.js new file mode 100644 index 000000000..2b37ef64b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-var-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/var-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: var is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { v\u0061r } = { var: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-void-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-void-escaped.js new file mode 100644 index 000000000..c5e462992 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-void-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/void-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: void is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { voi\u0064 } = { void: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-while-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-while-escaped.js new file mode 100644 index 000000000..061c74738 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-while-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/while-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: while is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { whil\u0065 } = { while: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-with-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-with-escaped.js new file mode 100644 index 000000000..0fcac64a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/dstr/syntax-error-ident-ref-with-escaped.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/identifier-names/with-escaped.case +// - src/identifier-names/default/obj-assignment-identifier.template +/*--- +description: with is a valid identifier name, using escape (IdentifierReference in ObjectAssignmentPattern cannot be a ReservedWord) +esid: prod-AssignmentPattern +features: [destructuring-assignment] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AssignmentPattern: + ObjectAssignmentPattern + + ObjectAssignmentPattern: + { AssignmentPropertyList } + + AssignmentPropertyList: + AssignmentProperty + AssignmentPropertyList , AssignmentProperty + + AssignmentProperty: + IdentifierReference Initializer_opt + PropertyName : AssignmentElement + + IdentifierReference: + Identifier + [~Yield]yield + [~Await]await + + Identifier: + IdentifierName but not ReservedWord + +---*/ + + +$DONOTEVALUATE(); + +var x = { w\u0069th } = { with: 42 }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/id-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/id-arguments-strict.js new file mode 100644 index 000000000..200408aec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/id-arguments-strict.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.13.1-4-30-s +description: > + Strict Mode - SyntaxError is thrown if the identifier 'arguments' appears as + the LeftHandSideExpression (PrimaryExpression) of simple assignment(=). +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +(arguments) = 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/id-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/id-eval-strict.js new file mode 100644 index 000000000..e95b10c29 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/id-eval-strict.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.13.1-4-30-s +description: > + Strict Mode - SyntaxError is thrown if the identifier 'eval' appears as the + LeftHandSideExpression (PrimaryExpression) of simple assignment(=). +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +(eval) = 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/non-simple-target.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/non-simple-target.js new file mode 100644 index 000000000..a0da0c613 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/non-simple-target.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-assignment-inside-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-assignment-inside-function.js new file mode 100644 index 000000000..58d7dd2e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-assignment-inside-function.js @@ -0,0 +1,23 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: Applied to assignment +info: | + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + - It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function f() { + var a, b = 2; + (a = b) = 1; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-assignment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-assignment.js new file mode 100644 index 000000000..18b798449 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-assignment.js @@ -0,0 +1,21 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: Applied to assignment +info: | + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + - It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var a, b = 2; +(a = b) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-boolean.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-boolean.js new file mode 100644 index 000000000..c39c7b71c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-boolean.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: > + simple assignment throws SyntaxError if LeftHandSide is not a + reference (boolean) +info: | + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +true = 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-cover-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-cover-newtarget.js new file mode 100644 index 000000000..124acd309 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-cover-newtarget.js @@ -0,0 +1,30 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: Applied to a "covered" new.target +info: | + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + - It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + (new.target) = 1; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-cover-yieldexpr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-cover-yieldexpr.js new file mode 100644 index 000000000..8e96d4ed0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-cover-yieldexpr.js @@ -0,0 +1,33 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: Applied to a "covered" YieldExpression +info: | + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + - It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + + 12.15.3 Static Semantics: IsValidSimpleAssignmentTarget + + AssignmentExpression: + YieldExpression + ArrowFunction + AsyncArrowFunction + LeftHandSideExpression = AssignmentExpression + LeftHandSideExpression AssignmentOperator AssignmentExpression + + 1. Return invalid. +features: [generators] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function* g() { + (yield) = 1; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-newtarget.js new file mode 100644 index 000000000..a50a04a45 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-newtarget.js @@ -0,0 +1,30 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: Applied to new.target +info: | + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + - It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + new.target = 1; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-null.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-null.js new file mode 100644 index 000000000..5adbb4ce4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-null.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: > + simple assignment throws SyntaxError if LeftHandSide is not a + reference (null) +info: | + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +null = 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-number.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-number.js new file mode 100644 index 000000000..326043282 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-number.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: > + simple assignment throws SyntaxError if LeftHandSide is not a + reference (number) +info: | + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +42 = 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-string.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-string.js new file mode 100644 index 000000000..cd277c903 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignment/target-string.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: > + simple assignment throws SyntaxError if LeftHandSide is not a + reference (string) +info: | + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + It is an early Syntax Error if LeftHandSideExpression is neither an + ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +'x' = 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-0.js new file mode 100644 index 000000000..7361ef586 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-minus-multiplicativeexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AdditiveExpression - MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x - y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-1.js new file mode 100644 index 000000000..f1a7d8c11 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-minus-multiplicativeexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AdditiveExpression - MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 - 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-2.js new file mode 100644 index 000000000..3eb98027f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-minus-multiplicativeexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-minus-multiplicativeexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AdditiveExpression - MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true - false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-0.js new file mode 100644 index 000000000..12cc63225 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-plus-multiplicativeexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AdditiveExpression + MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x + y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-1.js new file mode 100644 index 000000000..783a114f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-plus-multiplicativeexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AdditiveExpression + MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 + 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-2.js new file mode 100644 index 000000000..93f95ff2e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-additiveexpression-plus-multiplicativeexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-plus-multiplicativeexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AdditiveExpression + MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true + false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-0.js new file mode 100644 index 000000000..646581fce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +() => {} = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-1.js new file mode 100644 index 000000000..6c2d64c5e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +() => ({}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-2.js new file mode 100644 index 000000000..c044f0329 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x => x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-3.js new file mode 100644 index 000000000..f99f81323 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-3.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-3.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x) => x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-4.js new file mode 100644 index 000000000..aa849db02 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-4.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-4.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(() => 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-5.js new file mode 100644 index 000000000..30c151227 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-5.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-5.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(() => true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-6.js new file mode 100644 index 000000000..e94f1e031 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-arrowfunction-6.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-6.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(() => 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-0.js new file mode 100644 index 000000000..55301f5e2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +async () => {} = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-1.js new file mode 100644 index 000000000..bb354b6b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +async () => ({}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-2.js new file mode 100644 index 000000000..67b2fcca4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(async x => x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-3.js new file mode 100644 index 000000000..d2bccb627 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-3.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-3.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(async (x) => x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-4.js new file mode 100644 index 000000000..9eb4f3130 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-4.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-4.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(async () => 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-5.js new file mode 100644 index 000000000..e24e8918d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-5.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-5.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(async () => true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-6.js new file mode 100644 index 000000000..9f4314228 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-asyncarrowfunction-6.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-6.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(async () => 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-0.js new file mode 100644 index 000000000..9efb3d77d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseandexpression-bitwise-and-equalityexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + BitwiseANDExpression: BitwiseANDExpression & EqualityExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x & y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-1.js new file mode 100644 index 000000000..bdd8051f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseandexpression-bitwise-and-equalityexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + BitwiseANDExpression: BitwiseANDExpression & EqualityExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 & 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-2.js new file mode 100644 index 000000000..bc85d449d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseandexpression-bitwise-and-equalityexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseandexpression-bitwise-and-equalityexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + BitwiseANDExpression: BitwiseANDExpression & EqualityExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true & false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js new file mode 100644 index 000000000..78dea33fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseorexpression-bitwise-or-bitwisexorexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + BitwiseORExpression: BitwiseORExpression | BitwiseXORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x | y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js new file mode 100644 index 000000000..c073b0df4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseorexpression-bitwise-or-bitwisexorexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + BitwiseORExpression: BitwiseORExpression | BitwiseXORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 | 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js new file mode 100644 index 000000000..84378b905 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseorexpression-bitwise-or-bitwisexorexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + BitwiseORExpression: BitwiseORExpression | BitwiseXORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true | false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js new file mode 100644 index 000000000..246e7a146 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + BitwiseXORExpression: BitwiseXORExpression ^ BitwiseANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x ^ y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js new file mode 100644 index 000000000..147322db6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + BitwiseXORExpression: BitwiseXORExpression ^ BitwiseANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 ^ 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js new file mode 100644 index 000000000..d8a4117df --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + BitwiseXORExpression: BitwiseXORExpression ^ BitwiseANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true ^ false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-as-for-in-lhs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-as-for-in-lhs.js new file mode 100644 index 000000000..b4913aef5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-as-for-in-lhs.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-as-for-in-lhs.case +// - src/assignment-target-type/invalid/statement/default.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (Direct assignment) +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +for (f() in [1]) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-as-for-of-lhs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-as-for-of-lhs.js new file mode 100644 index 000000000..6352d1371 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-as-for-of-lhs.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-as-for-of-lhs.case +// - src/assignment-target-type/invalid/statement/default.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (Direct assignment) +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +for (f() of [1]) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-compound-assignment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-compound-assignment.js new file mode 100644 index 000000000..013e725d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-compound-assignment.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-in-compound-assignment.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (Direct assignment) +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +f() += 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-logical-assignment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-logical-assignment.js new file mode 100644 index 000000000..e4a7563ae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-logical-assignment.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-in-logical-assignment.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +f() &&= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-postfix-update.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-postfix-update.js new file mode 100644 index 000000000..d4e5a5275 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-postfix-update.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-in-postfix-update.case +// - src/assignment-target-type/invalid/statement/default.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (Direct assignment) +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +f()++; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-prefix-update.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-prefix-update.js new file mode 100644 index 000000000..93ff1671f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-in-prefix-update.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-in-prefix-update.case +// - src/assignment-target-type/invalid/statement/default.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (Direct assignment) +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +++f(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-templateliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-templateliteral.js new file mode 100644 index 000000000..e44d6e145 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression-templateliteral.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-templateliteral.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CallExpression TemplateLiteral + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +f()`` = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression.js new file mode 100644 index 000000000..28475f377 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-callexpression.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (Direct assignment) +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +f() = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js new file mode 100644 index 000000000..ff1de78ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/coalesceexpressionhead-coalesce-bitwiseorexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CoalesceExpression: CoalesceExpressionHead ?? BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x ?? y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js new file mode 100644 index 000000000..c04973f88 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/coalesceexpressionhead-coalesce-bitwiseorexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CoalesceExpression: CoalesceExpressionHead ?? BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 ?? 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js new file mode 100644 index 000000000..db7f21f20 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/coalesceexpressionhead-coalesce-bitwiseorexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + CoalesceExpression: CoalesceExpressionHead ?? BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true ?? false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-0.js new file mode 100644 index 000000000..d5425f03d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-equal-relationalexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression == RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x == y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-1.js new file mode 100644 index 000000000..f8053059e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-equal-relationalexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression == RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 == 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-2.js new file mode 100644 index 000000000..04abbf971 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-equal-relationalexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-equal-relationalexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression == RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true == false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-0.js new file mode 100644 index 000000000..22a239342 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-not-equal-relationalexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression != RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x != y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-1.js new file mode 100644 index 000000000..bcaeba7fc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-not-equal-relationalexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression != RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 != 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-2.js new file mode 100644 index 000000000..b98544cb6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-abstract-not-equal-relationalexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-not-equal-relationalexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression != RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true != false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-0.js new file mode 100644 index 000000000..8e140f08b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-equal-relationalexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression === RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x == y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-1.js new file mode 100644 index 000000000..98ad9b75e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-equal-relationalexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression === RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 == 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-2.js new file mode 100644 index 000000000..72694e295 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-equal-relationalexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-equal-relationalexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression === RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true == false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-0.js new file mode 100644 index 000000000..124f75855 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-not-equal-relationalexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression !== RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x !== y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-1.js new file mode 100644 index 000000000..8f6c442ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-not-equal-relationalexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression !== RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 !== 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-2.js new file mode 100644 index 000000000..d47d4c3ff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-equalityexpression-strict-not-equal-relationalexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-not-equal-relationalexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + EqualityExpression !== RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true !== false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-0.js new file mode 100644 index 000000000..c230ab11d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/expression-comma-assignmentexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + Expression: Expression , AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x, y = z) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-1.js new file mode 100644 index 000000000..a5575ff52 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/expression-comma-assignmentexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + Expression: Expression , AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x, y = 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-2.js new file mode 100644 index 000000000..cea95c642 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-expression-comma-assignmentexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/expression-comma-assignmentexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + Expression: Expression , AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x, y = true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-identifierreference-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-identifierreference-arguments-strict.js new file mode 100644 index 000000000..3b722402a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-identifierreference-arguments-strict.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/identifierreference-arguments-strict.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return invalid. (Direct assignment) +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +arguments = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-identifierreference-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-identifierreference-eval-strict.js new file mode 100644 index 000000000..a0056347c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-identifierreference-eval-strict.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/identifierreference-eval-strict.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return invalid. (Direct assignment) +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +eval = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-import.meta.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-import.meta.js new file mode 100644 index 000000000..83b2d11fd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-import.meta.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/import.meta.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + import.meta + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +import.meta = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-importcall-defer.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-importcall-defer.js new file mode 100644 index 000000000..cf36b1cf8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-importcall-defer.js @@ -0,0 +1,21 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/importcall-defer.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +features: [import-defer] +flags: [generated, module] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ImportCall + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +import.defer() = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-importcall-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-importcall-source.js new file mode 100644 index 000000000..1158123b0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-importcall-source.js @@ -0,0 +1,21 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/importcall-source.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +features: [source-phase-imports] +flags: [generated, module] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ImportCall + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +import.source() = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-importcall.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-importcall.js new file mode 100644 index 000000000..5695be8ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-importcall.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/importcall.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated, module] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ImportCall + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +import() = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-0.js new file mode 100644 index 000000000..d85e955a9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-assignment-assignmentexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression = AssignmentExpression + If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +(x = y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-1.js new file mode 100644 index 000000000..a2f92ee0f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-assignment-assignmentexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression = AssignmentExpression + If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +(x = 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-2.js new file mode 100644 index 000000000..7233016c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-assignment-assignmentexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-assignment-assignmentexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression = AssignmentExpression + If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +(x = true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js new file mode 100644 index 000000000..e75836ba1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-coalesce-assignment-assignmentexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression ??= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ??= y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js new file mode 100644 index 000000000..2648550e1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-coalesce-assignment-assignmentexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression ??= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ??= 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js new file mode 100644 index 000000000..be3da47d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-coalesce-assignment-assignmentexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression ??= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ??= true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js new file mode 100644 index 000000000..90547079a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-and-assignment-assignmentexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression &&= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x &&= y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js new file mode 100644 index 000000000..15dd1eb61 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-and-assignment-assignmentexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression &&= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x &&= 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js new file mode 100644 index 000000000..c4931692e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-and-assignment-assignmentexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression &&= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x &&= true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js new file mode 100644 index 000000000..81aa10afb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-or-assignment-assignmentexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression ||= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ||= y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js new file mode 100644 index 000000000..afdeb178d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-or-assignment-assignmentexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression ||= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ||= 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js new file mode 100644 index 000000000..3c62ca2af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-or-assignment-assignmentexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LeftHandSideExpression ||= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ||= true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-minus-minus.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-minus-minus.js new file mode 100644 index 000000000..1d21a9607 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-minus-minus.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-minus-minus.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UpdateExpression: LeftHandSideExpression-- + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +x-- = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-plus-plus.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-plus-plus.js new file mode 100644 index 000000000..8c4455be4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-lefthandsideexpression-plus-plus.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-plus-plus.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UpdateExpression: LeftHandSideExpression ++ + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +x++ = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-0.js new file mode 100644 index 000000000..081996bc7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalandexpression-logical-and-bitwiseorexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LogicalANDExpression: LogicalANDExpression && BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x && y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-1.js new file mode 100644 index 000000000..e8029f076 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalandexpression-logical-and-bitwiseorexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LogicalANDExpression: LogicalANDExpression && BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 && 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-2.js new file mode 100644 index 000000000..6017f3ddb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalandexpression-logical-and-bitwiseorexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalandexpression-logical-and-bitwiseorexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LogicalANDExpression: LogicalANDExpression && BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true && false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-0.js new file mode 100644 index 000000000..5ec31c881 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalorexpression-logical-or-logicalandexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LogicalORExpression: LogicalORExpression || LogicalANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x || y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-1.js new file mode 100644 index 000000000..2d83754f1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalorexpression-logical-or-logicalandexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LogicalORExpression: LogicalORExpression || LogicalANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 || 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-2.js new file mode 100644 index 000000000..4254f3e58 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-logicalorexpression-logical-or-logicalandexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalorexpression-logical-or-logicalandexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + LogicalORExpression: LogicalORExpression || LogicalANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true || false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-memberexpression-templateliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-memberexpression-templateliteral.js new file mode 100644 index 000000000..7a4782b6b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-memberexpression-templateliteral.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/memberexpression-templateliteral.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + MemberExpression TemplateLiteral + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +o.f()`` = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-minus-minus-unaryexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-minus-minus-unaryexpression.js new file mode 100644 index 000000000..0fd106fea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-minus-minus-unaryexpression.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/minus-minus-unaryexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UpdateExpression: --UnaryExpression + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +--x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js new file mode 100644 index 000000000..4a9282bdd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x * y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js new file mode 100644 index 000000000..c48c60f55 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 * 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js new file mode 100644 index 000000000..82d4bcafc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true * false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js new file mode 100644 index 000000000..0de7ac87a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x / y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js new file mode 100644 index 000000000..6f9b0b39e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 / 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js new file mode 100644 index 000000000..7735c5921 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true / false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-new-memberexpression-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-new-memberexpression-arguments.js new file mode 100644 index 000000000..0e75b5857 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-new-memberexpression-arguments.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/new-memberexpression-arguments.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + new MemberExpression Arguments + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +new f() = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-new-newexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-new-newexpression.js new file mode 100644 index 000000000..be1559d33 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-new-newexpression.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/new-newexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + new NewExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +new f = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-optionalexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-optionalexpression.js new file mode 100644 index 000000000..3382c079c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-optionalexpression.js @@ -0,0 +1,21 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/optionalexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +features: [optional-chaining] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + OptionalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x?.y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-plus-plus-unaryexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-plus-plus-unaryexpression.js new file mode 100644 index 000000000..4e91e76d0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-plus-plus-unaryexpression.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/plus-plus-unaryexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UpdateExpression: ++UnaryExpression + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +++x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-asyncfunctionexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-asyncfunctionexpression.js new file mode 100644 index 000000000..7e36c917d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-asyncfunctionexpression.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-asyncfunctionexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression AsyncFunctionExpression; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +async function () {} = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-asyncgeneratorexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-asyncgeneratorexpression.js new file mode 100644 index 000000000..0918a8c96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-asyncgeneratorexpression.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-asyncgeneratorexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression AsyncGeneratorExpression; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +async function () {} = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-classexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-classexpression.js new file mode 100644 index 000000000..bd0f36b2e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-classexpression.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-classexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression ClassExpression; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +class {} = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-functionexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-functionexpression.js new file mode 100644 index 000000000..a78aa80e6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-functionexpression.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-functionexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression FunctionExpression, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +function() {} = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-generatorexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-generatorexpression.js new file mode 100644 index 000000000..25d27f2e6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-generatorexpression.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-generatorexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression ArrayLiteral; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +function * () {} = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-boolean.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-boolean.js new file mode 100644 index 000000000..a0def9093 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-boolean.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-literal-boolean.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression Literal BooleanLiteral; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +true = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-null.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-null.js new file mode 100644 index 000000000..814f7537d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-null.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-literal-null.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression Literal NullLiteral; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +null = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-numeric.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-numeric.js new file mode 100644 index 000000000..12c9ede95 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-numeric.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-literal-numeric.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression Literal NumericLiteral; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +0 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-string.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-string.js new file mode 100644 index 000000000..2ad74c5a2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-literal-string.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-literal-string.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression Literal StringLiteral; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +'' = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-objectliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-objectliteral.js new file mode 100644 index 000000000..605994532 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-objectliteral.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-objectliteral.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression ObjectLiteral; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +{} = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-regularexpressionliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-regularexpressionliteral.js new file mode 100644 index 000000000..12ff959d8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-regularexpressionliteral.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-regularexpressionliteral.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression RegularExpressionLiteral; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +/1/ = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-templateliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-templateliteral.js new file mode 100644 index 000000000..ff5ff9e28 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-templateliteral.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-templateliteral.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression TemplateLiteral; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +`` = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-this.js new file mode 100644 index 000000000..ea5dce30a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-primaryexpression-this.js @@ -0,0 +1,16 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-this.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: PrimaryExpression this; Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment +---*/ + +$DONOTEVALUATE(); + +this = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js new file mode 100644 index 000000000..a2b726f44 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-or-equal-to-shiftexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression >= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x >= y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js new file mode 100644 index 000000000..eb47e4db3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-or-equal-to-shiftexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression >= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 >= 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js new file mode 100644 index 000000000..9782a47c2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-or-equal-to-shiftexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression >= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true >= false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-0.js new file mode 100644 index 000000000..9f9d262c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-shiftexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression > ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x > y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-1.js new file mode 100644 index 000000000..32bc7f564 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-shiftexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression > ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 > 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-2.js new file mode 100644 index 000000000..114822ddc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-greater-than-shiftexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-shiftexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression > ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true > false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-0.js new file mode 100644 index 000000000..c9c32ab10 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-in-shiftexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression in ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x in y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-1.js new file mode 100644 index 000000000..91628ae04 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-in-shiftexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression in ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 in 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-2.js new file mode 100644 index 000000000..1599db5a9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-in-shiftexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-in-shiftexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression in ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true in false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-0.js new file mode 100644 index 000000000..eebcebe9a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-instanceof-shiftexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression instanceof ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x instanceof y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-1.js new file mode 100644 index 000000000..b01c4e7fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-instanceof-shiftexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression instanceof ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 instanceof 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-2.js new file mode 100644 index 000000000..44fd3e657 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-instanceof-shiftexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-instanceof-shiftexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression instanceof ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true instanceof false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-0.js new file mode 100644 index 000000000..5aa1e1219 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-or-equal-to-shiftexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression <= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x <= y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-1.js new file mode 100644 index 000000000..7151d3d31 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-or-equal-to-shiftexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression <= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 <= 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-2.js new file mode 100644 index 000000000..1658ceeea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-or-equal-to-shiftexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-or-equal-to-shiftexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression <= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true <= false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-0.js new file mode 100644 index 000000000..01b996391 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-shiftexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression < ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x < y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-1.js new file mode 100644 index 000000000..a5282d271 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-shiftexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression < ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 < 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-2.js new file mode 100644 index 000000000..4b4eed749 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-relationalexpression-less-than-shiftexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-shiftexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + RelationalExpression < ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true < false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-0.js new file mode 100644 index 000000000..7621ce73d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-left-additiveexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShiftExpression << AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x << y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-1.js new file mode 100644 index 000000000..c8a8f9152 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-left-additiveexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShiftExpression << AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 << 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-2.js new file mode 100644 index 000000000..11f5fae24 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-left-additiveexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-left-additiveexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShiftExpression << AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true << false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-0.js new file mode 100644 index 000000000..3c46a06b9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-right-additiveexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShiftExpression >> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x >> y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-1.js new file mode 100644 index 000000000..585069a7c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-right-additiveexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShiftExpression >> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 >> 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-2.js new file mode 100644 index 000000000..2f42957b3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-bitwise-right-additiveexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-right-additiveexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShiftExpression >> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true >> false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js new file mode 100644 index 000000000..21b7a92b7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-unsigned-bitwise-right-additiveexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShiftExpression >>> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x >>> y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js new file mode 100644 index 000000000..95c773b27 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-unsigned-bitwise-right-additiveexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShiftExpression >>> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 >>> 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js new file mode 100644 index 000000000..ed2e95c0f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-unsigned-bitwise-right-additiveexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShiftExpression >>> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true >>> false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js new file mode 100644 index 000000000..37dc32845 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ? y : z) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js new file mode 100644 index 000000000..9276e7f74 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 ? 2 : 3) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js new file mode 100644 index 000000000..84b908fa8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true ? false : true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-delete-unaryexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-delete-unaryexpression.js new file mode 100644 index 000000000..020041287 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-delete-unaryexpression.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-delete-unaryexpression.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: delete UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +delete x.y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-0.js new file mode 100644 index 000000000..d391ef341 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-exclamation-unaryexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: ! UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +!x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-1.js new file mode 100644 index 000000000..d33190e0d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-exclamation-unaryexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: ! UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +!1 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-2.js new file mode 100644 index 000000000..499628e90 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-exclamation-unaryexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-exclamation-unaryexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: ! UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +!true = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-0.js new file mode 100644 index 000000000..1b66122ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-minus-unaryexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: - UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +-x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-1.js new file mode 100644 index 000000000..b681d002b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-minus-unaryexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: - UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +-1 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-2.js new file mode 100644 index 000000000..818caa465 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-minus-unaryexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-minus-unaryexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: - UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +-true = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-0.js new file mode 100644 index 000000000..134f7969d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-plus-unaryexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: + UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + ++x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-1.js new file mode 100644 index 000000000..30a5954be --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-plus-unaryexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: + UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + ++1 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-2.js new file mode 100644 index 000000000..ddf15c021 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-plus-unaryexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-plus-unaryexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: + UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + ++true = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-0.js new file mode 100644 index 000000000..1e2b4929b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-tilde-unaryexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: ~ UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +~x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-1.js new file mode 100644 index 000000000..2be2bdae0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-tilde-unaryexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: ~ UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +~1 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-2.js new file mode 100644 index 000000000..b40f431a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-tilde-unaryexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-tilde-unaryexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: ~ UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +~true = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-0.js new file mode 100644 index 000000000..a41e54b41 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-typeof-unaryexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: typeof UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +typeof x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-1.js new file mode 100644 index 000000000..4616c1559 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-typeof-unaryexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: typeof UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +typeof 1 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-2.js new file mode 100644 index 000000000..e6c3060a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-typeof-unaryexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-typeof-unaryexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: typeof UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +typeof true = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-0.js new file mode 100644 index 000000000..2ca9142f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-void-unaryexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: void UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +void x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-1.js new file mode 100644 index 000000000..18913ca98 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-void-unaryexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: void UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +void 1 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-2.js new file mode 100644 index 000000000..9e7be46ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-unaryexpression-void-unaryexpression-2.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-void-unaryexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UnaryExpression: void UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +void true = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-0.js new file mode 100644 index 000000000..4bf6b3701 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-0.js @@ -0,0 +1,21 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/updateexpression-star-star-exponentiationexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +features: [exponentiation] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UpdateExpression ** ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +x ** y = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-1.js new file mode 100644 index 000000000..2f4eb8e75 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-1.js @@ -0,0 +1,21 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/updateexpression-star-star-exponentiationexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +features: [exponentiation] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UpdateExpression ** ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +1 ** 2 = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-2.js new file mode 100644 index 000000000..bf20a2835 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-updateexpression-star-star-exponentiationexpression-2.js @@ -0,0 +1,21 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/updateexpression-star-star-exponentiationexpression-2.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +features: [exponentiation] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + UpdateExpression ** ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +true ** false = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-yieldexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-yieldexpression-0.js new file mode 100644 index 000000000..5282c2902 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-yieldexpression-0.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/yieldexpression-0.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + YieldExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +yield x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-yieldexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-yieldexpression-1.js new file mode 100644 index 000000000..d7df63a0f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/direct-yieldexpression-1.js @@ -0,0 +1,20 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/yieldexpression-1.case +// - src/assignment-target-type/invalid/direct.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (Direct assignment) +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Direct assignment + + YieldExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +yield * x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-0.js new file mode 100644 index 000000000..8fb8babc3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-minus-multiplicativeexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AdditiveExpression - MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x - y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-1.js new file mode 100644 index 000000000..7f14a1791 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-minus-multiplicativeexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AdditiveExpression - MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 - 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-2.js new file mode 100644 index 000000000..f0bca22e5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-minus-multiplicativeexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-minus-multiplicativeexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AdditiveExpression - MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true - false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-0.js new file mode 100644 index 000000000..b14290cab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-plus-multiplicativeexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AdditiveExpression + MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x + y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-1.js new file mode 100644 index 000000000..bffe3f040 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-plus-multiplicativeexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AdditiveExpression + MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 + 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-2.js new file mode 100644 index 000000000..764d4280f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-additiveexpression-plus-multiplicativeexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/additiveexpression-plus-multiplicativeexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AdditiveExpression + MultiplicativeExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true + false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-0.js new file mode 100644 index 000000000..71178cb62 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(() => {}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-1.js new file mode 100644 index 000000000..5d788466a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(() => ({})) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-2.js new file mode 100644 index 000000000..4afd8dfcb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x => x)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-3.js new file mode 100644 index 000000000..e96168a1b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-3.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-3.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(((x) => x)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-4.js new file mode 100644 index 000000000..bbf20f6fd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-4.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-4.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((() => 1)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-5.js new file mode 100644 index 000000000..00c079e2e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-5.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-5.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((() => true)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-6.js new file mode 100644 index 000000000..502616d66 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-arrowfunction-6.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/arrowfunction-6.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((() => 1)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-0.js new file mode 100644 index 000000000..eab590a6f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(async () => {}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-1.js new file mode 100644 index 000000000..953d7f240 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(async () => ({})) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-2.js new file mode 100644 index 000000000..3111dbb1e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((async x => x)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-3.js new file mode 100644 index 000000000..c8dc75a4f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-3.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-3.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((async (x) => x)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-4.js new file mode 100644 index 000000000..cadcce34e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-4.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-4.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((async () => 1)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-5.js new file mode 100644 index 000000000..d005f1a90 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-5.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-5.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((async () => true)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-6.js new file mode 100644 index 000000000..5a204c78d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-asyncarrowfunction-6.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/asyncarrowfunction-6.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + AsyncArrowFunction + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((async () => 1)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-0.js new file mode 100644 index 000000000..1f5ba62b5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseandexpression-bitwise-and-equalityexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + BitwiseANDExpression: BitwiseANDExpression & EqualityExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x & y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-1.js new file mode 100644 index 000000000..f396d6547 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseandexpression-bitwise-and-equalityexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + BitwiseANDExpression: BitwiseANDExpression & EqualityExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 & 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-2.js new file mode 100644 index 000000000..26a86d325 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseandexpression-bitwise-and-equalityexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseandexpression-bitwise-and-equalityexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + BitwiseANDExpression: BitwiseANDExpression & EqualityExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true & false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js new file mode 100644 index 000000000..83f11e43c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseorexpression-bitwise-or-bitwisexorexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + BitwiseORExpression: BitwiseORExpression | BitwiseXORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x | y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js new file mode 100644 index 000000000..914ebf8f5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseorexpression-bitwise-or-bitwisexorexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + BitwiseORExpression: BitwiseORExpression | BitwiseXORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 | 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js new file mode 100644 index 000000000..22aeb0fc2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwiseorexpression-bitwise-or-bitwisexorexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwiseorexpression-bitwise-or-bitwisexorexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + BitwiseORExpression: BitwiseORExpression | BitwiseXORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true | false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js new file mode 100644 index 000000000..1dd5832a1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwisexorexpression-bitwise-xor-bitwiseandexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + BitwiseXORExpression: BitwiseXORExpression ^ BitwiseANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ^ y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js new file mode 100644 index 000000000..7b832e1fd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwisexorexpression-bitwise-xor-bitwiseandexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + BitwiseXORExpression: BitwiseXORExpression ^ BitwiseANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 ^ 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js new file mode 100644 index 000000000..a77a120b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/bitwisexorexpression-bitwise-xor-bitwiseandexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + BitwiseXORExpression: BitwiseXORExpression ^ BitwiseANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true ^ false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression-in-compound-assignment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression-in-compound-assignment.js new file mode 100644 index 000000000..61838d1f6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression-in-compound-assignment.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-in-compound-assignment.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +(f()) += 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression-in-logical-assignment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression-in-logical-assignment.js new file mode 100644 index 000000000..eef6b0962 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression-in-logical-assignment.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-in-logical-assignment.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +(f()) &&= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression-templateliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression-templateliteral.js new file mode 100644 index 000000000..adb0c88d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression-templateliteral.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression-templateliteral.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + CallExpression TemplateLiteral + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(f()``) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression.js new file mode 100644 index 000000000..45e3eb6c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-callexpression.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/callexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return web-compat. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + CallExpression : + CoverCallExpressionAndAsyncArrowHead + CallExpression Arguments + 1. If the host is a web browser or otherwise supports Runtime Errors for Function Call Assignment Targets, then + a. If IsStrict(this CallExpression) is false, return ~web-compat~. + 2. Return ~invalid~. + +---*/ + +$DONOTEVALUATE(); + +(f()) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js new file mode 100644 index 000000000..0335a9cdf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/coalesceexpressionhead-coalesce-bitwiseorexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + CoalesceExpression: CoalesceExpressionHead ?? BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ?? y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js new file mode 100644 index 000000000..1bcc38df5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/coalesceexpressionhead-coalesce-bitwiseorexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + CoalesceExpression: CoalesceExpressionHead ?? BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 ?? 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js new file mode 100644 index 000000000..0144d84b1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-coalesceexpressionhead-coalesce-bitwiseorexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/coalesceexpressionhead-coalesce-bitwiseorexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + CoalesceExpression: CoalesceExpressionHead ?? BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true ?? false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-0.js new file mode 100644 index 000000000..b73e23060 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-equal-relationalexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression == RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x == y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-1.js new file mode 100644 index 000000000..dad167d15 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-equal-relationalexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression == RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 == 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-2.js new file mode 100644 index 000000000..0dfdac183 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-equal-relationalexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-equal-relationalexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression == RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true == false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-0.js new file mode 100644 index 000000000..c8e7de8c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-not-equal-relationalexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression != RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x != y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-1.js new file mode 100644 index 000000000..17241ddba --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-not-equal-relationalexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression != RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 != 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-2.js new file mode 100644 index 000000000..dd287fd7b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-abstract-not-equal-relationalexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-abstract-not-equal-relationalexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression != RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true != false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-0.js new file mode 100644 index 000000000..42ae3eb6f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-equal-relationalexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression === RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x == y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-1.js new file mode 100644 index 000000000..450140da1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-equal-relationalexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression === RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 == 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-2.js new file mode 100644 index 000000000..73ce27316 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-equal-relationalexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-equal-relationalexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression === RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true == false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-0.js new file mode 100644 index 000000000..253ae27e7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-not-equal-relationalexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression !== RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x !== y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-1.js new file mode 100644 index 000000000..7ceaacabf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-not-equal-relationalexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression !== RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 !== 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-2.js new file mode 100644 index 000000000..789850891 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-equalityexpression-strict-not-equal-relationalexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/equalityexpression-strict-not-equal-relationalexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + EqualityExpression !== RelationalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true !== false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-0.js new file mode 100644 index 000000000..df21baf29 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/expression-comma-assignmentexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + Expression: Expression , AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x, y = z)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-1.js new file mode 100644 index 000000000..fb77df5c3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/expression-comma-assignmentexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + Expression: Expression , AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x, y = 1)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-2.js new file mode 100644 index 000000000..b3fdea50e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-expression-comma-assignmentexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/expression-comma-assignmentexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + Expression: Expression , AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x, y = true)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-identifierreference-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-identifierreference-arguments-strict.js new file mode 100644 index 000000000..70ec1f4f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-identifierreference-arguments-strict.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/identifierreference-arguments-strict.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(arguments) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-identifierreference-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-identifierreference-eval-strict.js new file mode 100644 index 000000000..3f22d4369 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-identifierreference-eval-strict.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/identifierreference-eval-strict.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(eval) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-import.meta.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-import.meta.js new file mode 100644 index 000000000..8bbba726e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-import.meta.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/import.meta.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + import.meta + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(import.meta) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-importcall-defer.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-importcall-defer.js new file mode 100644 index 000000000..927f9e46b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-importcall-defer.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/importcall-defer.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +features: [import-defer] +flags: [generated, module] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ImportCall + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(import.defer()) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-importcall-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-importcall-source.js new file mode 100644 index 000000000..46fdeeec6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-importcall-source.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/importcall-source.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +features: [source-phase-imports] +flags: [generated, module] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ImportCall + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(import.source()) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-importcall.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-importcall.js new file mode 100644 index 000000000..a96060eb6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-importcall.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/importcall.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated, module] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ImportCall + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(import()) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-0.js new file mode 100644 index 000000000..ffccf25d2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-assignment-assignmentexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression = AssignmentExpression + If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +((x = y)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-1.js new file mode 100644 index 000000000..c48d2fb78 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-assignment-assignmentexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression = AssignmentExpression + If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +((x = 1)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-2.js new file mode 100644 index 000000000..8fb7146ab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-assignment-assignmentexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-assignment-assignmentexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression = AssignmentExpression + If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, the following Early Error rule is applied, It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +((x = true)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js new file mode 100644 index 000000000..4b4bacd89 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-coalesce-assignment-assignmentexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression ??= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x ??= y)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js new file mode 100644 index 000000000..7d36b1619 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-coalesce-assignment-assignmentexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression ??= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x ??= 1)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js new file mode 100644 index 000000000..98d373c54 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-coalesce-assignment-assignmentexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-coalesce-assignment-assignmentexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression ??= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x ??= true)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js new file mode 100644 index 000000000..680266b55 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-and-assignment-assignmentexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression &&= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x &&= y)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js new file mode 100644 index 000000000..c96a2fc86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-and-assignment-assignmentexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression &&= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x &&= 1)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js new file mode 100644 index 000000000..d90659a30 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-and-assignment-assignmentexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-and-assignment-assignmentexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression &&= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x &&= true)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js new file mode 100644 index 000000000..39010cbca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-or-assignment-assignmentexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression ||= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x ||= y)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js new file mode 100644 index 000000000..242789cda --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-or-assignment-assignmentexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression ||= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x ||= 1)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js new file mode 100644 index 000000000..73ec571c4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-logical-or-assignment-assignmentexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-logical-or-assignment-assignmentexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LeftHandSideExpression ||= AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x ||= true)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-minus-minus.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-minus-minus.js new file mode 100644 index 000000000..0ee6af2aa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-minus-minus.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-minus-minus.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UpdateExpression: LeftHandSideExpression-- + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +(x--) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-plus-plus.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-plus-plus.js new file mode 100644 index 000000000..a56646968 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-lefthandsideexpression-plus-plus.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/lefthandsideexpression-plus-plus.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UpdateExpression: LeftHandSideExpression ++ + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +(x++) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-0.js new file mode 100644 index 000000000..3a3e5246c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalandexpression-logical-and-bitwiseorexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LogicalANDExpression: LogicalANDExpression && BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x && y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-1.js new file mode 100644 index 000000000..8609f7500 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalandexpression-logical-and-bitwiseorexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LogicalANDExpression: LogicalANDExpression && BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 && 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-2.js new file mode 100644 index 000000000..fb64e1994 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalandexpression-logical-and-bitwiseorexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalandexpression-logical-and-bitwiseorexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LogicalANDExpression: LogicalANDExpression && BitwiseORExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true && false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-0.js new file mode 100644 index 000000000..7285fb693 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalorexpression-logical-or-logicalandexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LogicalORExpression: LogicalORExpression || LogicalANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x || y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-1.js new file mode 100644 index 000000000..16504fa80 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalorexpression-logical-or-logicalandexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LogicalORExpression: LogicalORExpression || LogicalANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 || 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-2.js new file mode 100644 index 000000000..050d85988 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-logicalorexpression-logical-or-logicalandexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/logicalorexpression-logical-or-logicalandexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + LogicalORExpression: LogicalORExpression || LogicalANDExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true || false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-memberexpression-templateliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-memberexpression-templateliteral.js new file mode 100644 index 000000000..f68af1e06 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-memberexpression-templateliteral.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/memberexpression-templateliteral.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + MemberExpression TemplateLiteral + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(o.f()``) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-minus-minus-unaryexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-minus-minus-unaryexpression.js new file mode 100644 index 000000000..4e8a9544a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-minus-minus-unaryexpression.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/minus-minus-unaryexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UpdateExpression: --UnaryExpression + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +(--x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js new file mode 100644 index 000000000..a82b2c3be --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x * y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js new file mode 100644 index 000000000..01e746a15 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 * 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js new file mode 100644 index 000000000..c7e04589e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true * false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js new file mode 100644 index 000000000..4a1872fec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-3.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x / y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js new file mode 100644 index 000000000..685eb6933 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-4.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 / 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js new file mode 100644 index 000000000..4209822d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/multiplicativeexpression-multiplicativeoperator-exponentiationexpression-5.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true / false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-new-memberexpression-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-new-memberexpression-arguments.js new file mode 100644 index 000000000..17b3de180 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-new-memberexpression-arguments.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/new-memberexpression-arguments.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + new MemberExpression Arguments + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(new f()) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-new-newexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-new-newexpression.js new file mode 100644 index 000000000..eca8a9579 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-new-newexpression.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/new-newexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + new NewExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(new f) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-optionalexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-optionalexpression.js new file mode 100644 index 000000000..8818c8bbf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-optionalexpression.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/optionalexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +features: [optional-chaining] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + OptionalExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x?.y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-plus-plus-unaryexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-plus-plus-unaryexpression.js new file mode 100644 index 000000000..6264ee7af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-plus-plus-unaryexpression.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/plus-plus-unaryexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UpdateExpression: ++UnaryExpression + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. + +---*/ + +$DONOTEVALUATE(); + +(++x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncfunctionexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncfunctionexpression.js new file mode 100644 index 000000000..28f74d812 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncfunctionexpression.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-asyncfunctionexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression AsyncFunctionExpression; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(async function () {}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncgeneratorexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncgeneratorexpression.js new file mode 100644 index 000000000..9be3c07de --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-asyncgeneratorexpression.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-asyncgeneratorexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression AsyncGeneratorExpression; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(async function () {}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-classexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-classexpression.js new file mode 100644 index 000000000..b0c626dd9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-classexpression.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-classexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression ClassExpression; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(class {}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-functionexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-functionexpression.js new file mode 100644 index 000000000..e57cb5325 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-functionexpression.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-functionexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression FunctionExpression, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(function() {}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-generatorexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-generatorexpression.js new file mode 100644 index 000000000..662dfdca9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-generatorexpression.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-generatorexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression ArrayLiteral; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(function * () {}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-boolean.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-boolean.js new file mode 100644 index 000000000..498702991 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-boolean.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-literal-boolean.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression Literal BooleanLiteral; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-null.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-null.js new file mode 100644 index 000000000..940099abb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-null.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-literal-null.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression Literal NullLiteral; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(null) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-numeric.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-numeric.js new file mode 100644 index 000000000..f0307ab9e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-numeric.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-literal-numeric.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression Literal NumericLiteral; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(0) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-string.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-string.js new file mode 100644 index 000000000..7e5393660 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-literal-string.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-literal-string.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression Literal StringLiteral; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +('') = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-objectliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-objectliteral.js new file mode 100644 index 000000000..a1d3e844c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-objectliteral.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-objectliteral.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression ObjectLiteral; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +({}) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-regularexpressionliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-regularexpressionliteral.js new file mode 100644 index 000000000..0743bd4c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-regularexpressionliteral.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-regularexpressionliteral.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression RegularExpressionLiteral; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(/1/) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-templateliteral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-templateliteral.js new file mode 100644 index 000000000..8d3409f76 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-templateliteral.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-templateliteral.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression TemplateLiteral; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(``) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-this.js new file mode 100644 index 000000000..b099da913 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-primaryexpression-this.js @@ -0,0 +1,19 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/primaryexpression-this.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: PrimaryExpression this; Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. +---*/ + +$DONOTEVALUATE(); + +(this) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js new file mode 100644 index 000000000..503107a1d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-or-equal-to-shiftexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression >= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x >= y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js new file mode 100644 index 000000000..076f4a989 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-or-equal-to-shiftexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression >= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 >= 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js new file mode 100644 index 000000000..bb34e3ed9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-or-equal-to-shiftexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-or-equal-to-shiftexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression >= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true >= false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-0.js new file mode 100644 index 000000000..10f18d72a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-shiftexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression > ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x > y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-1.js new file mode 100644 index 000000000..258296eeb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-shiftexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression > ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 > 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-2.js new file mode 100644 index 000000000..ada1ded5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-greater-than-shiftexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-greater-than-shiftexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression > ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true > false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-0.js new file mode 100644 index 000000000..0cd3af355 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-in-shiftexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression in ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x in y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-1.js new file mode 100644 index 000000000..e707449c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-in-shiftexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression in ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 in 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-2.js new file mode 100644 index 000000000..f8c77b5f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-in-shiftexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-in-shiftexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression in ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true in false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-0.js new file mode 100644 index 000000000..5081455cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-instanceof-shiftexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression instanceof ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x instanceof y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-1.js new file mode 100644 index 000000000..e81a6bfed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-instanceof-shiftexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression instanceof ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 instanceof 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-2.js new file mode 100644 index 000000000..cb420a6a4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-instanceof-shiftexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-instanceof-shiftexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression instanceof ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true instanceof false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-0.js new file mode 100644 index 000000000..113a08d35 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-or-equal-to-shiftexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression <= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x <= y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-1.js new file mode 100644 index 000000000..847c077ba --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-or-equal-to-shiftexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression <= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 <= 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-2.js new file mode 100644 index 000000000..afffaa31c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-or-equal-to-shiftexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-or-equal-to-shiftexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression <= ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true <= false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-0.js new file mode 100644 index 000000000..77b4bb9cb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-shiftexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression < ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x < y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-1.js new file mode 100644 index 000000000..c4d2b26c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-shiftexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression < ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 < 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-2.js new file mode 100644 index 000000000..20e47b48a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-relationalexpression-less-than-shiftexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/relationalexpression-less-than-shiftexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + RelationalExpression < ShiftExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true < false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-0.js new file mode 100644 index 000000000..4394b50ae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-left-additiveexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShiftExpression << AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x << y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-1.js new file mode 100644 index 000000000..3d2258e15 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-left-additiveexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShiftExpression << AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 << 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-2.js new file mode 100644 index 000000000..7c4cbc432 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-left-additiveexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-left-additiveexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShiftExpression << AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true << false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-0.js new file mode 100644 index 000000000..a0765d750 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-right-additiveexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShiftExpression >> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x >> y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-1.js new file mode 100644 index 000000000..d57052247 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-right-additiveexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShiftExpression >> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 >> 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-2.js new file mode 100644 index 000000000..69f9fb153 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-bitwise-right-additiveexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-bitwise-right-additiveexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShiftExpression >> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true >> false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js new file mode 100644 index 000000000..782b7267d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-unsigned-bitwise-right-additiveexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShiftExpression >>> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x >>> y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js new file mode 100644 index 000000000..9af6667e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-unsigned-bitwise-right-additiveexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShiftExpression >>> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 >>> 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js new file mode 100644 index 000000000..331a87dc0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shiftexpression-unsigned-bitwise-right-additiveexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shiftexpression-unsigned-bitwise-right-additiveexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShiftExpression >>> AdditiveExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true >>> false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js new file mode 100644 index 000000000..c6ada7b1d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((x ? y : z)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js new file mode 100644 index 000000000..31d2a59fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((1 ? 2 : 3)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js new file mode 100644 index 000000000..95630ec23 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/shortcircuitexpression-question-assignmentexpression-else-assignmentexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +((true ? false : true)) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-delete-unaryexpression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-delete-unaryexpression.js new file mode 100644 index 000000000..75fd9454f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-delete-unaryexpression.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-delete-unaryexpression.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: delete UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(delete x.y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-0.js new file mode 100644 index 000000000..b23451727 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-exclamation-unaryexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: ! UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(!x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-1.js new file mode 100644 index 000000000..d3143ef19 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-exclamation-unaryexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: ! UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(!1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-2.js new file mode 100644 index 000000000..e5265820f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-exclamation-unaryexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-exclamation-unaryexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: ! UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(!true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-0.js new file mode 100644 index 000000000..8c778fc7a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-minus-unaryexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: - UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(-x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-1.js new file mode 100644 index 000000000..72be3452f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-minus-unaryexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: - UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(-1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-2.js new file mode 100644 index 000000000..7ede67a93 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-minus-unaryexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-minus-unaryexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: - UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(-true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-0.js new file mode 100644 index 000000000..c9ec74251 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-plus-unaryexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: + UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(+x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-1.js new file mode 100644 index 000000000..df4ab3539 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-plus-unaryexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: + UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(+1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-2.js new file mode 100644 index 000000000..159a0f395 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-plus-unaryexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-plus-unaryexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: + UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(+true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-0.js new file mode 100644 index 000000000..93a4b0d48 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-tilde-unaryexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: ~ UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(~x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-1.js new file mode 100644 index 000000000..849cb83f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-tilde-unaryexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: ~ UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(~1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-2.js new file mode 100644 index 000000000..9039797a4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-tilde-unaryexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-tilde-unaryexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: ~ UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(~true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-0.js new file mode 100644 index 000000000..5e1d8da0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-typeof-unaryexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: typeof UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(typeof x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-1.js new file mode 100644 index 000000000..c61e7b124 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-typeof-unaryexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: typeof UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(typeof 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-2.js new file mode 100644 index 000000000..abd0e3a18 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-typeof-unaryexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-typeof-unaryexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: typeof UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(typeof true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-0.js new file mode 100644 index 000000000..5f6b51c5f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-void-unaryexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: void UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(void x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-1.js new file mode 100644 index 000000000..99319b61a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-void-unaryexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: void UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(void 1) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-2.js new file mode 100644 index 000000000..787bc45f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-unaryexpression-void-unaryexpression-2.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/unaryexpression-void-unaryexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UnaryExpression: void UnaryExpression + Static Semantics AssignmentTargetType, Return invalid + +---*/ + +$DONOTEVALUATE(); + +(void true) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-0.js new file mode 100644 index 000000000..9bdf63166 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-0.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/updateexpression-star-star-exponentiationexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +features: [exponentiation] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UpdateExpression ** ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(x ** y) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-1.js new file mode 100644 index 000000000..fc9fb628c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-1.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/updateexpression-star-star-exponentiationexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +features: [exponentiation] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UpdateExpression ** ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(1 ** 2) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-2.js new file mode 100644 index 000000000..937a37b5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-updateexpression-star-star-exponentiationexpression-2.js @@ -0,0 +1,24 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/updateexpression-star-star-exponentiationexpression-2.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +features: [exponentiation] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + UpdateExpression ** ExponentiationExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(true ** false) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-yieldexpression-0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-yieldexpression-0.js new file mode 100644 index 000000000..f655c70cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-yieldexpression-0.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/yieldexpression-0.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + YieldExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(yield x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-yieldexpression-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-yieldexpression-1.js new file mode 100644 index 000000000..e5162f89c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/assignmenttargettype/parenthesized-yieldexpression-1.js @@ -0,0 +1,23 @@ +// This file was procedurally generated from the following sources: +// - src/assignment-target-type/yieldexpression-1.case +// - src/assignment-target-type/invalid/parenthesized.template +/*--- +description: Static Semantics AssignmentTargetType, Return invalid. (ParenthesizedExpression) +esid: sec-grouping-operator-static-semantics-assignmenttargettype +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ParenthesizedExpression: (Expression) + + Return AssignmentTargetType of Expression. + + YieldExpression + Static Semantics AssignmentTargetType, Return invalid. + +---*/ + +$DONOTEVALUATE(); + +(yield * x) = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..9d425df49 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/array-destructuring-param-strict-body.js @@ -0,0 +1,123 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-arrow-function.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async arrow function expression) +esid: sec-async-arrow-function-definitions +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.7 Async Arrow Function Definitions + + AsyncArrowFunction : + ... + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + AsyncConciseBody : + { AsyncFunctionBody } + + ... + + Supplemental Syntax + + When processing an instance of the production AsyncArrowFunction : + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody the interpretation of + CoverCallExpressionAndAsyncArrowHead is refined using the following grammar: + + AsyncArrowHead : + async ArrowFormalParameters + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +(async ([element]) => { + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..a07d72d60 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-binding-identifier-escaped.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier-escaped.case +// - src/async-functions/syntax/async-arrow.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async arrow function) +esid: prod-AsyncArrowFunction +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Arrow Function Definitions + + AsyncArrowFunction[In, Yield, Await]: + async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In] + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] [no LineTerminator here] => AsyncConciseBody[?In] + + AsyncConciseBody[In]: + { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +async () => { + var \u0061wait; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-binding-identifier.js new file mode 100644 index 000000000..980e7b681 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-binding-identifier.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier.case +// - src/async-functions/syntax/async-arrow.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async arrow function) +esid: prod-AsyncArrowFunction +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Arrow Function Definitions + + AsyncArrowFunction[In, Yield, Await]: + async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In] + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] [no LineTerminator here] => AsyncConciseBody[?In] + + AsyncConciseBody[In]: + { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +async () => { + var await; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..766a185c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-identifier-reference-escaped.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference-escaped.case +// - src/async-functions/syntax/async-arrow.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async arrow function) +esid: prod-AsyncArrowFunction +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Arrow Function Definitions + + AsyncArrowFunction[In, Yield, Await]: + async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In] + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] [no LineTerminator here] => AsyncConciseBody[?In] + + AsyncConciseBody[In]: + { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +async () => { + void \u0061wait; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-identifier-reference.js new file mode 100644 index 000000000..f7d1144a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-identifier-reference.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference.case +// - src/async-functions/syntax/async-arrow.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async arrow function) +esid: prod-AsyncArrowFunction +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Arrow Function Definitions + + AsyncArrowFunction[In, Yield, Await]: + async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In] + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] [no LineTerminator here] => AsyncConciseBody[?In] + + AsyncConciseBody[In]: + { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +async () => { + void await; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..b56dfb019 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-label-identifier-escaped.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier-escaped.case +// - src/async-functions/syntax/async-arrow.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async arrow function) +esid: prod-AsyncArrowFunction +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Arrow Function Definitions + + AsyncArrowFunction[In, Yield, Await]: + async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In] + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] [no LineTerminator here] => AsyncConciseBody[?In] + + AsyncConciseBody[In]: + { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +async () => { + \u0061wait: ; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-label-identifier.js new file mode 100644 index 000000000..b2d11a1f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-label-identifier.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier.case +// - src/async-functions/syntax/async-arrow.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async arrow function) +esid: prod-AsyncArrowFunction +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Arrow Function Definitions + + AsyncArrowFunction[In, Yield, Await]: + async [no LineTerminator here] AsyncArrowBindingIdentifier[?Yield] [no LineTerminator here] => AsyncConciseBody[?In] + CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] [no LineTerminator here] => AsyncConciseBody[?In] + + AsyncConciseBody[In]: + { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +async () => { + await: ; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-ident-nested-arrow-parameter-position.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-ident-nested-arrow-parameter-position.js new file mode 100644 index 000000000..676067492 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-ident-nested-arrow-parameter-position.js @@ -0,0 +1,16 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-async-arrow-function-definitions +description: > + It is a SyntaxError if FormalParameters' default expressions contains await. +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); + +async(a = await => {}) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-nested-arrow-body-position.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-nested-arrow-body-position.js new file mode 100644 index 000000000..593915584 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-nested-arrow-body-position.js @@ -0,0 +1,16 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-async-arrow-function-definitions +description: > + It is a SyntaxError if FormalParameters' default expressions contains await. +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); + +async() => { (a = await/r/g) => {} }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-nested-arrow-parameter-position.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-nested-arrow-parameter-position.js new file mode 100644 index 000000000..52d7dc6fc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-nested-arrow-parameter-position.js @@ -0,0 +1,16 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-async-arrow-function-definitions +description: > + It is a SyntaxError if FormalParameters' default expressions contains await. +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); + +async(a = (await) => {}) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-rest-nested-arrow-parameter-position.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-rest-nested-arrow-parameter-position.js new file mode 100644 index 000000000..11b33a6ab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/await-as-param-rest-nested-arrow-parameter-position.js @@ -0,0 +1,16 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-async-arrow-function-definitions +description: > + It is a SyntaxError if FormalParameters' default expressions contains await. +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); + +async(a = (...await) => {}) => {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/dflt-params-duplicates.js new file mode 100644 index 000000000..cf9c279a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/dflt-params-duplicates.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/async-arrow-function.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (async arrow function expression) +esid: sec-async-arrow-function-definitions +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.7 Async Arrow Function Definitions + + AsyncArrowFunction : + ... + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + AsyncConciseBody : + { AsyncFunctionBody } + + ... + + Supplemental Syntax + + When processing an instance of the production AsyncArrowFunction : + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody the interpretation of + CoverCallExpressionAndAsyncArrowHead is refined using the following grammar: + + AsyncArrowHead : + async ArrowFormalParameters + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + + +(async (x = 0, x) => { + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/dflt-params-rest.js new file mode 100644 index 000000000..0c1476cc8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/dflt-params-rest.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/async-arrow-function.template +/*--- +description: RestParameter does not support an initializer (async arrow function expression) +esid: sec-async-arrow-function-definitions +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.7 Async Arrow Function Definitions + + AsyncArrowFunction : + ... + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + AsyncConciseBody : + { AsyncFunctionBody } + + ... + + Supplemental Syntax + + When processing an instance of the production AsyncArrowFunction : + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody the interpretation of + CoverCallExpressionAndAsyncArrowHead is refined using the following grammar: + + AsyncArrowHead : + async ArrowFormalParameters + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + + +(async (...x = []) => { + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-NSPL-with-USD.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-NSPL-with-USD.js new file mode 100644 index 000000000..8d3e5af18 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-NSPL-with-USD.js @@ -0,0 +1,16 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: > + It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is *true* and IsSimpleParameterList of ArrowParameters is *false*. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async (x = 1) => {"use strict"} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-arguments-in-formal-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-arguments-in-formal-parameters.js new file mode 100644 index 000000000..2128deff6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-arguments-in-formal-parameters.js @@ -0,0 +1,17 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if FormalParameters contains arguments +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +async(arguments) => { } + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-await-in-formals-default.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-await-in-formals-default.js new file mode 100644 index 000000000..aa8a71d15 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-await-in-formals-default.js @@ -0,0 +1,14 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if FormalParameters' default expressions contains await +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +async(x = await) => { } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-await-in-formals.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-await-in-formals.js new file mode 100644 index 000000000..843272906 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-await-in-formals.js @@ -0,0 +1,14 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if FormalParameters contains await +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +async(await) => { } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-call.js new file mode 100644 index 000000000..9001b5ee7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-call.js @@ -0,0 +1,15 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a syntax error if AsyncFunctionBody contains SuperCall is true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async(foo) => { super() }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-property.js new file mode 100644 index 000000000..7e2c032eb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-body-contains-super-property.js @@ -0,0 +1,15 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a syntax error if AsyncFunctionBody contains SuperProperty is true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async(foo) => { super.prop }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-duplicate-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-duplicate-parameters.js new file mode 100644 index 000000000..5f0aaca17 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-duplicate-parameters.js @@ -0,0 +1,35 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: sec-async-arrow-function-definitions +description: Formal parameters may not contain duplicates +info: | + # 14.2 Arrow Function Definitions + + When the production + + ArrowParameters:CoverParenthesizedExpressionAndArrowParameterList + + is recognized the following grammar is used to refine the interpretation + of CoverParenthesizedExpressionAndArrowParameterList: + + ArrowFormalParameters[Yield, Await]: + (UniqueFormalParameters[?Yield, ?Await]) + + # 14.1.2 Static Semantics: Early Errors + + UniqueFormalParameters:FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); + +async(a, a) => { } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-eval-in-formal-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-eval-in-formal-parameters.js new file mode 100644 index 000000000..26886e038 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-eval-in-formal-parameters.js @@ -0,0 +1,16 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if FormalParameters contains eval +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +async(eval) => { } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-body-duplicate.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-body-duplicate.js new file mode 100644 index 000000000..d469dc86d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-body-duplicate.js @@ -0,0 +1,15 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if BoundNames of FormalParameters also occurs in the LexicallyDeclaredNames of AsyncFunctionBody +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async(bar) => { let bar; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-call.js new file mode 100644 index 000000000..ec3111f34 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-call.js @@ -0,0 +1,15 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a syntax error if FormalParameters contains SuperCall is true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async(foo = super()) => {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-property.js new file mode 100644 index 000000000..be0dd9ef2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-contains-super-property.js @@ -0,0 +1,15 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a syntax error if FormalParameters contains SuperCall is true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async (foo = super.foo) => { } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-lineterminator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-lineterminator.js new file mode 100644 index 000000000..3267b3865 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/early-errors-arrow-formals-lineterminator.js @@ -0,0 +1,33 @@ +// Copyright (C) 2017 Mozilla Corporation. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-AsyncArrowHead +description: async arrows cannot have a line terminator between "async" and the formals +info: | + 14.7 Async Arrow Function Definitions + + AsyncArrowFunction: + [...] + CoverCallExpressionAndAsyncArrowHead [no LineTerminator here] => AsyncConciseBody + + Supplemental Syntax + + When processing an instance of the production + + AsyncArrowFunction: + CoverCallExpressionAndAsyncArrowHead [no LineTerminator here] => AsyncConciseBody + + the interpretation of CoverCallExpressionAndAsyncArrowHead is refined using the following grammar: + + AsyncArrowHead: + async [no LineTerminator here] ArrowFormalParameters +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async +(foo) => { } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/escaped-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/escaped-async.js new file mode 100644 index 000000000..4b70160af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/escaped-async.js @@ -0,0 +1,24 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `async` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); + +\u0061sync () => {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..0aa9aa187 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/object-destructuring-param-strict-body.js @@ -0,0 +1,123 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-arrow-function.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async arrow function expression) +esid: sec-async-arrow-function-definitions +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.7 Async Arrow Function Definitions + + AsyncArrowFunction : + ... + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + AsyncConciseBody : + { AsyncFunctionBody } + + ... + + Supplemental Syntax + + When processing an instance of the production AsyncArrowFunction : + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody the interpretation of + CoverCallExpressionAndAsyncArrowHead is refined using the following grammar: + + AsyncArrowHead : + async ArrowFormalParameters + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +(async ({property}) => { + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/rest-param-strict-body.js new file mode 100644 index 000000000..6f3db7664 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/rest-param-strict-body.js @@ -0,0 +1,123 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/async-arrow-function.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (async arrow function expression) +esid: sec-async-arrow-function-definitions +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.7 Async Arrow Function Definitions + + AsyncArrowFunction : + ... + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + AsyncConciseBody : + { AsyncFunctionBody } + + ... + + Supplemental Syntax + + When processing an instance of the production AsyncArrowFunction : + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody the interpretation of + CoverCallExpressionAndAsyncArrowHead is refined using the following grammar: + + AsyncArrowHead : + async ArrowFormalParameters + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +(async (a,...rest) => { + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..7dd44158c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-arrow-function/rest-params-trailing-comma-early-error.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/async-arrow-function.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (async arrow function expression) +esid: sec-async-arrow-function-definitions +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.7 Async Arrow Function Definitions + + AsyncArrowFunction : + ... + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + AsyncConciseBody : + { AsyncFunctionBody } + + ... + + Supplemental Syntax + + When processing an instance of the production AsyncArrowFunction : + CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody the interpretation of + CoverCallExpressionAndAsyncArrowHead is refined using the following grammar: + + AsyncArrowHead : + async ArrowFormalParameters + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + + +(async (...a,) => { + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..a439b7979 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-binding-identifier-escaped.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier-escaped.case +// - src/async-functions/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Unnamed async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function ( FormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function () { + var \u0061wait; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-binding-identifier.js new file mode 100644 index 000000000..77583d7fd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-binding-identifier.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier.case +// - src/async-functions/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Unnamed async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function ( FormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function () { + var await; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..0f7d3de79 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-identifier-reference-escaped.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference-escaped.case +// - src/async-functions/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Unnamed async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function ( FormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function () { + void \u0061wait; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-identifier-reference.js new file mode 100644 index 000000000..902335c77 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-identifier-reference.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference.case +// - src/async-functions/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Unnamed async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function ( FormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function () { + void await; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..f58df5ec0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-label-identifier-escaped.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier-escaped.case +// - src/async-functions/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Unnamed async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function ( FormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function () { + \u0061wait: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-label-identifier.js new file mode 100644 index 000000000..a71d5026d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/await-as-label-identifier.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier.case +// - src/async-functions/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Unnamed async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function ( FormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function () { + await: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-NSPL-with-USD.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-NSPL-with-USD.js new file mode 100644 index 000000000..09592f8bd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-NSPL-with-USD.js @@ -0,0 +1,16 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: > + It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is *true* and IsSimpleParameterList of ArrowParameters is *false*. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(async function (x = 1) {"use strict"}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-binding-identifier-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-binding-identifier-arguments.js new file mode 100644 index 000000000..5703a8b55 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-binding-identifier-arguments.js @@ -0,0 +1,17 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: > + If the source code matching this production is strict code, it is a Syntax Error if BindingIdentifier is the IdentifierName arguments. +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +(async function arguments () { }) + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-binding-identifier-eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-binding-identifier-eval.js new file mode 100644 index 000000000..dc49dcf7f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-binding-identifier-eval.js @@ -0,0 +1,16 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: > + If the source code matching this production is strict code, it is a Syntax Error if BindingIdentifier is the IdentifierName eval. +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); +(async function eval () { }) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-body-contains-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-body-contains-super-call.js new file mode 100644 index 000000000..e30328e92 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-body-contains-super-call.js @@ -0,0 +1,15 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a syntax error if AsyncFunctionBody contains SuperCall is true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(async function foo (foo) { super() }) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-body-contains-super-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-body-contains-super-property.js new file mode 100644 index 000000000..ce7162c3f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-body-contains-super-property.js @@ -0,0 +1,16 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a syntax error if AsyncFunctionBody contains SuperProperty is true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(async function foo (foo) { super.prop }); + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-eval-in-formal-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-eval-in-formal-parameters.js new file mode 100644 index 000000000..f6fcb7c31 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-eval-in-formal-parameters.js @@ -0,0 +1,16 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if FormalParameters contains eval in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +(async function foo (eval) { }) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-formals-body-duplicate.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-formals-body-duplicate.js new file mode 100644 index 000000000..50bffdeec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-formals-body-duplicate.js @@ -0,0 +1,15 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if BoundNames of FormalParameters also occurs in the LexicallyDeclaredNames of AsyncFunctionBody +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(async function foo (bar) { let bar; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-formals-contains-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-formals-contains-super-call.js new file mode 100644 index 000000000..1d8f3fdc9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-formals-contains-super-call.js @@ -0,0 +1,15 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a syntax error if FormalParameters contains SuperCall is true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(async function foo (foo = super()) { var bar; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-formals-contains-super-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-formals-contains-super-property.js new file mode 100644 index 000000000..bec91bf3b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-formals-contains-super-property.js @@ -0,0 +1,15 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a syntax error if FormalParameters contains SuperCall is true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(async function foo (foo = super.foo) { var bar; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-not-simple-assignment-target.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-not-simple-assignment-target.js new file mode 100644 index 000000000..8718c4f36 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/early-errors-expression-not-simple-assignment-target.js @@ -0,0 +1,16 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: > + Async function expressions are not a simple assignment target. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(async function foo() { } = 1) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/escaped-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/escaped-async.js new file mode 100644 index 000000000..281646d64 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/escaped-async.js @@ -0,0 +1,24 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `async` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); + +void \u0061sync function f(){} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-array-destructuring-param-strict-body.js new file mode 100644 index 000000000..ec7c1e28c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-array-destructuring-param-strict-body.js @@ -0,0 +1,109 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-func-expr-named.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async function named expression) +esid: sec-async-function-definitions +features: [rest-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +(async function f([element]) { + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..f3b1564c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-binding-identifier-escaped.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier-escaped.case +// - src/async-functions/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Named async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function asyncFn() { + var \u0061wait; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-binding-identifier.js new file mode 100644 index 000000000..14bfd60ec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-binding-identifier.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier.case +// - src/async-functions/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Named async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function asyncFn() { + var await; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..aa80d5b3a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-identifier-reference-escaped.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference-escaped.case +// - src/async-functions/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Named async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function asyncFn() { + void \u0061wait; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-identifier-reference.js new file mode 100644 index 000000000..dcca9a767 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-identifier-reference.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference.case +// - src/async-functions/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Named async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function asyncFn() { + void await; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-label-identifier-escaped.js new file mode 100644 index 000000000..0c003cb96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-label-identifier-escaped.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier-escaped.case +// - src/async-functions/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Named async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function asyncFn() { + \u0061wait: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-label-identifier.js new file mode 100644 index 000000000..6e586a390 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-await-as-label-identifier.js @@ -0,0 +1,30 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier.case +// - src/async-functions/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Named async function expression) +esid: prod-AsyncFunctionExpression +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncFunctionExpression : + async [no LineTerminator here] function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var asyncFn = async function asyncFn() { + await: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-dflt-params-duplicates.js new file mode 100644 index 000000000..6449eb2b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-dflt-params-duplicates.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/async-func-expr-named.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (async function named expression) +esid: sec-async-function-definitions +features: [default-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + + +(async function f(x = 0, x) { + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-dflt-params-rest.js new file mode 100644 index 000000000..69960bb7f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-dflt-params-rest.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/async-func-expr-named.template +/*--- +description: RestParameter does not support an initializer (async function named expression) +esid: sec-async-function-definitions +features: [default-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + + +(async function f(...x = []) { + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-object-destructuring-param-strict-body.js new file mode 100644 index 000000000..3ea2daa42 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-object-destructuring-param-strict-body.js @@ -0,0 +1,109 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-func-expr-named.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async function named expression) +esid: sec-async-function-definitions +features: [rest-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +(async function f({property}) { + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-rest-param-strict-body.js new file mode 100644 index 000000000..f34765acb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-rest-param-strict-body.js @@ -0,0 +1,109 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/async-func-expr-named.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (async function named expression) +esid: sec-async-function-definitions +features: [rest-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +(async function f(a,...rest) { + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..c26b11219 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/named-rest-params-trailing-comma-early-error.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/async-func-expr-named.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (async function named expression) +esid: sec-async-function-definitions +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + + +(async function f(...a,) { + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-array-destructuring-param-strict-body.js new file mode 100644 index 000000000..9a79a933d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-array-destructuring-param-strict-body.js @@ -0,0 +1,109 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-func-expr-nameless.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async function nameless expression) +esid: sec-async-function-definitions +features: [rest-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function ( FormalParameters ) { AsyncFunctionBody } + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +(async function([element]) { + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-dflt-params-duplicates.js new file mode 100644 index 000000000..8ec5eb7d8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-dflt-params-duplicates.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/async-func-expr-nameless.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (async function nameless expression) +esid: sec-async-function-definitions +features: [default-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function ( FormalParameters ) { AsyncFunctionBody } + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + + +(async function(x = 0, x) { + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-dflt-params-rest.js new file mode 100644 index 000000000..805fca8e4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-dflt-params-rest.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/async-func-expr-nameless.template +/*--- +description: RestParameter does not support an initializer (async function nameless expression) +esid: sec-async-function-definitions +features: [default-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function ( FormalParameters ) { AsyncFunctionBody } + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + + +(async function(...x = []) { + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-object-destructuring-param-strict-body.js new file mode 100644 index 000000000..703bcb234 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-object-destructuring-param-strict-body.js @@ -0,0 +1,109 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-func-expr-nameless.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async function nameless expression) +esid: sec-async-function-definitions +features: [rest-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function ( FormalParameters ) { AsyncFunctionBody } + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +(async function({property}) { + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-rest-param-strict-body.js new file mode 100644 index 000000000..a98b2b73b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-rest-param-strict-body.js @@ -0,0 +1,109 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/async-func-expr-nameless.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (async function nameless expression) +esid: sec-async-function-definitions +features: [rest-parameters, async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function ( FormalParameters ) { AsyncFunctionBody } + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +(async function(a,...rest) { + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..b9c8ec05f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-function/nameless-rest-params-trailing-comma-early-error.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/async-func-expr-nameless.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (async function nameless expression) +esid: sec-async-function-definitions +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncFunctionExpression : + async function ( FormalParameters ) { AsyncFunctionBody } + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + + +(async function(...a,) { + +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..b8ba22c88 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/array-destructuring-param-strict-body.js @@ -0,0 +1,112 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-gen-func-expr.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +0, async function*([element]) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..038271a40 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-binding-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + var \u0061wait; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-binding-identifier.js new file mode 100644 index 000000000..af4987861 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-binding-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + var await; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..e1712a87a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-identifier-reference-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + void \u0061wait; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-identifier-reference.js new file mode 100644 index 000000000..932158daf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-identifier-reference.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + void await; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..99007ca3a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-label-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + \u0061wait: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-label-identifier.js new file mode 100644 index 000000000..09b1030d3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/await-as-label-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + await: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dflt-params-duplicates.js new file mode 100644 index 000000000..ec3299c48 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dflt-params-duplicates.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/async-gen-func-expr.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + + +0, async function*(x = 0, x) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dflt-params-rest.js new file mode 100644 index 000000000..db46a380b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dflt-params-rest.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/async-gen-func-expr.template +/*--- +description: RestParameter does not support an initializer (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + + +0, async function*(...x = []) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..b28f222c2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-init-ary.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/async-gen-func-expr.template +/*--- +description: Rest element (nested array pattern) does not support initializer (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...[ x ] = []]) { + + callCount = callCount + 1; +}; + +f([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..a09176c7f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-init-id.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/async-gen-func-expr.template +/*--- +description: Rest element (identifier) does not support initializer (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...x = []]) { + + callCount = callCount + 1; +}; + +f([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..a46c995a9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-init-obj.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/async-gen-func-expr.template +/*--- +description: Rest element (nested object pattern) does not support initializer (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...{ x } = []]) { + + callCount = callCount + 1; +}; + +f([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..c14a5cb53 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/async-gen-func-expr.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...[x], y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..5d33ed3b7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-id.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/async-gen-func-expr.template +/*--- +description: Rest element (identifier) may not be followed by any element (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...x, y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..101ecd988 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/async-gen-func-expr.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...{ x }, y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..fca8e4353 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/async-gen-func-expr-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (async generator function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...[ x ] = []] = []) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..0597ce4fc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/async-gen-func-expr-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (async generator function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...x = []] = []) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..73bc3137b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/async-gen-func-expr-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (async generator function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...{ x } = []] = []) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..7b0f81b45 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/async-gen-func-expr-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (async generator function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..7c7446d7b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/async-gen-func-expr-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (async generator function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..a1a05d091 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/async-gen-func-expr-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (async generator function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function*([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..befbe666f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-ary.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/async-gen-func-named-expr.template +/*--- +description: Rest element (nested array pattern) does not support initializer (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...[ x ] = []]) { + + callCount = callCount + 1; +}; + +f([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..cd81cdcca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-id.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/async-gen-func-named-expr.template +/*--- +description: Rest element (identifier) does not support initializer (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...x = []]) { + + callCount = callCount + 1; +}; + +f([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..583955a8d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-init-obj.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/async-gen-func-named-expr.template +/*--- +description: Rest element (nested object pattern) does not support initializer (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...{ x } = []]) { + + callCount = callCount + 1; +}; + +f([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..c136e8a62 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/async-gen-func-named-expr.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...[x], y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..7c091c8e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/async-gen-func-named-expr.template +/*--- +description: Rest element (identifier) may not be followed by any element (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...x, y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..16f5b4bca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/async-gen-func-named-expr.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...{ x }, y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..b88f7f8b1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (async generator named function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...[ x ] = []] = []) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..f090ebe39 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (async generator named function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...x = []] = []) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..628202cb8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (async generator named function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...{ x } = []] = []) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..dbddd223b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (async generator named function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..b412bf124 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (async generator named function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..ff05397a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/dstr/named-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (async generator named function expression (default parameter)) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var f; +f = async function* h([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-NSPL-with-USD.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-NSPL-with-USD.js new file mode 100644 index 000000000..caf0fb996 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-NSPL-with-USD.js @@ -0,0 +1,18 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(x = 1) {"use strict"}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-arguments-in-formal-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-arguments-in-formal-parameters.js new file mode 100644 index 000000000..877a4085f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-arguments-in-formal-parameters.js @@ -0,0 +1,18 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a SyntaxError if FormalParameters contains arguments in strict mode. +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(arguments) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-await-as-function-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-await-as-function-binding-identifier.js new file mode 100644 index 000000000..2d409092f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-await-as-function-binding-identifier.js @@ -0,0 +1,17 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-identifiers-static-semantics-early-errors +description: > + `await` is not a valid BindingIdentifier for AsyncGeneratorExpressions. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function* await() { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-binding-identifier-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-binding-identifier-arguments.js new file mode 100644 index 000000000..d565550a2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-binding-identifier-arguments.js @@ -0,0 +1,19 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-identifiers-static-semantics-early-errors +description: > + If the source code matching this production is strict code, it is a + Syntax Error if BindingIdentifier is the IdentifierName arguments. +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function* arguments() { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-binding-identifier-eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-binding-identifier-eval.js new file mode 100644 index 000000000..e65ed0681 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-binding-identifier-eval.js @@ -0,0 +1,19 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-identifiers-static-semantics-early-errors +description: > + If the source code matching this production is strict code, it is a + Syntax Error if BindingIdentifier is the IdentifierName eval. +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function* eval() { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-body-contains-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-body-contains-super-call.js new file mode 100644 index 000000000..41811a180 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-body-contains-super-call.js @@ -0,0 +1,17 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a syntax error if AsyncGeneratorBody contains SuperCall is true. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*() { super(); }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-body-contains-super-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-body-contains-super-property.js new file mode 100644 index 000000000..98666f486 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-body-contains-super-property.js @@ -0,0 +1,17 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a syntax error if AsyncGeneratorBody contains SuperProperty is true. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*() { super.prop; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-eval-in-formal-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-eval-in-formal-parameters.js new file mode 100644 index 000000000..5d8192db6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-eval-in-formal-parameters.js @@ -0,0 +1,18 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-strict-mode-of-ecmascript +description: > + It is a SyntaxError if FormalParameters contains eval in strict mode. +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(eval) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-const.js new file mode 100644 index 000000000..64f65269f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-const.js @@ -0,0 +1,21 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a SyntaxError if BoundNames of FormalParameters also occurs in the + LexicallyDeclaredNames of AsyncFunctionBody +info: | + It is a Syntax Error if any element of the BoundNames of FormalParameters + also occurs in the LexicallyDeclaredNames of GeneratorBody. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(a) { const a = 0; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-let.js new file mode 100644 index 000000000..5571e7956 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-let.js @@ -0,0 +1,18 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a SyntaxError if BoundNames of FormalParameters also occurs in the + LexicallyDeclaredNames of AsyncFunctionBody +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(a) { let a; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-await-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-await-expr.js new file mode 100644 index 000000000..32d64984f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-await-expr.js @@ -0,0 +1,17 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a Syntax Error if FormalParameters Contains AwaitExpression is true. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(x = await 1) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-await.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-await.js new file mode 100644 index 000000000..f1831c99a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-await.js @@ -0,0 +1,18 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-identifiers-static-semantics-early-errors +description: > + `await` is a reserved keyword within async generator function bodies and may + not be used as the binding identifier of a parameter. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(await) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-super-call.js new file mode 100644 index 000000000..816329952 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-super-call.js @@ -0,0 +1,17 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a syntax error if FormalParameters contains SuperCall is true. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(a = super()) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-super-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-super-property.js new file mode 100644 index 000000000..906945bd3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-super-property.js @@ -0,0 +1,17 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a syntax error if FormalParameters contains SuperProperty is true. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(a = super.prop) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-yield-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-yield-expr.js new file mode 100644 index 000000000..60add8636 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-yield-expr.js @@ -0,0 +1,17 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + It is a Syntax Error if FormalParameters Contains YieldExpression is true. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(x = yield) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-yield.js new file mode 100644 index 000000000..6eb132382 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-formals-contains-yield.js @@ -0,0 +1,18 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-identifiers-static-semantics-early-errors +description: > + `yield` is a reserved keyword within async generator function bodies and may + not be used as the binding identifier of a parameter. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*(yield) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-label-name-await.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-label-name-await.js new file mode 100644 index 000000000..6b74945ce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-label-name-await.js @@ -0,0 +1,24 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-identifiers-static-semantics-early-errors +description: > + `await` is a reserved keyword within async generator function bodies and may + not be used as a label. +info: | + BindingIdentifier : await + + It is a Syntax Error if this production has an [Await] parameter. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*() { + await: 1; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-label-name-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-label-name-yield.js new file mode 100644 index 000000000..bc79529c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-label-name-yield.js @@ -0,0 +1,26 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-identifiers-static-semantics-early-errors +description: > + `yield` is a reserved keyword within async generator function bodies and may + not be used as a label. +info: | + BindingIdentifier : Identifier + LabelIdentifier : Identifier + + It is a Syntax Error if this production has an [Await] parameter and + StringValue of Identifier is "await". +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*() { + yield: 1; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-not-simple-assignment-target.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-not-simple-assignment-target.js new file mode 100644 index 000000000..46c597ca5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-not-simple-assignment-target.js @@ -0,0 +1,17 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: prod-LeftHandSideExpression +description: > + Async generator function expressions are not a simple assignment target. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*() { } = 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-yield-as-function-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-yield-as-function-binding-identifier.js new file mode 100644 index 000000000..3101d8f0d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-yield-as-function-binding-identifier.js @@ -0,0 +1,17 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-async-generator-function-definitions-static-semantics-early-errors +description: > + `yield` is not a valid BindingIdentifier for AsyncGeneratorExpressions. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function* yield() { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-yield-star-after-newline.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-yield-star-after-newline.js new file mode 100644 index 000000000..54fe753af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/early-errors-expression-yield-star-after-newline.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: sec-generator-function-definitions +description: > + A newline may not precede the `*` token in a `yield` expression. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +(async function*() { + yield + * 1; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/escaped-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/escaped-async.js new file mode 100644 index 000000000..e24d8e2a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/escaped-async.js @@ -0,0 +1,24 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `async` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +void \u0061sync function* f(){}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-array-destructuring-param-strict-body.js new file mode 100644 index 000000000..2f8689ef0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-array-destructuring-param-strict-body.js @@ -0,0 +1,112 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-gen-named-func-expr.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +0, async function* g([element]) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..c33c564c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-binding-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + var \u0061wait; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-binding-identifier.js new file mode 100644 index 000000000..cf6bc24ef --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-binding-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + var await; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..9519f37ff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-identifier-reference-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + void \u0061wait; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-identifier-reference.js new file mode 100644 index 000000000..189b8156d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-identifier-reference.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + void await; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-label-identifier-escaped.js new file mode 100644 index 000000000..6baafd782 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-label-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + \u0061wait: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-label-identifier.js new file mode 100644 index 000000000..a5474582a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-await-as-label-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + await: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-dflt-params-duplicates.js new file mode 100644 index 000000000..eeb00f641 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-dflt-params-duplicates.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/async-gen-named-func-expr.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + + +0, async function* g(x = 0, x) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-dflt-params-rest.js new file mode 100644 index 000000000..f4993d67b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-dflt-params-rest.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/async-gen-named-func-expr.template +/*--- +description: RestParameter does not support an initializer (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + + +0, async function* g(...x = []) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-object-destructuring-param-strict-body.js new file mode 100644 index 000000000..5de0e48c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-object-destructuring-param-strict-body.js @@ -0,0 +1,112 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-gen-named-func-expr.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +0, async function* g({property}) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-rest-param-strict-body.js new file mode 100644 index 000000000..17f090e4e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-rest-param-strict-body.js @@ -0,0 +1,112 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/async-gen-named-func-expr.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +0, async function* g(a,...rest) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..49a9d85df --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-rest-params-trailing-comma-early-error.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/async-gen-named-func-expr.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + + +0, async function* g(...a,) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..87984b943 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-binding-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + var yi\u0065ld; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-binding-identifier.js new file mode 100644 index 000000000..457a8354a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-binding-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + var yield; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..b7770f1e5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-identifier-reference-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + void yi\u0065ld; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-identifier-reference.js new file mode 100644 index 000000000..507b35566 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-identifier-reference.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + void yield; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..777dad4b5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-label-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + yi\u0065ld: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-label-identifier.js new file mode 100644 index 000000000..9ac700391 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-as-label-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier.case +// - src/async-generators/syntax/async-expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *g() { + yield: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-identifier-spread-strict.js new file mode 100644 index 000000000..9d256450a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-identifier-spread-strict.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-spread-strict.case +// - src/async-generators/default/async-expression-named.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [object-spread, async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var gen = async function *g() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } +}; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-identifier-strict.js new file mode 100644 index 000000000..87910c143 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/named-yield-identifier-strict.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-strict.case +// - src/async-generators/default/async-expression-named.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Named async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var gen = async function *g() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) +}; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..d06bc1e3a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/object-destructuring-param-strict-body.js @@ -0,0 +1,112 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-gen-func-expr.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +0, async function*({property}) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/rest-param-strict-body.js new file mode 100644 index 000000000..a896967b0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/rest-param-strict-body.js @@ -0,0 +1,112 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/async-gen-func-expr.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +0, async function*(a,...rest) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..77cb356e1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/rest-params-trailing-comma-early-error.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/async-gen-func-expr.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + + +0, async function*(...a,) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..4395fba79 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-binding-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + var yi\u0065ld; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-binding-identifier.js new file mode 100644 index 000000000..2625bea6f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-binding-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + var yield; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..63415920e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-identifier-reference-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + void yi\u0065ld; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-identifier-reference.js new file mode 100644 index 000000000..06f2ee351 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-identifier-reference.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + void yield; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..ebff74192 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-label-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + yi\u0065ld: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-label-identifier.js new file mode 100644 index 000000000..d44ea5a29 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-as-label-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier.case +// - src/async-generators/syntax/async-expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var gen = async function *() { + yield: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-identifier-spread-strict.js new file mode 100644 index 000000000..dfd6f5db1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-identifier-spread-strict.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-spread-strict.case +// - src/async-generators/default/async-expression.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [object-spread, async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var gen = async function *() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } +}; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-identifier-strict.js new file mode 100644 index 000000000..9654357dc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/async-generator/yield-identifier-strict.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-strict.case +// - src/async-generators/default/async-expression.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Unnamed async generator expression) +esid: prod-AsyncGeneratorExpression +features: [async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorExpression : + async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) { + AsyncGeneratorBody } + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var gen = async function *() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) +}; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/await/await-BindingIdentifier-nested.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/await/await-BindingIdentifier-nested.js new file mode 100644 index 000000000..c04b7a70d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/await/await-BindingIdentifier-nested.js @@ -0,0 +1,19 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: > + Await is not allowed as an identifier in functions nested in async functions +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async function foo() { + function await() { + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/await/early-errors-await-not-simple-assignment-target.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/await/early-errors-await-not-simple-assignment-target.js new file mode 100644 index 000000000..2be96cb82 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/await/early-errors-await-not-simple-assignment-target.js @@ -0,0 +1,18 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: > + await is not a simple assignment target and cannot be assigned to. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async function foo() { + (await 1) = 1; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/await/no-operand.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/await/no-operand.js new file mode 100644 index 000000000..b08339a0d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/await/no-operand.js @@ -0,0 +1,18 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: > + await requries an operand. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +async function foo() { + await; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/call/S11.2.4_A1.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/call/S11.2.4_A1.3_T1.js new file mode 100644 index 000000000..3f385d793 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/call/S11.2.4_A1.3_T1.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Arguments : (ArgumentList : ArgumentList,, AssignmentExpression) is a bad + syntax +es5id: 11.2.4_A1.3_T1 +description: incorrect syntax +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function f_arg() { +} + +f_arg(1,,2); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..f8c2e1294 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/array-destructuring-param-strict-body.js @@ -0,0 +1,137 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-gen-meth-static.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + static async *method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..95dd9b9a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-binding-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + var \u0061wait; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-binding-identifier.js new file mode 100644 index 000000000..3dab50c61 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-binding-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + var await; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..b07a4d8a8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-identifier-reference-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + void \u0061wait; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-identifier-reference.js new file mode 100644 index 000000000..309c184c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-identifier-reference.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + void await; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..4bffedd4e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-label-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + \u0061wait: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-label-identifier.js new file mode 100644 index 000000000..ae8173afa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/await-as-label-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + await: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/dflt-params-duplicates.js new file mode 100644 index 000000000..911e304d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/dflt-params-duplicates.js @@ -0,0 +1,66 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/cls-expr-async-gen-meth-static.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, class { + static async *method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/dflt-params-rest.js new file mode 100644 index 000000000..7d9c26c6b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/dflt-params-rest.js @@ -0,0 +1,70 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/cls-expr-async-gen-meth-static.template +/*--- +description: RestParameter does not support an initializer (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, class { + static async *method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..70cdfccf9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/object-destructuring-param-strict-body.js @@ -0,0 +1,137 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-gen-meth-static.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + static async *method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/rest-param-strict-body.js new file mode 100644 index 000000000..714202f11 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/rest-param-strict-body.js @@ -0,0 +1,137 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-gen-meth-static.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + static async *method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..b065ee9d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/rest-params-trailing-comma-early-error.js @@ -0,0 +1,63 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/cls-expr-async-gen-meth-static.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, class { + static async *method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..1dc57c85b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-binding-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + var yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-binding-identifier.js new file mode 100644 index 000000000..80239d7cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-binding-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + var yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..69a4ed10c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-identifier-reference-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + void yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-identifier-reference.js new file mode 100644 index 000000000..5d119dbea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-identifier-reference.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + void yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..ed32e0fcb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-label-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + yi\u0065ld: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-label-identifier.js new file mode 100644 index 000000000..f60a637fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-as-label-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier.case +// - src/async-generators/syntax/async-class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *gen() { + yield: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-identifier-spread-strict.js new file mode 100644 index 000000000..d3332fb53 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-identifier-spread-strict.js @@ -0,0 +1,53 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-spread-strict.case +// - src/async-generators/default/async-class-expr-static-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [object-spread, async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var C = class { static async *gen() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } +}} + +var gen = C.gen; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-identifier-strict.js new file mode 100644 index 000000000..c84b09e28 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method-static/yield-identifier-strict.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-strict.case +// - src/async-generators/default/async-class-expr-static-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var C = class { static async *gen() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) +}} + +var gen = C.gen; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..1b912fbcb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/array-destructuring-param-strict-body.js @@ -0,0 +1,137 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-gen-meth.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + async *method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..4ba5257f1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-binding-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + var \u0061wait; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-binding-identifier.js new file mode 100644 index 000000000..1d55d965f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-binding-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + var await; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..5e8112eab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-identifier-reference-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + void \u0061wait; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-identifier-reference.js new file mode 100644 index 000000000..cad0e8334 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-identifier-reference.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + void await; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..4820e9117 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-label-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + \u0061wait: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-label-identifier.js new file mode 100644 index 000000000..d72782255 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/await-as-label-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + await: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/dflt-params-duplicates.js new file mode 100644 index 000000000..e67b9a9d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/dflt-params-duplicates.js @@ -0,0 +1,66 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/cls-expr-async-gen-meth.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, class { + async *method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/dflt-params-rest.js new file mode 100644 index 000000000..df1df48f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/dflt-params-rest.js @@ -0,0 +1,70 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/cls-expr-async-gen-meth.template +/*--- +description: RestParameter does not support an initializer (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, class { + async *method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..d58b31f8e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/object-destructuring-param-strict-body.js @@ -0,0 +1,137 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-gen-meth.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + async *method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/rest-param-strict-body.js new file mode 100644 index 000000000..3aad7a0b3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/rest-param-strict-body.js @@ -0,0 +1,137 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-gen-meth.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + async *method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..34e57024f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/rest-params-trailing-comma-early-error.js @@ -0,0 +1,63 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/cls-expr-async-gen-meth.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, class { + async *method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..89a90d57e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-binding-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + var yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-binding-identifier.js new file mode 100644 index 000000000..8c3142e1b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-binding-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + var yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..1eab3163c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-identifier-reference-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + void yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-identifier-reference.js new file mode 100644 index 000000000..6672e86a3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-identifier-reference.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + void yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..0d0a196a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-label-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + yi\u0065ld: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-label-identifier.js new file mode 100644 index 000000000..75358b1fa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-as-label-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier.case +// - src/async-generators/syntax/async-class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *gen() { + yield: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-identifier-spread-strict.js new file mode 100644 index 000000000..2ccd86d32 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-identifier-spread-strict.js @@ -0,0 +1,53 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-spread-strict.case +// - src/async-generators/default/async-class-expr-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [object-spread, async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var C = class { async *gen() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } +}} + +var gen = C.prototype.gen; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-identifier-strict.js new file mode 100644 index 000000000..2f832d6ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-gen-method/yield-identifier-strict.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-strict.case +// - src/async-generators/default/async-class-expr-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var C = class { async *gen() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) +}} + +var gen = C.prototype.gen; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..c11f0b26d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/array-destructuring-param-strict-body.js @@ -0,0 +1,135 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-meth-static.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (static class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..02d154457 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-binding-identifier-escaped.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier-escaped.case +// - src/async-functions/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async method() { + var \u0061wait; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-binding-identifier.js new file mode 100644 index 000000000..f8d568fa3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-binding-identifier.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier.case +// - src/async-functions/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async method() { + var await; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..9182d12eb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-identifier-reference-escaped.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference-escaped.case +// - src/async-functions/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async method() { + void \u0061wait; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-identifier-reference.js new file mode 100644 index 000000000..828a2e7f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-identifier-reference.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference.case +// - src/async-functions/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async method() { + void await; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..e8f9cdaf8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-label-identifier-escaped.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier-escaped.case +// - src/async-functions/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async method() { + \u0061wait: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-label-identifier.js new file mode 100644 index 000000000..8a9f14098 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/await-as-label-identifier.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier.case +// - src/async-functions/syntax/async-class-expr-static-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async method() { + await: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/dflt-params-duplicates.js new file mode 100644 index 000000000..949fe1d96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/dflt-params-duplicates.js @@ -0,0 +1,64 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/cls-expr-async-meth-static.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (static class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/dflt-params-rest.js new file mode 100644 index 000000000..0af3c1c0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/dflt-params-rest.js @@ -0,0 +1,68 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/cls-expr-async-meth-static.template +/*--- +description: RestParameter does not support an initializer (static class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..d4a4daf91 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/object-destructuring-param-strict-body.js @@ -0,0 +1,135 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-meth-static.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (static class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/rest-param-strict-body.js new file mode 100644 index 000000000..02d2ab656 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/rest-param-strict-body.js @@ -0,0 +1,135 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-meth-static.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (static class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..bba144c84 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method-static/rest-params-trailing-comma-early-error.js @@ -0,0 +1,60 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/cls-expr-async-meth-static.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (static class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..b7db985c6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/array-destructuring-param-strict-body.js @@ -0,0 +1,135 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-meth.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..91e11ee40 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-binding-identifier-escaped.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier-escaped.case +// - src/async-functions/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async method() { + var \u0061wait; + } +}; + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-binding-identifier.js new file mode 100644 index 000000000..d78c6f81c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-binding-identifier.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier.case +// - src/async-functions/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async method() { + var await; + } +}; + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..4d3a1849a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-identifier-reference-escaped.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference-escaped.case +// - src/async-functions/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async method() { + void \u0061wait; + } +}; + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-identifier-reference.js new file mode 100644 index 000000000..3ee071548 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-identifier-reference.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference.case +// - src/async-functions/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async method() { + void await; + } +}; + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..08c6c1aa0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-label-identifier-escaped.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier-escaped.case +// - src/async-functions/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async method() { + \u0061wait: ; + } +}; + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-label-identifier.js new file mode 100644 index 000000000..fcc6b9ada --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/await-as-label-identifier.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier.case +// - src/async-functions/syntax/async-class-expr-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async method() { + await: ; + } +}; + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/dflt-params-duplicates.js new file mode 100644 index 000000000..8ef4b5f34 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/dflt-params-duplicates.js @@ -0,0 +1,64 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/cls-expr-async-meth.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/dflt-params-rest.js new file mode 100644 index 000000000..72955d115 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/dflt-params-rest.js @@ -0,0 +1,68 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/cls-expr-async-meth.template +/*--- +description: RestParameter does not support an initializer (class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..832e0fea2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/object-destructuring-param-strict-body.js @@ -0,0 +1,135 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-meth.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/rest-param-strict-body.js new file mode 100644 index 000000000..c90a7fa2b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/rest-param-strict-body.js @@ -0,0 +1,135 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/cls-expr-async-meth.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..9af9a0472 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/async-method/rest-params-trailing-comma-early-error.js @@ -0,0 +1,60 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/cls-expr-async-meth.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (class expression async method) +esid: sec-class-definitions-runtime-semantics-evaluation +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncMethod is strict mode code, let strict be true. Otherwise + let strict be false. + 4. Let scope be the LexicalEnvironment of the running execution context. + 5. Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, + scope, strict). + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +var C = class { + static async method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-await-escaped-module.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-await-escaped-module.js new file mode 100644 index 000000000..2801e9a6b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-await-escaped-module.js @@ -0,0 +1,23 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-class-definitions +description: > + `await` with escape sequence is a valid class-name identifier. +info: | + 12.1.1 Static Semantics: Early Errors + + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if the goal symbol of the syntactic grammar is Module + and the StringValue of IdentifierName is "await". +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +var C = class aw\u0061it {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-await-module.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-await-module.js new file mode 100644 index 000000000..ea58d64bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-await-module.js @@ -0,0 +1,22 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-class-definitions +description: > + `await` is a valid class-name identifier. +info: | + 12.1.1 Static Semantics: Early Errors + + IdentifierReference : yield + + It is a Syntax Error if the goal symbol of the syntactic grammar is Module. +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +var C = class await {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-let-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-let-escaped.js new file mode 100644 index 000000000..300e8edc2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-let-escaped.js @@ -0,0 +1,27 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-class-definitions +description: > + `let` with escape sequence is not a valid class-name identifier. +info: | + 12.1.1 Static Semantics: Early Errors + + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". + + 10.2.1 Strict Mode Code + + All parts of a ClassDeclaration or a ClassExpression are strict mode code. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class l\u0065t {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-let.js new file mode 100644 index 000000000..b2665fdc3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-let.js @@ -0,0 +1,27 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-class-definitions +description: > + `let` is not a valid class-name identifier. +info: | + 12.1.1 Static Semantics: Early Errors + + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". + + 10.2.1 Strict Mode Code + + All parts of a ClassDeclaration or a ClassExpression are strict mode code. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class let {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-static-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-static-escaped.js new file mode 100644 index 000000000..e740d54ac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-static-escaped.js @@ -0,0 +1,27 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-class-definitions +description: > + `static` with escape sequence is not a valid class-name identifier. +info: | + 12.1.1 Static Semantics: Early Errors + + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". + + 10.2.1 Strict Mode Code + + All parts of a ClassDeclaration or a ClassExpression are strict mode code. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class st\u0061tic {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-static.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-static.js new file mode 100644 index 000000000..3929c10f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-static.js @@ -0,0 +1,27 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-class-definitions +description: > + `static` is not a valid class-name identifier. +info: | + 12.1.1 Static Semantics: Early Errors + + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". + + 10.2.1 Strict Mode Code + + All parts of a ClassDeclaration or a ClassExpression are strict mode code. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class static {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-yield-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-yield-escaped.js new file mode 100644 index 000000000..f4d7a8d37 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-yield-escaped.js @@ -0,0 +1,27 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-class-definitions +description: > + `yield` with escape sequence is not a valid class-name identifier. +info: | + 12.1.1 Static Semantics: Early Errors + + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". + + 10.2.1 Strict Mode Code + + All parts of a ClassDeclaration or a ClassExpression are strict mode code. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class yi\u0065ld {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-yield.js new file mode 100644 index 000000000..93e245a6e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/class-name-ident-yield.js @@ -0,0 +1,25 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-class-definitions +description: > + `yield` is not a valid class-name identifier. +info: | + 12.1.1 Static Semantics: Early Errors + + IdentifierReference : yield + + It is a Syntax Error if the code matched by this production is contained in strict mode code. + + 10.2.1 Strict Mode Code + + All parts of a ClassDeclaration or a ClassExpression are strict mode code. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class yield {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..2241c1a29 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-async-gen-meth.template +/*--- +description: Rest element (nested array pattern) does not support initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...[ x ] = []]) { + + callCount = callCount + 1; + } +}; + +new C().method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..856797c05 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-async-gen-meth.template +/*--- +description: Rest element (identifier) does not support initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...x = []]) { + + callCount = callCount + 1; + } +}; + +new C().method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..3d6b73b6a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-async-gen-meth.template +/*--- +description: Rest element (nested object pattern) does not support initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...{ x } = []]) { + + callCount = callCount + 1; + } +}; + +new C().method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..ffedbae8e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-async-gen-meth.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...[x], y]) { + + callCount = callCount + 1; + } +}; + +new C().method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..4c26236dc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-async-gen-meth.template +/*--- +description: Rest element (identifier) may not be followed by any element (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...x, y]) { + + callCount = callCount + 1; + } +}; + +new C().method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..cb2154016 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-async-gen-meth.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...{ x }, y]) { + + callCount = callCount + 1; + } +}; + +new C().method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..dfbe5f561 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..32c8fe435 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...x = []] = []) { + + callCount = callCount + 1; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..2710865c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...{ x } = []] = []) { + + callCount = callCount + 1; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..52bebbbfa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..bb34e439f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..454f0e015 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async *method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..fab32a057 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template +/*--- +description: Rest element (nested array pattern) does not support initializer (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...[ x ] = []]) { + + callCount = callCount + 1; + } +}; + +C.method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..e64ee6934 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template +/*--- +description: Rest element (identifier) does not support initializer (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...x = []]) { + + callCount = callCount + 1; + } +}; + +C.method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..84cbf9ce5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-init-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template +/*--- +description: Rest element (nested object pattern) does not support initializer (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...{ x } = []]) { + + callCount = callCount + 1; + } +}; + +C.method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..151ff6b2e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...[x], y]) { + + callCount = callCount + 1; + } +}; + +C.method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..33c266738 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template +/*--- +description: Rest element (identifier) may not be followed by any element (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...x, y]) { + + callCount = callCount + 1; + } +}; + +C.method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..c898ddc9c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...{ x }, y]) { + + callCount = callCount + 1; + } +}; + +C.method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..11a411ae4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..8f1dad2a1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...x = []] = []) { + + callCount = callCount + 1; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..e16e9e8fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...{ x } = []] = []) { + + callCount = callCount + 1; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..cd5b0753c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..1fb45220b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..d9481f047 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async *method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..3ec38220a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-ary.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...[ x ] = []]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..00fb6dd27 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-id.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth.template +/*--- +description: Rest element (identifier) does not support initializer (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...x = []]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..ae3be45df --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-init-obj.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...{ x } = []]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..bba32c145 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...[x], y]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..d54080200 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth.template +/*--- +description: Rest element (identifier) may not be followed by any element (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...x, y]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..69f99f169 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...{ x }, y]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..ca1a39b28 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..f15312cb4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (private class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...x = []] = []) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..0a5ba1c97 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...{ x } = []] = []) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..ee9d6a312 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..37c3721a4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (private class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..196914580 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + async * #method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..4dc1a19e6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-ary.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...[ x ] = []]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..3658abf09 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-id.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: Rest element (identifier) does not support initializer (private static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...x = []]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..79e52dc13 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-init-obj.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...{ x } = []]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..e80c73787 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...[x], y]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..78c9e32cb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: Rest element (identifier) may not be followed by any element (private static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...x, y]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..4edd682c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...{ x }, y]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..17780a964 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..a1e60a67f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (private static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...x = []] = []) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..c2bd37005 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...{ x } = []] = []) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..2c4df6f27 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..1d90c4ffc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (private static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..165442491 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/async-private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-async-private-gen-meth-static-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private static class expression async generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var C = class { + static async * #method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..2c9255885 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-ary.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-gen-meth.template +/*--- +description: Rest element (nested array pattern) does not support initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...[ x ] = []]) { + + callCount = callCount + 1; + } +}; + +new C().method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..6b6e7155f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-id.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-gen-meth.template +/*--- +description: Rest element (identifier) does not support initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...x = []]) { + + callCount = callCount + 1; + } +}; + +new C().method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..fcd7dea37 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-init-obj.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-gen-meth.template +/*--- +description: Rest element (nested object pattern) does not support initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...{ x } = []]) { + + callCount = callCount + 1; + } +}; + +new C().method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..3c54e2001 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-gen-meth.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...[x], y]) { + + callCount = callCount + 1; + } +}; + +new C().method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..6756acb0d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-gen-meth.template +/*--- +description: Rest element (identifier) may not be followed by any element (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...x, y]) { + + callCount = callCount + 1; + } +}; + +new C().method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..1f5c47433 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-gen-meth.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...{ x }, y]) { + + callCount = callCount + 1; + } +}; + +new C().method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..ee5acf2cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-gen-meth-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..60c8be924 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-gen-meth-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...x = []] = []) { + + callCount = callCount + 1; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..0930c4e21 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-gen-meth-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...{ x } = []] = []) { + + callCount = callCount + 1; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..ea1527390 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-gen-meth-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..da91a9346 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-gen-meth-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..024d93358 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-gen-meth-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + *method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..d14acee91 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-ary.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-gen-meth-static.template +/*--- +description: Rest element (nested array pattern) does not support initializer (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...[ x ] = []]) { + + callCount = callCount + 1; + } +}; + +C.method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..9385ed5ef --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-id.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-gen-meth-static.template +/*--- +description: Rest element (identifier) does not support initializer (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...x = []]) { + + callCount = callCount + 1; + } +}; + +C.method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..1a1253b76 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-init-obj.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-gen-meth-static.template +/*--- +description: Rest element (nested object pattern) does not support initializer (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...{ x } = []]) { + + callCount = callCount + 1; + } +}; + +C.method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..60af25f4b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-gen-meth-static.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...[x], y]) { + + callCount = callCount + 1; + } +}; + +C.method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..d2daa0299 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-gen-meth-static.template +/*--- +description: Rest element (identifier) may not be followed by any element (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...x, y]) { + + callCount = callCount + 1; + } +}; + +C.method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..9552c185b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-gen-meth-static.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...{ x }, y]) { + + callCount = callCount + 1; + } +}; + +C.method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..4190640d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-gen-meth-static-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..1bb19c7fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-gen-meth-static-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...x = []] = []) { + + callCount = callCount + 1; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..a088e2078 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-gen-meth-static-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...{ x } = []] = []) { + + callCount = callCount + 1; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..a375b2d0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-gen-meth-static-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..24b5b1d70 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-gen-meth-static-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..268c441d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-gen-meth-static-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static *method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..064528a0f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-init-ary.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-meth.template +/*--- +description: Rest element (nested array pattern) does not support initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...[ x ] = []]) { + + callCount = callCount + 1; + } +}; + +new C().method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..7f332cf87 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-init-id.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-meth.template +/*--- +description: Rest element (identifier) does not support initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...x = []]) { + + callCount = callCount + 1; + } +}; + +new C().method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..2540fd086 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-init-obj.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-meth.template +/*--- +description: Rest element (nested object pattern) does not support initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...{ x } = []]) { + + callCount = callCount + 1; + } +}; + +new C().method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..9147dd39d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-meth.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...[x], y]) { + + callCount = callCount + 1; + } +}; + +new C().method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..16b4e82fa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-meth.template +/*--- +description: Rest element (identifier) may not be followed by any element (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...x, y]) { + + callCount = callCount + 1; + } +}; + +new C().method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..2ba6ceba1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-meth.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...{ x }, y]) { + + callCount = callCount + 1; + } +}; + +new C().method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..77e385ec1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-meth-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..e8119e4f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-meth-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...x = []] = []) { + + callCount = callCount + 1; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..70d3c20fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-meth-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...{ x } = []] = []) { + + callCount = callCount + 1; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..226446696 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-meth-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..8c2501836 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-meth-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..f78c08180 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-meth-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..26ff539f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-ary.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-meth-static.template +/*--- +description: Rest element (nested array pattern) does not support initializer (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...[ x ] = []]) { + + callCount = callCount + 1; + } +}; + +C.method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..0ef4d4cd9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-id.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-meth-static.template +/*--- +description: Rest element (identifier) does not support initializer (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...x = []]) { + + callCount = callCount + 1; + } +}; + +C.method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..0a8d10a67 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-init-obj.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-meth-static.template +/*--- +description: Rest element (nested object pattern) does not support initializer (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...{ x } = []]) { + + callCount = callCount + 1; + } +}; + +C.method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..bb4d11dd3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-meth-static.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...[x], y]) { + + callCount = callCount + 1; + } +}; + +C.method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..5bed5a41f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-meth-static.template +/*--- +description: Rest element (identifier) may not be followed by any element (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...x, y]) { + + callCount = callCount + 1; + } +}; + +C.method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..12fda67ab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-meth-static.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...{ x }, y]) { + + callCount = callCount + 1; + } +}; + +C.method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..24645e56c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-meth-static-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..7cd4bdf5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-meth-static-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...x = []] = []) { + + callCount = callCount + 1; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..979547d92 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-meth-static-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...{ x } = []] = []) { + + callCount = callCount + 1; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..15ef560a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-meth-static-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..15c4c3ef0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-meth-static-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..300e8e2d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/meth-static-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,80 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-meth-static-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..4b204f580 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-ary.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-private-gen-meth.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...[ x ] = []]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..90c76b384 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-id.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-private-gen-meth.template +/*--- +description: Rest element (identifier) does not support initializer (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...x = []]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..73978a155 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-init-obj.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-private-gen-meth.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...{ x } = []]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..08c8e1472 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-private-gen-meth.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...[x], y]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..7536c82f1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-private-gen-meth.template +/*--- +description: Rest element (identifier) may not be followed by any element (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...x, y]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..e51e07335 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-private-gen-meth.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...{ x }, y]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..1dcc913b4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..86b7ae6ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...x = []] = []) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..38d096213 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...{ x } = []] = []) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..98b9e434b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..d91491156 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..9fb7bdddc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + * #method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..684bd2f70 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-ary.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...[ x ] = []]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..27c9c660e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-id.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static.template +/*--- +description: Rest element (identifier) does not support initializer (private static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...x = []]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..5932f8ed4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-init-obj.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...{ x } = []]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..6fd790b35 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...[x], y]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..634267415 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static.template +/*--- +description: Rest element (identifier) may not be followed by any element (private static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...x, y]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..ce2e51ce1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...{ x }, y]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..4296aee58 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..ea91823b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (private static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...x = []] = []) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..1c3ed4ca2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...{ x } = []] = []) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..8356029a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..4936dbbe6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (private static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..725dc52e2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-private-gen-meth-static-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private static class expression generator method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static * #method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method().next(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..42b553f53 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-ary.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-private-meth.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...[ x ] = []]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..c8592fb7d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-id.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-private-meth.template +/*--- +description: Rest element (identifier) does not support initializer (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...x = []]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..7574a6d69 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-init-obj.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-private-meth.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...{ x } = []]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..d02077e10 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-private-meth.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...[x], y]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..26743dcea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-private-meth.template +/*--- +description: Rest element (identifier) may not be followed by any element (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...x, y]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..d8fd4ea59 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-private-meth.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...{ x }, y]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..e840fc358 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-private-meth-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..c7fb0067e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-private-meth-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...x = []] = []) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..ed1641004 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-private-meth-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...{ x } = []] = []) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..599b923d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-private-meth-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..873ddce44 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-private-meth-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..a5816a626 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-private-meth-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + #method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..2a45d9c86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-ary.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-private-meth-static.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...[ x ] = []]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..9b1af4e24 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-id.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-private-meth-static.template +/*--- +description: Rest element (identifier) does not support initializer (private static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...x = []]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..524bdabd3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-init-obj.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-private-meth-static.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...{ x } = []]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..804eca513 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-private-meth-static.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...[x], y]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..b36c6eb77 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-private-meth-static.template +/*--- +description: Rest element (identifier) may not be followed by any element (private static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...x, y]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..15f40eb62 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-private-meth-static.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...{ x }, y]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..7f4de6fad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/cls-expr-private-meth-static-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (private static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..277df5bce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/cls-expr-private-meth-static-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (private static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...x = []] = []) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..dd91e54cf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/cls-expr-private-meth-static-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (private static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...{ x } = []] = []) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..fe548d045 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/cls-expr-private-meth-static-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (private static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..fe990e274 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/cls-expr-private-meth-static-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (private static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..edb913753 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/dstr/private-meth-static-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/cls-expr-private-meth-static-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (private static class expression method (default parameter)) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [class, class-static-methods-private, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var C = class { + static #method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/arrow-fnc-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/arrow-fnc-init-err-contains-arguments.js new file mode 100644 index 000000000..efa5e5468 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/arrow-fnc-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-arrow-fnc.template +/*--- +description: Syntax error if `arguments` used in class field (arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, arrow-function] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/arrow-fnc-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/arrow-fnc-init-err-contains-super.js new file mode 100644 index 000000000..79aacd2e5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/arrow-fnc-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-arrow-fnc.template +/*--- +description: Syntax error if `super()` used in class field (arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, arrow-function] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..63abc8dde --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + var \u0061wait; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier.js new file mode 100644 index 000000000..6685dcb0c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-binding-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + var await; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..1848905aa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + void \u0061wait; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference.js new file mode 100644 index 000000000..9f6f2cdd3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-identifier-reference.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + void await; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..4a28c449c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + \u0061wait: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier.js new file mode 100644 index 000000000..c6e2c464c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/await-as-label-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + await: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..79a4bb4a2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + var yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier.js new file mode 100644 index 000000000..9fc5a2cf2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-binding-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + var yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..ff7b42055 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + void yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference.js new file mode 100644 index 000000000..210d386ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-identifier-reference.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + void yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..03bf5ac33 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + yi\u0065ld: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier.js new file mode 100644 index 000000000..0cc58a12b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-as-label-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier.case +// - src/async-generators/syntax/async-class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { static async *#gen() { + yield: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js new file mode 100644 index 000000000..6aab422cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js @@ -0,0 +1,74 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-spread-strict.case +// - src/async-generators/default/async-class-expr-static-private-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorPrivateMethod +features: [object-spread, async-iteration, class-static-methods-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var C = class { + static async *#gen() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } + } + static get gen() { return this.#gen; } +} + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "#gen does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "#gen does not appear as an own property on C constructor" +); + +var iter = C.gen(); + + + +assert.sameValue(callCount, 1); + +// Test the private fields do not appear as properties after set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "#gen does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "#gen does not appear as an own property on C constructor" +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-strict.js new file mode 100644 index 000000000..7fad8ec2d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-strict.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-strict.case +// - src/async-generators/default/async-class-expr-static-private-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Static async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorPrivateMethod +features: [async-iteration, class-static-methods-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var C = class { + static async *#gen() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) + } + static get gen() { return this.#gen; } +} + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "#gen does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "#gen does not appear as an own property on C constructor" +); + +var iter = C.gen(); + + + +assert.sameValue(callCount, 1); + +// Test the private fields do not appear as properties after set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "#gen does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "#gen does not appear as an own property on C constructor" +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..b299f40bd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + var \u0061wait; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier.js new file mode 100644 index 000000000..ab797d2b4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-binding-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + var await; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..c1eb49681 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + void \u0061wait; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference.js new file mode 100644 index 000000000..afe2e50d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-identifier-reference.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + void await; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..a6e6008db --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-label-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + \u0061wait: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-label-identifier.js new file mode 100644 index 000000000..4dada7b8d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/await-as-label-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + await: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..d7c45f0d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + var yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier.js new file mode 100644 index 000000000..bad19a0ff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-binding-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + var yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..6d7120d34 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + void yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference.js new file mode 100644 index 000000000..605433412 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-identifier-reference.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + void yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..827741635 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier-escaped.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + yi\u0065ld: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier.js new file mode 100644 index 000000000..c946482a8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-as-label-identifier.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier.case +// - src/async-generators/syntax/async-class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator private method as a ClassExpression element) +esid: prod-AsyncGeneratorMethod +features: [async-iteration, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * # PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + + +var C = class { async *#gen() { + yield: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-spread-strict.js new file mode 100644 index 000000000..2ecc39322 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-spread-strict.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-spread-strict.case +// - src/async-generators/default/async-class-expr-private-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorPrivateMethod +features: [object-spread, async-iteration, class-methods-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var C = class { + async *#gen() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } + } + get gen() { return this.#gen; } +} + +const c = new C(); + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "#gen does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "#gen does not appear as an own property on C constructor" +); +assert( + !Object.prototype.hasOwnProperty.call(c, "#gen"), + "#gen does not appear as an own property on C instance" +); + +var iter = c.gen(); + + + +assert.sameValue(callCount, 1); + +// Test the private fields do not appear as properties after set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "#gen does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "#gen does not appear as an own property on C constructor" +); +assert( + !Object.prototype.hasOwnProperty.call(c, "#gen"), + "#gen does not appear as an own property on C instance" +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-strict.js new file mode 100644 index 000000000..8471e2486 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-strict.js @@ -0,0 +1,75 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-strict.case +// - src/async-generators/default/async-class-expr-private-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Async generator method as a ClassExpression element) +esid: prod-AsyncGeneratorPrivateMethod +features: [async-iteration, class-methods-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncGeneratorMethod + + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; + +var C = class { + async *#gen() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) + } + get gen() { return this.#gen; } +} + +const c = new C(); + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "#gen does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "#gen does not appear as an own property on C constructor" +); +assert( + !Object.prototype.hasOwnProperty.call(c, "#gen"), + "#gen does not appear as an own property on C instance" +); + +var iter = c.gen(); + + + +assert.sameValue(callCount, 1); + +// Test the private fields do not appear as properties after set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "#gen does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "#gen does not appear as an own property on C constructor" +); +assert( + !Object.prototype.hasOwnProperty.call(c, "#gen"), + "#gen does not appear as an own property on C instance" +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..ed1b6c9db --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-binding-identifier-escaped.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier-escaped.case +// - src/async-functions/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static private async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async #method() { + var \u0061wait; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-binding-identifier.js new file mode 100644 index 000000000..23ad943cb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-binding-identifier.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier.case +// - src/async-functions/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static private async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async #method() { + var await; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..daee8cb41 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-identifier-reference-escaped.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference-escaped.case +// - src/async-functions/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static private async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async #method() { + void \u0061wait; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-identifier-reference.js new file mode 100644 index 000000000..7674dbe0a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-identifier-reference.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference.case +// - src/async-functions/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static private async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async #method() { + void await; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..0c2baef08 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-label-identifier-escaped.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier-escaped.case +// - src/async-functions/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static private async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async #method() { + \u0061wait: ; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-label-identifier.js new file mode 100644 index 000000000..94a503260 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method-static/await-as-label-identifier.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier.case +// - src/async-functions/syntax/async-class-expr-static-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static private async method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + static async #method() { + await: ; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..e72691686 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-binding-identifier-escaped.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier-escaped.case +// - src/async-functions/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async private method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async #method() { + var \u0061wait; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-binding-identifier.js new file mode 100644 index 000000000..a335cb10a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-binding-identifier.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier.case +// - src/async-functions/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async private method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async #method() { + var await; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..b76a637a8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-identifier-reference-escaped.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference-escaped.case +// - src/async-functions/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async private method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async #method() { + void \u0061wait; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-identifier-reference.js new file mode 100644 index 000000000..0390b498c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-identifier-reference.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference.case +// - src/async-functions/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async private method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async #method() { + void await; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-label-identifier-escaped.js new file mode 100644 index 000000000..df664ed86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-label-identifier-escaped.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier-escaped.case +// - src/async-functions/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async private method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async #method() { + \u0061wait: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-label-identifier.js new file mode 100644 index 000000000..f76fcf8f6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/async-private-method/await-as-label-identifier.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier.case +// - src/async-functions/syntax/async-class-expr-private-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async private method as a ClassExpression element) +esid: prod-AsyncMethod +features: [async-functions, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + AsyncMethod + + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] # PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var C = class { + async #method() { + await: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/comp-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/comp-name-init-err-contains-arguments.js new file mode 100644 index 000000000..7f0cecb79 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/comp-name-init-err-contains-arguments.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-comp-name.template +/*--- +description: Syntax error if `arguments` used in class field (computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var x = "string"; +var C = class { + [x] = arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/comp-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/comp-name-init-err-contains-super.js new file mode 100644 index 000000000..eab5577bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/comp-name-init-err-contains-super.js @@ -0,0 +1,28 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-comp-name.template +/*--- +description: Syntax error if `super()` used in class field (computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var x = "string"; +var C = class { + [x] = super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/equality-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/equality-init-err-contains-arguments.js new file mode 100644 index 000000000..5501e918b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/equality-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-equality.template +/*--- +description: Syntax error if `arguments` used in class field (equality expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = {} == arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/equality-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/equality-init-err-contains-super.js new file mode 100644 index 000000000..f526efff2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/equality-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-equality.template +/*--- +description: Syntax error if `super()` used in class field (equality expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = {} == super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-3.js new file mode 100644 index 000000000..e63aa4410 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-3.js @@ -0,0 +1,18 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: ASI test in field declarations -- error when computed name interpreted as index +esid: sec-automatic-semicolon-insertion +features: [class, class-fields-public] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = "string" + [0]() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-4.js new file mode 100644 index 000000000..dc207ba8b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-4.js @@ -0,0 +1,18 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: ASI test in field declarations -- error when generator interpreted as multiplication +esid: sec-automatic-semicolon-insertion +features: [class, class-fields-public, generators] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = 42 + *gen() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-same-line-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-same-line-1.js new file mode 100644 index 000000000..d500358b0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-same-line-1.js @@ -0,0 +1,17 @@ +// Copyright (C) 2019 Jason Orendorff. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: ASI test in field declarations -- error when method on same line +esid: sec-automatic-semicolon-insertion +features: [class, class-fields-public] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class { + field /* no ASI here */ method(){} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-same-line-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-same-line-2.js new file mode 100644 index 000000000..6e7fe27ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-asi-same-line-2.js @@ -0,0 +1,17 @@ +// Copyright (C) 2019 Jason Orendorff. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: ASI test in field declarations -- error when method on same line after initializer +esid: sec-automatic-semicolon-insertion +features: [class, class-fields-public] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var C = class { + field = 1 /* no ASI here */ method(){} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-duplicate-privatenames.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-duplicate-privatenames.js new file mode 100644 index 000000000..913cc812d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-duplicate-privatenames.js @@ -0,0 +1,24 @@ +// Copyright 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Syntax error if the same private field defined twice +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries. +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + #x; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-literal-name-propname-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-literal-name-propname-constructor.js new file mode 100644 index 000000000..215facdac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-literal-name-propname-constructor.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: class fields forbid PropName 'constructor' (early error -- PropName of IdentifierName is forbidden) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: PropName + LiteralPropertyName : IdentifierName + Return StringValue of IdentifierName. + + + // This test file tests the following early error: + Static Semantics: Early Errors + + ClassElement : FieldDefinition; + It is a Syntax Error if PropName of FieldDefinition is "constructor". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + constructor; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-literal-name-static-propname-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-literal-name-static-propname-constructor.js new file mode 100644 index 000000000..6e403bb88 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-literal-name-static-propname-constructor.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: static class field forbid PropName 'constructor' (early error -- PropName of IdentifierName is forbidden) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: PropName + LiteralPropertyName : IdentifierName + Return StringValue of IdentifierName. + + + // This test file tests the following early error: + Static Semantics: Early Errors + + ClassElement : staticFieldDefinition; + It is a Syntax Error if PropName of FieldDefinition is "prototype" or "constructor". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static constructor; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-literal-name-static-propname-prototype.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-literal-name-static-propname-prototype.js new file mode 100644 index 000000000..bf988cb26 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-literal-name-static-propname-prototype.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: static class fields forbid PropName 'prototype' (early error -- PropName of IdentifierName is forbidden) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: PropName + LiteralPropertyName : IdentifierName + Return StringValue of IdentifierName. + + + // This test file tests the following early error: + Static Semantics: Early Errors + + ClassElement : staticFieldDefinition; + It is a Syntax Error if PropName of FieldDefinition is "prototype" or "constructor". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static prototype; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-string-name-propname-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-string-name-propname-constructor.js new file mode 100644 index 000000000..270ff49f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-string-name-propname-constructor.js @@ -0,0 +1,30 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: class fields forbid PropName 'constructor' (early error -- PropName of StringLiteral is forbidden) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: PropName + ... + LiteralPropertyName : StringLiteral + Return the String value whose code units are the SV of the StringLiteral. + + + // This test file tests the following early error: + Static Semantics: Early Errors + + ClassElement : FieldDefinition; + It is a Syntax Error if PropName of FieldDefinition is "constructor". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + 'constructor'; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-string-name-static-propname-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-string-name-static-propname-constructor.js new file mode 100644 index 000000000..4140a989b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-string-name-static-propname-constructor.js @@ -0,0 +1,30 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: static class field forbid PropName 'constructor' (early error -- PropName of StringLiteral is forbidden) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: PropName + ... + LiteralPropertyName : StringLiteral + Return the String value whose code units are the SV of the StringLiteral. + + + // This test file tests the following early error: + Static Semantics: Early Errors + + ClassElement : staticFieldDefinition; + It is a Syntax Error if PropName of FieldDefinition is "prototype" or "constructor". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static 'constructor'; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-string-name-static-propname-prototype.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-string-name-static-propname-prototype.js new file mode 100644 index 000000000..f4bff12d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/fields-string-name-static-propname-prototype.js @@ -0,0 +1,30 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: static class fields forbid PropName 'prototype' (early error -- PropName of StringLiteral is forbidden) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: PropName + ... + LiteralPropertyName : StringLiteral + Return the String value whose code units are the SV of the StringLiteral. + + + // This test file tests the following early error: + Static Semantics: Early Errors + + ClassElement : staticFieldDefinition; + It is a Syntax Error if PropName of FieldDefinition is "prototype" or "constructor". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static 'prototype'; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..069cd96a8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier-escaped.case +// - src/generators/syntax/class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *#gen() { + var yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier.js new file mode 100644 index 000000000..6fd622c96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-binding-identifier.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier.case +// - src/generators/syntax/class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *#gen() { + var yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..1a9d1e8f2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference-escaped.case +// - src/generators/syntax/class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *#gen() { + void yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference.js new file mode 100644 index 000000000..e27e4587c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-identifier-reference.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference.case +// - src/generators/syntax/class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *#gen() { + void yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..9c79dd2fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier-escaped.case +// - src/generators/syntax/class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *#gen() { + yi\u0065ld: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier.js new file mode 100644 index 000000000..ca8a2f0f4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-as-label-identifier.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier.case +// - src/generators/syntax/class-expr-static-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-static-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *#gen() { + yield: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-spread-strict.js new file mode 100644 index 000000000..13ea2450a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-spread-strict.js @@ -0,0 +1,73 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-spread-strict.case +// - src/generators/default/class-expr-static-private-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Static generator private method as a ClassExpression element) +esid: prod-GeneratorPrivateMethod +features: [object-spread, generators, class-static-methods-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var C = class { + static *#gen() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } + } + static get gen() { return this.#gen; } +} + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "Private field '#gen' does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "Private field '#gen' does not appear as an own property on C constructor" +); + +var iter = C.gen(); + + + +assert.sameValue(callCount, 1); + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "Private field '#gen' does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "Private field '#gen' does not appear as an own property on C constructor" +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-strict.js new file mode 100644 index 000000000..ff874f7b8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-strict.js @@ -0,0 +1,64 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-strict.case +// - src/generators/default/class-expr-static-private-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Static generator private method as a ClassExpression element) +esid: prod-GeneratorPrivateMethod +features: [generators, class-static-methods-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var C = class { + static *#gen() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) + } + static get gen() { return this.#gen; } +} + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "Private field '#gen' does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "Private field '#gen' does not appear as an own property on C constructor" +); + +var iter = C.gen(); + + + +assert.sameValue(callCount, 1); + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "Private field '#gen' does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "Private field '#gen' does not appear as an own property on C constructor" +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..72f907625 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-binding-identifier-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier-escaped.case +// - src/generators/syntax/class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*#gen() { + var yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-binding-identifier.js new file mode 100644 index 000000000..5835b3639 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-binding-identifier.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier.case +// - src/generators/syntax/class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*#gen() { + var yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..18cb04ad4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-identifier-reference-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference-escaped.case +// - src/generators/syntax/class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*#gen() { + void yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-identifier-reference.js new file mode 100644 index 000000000..ddfc0e4dd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-identifier-reference.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference.case +// - src/generators/syntax/class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*#gen() { + void yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..e2e88380c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-label-identifier-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier-escaped.case +// - src/generators/syntax/class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*#gen() { + yi\u0065ld: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-label-identifier.js new file mode 100644 index 000000000..80b1e7ac0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-as-label-identifier.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier.case +// - src/generators/syntax/class-expr-private-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Generator private method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators, class-methods-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * # PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*#gen() { + yield: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-identifier-spread-strict.js new file mode 100644 index 000000000..55208f510 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-identifier-spread-strict.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-spread-strict.case +// - src/generators/default/class-expr-private-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Generator private method as a ClassExpression element) +esid: prod-GeneratorPrivateMethod +features: [object-spread, generators, class-methods-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var C = class { + *#gen() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } + } + get gen() { return this.#gen; } +} + +const c = new C(); + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "Private field '#gen' does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "Private field '#gen' does not appear as an own property on C constructor" +); +assert( + !Object.prototype.hasOwnProperty.call(c, "#gen"), + "Private field '#gen' does not appear as an own property on C instance" +); + +var iter = c.gen(); + + + +assert.sameValue(callCount, 1); + +// Test the private fields do not appear as properties after set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "Private field '#gen' does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "Private field '#gen' does not appear as an own property on C constructor" +); +assert( + !Object.prototype.hasOwnProperty.call(c, "#gen"), + "Private field '#gen' does not appear as an own property on C instance" +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-identifier-strict.js new file mode 100644 index 000000000..a41c87971 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/gen-private-method/yield-identifier-strict.js @@ -0,0 +1,74 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-strict.case +// - src/generators/default/class-expr-private-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Generator private method as a ClassExpression element) +esid: prod-GeneratorPrivateMethod +features: [generators, class-methods-private] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + PrivateMethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var C = class { + *#gen() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) + } + get gen() { return this.#gen; } +} + +const c = new C(); + +// Test the private fields do not appear as properties before set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "Private field '#gen' does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "Private field '#gen' does not appear as an own property on C constructor" +); +assert( + !Object.prototype.hasOwnProperty.call(c, "#gen"), + "Private field '#gen' does not appear as an own property on C instance" +); + +var iter = c.gen(); + + + +assert.sameValue(callCount, 1); + +// Test the private fields do not appear as properties after set to value +assert( + !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"), + "Private field '#gen' does not appear as an own property on C prototype" +); +assert( + !Object.prototype.hasOwnProperty.call(C, "#gen"), + "Private field '#gen' does not appear as an own property on C constructor" +); +assert( + !Object.prototype.hasOwnProperty.call(c, "#gen"), + "Private field '#gen' does not appear as an own property on C instance" +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/literal-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/literal-name-init-err-contains-arguments.js new file mode 100644 index 000000000..41257db8b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/literal-name-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/literal-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/literal-name-init-err-contains-super.js new file mode 100644 index 000000000..f9c215cab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-arrow-fnc-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-arrow-fnc-init-err-contains-arguments.js new file mode 100644 index 000000000..081119ab8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-arrow-fnc-init-err-contains-arguments.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-arrow-fnc-nested.template +/*--- +description: Syntax error if `arguments` used in class field (arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, arrow-function] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = () => { + var t = () => arguments; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-arrow-fnc-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-arrow-fnc-init-err-contains-super.js new file mode 100644 index 000000000..c6172aec0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-arrow-fnc-init-err-contains-super.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-arrow-fnc-nested.template +/*--- +description: Syntax error if `super()` used in class field (arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, arrow-function] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = () => { + var t = () => super(); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-comp-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-comp-name-init-err-contains-arguments.js new file mode 100644 index 000000000..9055ba9c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-comp-name-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-comp-name-nested.template +/*--- +description: Syntax error if `arguments` used in class field (computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var x = "string"; +var C = class { + [x] = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-comp-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-comp-name-init-err-contains-super.js new file mode 100644 index 000000000..2e2e2a4c5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-comp-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-comp-name-nested.template +/*--- +description: Syntax error if `super()` used in class field (computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var x = "string"; +var C = class { + [x] = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-equality-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-equality-init-err-contains-arguments.js new file mode 100644 index 000000000..3c2b49b3f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-equality-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-equality-nested.template +/*--- +description: Syntax error if `arguments` used in class field (equality expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = () => {} == arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-equality-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-equality-init-err-contains-super.js new file mode 100644 index 000000000..f89f0d950 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-equality-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-equality-nested.template +/*--- +description: Syntax error if `super()` used in class field (equality expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = () => {} == super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-literal-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-literal-name-init-err-contains-arguments.js new file mode 100644 index 000000000..0cf3fae85 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-literal-name-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-literal-name-nested.template +/*--- +description: Syntax error if `arguments` used in class field (literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-literal-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-literal-name-init-err-contains-super.js new file mode 100644 index 000000000..946b3a5fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-literal-name-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-literal-name-nested.template +/*--- +description: Syntax error if `super()` used in class field (literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-arguments.js new file mode 100644 index 000000000..32fde6eae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-arguments.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-private-arrow-fnc-nested.template +/*--- +description: Syntax error if `arguments` used in class field (private field, arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, arrow-function, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = () => { + var t = () => arguments; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-super.js new file mode 100644 index 000000000..2bb202cd8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-arrow-fnc-init-err-contains-super.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-private-arrow-fnc-nested.template +/*--- +description: Syntax error if `super()` used in class field (private field, arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, arrow-function, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = () => { + var t = () => super(); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-literal-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-literal-name-init-err-contains-arguments.js new file mode 100644 index 000000000..73c832eb9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-literal-name-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-private-name-nested.template +/*--- +description: Syntax error if `arguments` used in class field (ClassElementName PrivateName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + #x = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-literal-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-literal-name-init-err-contains-super.js new file mode 100644 index 000000000..ca6375aa8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-literal-name-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-private-name-nested.template +/*--- +description: Syntax error if `super()` used in class field (ClassElementName PrivateName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + #x = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-ternary-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-ternary-init-err-contains-arguments.js new file mode 100644 index 000000000..2794d87f2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-ternary-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-private-ternary-nested.template +/*--- +description: Syntax error if `arguments` used in class field (private field, ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + #x = () => true ? {} : arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-ternary-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-ternary-init-err-contains-super.js new file mode 100644 index 000000000..3e278973a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-ternary-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-private-ternary-nested.template +/*--- +description: Syntax error if `super()` used in class field (private field, ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + #x = () => true ? {} : super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-typeof-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-typeof-init-err-contains-arguments.js new file mode 100644 index 000000000..8c4b53f73 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-typeof-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-private-typeof-nested.template +/*--- +description: Syntax error if `arguments` used in class field (private field, typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + #x = () => typeof arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-typeof-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-typeof-init-err-contains-super.js new file mode 100644 index 000000000..df6cc11d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-private-typeof-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-private-typeof-nested.template +/*--- +description: Syntax error if `super()` used in class field (private field, typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + #x = () => typeof super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-comp-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-comp-name-init-err-contains-arguments.js new file mode 100644 index 000000000..496640f89 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-comp-name-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-static-comp-name-nested.template +/*--- +description: Syntax error if `arguments` used in class field (static computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public, computed-property-names] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var x = "string"; +var C = class { + static [x] = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-comp-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-comp-name-init-err-contains-super.js new file mode 100644 index 000000000..dc2217de7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-comp-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-static-comp-name-nested.template +/*--- +description: Syntax error if `super()` used in class field (static computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public, computed-property-names] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var x = "string"; +var C = class { + static [x] = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-literal-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-literal-init-err-contains-arguments.js new file mode 100644 index 000000000..51c192488 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-literal-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-static-literal-name-nested.template +/*--- +description: Syntax error if `arguments` used in class field (static literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + static x = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-literal-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-literal-init-err-contains-super.js new file mode 100644 index 000000000..0688c5d9d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-literal-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-static-literal-name-nested.template +/*--- +description: Syntax error if `super()` used in class field (static literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + static x = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-private-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-private-init-err-contains-arguments.js new file mode 100644 index 000000000..ba98f8961 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-private-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-static-private-name-nested.template +/*--- +description: Syntax error if `arguments` used in class field (static PrivateName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + static #x = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-private-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-private-init-err-contains-super.js new file mode 100644 index 000000000..acd4e1e43 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-private-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-static-private-name-nested.template +/*--- +description: Syntax error if `super()` used in class field (static PrivateName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + static #x = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-arguments.js new file mode 100644 index 000000000..36cd3ec41 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-static-string-literal-name-nested.template +/*--- +description: Syntax error if `arguments` used in class field (static string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + static 'x' = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-super.js new file mode 100644 index 000000000..28c8da09f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-static-string-literal-name-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-static-string-literal-name-nested.template +/*--- +description: Syntax error if `super()` used in class field (static string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + static 'x' = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-string-literal-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-string-literal-name-init-err-contains-arguments.js new file mode 100644 index 000000000..43d80b336 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-string-literal-name-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-string-literal-name-nested.template +/*--- +description: Syntax error if `arguments` used in class field (string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + 'x' = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-string-literal-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-string-literal-name-init-err-contains-super.js new file mode 100644 index 000000000..ffef0598c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-string-literal-name-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-string-literal-name-nested.template +/*--- +description: Syntax error if `super()` used in class field (string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + 'x' = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-ternary-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-ternary-init-err-contains-arguments.js new file mode 100644 index 000000000..68ea1ddfe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-ternary-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-ternary-nested.template +/*--- +description: Syntax error if `arguments` used in class field (ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = () => true ? {} : arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-ternary-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-ternary-init-err-contains-super.js new file mode 100644 index 000000000..7d365a86c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-ternary-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-ternary-nested.template +/*--- +description: Syntax error if `super()` used in class field (ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = () => true ? {} : super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-typeof-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-typeof-init-err-contains-arguments.js new file mode 100644 index 000000000..027a56390 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-typeof-init-err-contains-arguments.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-typeof-nested.template +/*--- +description: Syntax error if `arguments` used in class field (typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = () => typeof arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-typeof-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-typeof-init-err-contains-super.js new file mode 100644 index 000000000..f36c306cb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/nested-typeof-init-err-contains-super.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-typeof-nested.template +/*--- +description: Syntax error if `super()` used in class field (typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + +$DONOTEVALUATE(); + +var C = class { + x = () => typeof super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-arrow-fnc-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-arrow-fnc-init-err-contains-arguments.js new file mode 100644 index 000000000..02f0cf963 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-arrow-fnc-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-private-arrow-fnc.template +/*--- +description: Syntax error if `arguments` used in class field (private field, arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, arrow-function, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = () => arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-arrow-fnc-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-arrow-fnc-init-err-contains-super.js new file mode 100644 index 000000000..89cafd2ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-arrow-fnc-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-private-arrow-fnc.template +/*--- +description: Syntax error if `super()` used in class field (private field, arrow function expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, arrow-function, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = () => super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-literal-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-literal-name-init-err-contains-arguments.js new file mode 100644 index 000000000..5bfd976d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-literal-name-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-private-name.template +/*--- +description: Syntax error if `arguments` used in class field (ClassElementName PrivateName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-literal-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-literal-name-init-err-contains-super.js new file mode 100644 index 000000000..675541051 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-private-name.template +/*--- +description: Syntax error if `super()` used in class field (ClassElementName PrivateName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-ternary-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-ternary-init-err-contains-arguments.js new file mode 100644 index 000000000..5c204007e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-ternary-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-private-ternary.template +/*--- +description: Syntax error if `arguments` used in class field (private field, ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = true ? {} : arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-ternary-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-ternary-init-err-contains-super.js new file mode 100644 index 000000000..0bd64644e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-ternary-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-private-ternary.template +/*--- +description: Syntax error if `super()` used in class field (private field, ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = true ? {} : super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-typeof-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-typeof-init-err-contains-arguments.js new file mode 100644 index 000000000..7a77b47cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-typeof-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-private-typeof.template +/*--- +description: Syntax error if `arguments` used in class field (private field, typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = typeof arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-typeof-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-typeof-init-err-contains-super.js new file mode 100644 index 000000000..51fb74c82 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/private-typeof-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-private-typeof.template +/*--- +description: Syntax error if `super()` used in class field (private field, typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = typeof super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-comp-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-comp-name-init-err-contains-arguments.js new file mode 100644 index 000000000..2e3527b5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-comp-name-init-err-contains-arguments.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-static-comp-name.template +/*--- +description: Syntax error if `arguments` used in class field (static computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public, computed-property-names] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var x = "string"; +var C = class { + static [x] = arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-comp-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-comp-name-init-err-contains-super.js new file mode 100644 index 000000000..02744854c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-comp-name-init-err-contains-super.js @@ -0,0 +1,28 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-static-comp-name.template +/*--- +description: Syntax error if `super()` used in class field (static computed ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public, computed-property-names] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var x = "string"; +var C = class { + static [x] = super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-literal-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-literal-init-err-contains-arguments.js new file mode 100644 index 000000000..7cc9c62b3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-literal-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-static-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (static literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static x = arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-literal-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-literal-init-err-contains-super.js new file mode 100644 index 000000000..4236eca73 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-literal-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-static-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (static literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static x = super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-private-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-private-init-err-contains-arguments.js new file mode 100644 index 000000000..f48e79b5b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-private-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-static-private-name.template +/*--- +description: Syntax error if `arguments` used in class field (static PrivateName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static #x = arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-private-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-private-init-err-contains-super.js new file mode 100644 index 000000000..696049dc1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-private-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-static-private-name.template +/*--- +description: Syntax error if `super()` used in class field (static PrivateName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static #x = super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-string-literal-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-string-literal-name-init-err-contains-arguments.js new file mode 100644 index 000000000..d16e9ab4e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-string-literal-name-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-static-string-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (static string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static 'x' = arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-string-literal-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-string-literal-name-init-err-contains-super.js new file mode 100644 index 000000000..d443984ae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/static-string-literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-static-string-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (static string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public, class-static-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static 'x' = super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/string-literal-name-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/string-literal-name-init-err-contains-arguments.js new file mode 100644 index 000000000..ad5c5e3bb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/string-literal-name-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-string-literal-name.template +/*--- +description: Syntax error if `arguments` used in class field (string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + 'x' = arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/string-literal-name-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/string-literal-name-init-err-contains-super.js new file mode 100644 index 000000000..99b6e6c42 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/string-literal-name-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-string-literal-name.template +/*--- +description: Syntax error if `super()` used in class field (string literal ClassElementName) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + 'x' = super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-arrow-heritage.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-arrow-heritage.js new file mode 100644 index 000000000..fad926e96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-arrow-heritage.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/class-heritage-array-literal-arrow-heritage.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if an array literal evaluated on ClassHeritage uses a private name. (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassTail : ClassHeritage { ClassBody } + + ClassHeritage : + extends LeftHandSideExpression + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends () => {} { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-async-arrow-heritage.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-async-arrow-heritage.js new file mode 100644 index 000000000..2525a9c2c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/class-heritage-array-literal-async-arrow-heritage.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/class-heritage-array-literal-async-arrow-heritage.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if an array literal evaluated on ClassHeritage uses a private name. (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassTail : ClassHeritage { ClassBody } + + ClassHeritage : + extends LeftHandSideExpression + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends async () => {} { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 000000000..8ede7cbd3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName async generator (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-iteration, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete (g().#m); + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 000000000..3d6b65f85 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName async method (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-functions, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete (g().#m); + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 000000000..258431945 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName generator (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete (g().#m); + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method.js new file mode 100644 index 000000000..5f5f9f47c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private ordinary method (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete (g().#m); + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-no-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-no-reference.js new file mode 100644 index 000000000..aeee011c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-private-no-reference.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-no-reference.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName no referencing class element (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete (g().#m); + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-privatename.js new file mode 100644 index 000000000..2b3c68968 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private field (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete (g().#x); + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 000000000..3a82b19f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName async method (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-functions, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete (this.#m +); + + async #m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 000000000..1eeef9e4c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName generator (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete (this.#m +); + + *#m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method.js new file mode 100644 index 000000000..e1b2acd6a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private ordinary method (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete (this.#m +); + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-no-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-no-reference.js new file mode 100644 index 000000000..aad758e7f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-private-no-reference.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-no-reference.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName no referencing class element (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete (this.#m); + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-privatename.js new file mode 100644 index 000000000..d3b62702e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private field (in field, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete (this.#x); + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-get.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-get.js new file mode 100644 index 000000000..803bfb1b4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-get.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-accessor-get.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName accessor get method (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class-fields-public, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-set.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-set.js new file mode 100644 index 000000000..6bf506f8a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-accessor-set.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-accessor-set.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName accessor set method (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 000000000..7ee6b5cd6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName async generator (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-iteration, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async.js new file mode 100644 index 000000000..30b91bc68 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-async.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName async method (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-functions, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-gen.js new file mode 100644 index 000000000..f106ee95d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName generator (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method.js new file mode 100644 index 000000000..48ab826ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-method.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private ordinary method (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-no-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-no-reference.js new file mode 100644 index 000000000..b9c728be6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-private-no-reference.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-no-reference.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName no referencing class element (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete g().#m; + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-privatename.js new file mode 100644 index 000000000..2e155228e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-call-expression-privatename.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private field (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete g().#x; + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-get.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-get.js new file mode 100644 index 000000000..447416cd5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-get.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-accessor-get.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName accessor get method (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete this.#m +; + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-set.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-set.js new file mode 100644 index 000000000..f6e05683c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-accessor-set.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-accessor-set.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName accessor set method (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete this.#m +; + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 000000000..cccec5f44 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName async generator (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-iteration, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete this.#m +; + + async *#m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async.js new file mode 100644 index 000000000..fa891f092 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-async.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName async method (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-functions, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete this.#m +; + + async #m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-gen.js new file mode 100644 index 000000000..1ff1d34a9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName generator (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete this.#m +; + + *#m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method.js new file mode 100644 index 000000000..850d5c7bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-method.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private ordinary method (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete this.#m +; + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-no-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-no-reference.js new file mode 100644 index 000000000..81acef6f6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-private-no-reference.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-no-reference.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName no referencing class element (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete this.#m; + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-privatename.js new file mode 100644 index 000000000..0bb5693b3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-err-delete-member-expression-privatename.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private field (in field) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete this.#x; + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 000000000..ec0e7365f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName generator (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method.js new file mode 100644 index 000000000..782c8f14b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private ordinary method (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete ((g().#m)); + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-privatename.js new file mode 100644 index 000000000..55e5fd8de --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private field (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + g = this.f; + x = delete ((g().#x)); + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method.js new file mode 100644 index 000000000..c13afa8ad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private ordinary method (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete ((this.#m +)); + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-privatename.js new file mode 100644 index 000000000..3cf5819f2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/field-delete-twice-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-field-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private field (in field, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x = delete ((this.#x)); + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 000000000..97f063948 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName async generator (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-iteration, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async.js new file mode 100644 index 000000000..db862617e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-async.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName async method (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-functions, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 000000000..b82cf3670 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName generator (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method.js new file mode 100644 index 000000000..e66f68359 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private ordinary method (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-no-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-no-reference.js new file mode 100644 index 000000000..5c0ae4d37 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-private-no-reference.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-no-reference.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName no referencing class element (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#m); + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-privatename.js new file mode 100644 index 000000000..c63a79c24 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private field (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete (g().#x); + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-async.js new file mode 100644 index 000000000..0ef68a916 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-async.js @@ -0,0 +1,47 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName async method (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-functions, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete (this.#m +); + } + + async #m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-gen.js new file mode 100644 index 000000000..28b19b7be --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,47 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName generator (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete (this.#m +); + } + + *#m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method.js new file mode 100644 index 000000000..91d354cee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,47 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private ordinary method (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete (this.#m +); + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-no-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-no-reference.js new file mode 100644 index 000000000..38880ddc2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-private-no-reference.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-no-reference.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName no referencing class element (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete (this.#m); + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-privatename.js new file mode 100644 index 000000000..83fe121bd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private field (in method, covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete (this.#x); + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-get.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-get.js new file mode 100644 index 000000000..d9815d088 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-get.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-accessor-get.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName accessor get method (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class-fields-public, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-set.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-set.js new file mode 100644 index 000000000..6037f2dc5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-accessor-set.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-accessor-set.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName accessor set method (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private, class-methods-private, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async-gen.js new file mode 100644 index 000000000..1cf65b55c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async-gen.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName async generator (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-iteration, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async.js new file mode 100644 index 000000000..718ffd27d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-async.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName async method (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-functions, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-gen.js new file mode 100644 index 000000000..09d1ac0ad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName generator (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method.js new file mode 100644 index 000000000..149f201a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-method.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private ordinary method (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-no-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-no-reference.js new file mode 100644 index 000000000..85ccb27de --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-private-no-reference.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-no-reference.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName no referencing class element (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#m; + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-privatename.js new file mode 100644 index 000000000..8880ffbb6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-call-expression-privatename.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private field (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete g().#x; + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-get.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-get.js new file mode 100644 index 000000000..f1e4b5efb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-get.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-accessor-get.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName accessor get method (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-set.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-set.js new file mode 100644 index 000000000..fd224e1ef --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-accessor-set.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-accessor-set.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName accessor set method (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async-gen.js new file mode 100644 index 000000000..3c3776ba7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName async generator (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-iteration, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + async *#m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async.js new file mode 100644 index 000000000..62e5eed65 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-async.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-async.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName async method (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, async-functions, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + async #m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-gen.js new file mode 100644 index 000000000..4d9fcfe7b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method-gen.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName generator (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + *#m() {} +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method.js new file mode 100644 index 000000000..5faa840ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-method.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private ordinary method (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete this.#m +; + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-no-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-no-reference.js new file mode 100644 index 000000000..4f60ab45a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-private-no-reference.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-no-reference.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName no referencing class element (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete this.#m; + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-privatename.js new file mode 100644 index 000000000..f2935536a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-err-delete-member-expression-privatename.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private field (in method) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete this.#x; + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-gen.js new file mode 100644 index 000000000..be38248e6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method-gen.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method-gen.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName generator (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, generators, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method.js new file mode 100644 index 000000000..e97c9c4d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-private-method.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private ordinary method (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete ((g().#m)); + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-privatename.js new file mode 100644 index 000000000..9c40ddc25 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-call-expression-privatename.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-call-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to CallExpression.PrivateName private field (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + var g = this.f; + delete ((g().#x)); + } + + f() { + return this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method.js new file mode 100644 index 000000000..24ee52717 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-private-method.js @@ -0,0 +1,47 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-private-method.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private ordinary method (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class-methods-private, class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete ((this.#m +)); + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-privatename.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-privatename.js new file mode 100644 index 000000000..a2df79768 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/delete/method-delete-twice-covered-err-delete-member-expression-privatename.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/err-delete-member-expression-privatename.case +// - src/class-elements/delete-error/cls-expr-method-delete-twice-covered.template +/*--- +description: It's a SyntaxError if delete operator is applied to MemberExpression.PrivateName private field (in method, recursively covered) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + This file must never use the onlyStrict flag as the strict mode should always + be observed inside class bodies. + + Static Semantics: Early Errors + + UnaryExpression : delete UnaryExpression + + It is a Syntax Error if the UnaryExpression is contained in strict mode + code and the derived UnaryExpression is + PrimaryExpression : IdentifierReference , + MemberExpression : MemberExpression.PrivateName , or + CallExpression : CallExpression.PrivateName . + + It is a Syntax Error if the derived UnaryExpression is + PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList and + CoverParenthesizedExpressionAndArrowParameterList ultimately derives a + phrase that, if used in place of UnaryExpression, would produce a + Syntax Error according to these rules. This rule is recursively applied. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + x() { + + delete ((this.#x)); + } + + +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-class-body-ctor-duplicate.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-class-body-ctor-duplicate.js new file mode 100644 index 000000000..9f916729b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-class-body-ctor-duplicate.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-class-body-ctor-duplicate.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It is a SyntaxError if the class body has more than one constructor (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassBody : ClassElementList + It is a Syntax Error if PrototypePropertyNameList of ClassElementList contains more + than one occurrence of "constructor". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + constructor() {} + constructor() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-ctor-super-no-heritage.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-ctor-super-no-heritage.js new file mode 100644 index 000000000..969899d01 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-ctor-super-no-heritage.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-ctor-super-no-heritage.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It is a SyntaxError if class has no heritage and constructor has a direct super (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassTail : ClassHeritageopt { ClassBody } + + It is a Syntax Error if ClassHeritage is not present and the following algorithm evaluates to true: + 1. Let constructor be ConstructorMethod of ClassBody. + 2. If constructor is empty, return false. + 3. Return HasDirectSuper of constructor. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + constructor() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-ues-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-ues-error.js new file mode 100644 index 000000000..7da5846aa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-ues-error.js @@ -0,0 +1,70 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-field-identifier-invalid-ues-error.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Invalid FieldDefinition, ClassElementName, PropertyName Syntax (class expression) +esid: prod-ClassElement +features: [class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + static MethodDefinition + FieldDefinition ; + ; + + FieldDefinition : + ClassElementName Initializer _opt + + ClassElementName : + PropertyName + PrivateName + + PropertyName : + LiteralPropertyName + ComputedPropertyName + + LiteralPropertyName : + IdentifierName + StringLiteral + NumericLiteral + + IdentifierName :: + IdentifierStart + IdentifierName IdentifierPart + + IdentifierStart :: + UnicodeIDStart + $ + _ + \ UnicodeEscapeSequence + + IdentifierPart :: + UnicodeIDContinue + $ + \ UnicodeEscapeSequence + + + UnicodeIDStart :: + any Unicode code point with the Unicode property "ID_Start" + + UnicodeIDContinue :: + any Unicode code point with the Unicode property "ID_Continue" + + + NOTE 3 + The sets of code points with Unicode properties "ID_Start" and + "ID_Continue" include, respectively, the code points with Unicode + properties "Other_ID_Start" and "Other_ID_Continue". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + \u0000; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwj-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwj-error.js new file mode 100644 index 000000000..64725f09f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwj-error.js @@ -0,0 +1,70 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-field-identifier-invalid-zwj-error.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Invalid FieldDefinition, ClassElementName, PropertyName Syntax (class expression) +esid: prod-ClassElement +features: [class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + static MethodDefinition + FieldDefinition ; + ; + + FieldDefinition : + ClassElementName Initializer _opt + + ClassElementName : + PropertyName + PrivateName + + PropertyName : + LiteralPropertyName + ComputedPropertyName + + LiteralPropertyName : + IdentifierName + StringLiteral + NumericLiteral + + IdentifierName :: + IdentifierStart + IdentifierName IdentifierPart + + IdentifierStart :: + UnicodeIDStart + $ + _ + \ UnicodeEscapeSequence + + IdentifierPart :: + UnicodeIDContinue + $ + \ UnicodeEscapeSequence + + + UnicodeIDStart :: + any Unicode code point with the Unicode property "ID_Start" + + UnicodeIDContinue :: + any Unicode code point with the Unicode property "ID_Continue" + + + NOTE 3 + The sets of code points with Unicode properties "ID_Start" and + "ID_Continue" include, respectively, the code points with Unicode + properties "Other_ID_Start" and "Other_ID_Continue". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + \u200D_ZWJ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwnj-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwnj-error.js new file mode 100644 index 000000000..c37a02634 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-field-identifier-invalid-zwnj-error.js @@ -0,0 +1,70 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-field-identifier-invalid-zwnj-error.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Invalid FieldDefinition, ClassElementName, PropertyName Syntax (class expression) +esid: prod-ClassElement +features: [class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + static MethodDefinition + FieldDefinition ; + ; + + FieldDefinition : + ClassElementName Initializer _opt + + ClassElementName : + PropertyName + PrivateName + + PropertyName : + LiteralPropertyName + ComputedPropertyName + + LiteralPropertyName : + IdentifierName + StringLiteral + NumericLiteral + + IdentifierName :: + IdentifierStart + IdentifierName IdentifierPart + + IdentifierStart :: + UnicodeIDStart + $ + _ + \ UnicodeEscapeSequence + + IdentifierPart :: + UnicodeIDContinue + $ + \ UnicodeEscapeSequence + + + UnicodeIDStart :: + any Unicode code point with the Unicode property "ID_Start" + + UnicodeIDContinue :: + any Unicode code point with the Unicode property "ID_Continue" + + + NOTE 3 + The sets of code points with Unicode properties "ID_Start" and + "ID_Continue" include, respectively, the code points with Unicode + properties "Other_ID_Start" and "Other_ID_Continue". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + \u200C_ZWNJ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-fields-same-line-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-fields-same-line-error.js new file mode 100644 index 000000000..6b596446f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-fields-same-line-error.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-fields-same-line-error.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: SyntaxError (class expression) +esid: prod-ClassElement +features: [class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + static MethodDefinition + FieldDefinition ; + ; + + FieldDefinition : + ClassElementName Initializer _opt + + ClassElementName : + PropertyName + PrivateName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x y +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-array-literal.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-array-literal.js new file mode 100644 index 000000000..8c8cbae85 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-array-literal.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-private-environment-on-class-heritage-array-literal.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if an array literal evaluated on ClassHeritage uses a private name. (class expression) +esid: prod-ClassElement +features: [class-fields-private, class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Runtime Semantics: ClassDefinitionEvaluation + + ClassTail : ClassHeritage { ClassBody } + ... + 5. Let outerPrivateEnvironment be the PrivateEnvironment of the running execution context. + 6. Let classPrivateEnvironment be NewDeclarativeEnvironment(outerPrivateEnvironment). + 7. Let classPrivateEnvRec be classPrivateEnvironment's EnvironmentRecord. + 8. If ClassBodyopt is present, then + a. For each element dn of the PrivateBoundIdentifiers of ClassBodyopt, + i. Perform classPrivateEnvRec.CreateImmutableBinding(dn, true). + 9. If ClassHeritageopt is not present, then + a. Let protoParent be the intrinsic object %ObjectPrototype%. + b. Let constructorParent be the intrinsic object %FunctionPrototype%. + 10. Else, + a. Set the running execution context's LexicalEnvironment to classScope. + b. NOTE: The running execution context's PrivateEnvironment is outerPrivateEnvironment when evaluating ClassHeritage. + ... + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends (o) => [o.#foo] +{ + #foo; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-chained-usage.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-chained-usage.js new file mode 100644 index 000000000..d2188879c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-chained-usage.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-private-environment-on-class-heritage-chained-usage.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class expression evaluated on ClassHeritage uses an private name declared on subclass. (class expression) +esid: prod-ClassElement +features: [class-fields-private, class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Runtime Semantics: ClassDefinitionEvaluation + + ClassTail : ClassHeritage { ClassBody } + ... + 5. Let outerPrivateEnvironment be the PrivateEnvironment of the running execution context. + 6. Let classPrivateEnvironment be NewDeclarativeEnvironment(outerPrivateEnvironment). + 7. Let classPrivateEnvRec be classPrivateEnvironment's EnvironmentRecord. + 8. If ClassBodyopt is present, then + a. For each element dn of the PrivateBoundIdentifiers of ClassBodyopt, + i. Perform classPrivateEnvRec.CreateImmutableBinding(dn, true). + 9. If ClassHeritageopt is not present, then + a. Let protoParent be the intrinsic object %ObjectPrototype%. + b. Let constructorParent be the intrinsic object %FunctionPrototype%. + 10. Else, + a. Set the running execution context's LexicalEnvironment to classScope. + b. NOTE: The running execution context's PrivateEnvironment is outerPrivateEnvironment when evaluating ClassHeritage. + ... + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends class extends class extends class { x = this.#foo; } { #foo; x = this.#bar; } { #bar; x = this.#fuz; } +{ + #fuz; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-function-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-function-expression.js new file mode 100644 index 000000000..0b318fa8b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-function-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-private-environment-on-class-heritage-function-expression.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a function expression evaluated on ClassHeritage uses a private name. (class expression) +esid: prod-ClassElement +features: [class-fields-private, class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Runtime Semantics: ClassDefinitionEvaluation + + ClassTail : ClassHeritage { ClassBody } + ... + 5. Let outerPrivateEnvironment be the PrivateEnvironment of the running execution context. + 6. Let classPrivateEnvironment be NewDeclarativeEnvironment(outerPrivateEnvironment). + 7. Let classPrivateEnvRec be classPrivateEnvironment's EnvironmentRecord. + 8. If ClassBodyopt is present, then + a. For each element dn of the PrivateBoundIdentifiers of ClassBodyopt, + i. Perform classPrivateEnvRec.CreateImmutableBinding(dn, true). + 9. If ClassHeritageopt is not present, then + a. Let protoParent be the intrinsic object %ObjectPrototype%. + b. Let constructorParent be the intrinsic object %FunctionPrototype%. + 10. Else, + a. Set the running execution context's LexicalEnvironment to classScope. + b. NOTE: The running execution context's PrivateEnvironment is outerPrivateEnvironment when evaluating ClassHeritage. + ... + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends function() { x = this.#foo; } +{ + #foo; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-obj-literal.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-obj-literal.js new file mode 100644 index 000000000..0fcb85854 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-obj-literal.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-private-environment-on-class-heritage-obj-literal.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a object literal evaluated on ClassHeritage uses a private name. (class expression) +esid: prod-ClassElement +features: [class-fields-private, class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Runtime Semantics: ClassDefinitionEvaluation + + ClassTail : ClassHeritage { ClassBody } + ... + 5. Let outerPrivateEnvironment be the PrivateEnvironment of the running execution context. + 6. Let classPrivateEnvironment be NewDeclarativeEnvironment(outerPrivateEnvironment). + 7. Let classPrivateEnvRec be classPrivateEnvironment's EnvironmentRecord. + 8. If ClassBodyopt is present, then + a. For each element dn of the PrivateBoundIdentifiers of ClassBodyopt, + i. Perform classPrivateEnvRec.CreateImmutableBinding(dn, true). + 9. If ClassHeritageopt is not present, then + a. Let protoParent be the intrinsic object %ObjectPrototype%. + b. Let constructorParent be the intrinsic object %FunctionPrototype%. + 10. Else, + a. Set the running execution context's LexicalEnvironment to classScope. + b. NOTE: The running execution context's PrivateEnvironment is outerPrivateEnvironment when evaluating ClassHeritage. + ... + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends (o) => {x: o.#foo} +{ + #foo; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-recursive.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-recursive.js new file mode 100644 index 000000000..07f2f31d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage-recursive.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-private-environment-on-class-heritage-recursive.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class expression evaluated on ClassHeritage of a ClassHeritage uses an undeclared private name. (class expression) +esid: prod-ClassElement +features: [class-fields-private, class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Runtime Semantics: ClassDefinitionEvaluation + + ClassTail : ClassHeritage { ClassBody } + ... + 5. Let outerPrivateEnvironment be the PrivateEnvironment of the running execution context. + 6. Let classPrivateEnvironment be NewDeclarativeEnvironment(outerPrivateEnvironment). + 7. Let classPrivateEnvRec be classPrivateEnvironment's EnvironmentRecord. + 8. If ClassBodyopt is present, then + a. For each element dn of the PrivateBoundIdentifiers of ClassBodyopt, + i. Perform classPrivateEnvRec.CreateImmutableBinding(dn, true). + 9. If ClassHeritageopt is not present, then + a. Let protoParent be the intrinsic object %ObjectPrototype%. + b. Let constructorParent be the intrinsic object %FunctionPrototype%. + 10. Else, + a. Set the running execution context's LexicalEnvironment to classScope. + b. NOTE: The running execution context's PrivateEnvironment is outerPrivateEnvironment when evaluating ClassHeritage. + ... + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends class extends class { x = this.#foo; } {} +{ + #foo; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage.js new file mode 100644 index 000000000..7089a34ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-environment-on-class-heritage.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-private-environment-on-class-heritage.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class expression evaluated on ClassHeritage uses an undeclared private name. (class expression) +esid: prod-ClassElement +features: [class-fields-private, class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Runtime Semantics: ClassDefinitionEvaluation + + ClassTail : ClassHeritage { ClassBody } + ... + 5. Let outerPrivateEnvironment be the PrivateEnvironment of the running execution context. + 6. Let classPrivateEnvironment be NewDeclarativeEnvironment(outerPrivateEnvironment). + 7. Let classPrivateEnvRec be classPrivateEnvironment's EnvironmentRecord. + 8. If ClassBodyopt is present, then + a. For each element dn of the PrivateBoundIdentifiers of ClassBodyopt, + i. Perform classPrivateEnvRec.CreateImmutableBinding(dn, true). + 9. If ClassHeritageopt is not present, then + a. Let protoParent be the intrinsic object %ObjectPrototype%. + b. Let constructorParent be the intrinsic object %FunctionPrototype%. + 10. Else, + a. Set the running execution context's LexicalEnvironment to classScope. + b. NOTE: The running execution context's PrivateEnvironment is outerPrivateEnvironment when evaluating ClassHeritage. + ... + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends class { x = this.#foo; } +{ + #foo; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-field-on-object-destructuring.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-field-on-object-destructuring.js new file mode 100644 index 000000000..d83b0deda --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-field-on-object-destructuring.js @@ -0,0 +1,32 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-private-field-on-object-destructuring.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Acessing private field from object destructuring pattern is not a valid syntax (class expression) +esid: prod-ClassElement +features: [class-fields-private, destructuring-binding, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ObjectAssignmentPattern[Yield, Await]: + {} + {AssignmentRestProperty[?Yield, ?Await]} + {AssignmentPropertyList[?Yield, ?Await]} + {AssignmentPropertyList[?Yield, ?Await],AssignmentRestProperty[?Yield, ?Await]opt} + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x = 1; + + destructureX() { + const { #x: x } = this; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-field-super-access.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-field-super-access.js new file mode 100644 index 000000000..918b3ba93 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-private-field-super-access.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-private-field-super-access.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Acessing private field from super is not a valid syntax (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + MemberExpression[Yield]: + MemberExpression[?Yield].PrivateName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #m = function() { return 'test262'; }; + + Child = class extends C { + access() { + return super.#m; + } + + method() { + return super.#m(); + } + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async-gen.js new file mode 100644 index 000000000..e7a9f2315 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async-gen.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-async-gen.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private async generator and a private field with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class-fields-private, async-iteration, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #m; + async * #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async.js new file mode 100644 index 000000000..837f9bdc6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-async.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-async.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private async function and a private field with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class-fields-private, async-functions, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #m; + async #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-gen.js new file mode 100644 index 000000000..3eb788f24 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-gen.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-gen.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private generator and a private field with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class-fields-private, generators, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #m; + * #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-field.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-field.js new file mode 100644 index 000000000..d089a43ac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-field.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-get-field.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private getter and a private field with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #m; + get #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-get.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-get.js new file mode 100644 index 000000000..3331ba805 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-get-get.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-get-get.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains multiple private getters with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + get #m() {} + get #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-field.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-field.js new file mode 100644 index 000000000..8ca448d3b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-field.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-meth-field.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private method and a private field with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #m; + #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-get.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-get.js new file mode 100644 index 000000000..8bf3f2eb8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-get.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-meth-get.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private method and a private getter with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + get #m() {} + #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-meth.js new file mode 100644 index 000000000..5659455e0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-meth.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-meth-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains multiple private methods with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #m() {} + #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-set.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-set.js new file mode 100644 index 000000000..f2ecbb3c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-set.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-meth-set.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private method and a private setter with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + set #m(_) {} + #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticfield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticfield.js new file mode 100644 index 000000000..900715c75 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticfield.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-meth-staticfield.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private method and a private static field with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class-static-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static #m; + #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticmeth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticmeth.js new file mode 100644 index 000000000..6108d7b5d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-meth-staticmeth.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-meth-staticmeth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private method and a private static method with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static #m() {} + #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-field.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-field.js new file mode 100644 index 000000000..c88d2cc89 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-field.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-set-field.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains a private setter and a private field with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #m; + set #m(_) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-set.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-set.js new file mode 100644 index 000000000..f78584b9e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatemeth-duplicate-set-set.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatemeth-duplicate-set-set.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It's a SyntaxError if a class contains multiple private setters with the same name (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + ClassBody : ClassElementList + It is a Syntax Error if PrivateBoundNames of ClassBody contains any duplicate entries, unless the name is used once for a getter and once for a setter and in no other entries. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + set #m(_) {} + set #m(_) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-constructor.js new file mode 100644 index 000000000..bc71785cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-constructor.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-constructor.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Private Fields cannot be named constructor (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElementName : PrivateName ; + It is a Syntax Error if StringValue of PrivateName is "#constructor" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #constructor +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-error.js new file mode 100644 index 000000000..c2b27723a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-error.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-error.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigial and IdentifierName (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + static MethodDefinition + FieldDefinition ; + ; + + FieldDefinition : + ClassElementName Initializer _opt + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + # x +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-ues.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-ues.js new file mode 100644 index 000000000..a66d4a43c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-ues.js @@ -0,0 +1,64 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-identifier-invalid-ues.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Valid PrivateName Syntax (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + static MethodDefinition + FieldDefinition ; + ; + + FieldDefinition : + ClassElementName Initializer _opt + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + + IdentifierName :: + IdentifierStart + IdentifierName IdentifierPart + + IdentifierStart :: + UnicodeIDStart + $ + _ + \ UnicodeEscapeSequence + + IdentifierPart:: + UnicodeIDContinue + $ + \ UnicodeEscapeSequence + + + UnicodeIDStart:: + any Unicode code point with the Unicode property "ID_Start" + + UnicodeIDContinue:: + any Unicode code point with the Unicode property "ID_Continue" + + + NOTE 3 + The sets of code points with Unicode properties "ID_Start" and + "ID_Continue" include, respectively, the code points with Unicode + properties "Other_ID_Start" and "Other_ID_Continue". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #\u0000; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwj-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwj-error.js new file mode 100644 index 000000000..3dd100dfc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwj-error.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-identifier-invalid-zwj-error.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Valid PrivateName Syntax (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + static MethodDefinition + FieldDefinition ; + ; + + FieldDefinition : + ClassElementName Initializer _opt + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + + IdentifierName :: + IdentifierStart + IdentifierName IdentifierPart + + IdentifierStart :: + UnicodeIDStart + $ + _ + \ UnicodeEscapeSequence + + IdentifierPart:: + UnicodeIDContinue + $ + \ UnicodeEscapeSequence + + + UnicodeIDStart:: + any Unicode code point with the Unicode property "ID_Start" + + UnicodeIDContinue:: + any Unicode code point with the Unicode property "ID_Continue" + + + NOTE 3 + The sets of code points with Unicode properties "ID_Start" and + "ID_Continue" include, respectively, the code points with Unicode + properties "Other_ID_Start" and "Other_ID_Continue". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #\u200D_ZWJ; + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwnj-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwnj-error.js new file mode 100644 index 000000000..8dc8cc96e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-identifier-invalid-zwnj-error.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-identifier-invalid-zwnj-error.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Valid PrivateName Syntax (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + static MethodDefinition + FieldDefinition ; + ; + + FieldDefinition : + ClassElementName Initializer _opt + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + + IdentifierName :: + IdentifierStart + IdentifierName IdentifierPart + + IdentifierStart :: + UnicodeIDStart + $ + _ + \ UnicodeEscapeSequence + + IdentifierPart:: + UnicodeIDContinue + $ + \ UnicodeEscapeSequence + + + UnicodeIDStart:: + any Unicode code point with the Unicode property "ID_Start" + + UnicodeIDContinue:: + any Unicode code point with the Unicode property "ID_Continue" + + + NOTE 3 + The sets of code points with Unicode properties "ID_Start" and + "ID_Continue" include, respectively, the code points with Unicode + properties "Other_ID_Start" and "Other_ID_Continue". + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #\u200C_ZWNJ; + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-in-computed-property-missing.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-in-computed-property-missing.js new file mode 100644 index 000000000..223e4e117 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-in-computed-property-missing.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-in-computed-property-missing.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Use of undeclared PrivateName in ComputedProperty is a syntax error (class expression) +esid: prod-ClassElement +features: [class-fields-private, class-fields-public, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElementName: + PropertyName + PrivateIdentifier + + PropertyName: + LiteralPropertyName + ComputedPropertyName + + ComputedPropertyName: + [ AssignmentExpression ] + + AssignmentExpression ... MemberExpression + + MemberExpression: + MemberExpression . PrivateName + + Static Semantics: AllPrivateIdentifiersValid + AllPrivateIdentifiersValid is an abstract operation which takes names as an argument. + + MemberExpression : MemberExpression . PrivateIdentifier + 1. If StringValue of PrivateIdentifier is in names, return true. + 2. Return false. + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundIdentifiers of ClassBody. + 2. Return AllPrivateIdentifiersValid of ClassElementList with the argument newNames. + + Static Semantics: Early Errors + + ScriptBody : StatementList + It is a Syntax Error if AllPrivateIdentifiersValid of StatementList with an empty List as an argument is false unless the source code is eval code that is being processed by a direct eval. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + [this.#f] = 'Test262' +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-get-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-get-meth.js new file mode 100644 index 000000000..e1e6ca330 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-get-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-accessor-get-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName () (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + get # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-set-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-set-meth.js new file mode 100644 index 000000000..ef08b39ef --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-accessor-set-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-accessor-set-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Accessor set Method) (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + set # m(_) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-gen-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-gen-meth.js new file mode 100644 index 000000000..975657f60 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-gen-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-async-gen-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Async Generator Method) (class expression) +esid: prod-ClassElement +features: [async-iteration, class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + async * # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-meth.js new file mode 100644 index 000000000..6e8904915 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-async-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-async-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Async Method) (class expression) +esid: prod-ClassElement +features: [async-functions, class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + async # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-call-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-call-expr.js new file mode 100644 index 000000000..9a81053c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-call-expr.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-call-expr.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (CallExpression) (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + MemberExpression : + MemberExpression . PrivateName + + CallExpression : + CallExpression . PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + + f() { + return this; + } + + m() { + this.f().# x; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field-init.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field-init.js new file mode 100644 index 000000000..cadc86f39 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field-init.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-field-init.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Field with Initializer) (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + # x = 1; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field.js new file mode 100644 index 000000000..5edb526b0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-field.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-field.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Field) (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + # x; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-gen-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-gen-meth.js new file mode 100644 index 000000000..d63870c6b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-gen-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-gen-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Generator Method) (class expression) +esid: prod-ClassElement +features: [generators, class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + * # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-member-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-member-expr.js new file mode 100644 index 000000000..708780c49 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-member-expr.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-member-expr.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (MemberExpression) (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + MemberExpression : + MemberExpression . PrivateName + + CallExpression : + CallExpression . PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x; + m() { + this.# x; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-meth.js new file mode 100644 index 000000000..56dfceb54 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Method) (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-get-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-get-meth.js new file mode 100644 index 000000000..dafe8b22a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-get-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-static-accessor-get-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Static Accessor get Method) (class expression) +esid: prod-ClassElement +features: [class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static get # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-set-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-set-meth.js new file mode 100644 index 000000000..4a019e6bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-accessor-set-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-static-accessor-set-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Static Accessor set Method) (class expression) +esid: prod-ClassElement +features: [class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static set # m(_) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-gen-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-gen-meth.js new file mode 100644 index 000000000..680ff18db --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-gen-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-static-async-gen-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Static Async Generator Method) (class expression) +esid: prod-ClassElement +features: [async-iteration, class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static async * # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-meth.js new file mode 100644 index 000000000..078ff7c2b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-async-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-static-async-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Async Method) (class expression) +esid: prod-ClassElement +features: [class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static async # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field-init.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field-init.js new file mode 100644 index 000000000..1fa78e08d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field-init.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-static-field-init.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Static Field with Initializer) (class expression) +esid: prod-ClassElement +features: [class-static-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static # x = 1; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field.js new file mode 100644 index 000000000..7f4e496bd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-field.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-static-field.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Static Field) (class expression) +esid: prod-ClassElement +features: [class-static-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static # x; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-gen-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-gen-meth.js new file mode 100644 index 000000000..0f9b374c4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-gen-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-static-gen-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Static Generator Method) (class expression) +esid: prod-ClassElement +features: [generators, class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static * # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-meth.js new file mode 100644 index 000000000..cc7e1baff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatename-whitespace-error-static-meth.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatename-whitespace-error-static-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: No space allowed between sigil and IdentifierName (Static Method) (class expression) +esid: prod-ClassElement +features: [class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Updated Productions + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static # m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatenames-same-line-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatenames-same-line-error.js new file mode 100644 index 000000000..160af4f8a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-privatenames-same-line-error.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-privatenames-same-line-error.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: SyntaxError (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + static MethodDefinition + FieldDefinition ; + ; + + FieldDefinition : + ClassElementName Initializer _opt + + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + #x #y +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async-gen.js new file mode 100644 index 000000000..dea922ed7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async-gen.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-async-gen.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Async Generator Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [async-iteration, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + async * method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async.js new file mode 100644 index 000000000..2165ce99d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-async.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-async.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Async Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [async-functions, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + async method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-gen.js new file mode 100644 index 000000000..f5491a0fc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-gen.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-gen.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Generator Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [generators, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + * method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-get.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-get.js new file mode 100644 index 000000000..263650daf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-get.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-get.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Accessor get Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + get method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-method.js new file mode 100644 index 000000000..fcca09668 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-method.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-method.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async-gen.js new file mode 100644 index 000000000..9052ae871 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async-gen.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-private-async-gen.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Private Async Generators Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [async-iteration, class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + async * #method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async.js new file mode 100644 index 000000000..3a127ac55 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-async.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-private-async.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Private Async Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [async-functions, class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + async #method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-gen.js new file mode 100644 index 000000000..ad7d10442 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-gen.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-private-gen.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Private Generators Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [generators, class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + * #method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-method.js new file mode 100644 index 000000000..3ae853309 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-private-method.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-private-method.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Private Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + #method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-set.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-set.js new file mode 100644 index 000000000..b44b1afd0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-contains-super-set.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-contains-super-set.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Accessor set Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is not "constructor" and HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + set method(_) { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-gen.js new file mode 100644 index 000000000..583608d1a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-gen.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-ctor-async-gen.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Async Generator Methods cannot be named "constructor" (class expression) +esid: prod-ClassElement +features: [async-iteration, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "constructor" and SpecialMethod of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + async * constructor() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-meth.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-meth.js new file mode 100644 index 000000000..0d224848b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-async-meth.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-ctor-async-meth.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Async Methods cannot be named "constructor" (class expression) +esid: prod-ClassElement +features: [async-functions, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "constructor" and SpecialMethod of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + async constructor() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-gen.js new file mode 100644 index 000000000..21f372592 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-gen.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-ctor-gen.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Generator Methods cannot be named "constructor" (class expression) +esid: prod-ClassElement +features: [generators, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "constructor" and SpecialMethod of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + * constructor() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-get.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-get.js new file mode 100644 index 000000000..28e3b6320 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-get.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-ctor-get.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Accessor get Methods cannot be named "constructor" (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "constructor" and SpecialMethod of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + get constructor() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-set.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-set.js new file mode 100644 index 000000000..41cdab161 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-special-meth-ctor-set.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-special-meth-ctor-set.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Accessor set Methods cannot be named "constructor" (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "constructor" and SpecialMethod of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + set constructor(_) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-prototype.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-prototype.js new file mode 100644 index 000000000..9bb774f09 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-prototype.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-async-gen-meth-prototype.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Async Generator Methods cannot be named prototype (class expression) +esid: prod-ClassElement +features: [async-iteration, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "prototype" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static async * prototype() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-super.js new file mode 100644 index 000000000..6e64d4432 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-gen-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-async-gen-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Async Generator Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [async-iteration, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static async * method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-prototype.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-prototype.js new file mode 100644 index 000000000..625e490b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-prototype.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-async-meth-prototype.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Async Methods cannot be named prototype (class expression) +esid: prod-ClassElement +features: [async-functions, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "prototype" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static async prototype() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-super.js new file mode 100644 index 000000000..5570a1b1e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-async-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-async-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Async Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [async-functions, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static async method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-prototype.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-prototype.js new file mode 100644 index 000000000..9de068e20 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-prototype.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-gen-meth-prototype.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Generator Methods cannot be named prototype (class expression) +esid: prod-ClassElement +features: [generators, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "prototype" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static * prototype() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-super.js new file mode 100644 index 000000000..0e6daa732 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-gen-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-gen-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Generator Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [generators, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static * method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-prototype.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-prototype.js new file mode 100644 index 000000000..fa426754b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-prototype.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-get-meth-prototype.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Accessor get Methods cannot be named prototype (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "prototype" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static get prototype() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-super.js new file mode 100644 index 000000000..2754ebdd2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-get-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-get-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Accessor get Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static get method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-meth-prototype.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-meth-prototype.js new file mode 100644 index 000000000..03e540020 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-meth-prototype.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-meth-prototype.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Methods cannot be named prototype (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "prototype" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static prototype() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-meth-super.js new file mode 100644 index 000000000..d66700ca0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-constructor.js new file mode 100644 index 000000000..8e17609b9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-constructor.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-private-async-gen-meth-constructor.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Async Generator Private Methods cannot be named constructor (class expression) +esid: prod-ClassElement +features: [async-iteration, class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElementName : PrivateName ; + It is a Syntax Error if StringValue of PrivateName is "#constructor" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static async * #constructor() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-super.js new file mode 100644 index 000000000..64bd0cc1e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-gen-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-private-async-gen-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Async Generator Private Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [async-iteration, class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static async * #method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-constructor.js new file mode 100644 index 000000000..6e3798285 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-constructor.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-private-async-meth-constructor.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Async Private Methods cannot be named constructor (class expression) +esid: prod-ClassElement +features: [async-functions, class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElementName : PrivateName ; + It is a Syntax Error if StringValue of PrivateName is "#constructor" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static async #constructor() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-super.js new file mode 100644 index 000000000..558e55f0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-async-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-private-async-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Async Private Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [async-functions, class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static async #method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-constructor.js new file mode 100644 index 000000000..e903bf844 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-constructor.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-private-gen-meth-constructor.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Generator Private Methods cannot be named constructor (class expression) +esid: prod-ClassElement +features: [generators, class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElementName : PrivateName ; + It is a Syntax Error if StringValue of PrivateName is "#constructor" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static * #constructor() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-super.js new file mode 100644 index 000000000..b5b60939f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-gen-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-private-gen-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Generator Private Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [generators, class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static * #method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-constructor.js new file mode 100644 index 000000000..f4d795c43 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-constructor.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-private-meth-constructor.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Private Methods cannot be named constructor (class expression) +esid: prod-ClassElement +features: [class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElementName : PrivateName ; + It is a Syntax Error if StringValue of PrivateName is "#constructor" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static #constructor() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-super.js new file mode 100644 index 000000000..06c84fb86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-private-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-private-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Private Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [class-static-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static #method() { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-privatename-constructor.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-privatename-constructor.js new file mode 100644 index 000000000..fe40793ad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-privatename-constructor.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-privatename-constructor.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Private Fields cannot be named constructor (class expression) +esid: prod-ClassElement +features: [class-static-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElementName : PrivateName ; + It is a Syntax Error if StringValue of PrivateName is "#constructor" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static #constructor +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-prototype.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-prototype.js new file mode 100644 index 000000000..bbef49e79 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-prototype.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-set-meth-prototype.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Accessor set Methods cannot be named prototype (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if PropName of MethodDefinition is "prototype" + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + static set prototype(_) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-super.js new file mode 100644 index 000000000..93a666347 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/grammar-static-set-meth-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/grammar-static-set-meth-super.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: Static Accessor set Methods cannot contain direct super (class expression) +esid: prod-ClassElement +features: [class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Class Definitions / Static Semantics: Early Errors + + ClassElement : static MethodDefinition + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends Function{ + static set method(_) { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-bad-reference.js new file mode 100644 index 000000000..11be1d59e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-bad-reference.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-field-initializer.template +/*--- +description: bad reference in call expression (Invalid private names should throw a SyntaxError, class field initializer in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + f = (() => {})().#x +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-this.js new file mode 100644 index 000000000..e412b9992 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-call-expression-this.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-this.case +// - src/invalid-private-names/default/cls-expr-field-initializer.template +/*--- +description: this evaluated in call expression (Invalid private names should throw a SyntaxError, class field initializer in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + f = (() => this)().#x +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-bad-reference.js new file mode 100644 index 000000000..354b27ddc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-bad-reference.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-field-initializer-fn.template +/*--- +description: bad reference in call expression (Invalid private names should throw a SyntaxError, function in class field initializer in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + f = function() { (() => {})().#x } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-this.js new file mode 100644 index 000000000..6741392a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-call-expression-this.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-this.case +// - src/invalid-private-names/default/cls-expr-field-initializer-fn.template +/*--- +description: this evaluated in call expression (Invalid private names should throw a SyntaxError, function in class field initializer in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + f = function() { (() => this)().#x } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-bad-reference.js new file mode 100644 index 000000000..140c8805b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-bad-reference.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-field-initializer-fn.template +/*--- +description: bad reference in member expression (Invalid private names should throw a SyntaxError, function in class field initializer in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + f = function() { something.#x } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-this.js new file mode 100644 index 000000000..9eb100094 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-fn-member-expression-this.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-this.case +// - src/invalid-private-names/default/cls-expr-field-initializer-fn.template +/*--- +description: this reference in member expression (Invalid private names should throw a SyntaxError, function in class field initializer in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + f = function() { this.#x } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-bad-reference.js new file mode 100644 index 000000000..3812ab0e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-bad-reference.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-field-initializer-heritage.template +/*--- +description: bad reference in call expression (Invalid private names should throw a SyntaxError, field initializer in inner class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +class Parent { + #x = 42; +} + +var C = class extends Parent { + f = (() => {})().#x +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-this.js new file mode 100644 index 000000000..f1386b079 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-call-expression-this.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-this.case +// - src/invalid-private-names/default/cls-expr-field-initializer-heritage.template +/*--- +description: this evaluated in call expression (Invalid private names should throw a SyntaxError, field initializer in inner class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +class Parent { + #x = 42; +} + +var C = class extends Parent { + f = (() => this)().#x +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-bad-reference.js new file mode 100644 index 000000000..27a6dacec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-bad-reference.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-field-initializer-heritage.template +/*--- +description: bad reference in member expression (Invalid private names should throw a SyntaxError, field initializer in inner class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +class Parent { + #x = 42; +} + +var C = class extends Parent { + f = something.#x +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-this.js new file mode 100644 index 000000000..9eb4ee3b4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-heritage-member-expression-this.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-this.case +// - src/invalid-private-names/default/cls-expr-field-initializer-heritage.template +/*--- +description: this reference in member expression (Invalid private names should throw a SyntaxError, field initializer in inner class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +class Parent { + #x = 42; +} + +var C = class extends Parent { + f = this.#x +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-bad-reference.js new file mode 100644 index 000000000..da219eccd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-bad-reference.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-field-initializer.template +/*--- +description: bad reference in member expression (Invalid private names should throw a SyntaxError, class field initializer in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + f = something.#x +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-this.js new file mode 100644 index 000000000..66cca83e2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/field-init-member-expression-this.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-this.case +// - src/invalid-private-names/default/cls-expr-field-initializer.template +/*--- +description: this reference in member expression (Invalid private names should throw a SyntaxError, class field initializer in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + f = this.#x +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-bad-reference.js new file mode 100644 index 000000000..d4e0e5820 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-bad-reference.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-method.template +/*--- +description: bad reference in call expression (Invalid private names should throw a SyntaxError, method in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { (() => {})().#x } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-this.js new file mode 100644 index 000000000..3686d2abd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-call-expression-this.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-this.case +// - src/invalid-private-names/default/cls-expr-method.template +/*--- +description: this evaluated in call expression (Invalid private names should throw a SyntaxError, method in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { (() => this)().#x } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-bad-reference.js new file mode 100644 index 000000000..7833668c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-bad-reference.js @@ -0,0 +1,54 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-method-fn.template +/*--- +description: bad reference in call expression (Invalid private names should throw a SyntaxError, inner function in method in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { + function fn() { (() => {})().#x } + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-this.js new file mode 100644 index 000000000..7168b6ab9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-call-expression-this.js @@ -0,0 +1,54 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-this.case +// - src/invalid-private-names/default/cls-expr-method-fn.template +/*--- +description: this evaluated in call expression (Invalid private names should throw a SyntaxError, inner function in method in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { + function fn() { (() => this)().#x } + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-bad-reference.js new file mode 100644 index 000000000..86e68c10a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-bad-reference.js @@ -0,0 +1,54 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-method-fn.template +/*--- +description: bad reference in member expression (Invalid private names should throw a SyntaxError, inner function in method in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { + function fn() { something.#x } + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-this.js new file mode 100644 index 000000000..93b977005 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-fn-member-expression-this.js @@ -0,0 +1,54 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-this.case +// - src/invalid-private-names/default/cls-expr-method-fn.template +/*--- +description: this reference in member expression (Invalid private names should throw a SyntaxError, inner function in method in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { + function fn() { this.#x } + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-bad-reference.js new file mode 100644 index 000000000..823bed9f6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-bad-reference.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-method-heritage.template +/*--- +description: bad reference in call expression (Invalid private names should throw a SyntaxError, method in inner class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +class Parent { + #x = 42; +} + +var C = class extends Parent { + m() { + (() => {})().#x + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-this.js new file mode 100644 index 000000000..c4f35c61a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-call-expression-this.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-this.case +// - src/invalid-private-names/default/cls-expr-method-heritage.template +/*--- +description: this evaluated in call expression (Invalid private names should throw a SyntaxError, method in inner class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +class Parent { + #x = 42; +} + +var C = class extends Parent { + m() { + (() => this)().#x + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-bad-reference.js new file mode 100644 index 000000000..b010cf3ec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-bad-reference.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-method-heritage.template +/*--- +description: bad reference in member expression (Invalid private names should throw a SyntaxError, method in inner class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +class Parent { + #x = 42; +} + +var C = class extends Parent { + m() { + something.#x + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-this.js new file mode 100644 index 000000000..6383a205f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-heritage-member-expression-this.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-this.case +// - src/invalid-private-names/default/cls-expr-method-heritage.template +/*--- +description: this reference in member expression (Invalid private names should throw a SyntaxError, method in inner class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +class Parent { + #x = 42; +} + +var C = class extends Parent { + m() { + this.#x + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-bad-reference.js new file mode 100644 index 000000000..74aeab12d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-bad-reference.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-method.template +/*--- +description: bad reference in member expression (Invalid private names should throw a SyntaxError, method in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { something.#x } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-this.js new file mode 100644 index 000000000..e21e1b640 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-member-expression-this.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-this.case +// - src/invalid-private-names/default/cls-expr-method.template +/*--- +description: this reference in member expression (Invalid private names should throw a SyntaxError, method in class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { this.#x } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-bad-reference.js new file mode 100644 index 000000000..7841fdec3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-bad-reference.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-outter-method.template +/*--- +description: bad reference in call expression (Invalid private names should throw a SyntaxError, method in outter class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { + class Outter { + #x = 42; + } + + this.#x; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-this.js new file mode 100644 index 000000000..b27fef5cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-call-expression-this.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-this.case +// - src/invalid-private-names/default/cls-expr-outter-method.template +/*--- +description: this evaluated in call expression (Invalid private names should throw a SyntaxError, method in outter class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { + class Outter { + #x = 42; + } + + this.#x; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-bad-reference.js new file mode 100644 index 000000000..d2338248e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-bad-reference.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-bad-reference.case +// - src/invalid-private-names/default/cls-expr-outter-method.template +/*--- +description: bad reference in member expression (Invalid private names should throw a SyntaxError, method in outter class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { + class Outter { + #x = 42; + } + + this.#x; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-this.js new file mode 100644 index 000000000..789225a68 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/invalid-names/method-outter-member-expression-this.js @@ -0,0 +1,58 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-this.case +// - src/invalid-private-names/default/cls-expr-outter-method.template +/*--- +description: this reference in member expression (Invalid private names should throw a SyntaxError, method in outter class expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + Static Semantics: AllPrivateNamesValid + + ClassBody : ClassElementList + 1. Let newNames be the concatenation of names with PrivateBoundNames of ClassBody. + 2. Return AllPrivateNamesValid of ClassElementList with the argument newNames. + + For all other grammatical productions, recurse on subexpressions/substatements, + passing in the names of the caller. If all pieces return true, then return true. + If any returns false, return false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + m() { + class Outter { + #x = 42; + } + + this.#x; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-async-generator-cannot-escape-token.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-async-generator-cannot-escape-token.js new file mode 100644 index 000000000..c66aa3617 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-async-generator-cannot-escape-token.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-async-generator-cannot-escape-token.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: The pound signal in the private async generator cannot be escaped (class expression) +esid: prod-ClassElement +features: [class-methods-private, async-iteration, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + PrivateName:: + # IdentifierName + + U+0023 is the escape sequence for # + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + async * \u0023m() { return 42; } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-async-method-cannot-escape-token.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-async-method-cannot-escape-token.js new file mode 100644 index 000000000..f700528b8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-async-method-cannot-escape-token.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-async-method-cannot-escape-token.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: The pound signal in the private async method cannot be escaped (class expression) +esid: prod-ClassElement +features: [class-methods-private, async-functions, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + PrivateName:: + # IdentifierName + + U+0023 is the escape sequence for # + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + async \u0023m() { return 42; } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-call-exp-cannot-escape-token.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-call-exp-cannot-escape-token.js new file mode 100644 index 000000000..7512b356c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-call-exp-cannot-escape-token.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-call-exp-cannot-escape-token.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: The pound signal in the private reference cannot be escaped (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + PrivateName :: + # IdentifierName + + MemberExpression : + MemberExpression . PrivateName + + CallExpression : + CallExpression . PrivateName + + U+0023 is the escape sequence for # + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + method() { + foo().\u0023field; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-field-cannot-escape-token.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-field-cannot-escape-token.js new file mode 100644 index 000000000..aed2813d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-field-cannot-escape-token.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-field-cannot-escape-token.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: The pound signal in the private field cannot be escaped (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + PrivateName:: + # IdentifierName + + U+0023 is the escape sequence for # + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + \u0023field; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-generator-cannot-escape-token.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-generator-cannot-escape-token.js new file mode 100644 index 000000000..532af4c10 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-generator-cannot-escape-token.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-generator-cannot-escape-token.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: The pound signal in the private generator cannot be escaped (class expression) +esid: prod-ClassElement +features: [class-methods-private, generators, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + PrivateName:: + # IdentifierName + + U+0023 is the escape sequence for # + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + * \u0023m() { return 42; } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-member-exp-cannot-escape-token.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-member-exp-cannot-escape-token.js new file mode 100644 index 000000000..fd92406a4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-member-exp-cannot-escape-token.js @@ -0,0 +1,33 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-member-exp-cannot-escape-token.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: The pound signal in the private reference cannot be escaped (class expression) +esid: prod-ClassElement +features: [class-fields-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + PrivateName :: + # IdentifierName + + MemberExpression : + MemberExpression . PrivateName + + CallExpression : + CallExpression . PrivateName + + U+0023 is the escape sequence for # + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + method() { + this.\u0023field; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-method-cannot-escape-token.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-method-cannot-escape-token.js new file mode 100644 index 000000000..966012a5d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/private-method-cannot-escape-token.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/private-method-cannot-escape-token.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: The pound signal in the private method cannot be escaped (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + PrivateName:: + # IdentifierName + + U+0023 is the escape sequence for # + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + \u0023m() { return 42; } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/super-private-access-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/super-private-access-invalid.js new file mode 100644 index 000000000..44fa77756 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/syntax/early-errors/super-private-access-invalid.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/super-private-access-invalid.case +// - src/class-elements/syntax/invalid/cls-expr-elements-invalid-syntax.template +/*--- +description: It is syntax error if PrivateName IdentifierName is accessed on SuperProperty (class expression) +esid: prod-ClassElement +features: [class-methods-private, class] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElementName : + PropertyName + PrivateName + + PrivateName :: + # IdentifierName + + SuperProperty: + super[Expression] + super.IdentifierName + +---*/ + + +$DONOTEVALUATE(); + +var C = class extends B +{ + #x() {} + + method() { + super.#x(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/ternary-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/ternary-init-err-contains-arguments.js new file mode 100644 index 000000000..1b6650af5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/ternary-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-ternary.template +/*--- +description: Syntax error if `arguments` used in class field (ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = true ? {} : arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/ternary-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/ternary-init-err-contains-super.js new file mode 100644 index 000000000..b812bbee3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/ternary-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-ternary.template +/*--- +description: Syntax error if `super()` used in class field (ternary expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = true ? {} : super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/typeof-init-err-contains-arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/typeof-init-err-contains-arguments.js new file mode 100644 index 000000000..be45a5597 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/typeof-init-err-contains-arguments.js @@ -0,0 +1,34 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-arguments.case +// - src/class-elements/initializer-error/cls-expr-fields-typeof.template +/*--- +description: Syntax error if `arguments` used in class field (typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if ContainsArguments of Initializer is true. + + Static Semantics: ContainsArguments + IdentifierReference : Identifier + + 1. If the StringValue of Identifier is "arguments", return true. + ... + For all other grammatical productions, recurse on all nonterminals. If any piece returns true, then return true. Otherwise return false. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = typeof arguments; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/typeof-init-err-contains-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/typeof-init-err-contains-super.js new file mode 100644 index 000000000..f2ac2cd61 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/elements/typeof-init-err-contains-super.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/class-elements/init-err-contains-super.case +// - src/class-elements/initializer-error/cls-expr-fields-typeof.template +/*--- +description: Syntax error if `super()` used in class field (typeof expression) +esid: sec-class-definitions-static-semantics-early-errors +features: [class, class-fields-public] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Static Semantics: Early Errors + + FieldDefinition: + PropertyNameInitializeropt + + - It is a Syntax Error if Initializer is present and Initializer Contains SuperCall is true. + +---*/ + + +$DONOTEVALUATE(); + +var C = class { + x = typeof super(); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-param-dflt-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-param-dflt-yield.js new file mode 100644 index 000000000..9df05c656 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-param-dflt-yield.js @@ -0,0 +1,27 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-generator-function-definitions +es6id: 14.4 +description: > + YieldExpression cannot be used within the FormalParameters of a generator + function +info: | + GeneratorMethod[Yield]: + + * PropertyName[?Yield] ( StrictFormalParameters[Yield] ) { GeneratorBody } + + YieldExpression cannot be used within the FormalParameters of a generator + function because any expressions that are part of FormalParameters are + evaluated before the resulting generator object is in a resumable state. +features: [generators, default-parameters] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, class { + *g(x = yield) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..ed26e2e69 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/array-destructuring-param-strict-body.js @@ -0,0 +1,158 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-gen-meth-static.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + static *method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/dflt-params-duplicates.js new file mode 100644 index 000000000..ce82db720 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/dflt-params-duplicates.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/cls-expr-gen-meth-static.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, class { + static *method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/dflt-params-rest.js new file mode 100644 index 000000000..50d13109d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/dflt-params-rest.js @@ -0,0 +1,91 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/cls-expr-gen-meth-static.template +/*--- +description: RestParameter does not support an initializer (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, class { + static *method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..0385ea14b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/object-destructuring-param-strict-body.js @@ -0,0 +1,158 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-gen-meth-static.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + static *method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/rest-param-strict-body.js new file mode 100644 index 000000000..807d0c8ec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/rest-param-strict-body.js @@ -0,0 +1,158 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/cls-expr-gen-meth-static.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + static *method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..dfbf4eeed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/rest-params-trailing-comma-early-error.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/cls-expr-gen-meth-static.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (static class expression generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, class { + static *method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..126e14b0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-binding-identifier-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier-escaped.case +// - src/generators/syntax/class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *gen() { + var yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-binding-identifier.js new file mode 100644 index 000000000..d52504105 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-binding-identifier.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier.case +// - src/generators/syntax/class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Static generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *gen() { + var yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..e3ffa3bb7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-identifier-reference-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference-escaped.case +// - src/generators/syntax/class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *gen() { + void yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-identifier-reference.js new file mode 100644 index 000000000..b6680e837 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-identifier-reference.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference.case +// - src/generators/syntax/class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Static generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *gen() { + void yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..026174cbc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-label-identifier-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier-escaped.case +// - src/generators/syntax/class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *gen() { + yi\u0065ld: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-label-identifier.js new file mode 100644 index 000000000..bd76f9365 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-as-label-identifier.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier.case +// - src/generators/syntax/class-expr-static-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Static generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class { static *gen() { + yield: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-identifier-spread-strict.js new file mode 100644 index 000000000..6974c5231 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-identifier-spread-strict.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-spread-strict.case +// - src/generators/default/class-expr-static-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Static generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [object-spread, generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var C = class { static *gen() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } +}} + +var gen = C.gen; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-identifier-strict.js new file mode 100644 index 000000000..ccc5d97a1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method-static/yield-identifier-strict.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-strict.case +// - src/generators/default/class-expr-static-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Static generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + static MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var C = class { static *gen() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) +}} + +var gen = C.gen; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..c618eacb7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/array-destructuring-param-strict-body.js @@ -0,0 +1,158 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-gen-meth.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + *method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/dflt-params-duplicates.js new file mode 100644 index 000000000..122f24597 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/dflt-params-duplicates.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/cls-expr-gen-meth.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, class { + *method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/dflt-params-rest.js new file mode 100644 index 000000000..5a764c841 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/dflt-params-rest.js @@ -0,0 +1,91 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/cls-expr-gen-meth.template +/*--- +description: RestParameter does not support an initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, class { + *method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..3c0b376f3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/object-destructuring-param-strict-body.js @@ -0,0 +1,158 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-gen-meth.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + *method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/rest-param-strict-body.js new file mode 100644 index 000000000..c1588b713 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/rest-param-strict-body.js @@ -0,0 +1,158 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/cls-expr-gen-meth.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + *method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..90d4922f1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/rest-params-trailing-comma-early-error.js @@ -0,0 +1,84 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/cls-expr-gen-meth.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.4.13 Runtime Semantics: PropertyDefinitionEvaluation + + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, class { + *method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..589594148 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-binding-identifier-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier-escaped.case +// - src/generators/syntax/class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*gen() { + var yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-binding-identifier.js new file mode 100644 index 000000000..85d32ef32 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-binding-identifier.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier.case +// - src/generators/syntax/class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*gen() { + var yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..67322b052 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-identifier-reference-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference-escaped.case +// - src/generators/syntax/class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*gen() { + void yi\u0065ld; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-identifier-reference.js new file mode 100644 index 000000000..c4b364e74 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-identifier-reference.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference.case +// - src/generators/syntax/class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*gen() { + void yield; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..f55de9edf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-label-identifier-escaped.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier-escaped.case +// - src/generators/syntax/class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*gen() { + yi\u0065ld: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-label-identifier.js new file mode 100644 index 000000000..aacecafb4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-as-label-identifier.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier.case +// - src/generators/syntax/class-expr-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var C = class {*gen() { + yield: ; +}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-identifier-spread-strict.js new file mode 100644 index 000000000..2a78953d0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-identifier-spread-strict.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-spread-strict.case +// - src/generators/default/class-expr-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [object-spread, generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var C = class {*gen() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } +}} + +var gen = C.prototype.gen; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-identifier-strict.js new file mode 100644 index 000000000..6bc1bc3ac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/gen-method/yield-identifier-strict.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-strict.case +// - src/generators/default/class-expr-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Generator method as a ClassExpression element) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + ClassElement : + MethodDefinition + + MethodDefinition : + GeneratorMethod + + 14.4 Generator Function Definitions + + GeneratorMethod : + * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var C = class {*gen() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) +}} + +var gen = C.prototype.gen; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/getter-param-dflt.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/getter-param-dflt.js new file mode 100644 index 000000000..2c3a642b7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/getter-param-dflt.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-method-definitions +es6id: 14.3 +description: > + Get accessor method may not have a formal parameter (regardless of the + presence of an initializer) +info: | + Syntax + + MethodDefinition[Yield] : + + get PropertyName[?Yield] ( ) { FunctionBody } +features: [default-parameters] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, class { get a(param = null) {} }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-param-dflt-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-param-dflt-yield.js new file mode 100644 index 000000000..b99266f02 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-param-dflt-yield.js @@ -0,0 +1,22 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-method-definitions +es6id: 14.3 +description: > + YieldExpression cannot be used within the FormalParameters of a class method +info: | + MethodDefinition[Yield] : + + PropertyName[?Yield] ( StrictFormalParameters ) { FunctionBody } +features: [generators, default-parameters] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, class { + m(x = yield) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..f8404f411 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/array-destructuring-param-strict-body.js @@ -0,0 +1,154 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-meth-static.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + static method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/dflt-params-duplicates.js new file mode 100644 index 000000000..f64027fb6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/dflt-params-duplicates.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/cls-expr-meth-static.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, class { + static method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/dflt-params-rest.js new file mode 100644 index 000000000..653b82a45 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/dflt-params-rest.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/cls-expr-meth-static.template +/*--- +description: RestParameter does not support an initializer (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, class { + static method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..98fe3fa2a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/object-destructuring-param-strict-body.js @@ -0,0 +1,154 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-meth-static.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + static method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/rest-param-strict-body.js new file mode 100644 index 000000000..dafb48ad5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/rest-param-strict-body.js @@ -0,0 +1,154 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/cls-expr-meth-static.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + static method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..a067eca6a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method-static/rest-params-trailing-comma-early-error.js @@ -0,0 +1,79 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/cls-expr-meth-static.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (static class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, class { + static method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..ee95dc4e4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/array-destructuring-param-strict-body.js @@ -0,0 +1,154 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-meth.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/dflt-params-duplicates.js new file mode 100644 index 000000000..0ef3d191a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/dflt-params-duplicates.js @@ -0,0 +1,83 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/cls-expr-meth.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, class { + method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/dflt-params-rest.js new file mode 100644 index 000000000..9b42a970c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/dflt-params-rest.js @@ -0,0 +1,87 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/cls-expr-meth.template +/*--- +description: RestParameter does not support an initializer (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, class { + method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..d926a6740 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/object-destructuring-param-strict-body.js @@ -0,0 +1,154 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/cls-expr-meth.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/rest-param-strict-body.js new file mode 100644 index 000000000..bc76f2cc3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/rest-param-strict-body.js @@ -0,0 +1,154 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/cls-expr-meth.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, class { + method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..9ab7e276e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/method/rest-params-trailing-comma-early-error.js @@ -0,0 +1,79 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/cls-expr-meth.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + 14.3.8 Runtime Semantics: DefineMethod + + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, FunctionBody, + scope, strict). If functionPrototype was passed as a parameter then pass its + value as the functionPrototype optional argument of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, class { + method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/static-gen-method-param-dflt-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/static-gen-method-param-dflt-yield.js new file mode 100644 index 000000000..249eefec3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/static-gen-method-param-dflt-yield.js @@ -0,0 +1,27 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-generator-function-definitions +es6id: 14.4 +description: > + YieldExpression cannot be used within the FormalParameters of a generator + function +info: | + GeneratorMethod[Yield]: + + * PropertyName[?Yield] ( StrictFormalParameters[Yield] ) { GeneratorBody } + + YieldExpression cannot be used within the FormalParameters of a generator + function because any expressions that are part of FormalParameters are + evaluated before the resulting generator object is in a resumable state. +features: [generators, default-parameters] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, class { + static *g(x = yield) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/static-init-await-binding.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/static-init-await-binding.js new file mode 100644 index 000000000..c99b04c55 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/static-init-await-binding.js @@ -0,0 +1,23 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-class-definitions-static-semantics-early-errors +description: The `await` keyword is disallowed as a BindingIdentifier +info: | + ClassStaticBlockBody : ClassStaticBlockStatementList + + [...] + - It is a Syntax Error if ContainsAwait of ClassStaticBlockStatementList is true. +features: [class-static-block] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +class C { + static { + (class await {}); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/static-method-param-dflt-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/static-method-param-dflt-yield.js new file mode 100644 index 000000000..bfc9714d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/class/static-method-param-dflt-yield.js @@ -0,0 +1,22 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-method-definitions +es6id: 14.3 +description: > + YieldExpression cannot be used within the FormalParameters of a class method +info: | + MethodDefinition[Yield] : + + PropertyName[?Yield] ( StrictFormalParameters ) { FunctionBody } +features: [generators, default-parameters] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, class { + static m(x = yield) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-head-with-logical-and.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-head-with-logical-and.js new file mode 100644 index 000000000..de17de9f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-head-with-logical-and.js @@ -0,0 +1,31 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Cannot immediately contain, or be contained within, an && or || operation. +esid: sec-conditional-operator +info: | + ConditionalExpression : + ShortCircuitExpression + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + + ShortCircuitExpression : + LogicalORExpression + CoalesceExpression + + CoalesceExpression : + CoalesceExpressionHead ?? BitwiseORExpression + + CoalesceExpressionHead : + CoalesceExpression + BitwiseORExpression +features: [coalesce-expression] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0 && 0 ?? true; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-head-with-logical-or.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-head-with-logical-or.js new file mode 100644 index 000000000..de9ff3fff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-head-with-logical-or.js @@ -0,0 +1,31 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Cannot immediately contain, or be contained within, an && or || operation. +esid: sec-conditional-operator +info: | + ConditionalExpression : + ShortCircuitExpression + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + + ShortCircuitExpression : + LogicalORExpression + CoalesceExpression + + CoalesceExpression : + CoalesceExpressionHead ?? BitwiseORExpression + + CoalesceExpressionHead : + CoalesceExpression + BitwiseORExpression +features: [coalesce-expression] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0 || 0 ?? true; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-tail-with-logical-and.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-tail-with-logical-and.js new file mode 100644 index 000000000..a279608cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-tail-with-logical-and.js @@ -0,0 +1,32 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + If the CoalesceExpressionHead is undefined or null, follow return the right-side value. + Otherwise, return the left-side value. +esid: sec-conditional-operator +info: | + ConditionalExpression : + ShortCircuitExpression + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + + ShortCircuitExpression : + LogicalORExpression + CoalesceExpression + + CoalesceExpression : + CoalesceExpressionHead ?? BitwiseORExpression + + CoalesceExpressionHead : + CoalesceExpression + BitwiseORExpression +features: [coalesce-expression] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0 ?? 0 && true; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-tail-with-logical-or.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-tail-with-logical-or.js new file mode 100644 index 000000000..0849f7613 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/coalesce/cannot-chain-tail-with-logical-or.js @@ -0,0 +1,32 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + If the CoalesceExpressionHead is undefined or null, follow return the right-side value. + Otherwise, return the left-side value. +esid: sec-conditional-operator +info: | + ConditionalExpression : + ShortCircuitExpression + ShortCircuitExpression ? AssignmentExpression : AssignmentExpression + + ShortCircuitExpression : + LogicalORExpression + CoalesceExpression + + CoalesceExpression : + CoalesceExpressionHead ?? BitwiseORExpression + + CoalesceExpressionHead : + CoalesceExpression + BitwiseORExpression +features: [coalesce-expression] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0 ?? 0 || true; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/11.13.2-6-1gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/11.13.2-6-1gs.js new file mode 100644 index 000000000..78f9962bb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/11.13.2-6-1gs.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-1gs +description: > + Strict Mode - SyntaxError is throw if the identifier eval appears + as the LeftHandSideExpression of a Compound Assignment operator(*=) +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +eval *= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/add-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/add-arguments-strict.js new file mode 100644 index 000000000..0053c688a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/add-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-15-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(+=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments += 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/add-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/add-eval-strict.js new file mode 100644 index 000000000..ddc5ae014 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/add-eval-strict.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-4-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment operator(+=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval += 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/add-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/add-non-simple.js new file mode 100644 index 000000000..f74dd5fb5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/add-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound addition assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 += 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/and-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/and-arguments-strict.js new file mode 100644 index 000000000..a48915f5c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/and-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-20-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(&=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments &= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/and-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/and-eval-strict.js new file mode 100644 index 000000000..8fedf02a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/and-eval-strict.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-9-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment operator(&=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval &= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/btws-and-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/btws-and-non-simple.js new file mode 100644 index 000000000..ceac4aa86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/btws-and-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound "bitwise and" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 &= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/btws-or-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/btws-or-non-simple.js new file mode 100644 index 000000000..acbdd1e24 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/btws-or-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound "bitwise or" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 |= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/btws-xor-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/btws-xor-non-simple.js new file mode 100644 index 000000000..f5f8f6ee1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/btws-xor-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound "bitwise xor" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 ^= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/div-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/div-arguments-strict.js new file mode 100644 index 000000000..595ec5c16 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/div-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-13-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(/=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments /= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/div-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/div-eval-strict.js new file mode 100644 index 000000000..81deccc3a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/div-eval-strict.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-2-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment operator(/=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval /= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/div-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/div-non-simple.js new file mode 100644 index 000000000..b3b2238d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/div-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound division assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 /= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/left-shift-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/left-shift-non-simple.js new file mode 100644 index 000000000..171030b08 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/left-shift-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound "left shift" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 <<= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/lshift-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/lshift-arguments-strict.js new file mode 100644 index 000000000..04c7322d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/lshift-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-17-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(<<=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments <<= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/lshift-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/lshift-eval-strict.js new file mode 100644 index 000000000..6e66c97a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/lshift-eval-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-6-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment + operator(<<=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval <<= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mod-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mod-arguments-strict.js new file mode 100644 index 000000000..9bf55d6fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mod-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-14-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(%=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments %= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mod-div-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mod-div-non-simple.js new file mode 100644 index 000000000..33c4d56b5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mod-div-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound "modular division" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 %= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mod-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mod-eval-strict.js new file mode 100644 index 000000000..30c13e378 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mod-eval-strict.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-3-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment operator(%=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval %= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mult-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mult-arguments-strict.js new file mode 100644 index 000000000..3e6fa30a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mult-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-12-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(*=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments *= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mult-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mult-eval-strict.js new file mode 100644 index 000000000..a617f3acc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mult-eval-strict.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-1-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment operator(*=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval *= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mult-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mult-non-simple.js new file mode 100644 index 000000000..0c53254b5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/mult-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound multiplication assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 *= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/or-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/or-arguments-strict.js new file mode 100644 index 000000000..fb5e1de1f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/or-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-22-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(|=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments |= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/or-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/or-eval-strict.js new file mode 100644 index 000000000..4bc678fea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/or-eval-strict.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-11-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment operator(|=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval |= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/right-shift-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/right-shift-non-simple.js new file mode 100644 index 000000000..a8f141b42 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/right-shift-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound "right shift" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 >>= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/srshift-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/srshift-arguments-strict.js new file mode 100644 index 000000000..766ca8eb1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/srshift-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-18-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(>>=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments >>= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/srshift-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/srshift-eval-strict.js new file mode 100644 index 000000000..55dc97d08 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/srshift-eval-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-7-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment + operator(>>=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval >>= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/sub-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/sub-arguments-strict.js new file mode 100644 index 000000000..e57df6d12 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/sub-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-16-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(-=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments -= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/sub-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/sub-eval-strict.js new file mode 100644 index 000000000..f63ea8f5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/sub-eval-strict.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-5-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment operator(-=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval -= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/subtract-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/subtract-non-simple.js new file mode 100644 index 000000000..4221fa749 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/subtract-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound subtraction assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 -= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/u-right-shift-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/u-right-shift-non-simple.js new file mode 100644 index 000000000..b7c63dd5d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/u-right-shift-non-simple.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Compound "unsigned right shift" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +1 >>>= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/urshift-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/urshift-arguments-strict.js new file mode 100644 index 000000000..6af081654 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/urshift-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-19-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(>>>=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments >>>= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/urshift-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/urshift-eval-strict.js new file mode 100644 index 000000000..8dd62aa03 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/urshift-eval-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-8-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment + operator(>>>=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval >>>= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/xor-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/xor-arguments-strict.js new file mode 100644 index 000000000..55f6e865c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/xor-arguments-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-21-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Compound Assignment + operator(^=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments ^= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/xor-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/xor-eval-strict.js new file mode 100644 index 000000000..ba2f7b0a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/compound-assignment/xor-eval-strict.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.13.2-6-10-s +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Compound Assignment operator(^=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval ^= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/conditional/in-branch-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/conditional/in-branch-2.js new file mode 100644 index 000000000..cfcc63a45 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/conditional/in-branch-2.js @@ -0,0 +1,22 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-conditional-operator +es6id: 12.13 +description: > + The second AssignmentExpression cannot include the `in` keyword in contexts + where it is disallowed. +info: | + Syntax + + ConditionalExpression[In, Yield] : + LogicalORExpression[?In, ?Yield] + LogicalORExpression[?In, ?Yield] ? AssignmentExpression[+In, ?Yield] : AssignmentExpression[?In, ?Yield] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +for (true ? 0 : 0 in {}; false; ) ; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/conditional/in-condition.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/conditional/in-condition.js new file mode 100644 index 000000000..295c5592d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/conditional/in-condition.js @@ -0,0 +1,22 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-conditional-operator +es6id: 12.13 +description: > + The expression's LogicalORExpression sub-expression cannot include the `in` + keyword in contexts where it is disallowed. +info: | + Syntax + + ConditionalExpression[In, Yield] : + LogicalORExpression[?In, ?Yield] + LogicalORExpression[?In, ?Yield] ? AssignmentExpression[+In, ?Yield] : AssignmentExpression[?In, ?Yield] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +for ('' in {} ? 0 : 0; false; ) ; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/delete/identifier-strict-recursive.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/delete/identifier-strict-recursive.js new file mode 100644 index 000000000..a40179b1d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/delete/identifier-strict-recursive.js @@ -0,0 +1,18 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// Copyright (c) 2021 Gus Caplan. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-delete-operator-static-semantics-early-errors +description: Parsing error when operand is an IdentifierReference +info: | + It is a Syntax Error if the UnaryExpression is contained in strict mode code + and the derived UnaryExpression is PrimaryExpression:IdentifierReference. +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +delete ((identifier)); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/delete/identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/delete/identifier-strict.js new file mode 100644 index 000000000..5faa5b7d3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/delete/identifier-strict.js @@ -0,0 +1,17 @@ +// Copyright (c) 2018 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-delete-operator-static-semantics-early-errors +description: Parsing error when operand is an IdentifierReference +info: | + It is a Syntax Error if the UnaryExpression is contained in strict mode code + and the derived UnaryExpression is PrimaryExpression:IdentifierReference. +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +delete test262identifier; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/await-import-evaluation_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/await-import-evaluation_FIXTURE.js new file mode 100644 index 000000000..084888a6b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/await-import-evaluation_FIXTURE.js @@ -0,0 +1,14 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +var startTime = Date.now(); +var endTime; + +export { endTime as time } + +while (true) { + endTime = Date.now() - startTime; + if (endTime > 100) { + break; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/custom-tostring_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/custom-tostring_FIXTURE.js new file mode 100644 index 000000000..f077ef7fc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/custom-tostring_FIXTURE.js @@ -0,0 +1,6 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export function toString() { + return '1612'; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/custom-valueof_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/custom-valueof_FIXTURE.js new file mode 100644 index 000000000..8737f5c46 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/custom-valueof_FIXTURE.js @@ -0,0 +1,6 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export function valueOf() { + return 42; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/dynamic-import-module_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/dynamic-import-module_FIXTURE.js new file mode 100644 index 000000000..ef3f4207c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/dynamic-import-module_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2018 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export var x = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/empty_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/empty_FIXTURE.js new file mode 100644 index 000000000..96a3b8595 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/empty_FIXTURE.js @@ -0,0 +1,2 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/escape-sequence-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/escape-sequence-import.js new file mode 100644 index 000000000..294136c7e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/escape-sequence-import.js @@ -0,0 +1,35 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-left-hand-side-expressions +description: > + "import" must not contain escape sequences. +info: | + 5.1.5 Grammar Notation + + Terminal symbols are shown in fixed width + font, both in the productions of the grammars and throughout this specification whenever the + text directly refers to such a terminal symbol. These are to appear in a script exactly as + written. All terminal symbol code points specified in this way are to be understood as the + appropriate Unicode code points from the Basic Latin range, as opposed to any similar-looking + code points from other Unicode ranges. + + CallExpression : + MemberExpressionArguments + SuperCall + ImportCall + CallExpressionArguments + CallExpressionTemplateLiteral + + ImportCall : + import( AssignmentExpression ) +negative: + phase: parse + type: SyntaxError +features: [dynamic-import] +---*/ + +$DONOTEVALUATE(); + +im\u0070ort('./empty_FIXTURE.js'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/eval-rqstd-once_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/eval-rqstd-once_FIXTURE.js new file mode 100644 index 000000000..8af3363da --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/eval-rqstd-once_FIXTURE.js @@ -0,0 +1,15 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export default null; +var global = Function('return this;')(); + +if (global.test262) { + throw new Error('Module was evaluated more than once.'); +} + +global.test262 = 262; + +if (global.test262 !== 262) { + throw new Error('Module was unable to signal evaluation.'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/for-await-resolution-and-error-a_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/for-await-resolution-and-error-a_FIXTURE.js new file mode 100644 index 000000000..4ed0ca32d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/for-await-resolution-and-error-a_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export var x = 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/for-await-resolution-and-error-b_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/for-await-resolution-and-error-b_FIXTURE.js new file mode 100644 index 000000000..d2f423ccd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/for-await-resolution-and-error-b_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export var x = 39; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/for-await-resolution-and-error-poisoned_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/for-await-resolution-and-error-poisoned_FIXTURE.js new file mode 100644 index 000000000..e32796824 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/for-await-resolution-and-error-poisoned_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +throw 'foo'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-attributes/2nd-param-yield-ident-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-attributes/2nd-param-yield-ident-invalid.js new file mode 100644 index 000000000..304562c71 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-attributes/2nd-param-yield-ident-invalid.js @@ -0,0 +1,19 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + ImportCall parameter list forwards the Yield production parameter - invalid IdentifierReference +esid: sec-import-call-runtime-semantics-evaluation +info: | + ImportCall[Yield, Await]: + import ( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import ( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) +features: [dynamic-import, import-attributes] +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ +$DONOTEVALUATE(); + +import('./empty_FIXTURE.js', yield); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-attributes/2nd-param_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-attributes/2nd-param_FIXTURE.js new file mode 100644 index 000000000..fc9f2fa02 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-attributes/2nd-param_FIXTURE.js @@ -0,0 +1,3 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +export default 262; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-attributes/2nd-param_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-attributes/2nd-param_FIXTURE.json new file mode 100644 index 000000000..5484d8291 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-attributes/2nd-param_FIXTURE.json @@ -0,0 +1 @@ +262 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-errored-module_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-errored-module_FIXTURE.js new file mode 100644 index 000000000..230029907 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/import-errored-module_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2025 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +throw new Error("boom"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/indirect-resolution-1_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/indirect-resolution-1_FIXTURE.js new file mode 100644 index 000000000..e4fcf31a8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/indirect-resolution-1_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export default import('./indirect-resolution-2_FIXTURE.js'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/indirect-resolution-2_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/indirect-resolution-2_FIXTURE.js new file mode 100644 index 000000000..4cc5fc922 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/indirect-resolution-2_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export default 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/module-code_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/module-code_FIXTURE.js new file mode 100644 index 000000000..62cb5ae82 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/module-code_FIXTURE.js @@ -0,0 +1,10 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +// exports: default === 42, local1 === 'Test262', renamed === 'TC39', indirect === 'Test262' + +export var local1 = 'Test262'; +var local2 = 'TC39'; +export { local2 as renamed }; +export { local1 as indirect } from './module-code_FIXTURE.js'; +export default 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-1-update-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-1-update-expression.js new file mode 100644 index 000000000..9c41220f3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-1-update-expression.js @@ -0,0 +1,46 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + ImportCall is a valid CallExpression and UpdateExpression, but it is an invalid + AssginmentTargetType then it should throw a ReferenceError if used in some + UpdateExpressions +esid: prod-ImportCall +info: | + Update Expressions + Static Semantics: Early Errors + + UpdateExpression: + LeftHandSideExpression++ + LeftHandSideExpression-- + + - It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is invalid or strict. + + LeftHandSideExpression: + NewExpression + CallExpression + + CallExpression: + ImportCall + + Left-Hand-Side Expressions + Static Semantics: AssignmentTargetType + #sec-static-semantics-static-semantics-assignmenttargettype + + CallExpression : + MemberExpressionArguments + SuperCall + ImportCall + CallExpressionArguments + CallExpressionTemplateLiteral + + 1. Return invalid +negative: + phase: parse + type: SyntaxError +features: [dynamic-import] +---*/ + +$DONOTEVALUATE(); + +import('')++ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-2-update-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-2-update-expression.js new file mode 100644 index 000000000..13af3b8da --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-2-update-expression.js @@ -0,0 +1,46 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + ImportCall is a valid CallExpression and UpdateExpression, but it is an invalid + AssginmentTargetType then it should throw a SyntaxError if used in some + UpdateExpressions +esid: prod-ImportCall +info: | + Update Expressions + Static Semantics: Early Errors + + UpdateExpression: + LeftHandSideExpression++ + LeftHandSideExpression-- + + - It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is invalid or strict. + + LeftHandSideExpression: + NewExpression + CallExpression + + CallExpression: + ImportCall + + Left-Hand-Side Expressions + Static Semantics: AssignmentTargetType + #sec-static-semantics-static-semantics-assignmenttargettype + + CallExpression : + MemberExpressionArguments + SuperCall + ImportCall + CallExpressionArguments + CallExpressionTemplateLiteral + + 1. Return invalid +negative: + phase: parse + type: SyntaxError +features: [dynamic-import] +---*/ + +$DONOTEVALUATE(); + +import('')-- diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-3-update-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-3-update-expression.js new file mode 100644 index 000000000..52ac1d38e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-3-update-expression.js @@ -0,0 +1,46 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + ImportCall is a valid CallExpression and UnaryExpression, but it is an invalid + AssginmentTargetType then it should throw a SyntaxError if used in some + UpdateExpressions +esid: prod-ImportCall +info: | + Update Expressions + Static Semantics: Early Errors + + UpdateExpression: + ++UnaryExpression + --UnaryExpression + + - It is an early Syntax Error if AssignmentTargetType of UnaryExpression is invalid or strict. + + LeftHandSideExpression: + NewExpression + CallExpression + + CallExpression: + ImportCall + + Left-Hand-Side Expressions + Static Semantics: AssignmentTargetType + #sec-static-semantics-static-semantics-assignmenttargettype + + CallExpression : + MemberExpressionArguments + SuperCall + ImportCall + CallExpressionArguments + CallExpressionTemplateLiteral + + 1. Return invalid +negative: + phase: parse + type: SyntaxError +features: [dynamic-import] +---*/ + +$DONOTEVALUATE(); + +++import('') diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-4-update-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-4-update-expression.js new file mode 100644 index 000000000..4e57e456e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-4-update-expression.js @@ -0,0 +1,46 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + ImportCall is a valid CallExpression and UnaryExpression, but it is an invalid + AssginmentTargetType then it should throw a SyntaxError if used in some + UpdateExpressions +esid: prod-ImportCall +info: | + Update Expressions + Static Semantics: Early Errors + + UpdateExpression: + ++UnaryExpression + --UnaryExpression + + - It is an early Syntax Error if AssignmentTargetType of UnaryExpression is invalid or strict. + + LeftHandSideExpression: + NewExpression + CallExpression + + CallExpression: + ImportCall + + Left-Hand-Side Expressions + Static Semantics: AssignmentTargetType + #sec-static-semantics-static-semantics-assignmenttargettype + + CallExpression : + MemberExpressionArguments + SuperCall + ImportCall + CallExpressionArguments + CallExpressionTemplateLiteral + + 1. Return invalid +negative: + phase: parse + type: SyntaxError +features: [dynamic-import] +---*/ + +$DONOTEVALUATE(); + +--import('') diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-5-lhs-equals-assignment-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-5-lhs-equals-assignment-expression.js new file mode 100644 index 000000000..2fe58e633 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/invalid-assignmenttargettype-syntax-error-5-lhs-equals-assignment-expression.js @@ -0,0 +1,48 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + ImportCall is a valid CallExpression and LHSExpression, but it is an invalid + AssginmentTargetType then it should throw a SyntaxError if used in some + LHS Expression of a AssignmentExpression production +esid: prod-ImportCall +info: | + Assignment Operators + Static Semantics: Early Errors + + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + - It is an early Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral and AssignmentTargetType of LeftHandSideExpression is invalid or strict. + + AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression + + - It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is invalid or strict. + + LeftHandSideExpression: + NewExpression + CallExpression + + CallExpression: + ImportCall + + Left-Hand-Side Expressions + Static Semantics: AssignmentTargetType + #sec-static-semantics-static-semantics-assignmenttargettype + + CallExpression : + MemberExpressionArguments + SuperCall + ImportCall + CallExpressionArguments + CallExpressionTemplateLiteral + + 1. Return invalid +negative: + phase: parse + type: SyntaxError +features: [dynamic-import] +---*/ + +$DONOTEVALUATE(); + +import('') = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expr-not-optional.js new file mode 100644 index 000000000..f1b129875 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +let f = () => { + import(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-assignment-expr-not-optional.js new file mode 100644 index 000000000..3fc1d5c42 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-assignment-expr-not-optional.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +let f = () => import(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-call-unknown.js new file mode 100644 index 000000000..493f6f992 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-call-unknown.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: It's a SyntaxError on unknown import call (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => import.UNKNOWN('./empty_FIXTURE.js'); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..dc5aa7709 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => import.defer(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..4eb77f4e5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-defer-no-new-call-expression.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => new import.defer('./empty_FIXTURE.js'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-defer-no-rest-param.js new file mode 100644 index 000000000..36dc8653d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-defer-no-rest-param.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +let f = () => import.defer(...['./empty_FIXTURE.js']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..09770d739 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-source-assignment-expr-not-optional.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => import.source(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-source-no-new-call-expression.js new file mode 100644 index 000000000..158123f75 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-source-no-new-call-expression.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => new import.source(''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-source-no-rest-param.js new file mode 100644 index 000000000..9cf643bdb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-import-source-no-rest-param.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +let f = () => import.source(...['']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-new-call-expression.js new file mode 100644 index 000000000..02b15c2db --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-new-call-expression.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +let f = () => new import(''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-rest-param.js new file mode 100644 index 000000000..b8939a916 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-no-rest-param.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +let f = () => import(...['']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-not-extensible-args.js new file mode 100644 index 000000000..d4523aa17 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-not-extensible-args.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: ImportCall is not extensible - no arguments list (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +let f = () => import('./empty_FIXTURE.js', {}, ''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-typeof-import-call-source-property.js new file mode 100644 index 000000000..7e98e745f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-typeof-import-call-source-property.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => typeof import.source.UNKNOWN; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-typeof-import-source.js new file mode 100644 index 000000000..21f059b8c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-typeof-import-source.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => typeof import.source; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-typeof-import.js new file mode 100644 index 000000000..95bcfc9f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-assignment-expression-typeof-import.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-arrow-assignment-expression.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +let f = () => typeof import; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-call-unknown.js new file mode 100644 index 000000000..77c5f157d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: It's a SyntaxError on unknown import call (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => { + import.UNKNOWN('./empty_FIXTURE.js'); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..cc9156baa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => { + import.defer(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..638808f0f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => { + new import.defer('./empty_FIXTURE.js'); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-defer-no-rest-param.js new file mode 100644 index 000000000..1e57fdfe7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +let f = () => { + import.defer(...['./empty_FIXTURE.js']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..b01635012 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => { + import.source(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-source-no-new-call-expression.js new file mode 100644 index 000000000..00acabd06 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => { + new import.source(''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-source-no-rest-param.js new file mode 100644 index 000000000..219371053 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +let f = () => { + import.source(...['']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-new-call-expression.js new file mode 100644 index 000000000..a19fce876 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +let f = () => { + new import(''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-rest-param.js new file mode 100644 index 000000000..4b4f00813 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +let f = () => { + import(...['']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-not-extensible-args.js new file mode 100644 index 000000000..5469a9dde --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: ImportCall is not extensible - no arguments list (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +let f = () => { + import('./empty_FIXTURE.js', {}, ''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-typeof-import-call-source-property.js new file mode 100644 index 000000000..490f2fd01 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => { + typeof import.source.UNKNOWN; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-typeof-import-source.js new file mode 100644 index 000000000..352767b9f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let f = () => { + typeof import.source; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-typeof-import.js new file mode 100644 index 000000000..ecfa6d799 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-arrow-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-arrow.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +let f = () => { + typeof import; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-assignment-expr-not-optional.js new file mode 100644 index 000000000..9018eb885 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +(async () => { + await import() +}); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-call-unknown.js new file mode 100644 index 000000000..9fd621a4c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: It's a SyntaxError on unknown import call (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => { + await import.UNKNOWN('./empty_FIXTURE.js') +}); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..cec4eea37 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => { + await import.defer() +}); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..39a1fdaaa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => { + await new import.defer('./empty_FIXTURE.js') +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-defer-no-rest-param.js new file mode 100644 index 000000000..22a5e081f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +(async () => { + await import.defer(...['./empty_FIXTURE.js']) +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..0fae5d701 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => { + await import.source() +}); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-source-no-new-call-expression.js new file mode 100644 index 000000000..48df357bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => { + await new import.source('') +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-source-no-rest-param.js new file mode 100644 index 000000000..0f86c2d23 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +(async () => { + await import.source(...['']) +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-new-call-expression.js new file mode 100644 index 000000000..a06ae82fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +(async () => { + await new import('') +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-rest-param.js new file mode 100644 index 000000000..de2319927 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +(async () => { + await import(...['']) +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-not-extensible-args.js new file mode 100644 index 000000000..251716cef --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: ImportCall is not extensible - no arguments list (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +(async () => { + await import('./empty_FIXTURE.js', {}, '') +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-typeof-import-call-source-property.js new file mode 100644 index 000000000..cf3171f30 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => { + await typeof import.source.UNKNOWN +}); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-typeof-import-source.js new file mode 100644 index 000000000..3ee214c42 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => { + await typeof import.source +}); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-typeof-import.js new file mode 100644 index 000000000..9c3926532 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-await-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested in async arrow function, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +(async () => { + await typeof import +}); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-assignment-expr-not-optional.js new file mode 100644 index 000000000..40af54024 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-assignment-expr-not-optional.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +(async () => await import()) + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-call-unknown.js new file mode 100644 index 000000000..556887483 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-call-unknown.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: It's a SyntaxError on unknown import call (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => await import.UNKNOWN('./empty_FIXTURE.js')) + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..30255f572 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => await import.defer()) + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..ca540341c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-defer-no-new-call-expression.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => await new import.defer('./empty_FIXTURE.js')) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-defer-no-rest-param.js new file mode 100644 index 000000000..db2c249a2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-defer-no-rest-param.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +(async () => await import.defer(...['./empty_FIXTURE.js'])) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..8dd268622 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-source-assignment-expr-not-optional.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => await import.source()) + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-source-no-new-call-expression.js new file mode 100644 index 000000000..1da8cb0b4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-source-no-new-call-expression.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => await new import.source('')) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-source-no-rest-param.js new file mode 100644 index 000000000..eb3a8ebe0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-import-source-no-rest-param.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +(async () => await import.source(...[''])) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-new-call-expression.js new file mode 100644 index 000000000..acb1c1b3a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-new-call-expression.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +(async () => await new import('')) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-rest-param.js new file mode 100644 index 000000000..ac6f0bbc1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-no-rest-param.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +(async () => await import(...[''])) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-not-extensible-args.js new file mode 100644 index 000000000..5926d0e06 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-not-extensible-args.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: ImportCall is not extensible - no arguments list (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +(async () => await import('./empty_FIXTURE.js', {}, '')) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-typeof-import-call-source-property.js new file mode 100644 index 000000000..5d8443b0c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-typeof-import-call-source-property.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => await typeof import.source.UNKNOWN) + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-typeof-import-source.js new file mode 100644 index 000000000..edd72de3b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-typeof-import-source.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +(async () => await typeof import.source) + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-typeof-import.js new file mode 100644 index 000000000..40fa2c7a1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-arrow-function-return-await-typeof-import.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-async-arrow-fn-return-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested in async arrow function, returned) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +(async () => await typeof import) + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-assignment-expr-not-optional.js new file mode 100644 index 000000000..b3eeac59d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +async function f() { + import(); +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-assignment-expr-not-optional.js new file mode 100644 index 000000000..591b5c964 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +async function f() { + await import(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-call-unknown.js new file mode 100644 index 000000000..956703b78 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: It's a SyntaxError on unknown import call (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + await import.UNKNOWN('./empty_FIXTURE.js'); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..ffb328424 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + await import.defer(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..bc1fa4d14 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + await new import.defer('./empty_FIXTURE.js'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-defer-no-rest-param.js new file mode 100644 index 000000000..5b7e2bf80 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +async function f() { + await import.defer(...['./empty_FIXTURE.js']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..fff41d3d0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + await import.source(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-source-no-new-call-expression.js new file mode 100644 index 000000000..c9559953c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + await new import.source(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-source-no-rest-param.js new file mode 100644 index 000000000..4c4fec5ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +async function f() { + await import.source(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-new-call-expression.js new file mode 100644 index 000000000..e6a03d4bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +async function f() { + await new import(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-rest-param.js new file mode 100644 index 000000000..91a757456 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +async function f() { + await import(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-not-extensible-args.js new file mode 100644 index 000000000..2cd24442f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: ImportCall is not extensible - no arguments list (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +async function f() { + await import('./empty_FIXTURE.js', {}, ''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-typeof-import-call-source-property.js new file mode 100644 index 000000000..0e7cf1b4c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + await typeof import.source.UNKNOWN; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-typeof-import-source.js new file mode 100644 index 000000000..40a9082fd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + await typeof import.source; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-typeof-import.js new file mode 100644 index 000000000..5d0bdcb45 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-await-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-async-function-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +async function f() { + await typeof import; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-call-unknown.js new file mode 100644 index 000000000..2aaaca319 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-call-unknown.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: It's a SyntaxError on unknown import call (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + import.UNKNOWN('./empty_FIXTURE.js'); +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..935169ab0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + import.defer(); +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..7bb1c2291 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-defer-no-new-call-expression.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + new import.defer('./empty_FIXTURE.js'); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-defer-no-rest-param.js new file mode 100644 index 000000000..a1a90080e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-defer-no-rest-param.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +async function f() { + import.defer(...['./empty_FIXTURE.js']); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..64d2f3702 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-source-assignment-expr-not-optional.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + import.source(); +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-source-no-new-call-expression.js new file mode 100644 index 000000000..e1d1c50d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-source-no-new-call-expression.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + new import.source(''); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-source-no-rest-param.js new file mode 100644 index 000000000..03ba4b05c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-import-source-no-rest-param.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +async function f() { + import.source(...['']); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-new-call-expression.js new file mode 100644 index 000000000..316843faa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +async function f() { + new import(''); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-rest-param.js new file mode 100644 index 000000000..0498f8fc6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +async function f() { + import(...['']); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-not-extensible-args.js new file mode 100644 index 000000000..8a640b1ac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-not-extensible-args.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: ImportCall is not extensible - no arguments list (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +async function f() { + import('./empty_FIXTURE.js', {}, ''); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-assignment-expr-not-optional.js new file mode 100644 index 000000000..3f82765d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await import(); +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-call-unknown.js new file mode 100644 index 000000000..9feca84ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-call-unknown.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: It's a SyntaxError on unknown import call (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await import.UNKNOWN('./empty_FIXTURE.js'); +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..4573cca67 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await import.defer(); +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..501854f2d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-defer-no-new-call-expression.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await new import.defer('./empty_FIXTURE.js'); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-defer-no-rest-param.js new file mode 100644 index 000000000..cd64f3e05 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-defer-no-rest-param.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await import.defer(...['./empty_FIXTURE.js']); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..39f114716 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-source-assignment-expr-not-optional.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await import.source(); +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-source-no-new-call-expression.js new file mode 100644 index 000000000..365d574e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-source-no-new-call-expression.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await new import.source(''); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-source-no-rest-param.js new file mode 100644 index 000000000..8062d6cfe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-import-source-no-rest-param.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await import.source(...['']); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-new-call-expression.js new file mode 100644 index 000000000..eac92cb20 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await new import(''); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-rest-param.js new file mode 100644 index 000000000..6ee53b2f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await import(...['']); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-not-extensible-args.js new file mode 100644 index 000000000..abb78d5a9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-not-extensible-args.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: ImportCall is not extensible - no arguments list (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await import('./empty_FIXTURE.js', {}, ''); +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-typeof-import-call-source-property.js new file mode 100644 index 000000000..325a7a0e3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-typeof-import-call-source-property.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await typeof import.source.UNKNOWN; +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-typeof-import-source.js new file mode 100644 index 000000000..5ef24b07a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-typeof-import-source.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await typeof import.source; +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-typeof-import.js new file mode 100644 index 000000000..63b017062 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-return-await-typeof-import.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-async-function-return-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +async function f() { + return await typeof import; +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-typeof-import-call-source-property.js new file mode 100644 index 000000000..7622a3d31 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-typeof-import-call-source-property.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + typeof import.source.UNKNOWN; +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-typeof-import-source.js new file mode 100644 index 000000000..164a07542 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-typeof-import-source.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function f() { + typeof import.source; +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-typeof-import.js new file mode 100644 index 000000000..ee5767d8d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-function-typeof-import.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-async-function.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested arrow syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +async function f() { + typeof import; +} + + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-assignment-expr-not-optional.js new file mode 100644 index 000000000..d158254b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await import() +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-call-unknown.js new file mode 100644 index 000000000..992b41237 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: It's a SyntaxError on unknown import call (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await import.UNKNOWN('./empty_FIXTURE.js') +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..46a6da824 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await import.defer() +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..34cc167f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await new import.defer('./empty_FIXTURE.js') +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-defer-no-rest-param.js new file mode 100644 index 000000000..7327bb033 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await import.defer(...['./empty_FIXTURE.js']) +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..51f65e84e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await import.source() +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-source-no-new-call-expression.js new file mode 100644 index 000000000..8c914d3f2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await new import.source('') +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-source-no-rest-param.js new file mode 100644 index 000000000..ec9dca267 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await import.source(...['']) +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-new-call-expression.js new file mode 100644 index 000000000..44c0a43cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await new import('') +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-rest-param.js new file mode 100644 index 000000000..d044be3ad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await import(...['']) +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-not-extensible-args.js new file mode 100644 index 000000000..87e4f4819 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: ImportCall is not extensible - no arguments list (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await import('./empty_FIXTURE.js', {}, '') +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-typeof-import-call-source-property.js new file mode 100644 index 000000000..91a0b5a43 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await typeof import.source.UNKNOWN +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-typeof-import-source.js new file mode 100644 index 000000000..fd1afe433 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await typeof import.source +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-typeof-import.js new file mode 100644 index 000000000..cef4a33e1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-async-gen-await-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-async-generator-await.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested in async generator, awaited) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +async function * f() { + await typeof import +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-assignment-expr-not-optional.js new file mode 100644 index 000000000..03148f889 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +{ + import(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-call-unknown.js new file mode 100644 index 000000000..b6e9c715b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: It's a SyntaxError on unknown import call (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +{ + import.UNKNOWN('./empty_FIXTURE.js'); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..1d6a7dca2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +{ + import.defer(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..959d8b070 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +{ + new import.defer('./empty_FIXTURE.js'); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-defer-no-rest-param.js new file mode 100644 index 000000000..1283572db --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +{ + import.defer(...['./empty_FIXTURE.js']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..0818be7c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +{ + import.source(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-source-no-new-call-expression.js new file mode 100644 index 000000000..5ef3dcf4c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +{ + new import.source(''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-source-no-rest-param.js new file mode 100644 index 000000000..92b4f340d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +{ + import.source(...['']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-assignment-expr-not-optional.js new file mode 100644 index 000000000..b3f16a631 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +label: { + import(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-call-unknown.js new file mode 100644 index 000000000..67160207a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: It's a SyntaxError on unknown import call (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +label: { + import.UNKNOWN('./empty_FIXTURE.js'); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..f80e559ab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +label: { + import.defer(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..cc9e24611 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +label: { + new import.defer('./empty_FIXTURE.js'); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-defer-no-rest-param.js new file mode 100644 index 000000000..8db4ae842 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +label: { + import.defer(...['./empty_FIXTURE.js']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..9a10a50ef --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +label: { + import.source(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-source-no-new-call-expression.js new file mode 100644 index 000000000..f37ece233 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +label: { + new import.source(''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-source-no-rest-param.js new file mode 100644 index 000000000..1c805d9ce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +label: { + import.source(...['']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-new-call-expression.js new file mode 100644 index 000000000..09f87734f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +label: { + new import(''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-rest-param.js new file mode 100644 index 000000000..f6c9164fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +label: { + import(...['']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-not-extensible-args.js new file mode 100644 index 000000000..e2e7ea62e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: ImportCall is not extensible - no arguments list (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +label: { + import('./empty_FIXTURE.js', {}, ''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-typeof-import-call-source-property.js new file mode 100644 index 000000000..2b81b8491 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +label: { + typeof import.source.UNKNOWN; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-typeof-import-source.js new file mode 100644 index 000000000..fabe1d0dc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +label: { + typeof import.source; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-typeof-import.js new file mode 100644 index 000000000..b8b9ea597 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-labeled-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-block-labeled.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +label: { + typeof import; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-no-new-call-expression.js new file mode 100644 index 000000000..135ce12c7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +{ + new import(''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-no-rest-param.js new file mode 100644 index 000000000..d855bfd8d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +{ + import(...['']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-not-extensible-args.js new file mode 100644 index 000000000..48ec563ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: ImportCall is not extensible - no arguments list (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +{ + import('./empty_FIXTURE.js', {}, ''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-typeof-import-call-source-property.js new file mode 100644 index 000000000..aeb16967b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +{ + typeof import.source.UNKNOWN; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-typeof-import-source.js new file mode 100644 index 000000000..f58edf59b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +{ + typeof import.source; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-typeof-import.js new file mode 100644 index 000000000..e2d57395a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-block-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-block.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested block syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +{ + typeof import; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-assignment-expr-not-optional.js new file mode 100644 index 000000000..9ef6e8e26 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +do { + import(); +} while (false); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-call-unknown.js new file mode 100644 index 000000000..c1c2bcb0e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: It's a SyntaxError on unknown import call (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +do { + import.UNKNOWN('./empty_FIXTURE.js'); +} while (false); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..63f321e3a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +do { + import.defer(); +} while (false); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..2409a5dd0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +do { + new import.defer('./empty_FIXTURE.js'); +} while (false); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-defer-no-rest-param.js new file mode 100644 index 000000000..d65cdc136 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +do { + import.defer(...['./empty_FIXTURE.js']); +} while (false); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..a996c6d22 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +do { + import.source(); +} while (false); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-source-no-new-call-expression.js new file mode 100644 index 000000000..abc42277f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +do { + new import.source(''); +} while (false); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-source-no-rest-param.js new file mode 100644 index 000000000..d46f1fb02 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +do { + import.source(...['']); +} while (false); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-new-call-expression.js new file mode 100644 index 000000000..6cf313e9e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +do { + new import(''); +} while (false); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-rest-param.js new file mode 100644 index 000000000..fd423ba1e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +do { + import(...['']); +} while (false); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-not-extensible-args.js new file mode 100644 index 000000000..df8952545 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: ImportCall is not extensible - no arguments list (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +do { + import('./empty_FIXTURE.js', {}, ''); +} while (false); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-typeof-import-call-source-property.js new file mode 100644 index 000000000..c9c0bb1ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +do { + typeof import.source.UNKNOWN; +} while (false); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-typeof-import-source.js new file mode 100644 index 000000000..c7191d547 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +do { + typeof import.source; +} while (false); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-typeof-import.js new file mode 100644 index 000000000..a420c7289 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-do-while-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-do-while.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested do while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +do { + typeof import; +} while (false); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-assignment-expr-not-optional.js new file mode 100644 index 000000000..72a9dd6aa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-assignment-expr-not-optional.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + import(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-assignment-expr-not-optional.js new file mode 100644 index 000000000..201f168bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else import(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-call-unknown.js new file mode 100644 index 000000000..12f9382c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: It's a SyntaxError on unknown import call (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else import.UNKNOWN('./empty_FIXTURE.js'); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..0be28a2b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else import.defer(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..e8ca2ae8f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else new import.defer('./empty_FIXTURE.js'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-defer-no-rest-param.js new file mode 100644 index 000000000..fb5cf17e4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else import.defer(...['./empty_FIXTURE.js']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..253a9e2ae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else import.source(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-source-no-new-call-expression.js new file mode 100644 index 000000000..a8040c17c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else new import.source(''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-source-no-rest-param.js new file mode 100644 index 000000000..3ad21f1df --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else import.source(...['']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-new-call-expression.js new file mode 100644 index 000000000..d6d84ec5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else new import(''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-rest-param.js new file mode 100644 index 000000000..40df598ab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else import(...['']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-not-extensible-args.js new file mode 100644 index 000000000..c2885a822 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: ImportCall is not extensible - no arguments list (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else import('./empty_FIXTURE.js', {}, ''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-typeof-import-call-source-property.js new file mode 100644 index 000000000..2bb301914 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else typeof import.source.UNKNOWN; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-typeof-import-source.js new file mode 100644 index 000000000..9721f577d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else typeof import.source; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-typeof-import.js new file mode 100644 index 000000000..01cf40982 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-braceless-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-else-braceless.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else typeof import; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-call-unknown.js new file mode 100644 index 000000000..3e138c716 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-call-unknown.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: It's a SyntaxError on unknown import call (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + import.UNKNOWN('./empty_FIXTURE.js'); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..8af57918c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + import.defer(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..7461ae77e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-defer-no-new-call-expression.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + new import.defer('./empty_FIXTURE.js'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-defer-no-rest-param.js new file mode 100644 index 000000000..f5512b9ce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-defer-no-rest-param.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + import.defer(...['./empty_FIXTURE.js']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..2c830d295 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-source-assignment-expr-not-optional.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + import.source(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-source-no-new-call-expression.js new file mode 100644 index 000000000..2ed5b4fc2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-source-no-new-call-expression.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + new import.source(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-source-no-rest-param.js new file mode 100644 index 000000000..1385a433b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-import-source-no-rest-param.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + import.source(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-no-new-call-expression.js new file mode 100644 index 000000000..ef909cdcc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-no-new-call-expression.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + new import(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-no-rest-param.js new file mode 100644 index 000000000..668a4ddc0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-no-rest-param.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + import(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-not-extensible-args.js new file mode 100644 index 000000000..ffadf2928 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-not-extensible-args.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: ImportCall is not extensible - no arguments list (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + import('./empty_FIXTURE.js', {}, ''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-typeof-import-call-source-property.js new file mode 100644 index 000000000..f97643aec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-typeof-import-call-source-property.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + typeof import.source.UNKNOWN; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-typeof-import-source.js new file mode 100644 index 000000000..d15f8d4d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-typeof-import-source.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + typeof import.source; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-typeof-import.js new file mode 100644 index 000000000..7a4bbf43c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-else-typeof-import.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-else.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested else syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +if (false) { + +} else { + typeof import; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-assignment-expr-not-optional.js new file mode 100644 index 000000000..272dbca2e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +function fn() { + import(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-call-unknown.js new file mode 100644 index 000000000..2ac05f2f5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: It's a SyntaxError on unknown import call (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + import.UNKNOWN('./empty_FIXTURE.js'); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..2d97bd986 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + import.defer(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..008d4a40d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + new import.defer('./empty_FIXTURE.js'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-defer-no-rest-param.js new file mode 100644 index 000000000..a491d9231 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +function fn() { + import.defer(...['./empty_FIXTURE.js']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..609e2a503 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + import.source(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-source-no-new-call-expression.js new file mode 100644 index 000000000..139202b78 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + new import.source(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-source-no-rest-param.js new file mode 100644 index 000000000..4706106e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +function fn() { + import.source(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-no-new-call-expression.js new file mode 100644 index 000000000..6a743fe4f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +function fn() { + new import(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-no-rest-param.js new file mode 100644 index 000000000..142b19cff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +function fn() { + import(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-not-extensible-args.js new file mode 100644 index 000000000..af3919523 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: ImportCall is not extensible - no arguments list (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +function fn() { + import('./empty_FIXTURE.js', {}, ''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-assignment-expr-not-optional.js new file mode 100644 index 000000000..603f1b6eb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +function fn() { + return import(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-call-unknown.js new file mode 100644 index 000000000..d4959ae01 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: It's a SyntaxError on unknown import call (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + return import.UNKNOWN('./empty_FIXTURE.js'); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..7e436fa46 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + return import.defer(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..3a5d6e61a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + return new import.defer('./empty_FIXTURE.js'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-defer-no-rest-param.js new file mode 100644 index 000000000..12ce40f36 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +function fn() { + return import.defer(...['./empty_FIXTURE.js']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..7733eee82 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + return import.source(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-source-no-new-call-expression.js new file mode 100644 index 000000000..dde0539d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + return new import.source(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-source-no-rest-param.js new file mode 100644 index 000000000..68ad8dc44 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +function fn() { + return import.source(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-new-call-expression.js new file mode 100644 index 000000000..c26fed117 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +function fn() { + return new import(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-rest-param.js new file mode 100644 index 000000000..3a936489f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +function fn() { + return import(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-not-extensible-args.js new file mode 100644 index 000000000..93fcd65e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: ImportCall is not extensible - no arguments list (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +function fn() { + return import('./empty_FIXTURE.js', {}, ''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-typeof-import-call-source-property.js new file mode 100644 index 000000000..4ffe12ff6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + return typeof import.source.UNKNOWN; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-typeof-import-source.js new file mode 100644 index 000000000..d42993b52 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + return typeof import.source; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-typeof-import.js new file mode 100644 index 000000000..0c2cdfb4f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-return-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-function-return.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +function fn() { + return typeof import; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-typeof-import-call-source-property.js new file mode 100644 index 000000000..f8220b068 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + typeof import.source.UNKNOWN; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-typeof-import-source.js new file mode 100644 index 000000000..7bfc7deb3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +function fn() { + typeof import.source; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-typeof-import.js new file mode 100644 index 000000000..f44331335 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-function-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-function.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested function syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +function fn() { + typeof import; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-assignment-expr-not-optional.js new file mode 100644 index 000000000..bfef0ca24 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +if (true) { + import(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-assignment-expr-not-optional.js new file mode 100644 index 000000000..d29c46aad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-assignment-expr-not-optional.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +if (true) import(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-call-unknown.js new file mode 100644 index 000000000..97178b7fd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-call-unknown.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: It's a SyntaxError on unknown import call (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) import.UNKNOWN('./empty_FIXTURE.js'); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..47f7a0bd4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) import.defer(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..5878734ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-defer-no-new-call-expression.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) new import.defer('./empty_FIXTURE.js'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-defer-no-rest-param.js new file mode 100644 index 000000000..f09463f78 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-defer-no-rest-param.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +if (true) import.defer(...['./empty_FIXTURE.js']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..a63345e8f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-source-assignment-expr-not-optional.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) import.source(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-source-no-new-call-expression.js new file mode 100644 index 000000000..e046e2274 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-source-no-new-call-expression.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) new import.source(''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-source-no-rest-param.js new file mode 100644 index 000000000..a7e63408d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-import-source-no-rest-param.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +if (true) import.source(...['']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-new-call-expression.js new file mode 100644 index 000000000..ab0ace095 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-new-call-expression.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +if (true) new import(''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-rest-param.js new file mode 100644 index 000000000..4924b7e76 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-no-rest-param.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +if (true) import(...['']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-not-extensible-args.js new file mode 100644 index 000000000..ccaac3d5b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-not-extensible-args.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: ImportCall is not extensible - no arguments list (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +if (true) import('./empty_FIXTURE.js', {}, ''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-typeof-import-call-source-property.js new file mode 100644 index 000000000..8d4fb9765 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-typeof-import-call-source-property.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) typeof import.source.UNKNOWN; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-typeof-import-source.js new file mode 100644 index 000000000..ff592967a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-typeof-import-source.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) typeof import.source; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-typeof-import.js new file mode 100644 index 000000000..39e54b733 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-braceless-typeof-import.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-if-braceless.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +if (true) typeof import; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-call-unknown.js new file mode 100644 index 000000000..8ca718c4d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: It's a SyntaxError on unknown import call (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) { + import.UNKNOWN('./empty_FIXTURE.js'); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..b659460c0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) { + import.defer(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..4b7372710 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) { + new import.defer('./empty_FIXTURE.js'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-defer-no-rest-param.js new file mode 100644 index 000000000..722c57b30 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +if (true) { + import.defer(...['./empty_FIXTURE.js']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..17d1a2551 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) { + import.source(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-source-no-new-call-expression.js new file mode 100644 index 000000000..314cd647e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) { + new import.source(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-source-no-rest-param.js new file mode 100644 index 000000000..4fdb605f5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +if (true) { + import.source(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-no-new-call-expression.js new file mode 100644 index 000000000..d33bab138 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +if (true) { + new import(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-no-rest-param.js new file mode 100644 index 000000000..eb6fbeb9a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +if (true) { + import(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-not-extensible-args.js new file mode 100644 index 000000000..845c41d2d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: ImportCall is not extensible - no arguments list (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +if (true) { + import('./empty_FIXTURE.js', {}, ''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-typeof-import-call-source-property.js new file mode 100644 index 000000000..dcc50a2a2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) { + typeof import.source.UNKNOWN; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-typeof-import-source.js new file mode 100644 index 000000000..93fedf421 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +if (true) { + typeof import.source; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-typeof-import.js new file mode 100644 index 000000000..282f1a6d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-if-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-if.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested if syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +if (true) { + typeof import; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-assignment-expr-not-optional.js new file mode 100644 index 000000000..c2c3e24a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-assignment-expr-not-optional.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + import(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-call-unknown.js new file mode 100644 index 000000000..81b003d3e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-call-unknown.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: It's a SyntaxError on unknown import call (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + import.UNKNOWN('./empty_FIXTURE.js'); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..24779ab0a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + import.defer(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..af97d6a9e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-defer-no-new-call-expression.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + new import.defer('./empty_FIXTURE.js'); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-defer-no-rest-param.js new file mode 100644 index 000000000..3d076437a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-defer-no-rest-param.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + import.defer(...['./empty_FIXTURE.js']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..1e2cd1818 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-source-assignment-expr-not-optional.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + import.source(); +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-source-no-new-call-expression.js new file mode 100644 index 000000000..b11c3b96b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-source-no-new-call-expression.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + new import.source(''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-source-no-rest-param.js new file mode 100644 index 000000000..069e097cf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-import-source-no-rest-param.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + import.source(...['']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-no-new-call-expression.js new file mode 100644 index 000000000..132b851bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-no-new-call-expression.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + new import(''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-no-rest-param.js new file mode 100644 index 000000000..a072fc3b0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-no-rest-param.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + import(...['']); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-not-extensible-args.js new file mode 100644 index 000000000..cc535fc4e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-not-extensible-args.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: ImportCall is not extensible - no arguments list (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + import('./empty_FIXTURE.js', {}, ''); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-typeof-import-call-source-property.js new file mode 100644 index 000000000..8b400c79f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-typeof-import-call-source-property.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + typeof import.source.UNKNOWN; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-typeof-import-source.js new file mode 100644 index 000000000..7f0555bc5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-typeof-import-source.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + typeof import.source; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-typeof-import.js new file mode 100644 index 000000000..2a5195cc9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-while-typeof-import.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-while.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested while syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +let x = 0; +while (!x) { + x++; + typeof import; +}; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-assignment-expr-not-optional.js new file mode 100644 index 000000000..2d4a3c46e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-assignment-expr-not-optional.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +with ({}) { + import(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-assignment-expr-not-optional.js new file mode 100644 index 000000000..3030cffba --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-assignment-expr-not-optional.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +with (import()) {} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-call-unknown.js new file mode 100644 index 000000000..7da442673 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-call-unknown.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: It's a SyntaxError on unknown import call (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with (import.UNKNOWN('./empty_FIXTURE.js')) {} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..97bc80796 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with (import.defer()) {} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..f015efa59 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-defer-no-new-call-expression.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with (new import.defer('./empty_FIXTURE.js')) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-defer-no-rest-param.js new file mode 100644 index 000000000..6e7e13453 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-defer-no-rest-param.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +with (import.defer(...['./empty_FIXTURE.js'])) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..dde615dce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-source-assignment-expr-not-optional.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with (import.source()) {} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-source-no-new-call-expression.js new file mode 100644 index 000000000..6f3a20073 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-source-no-new-call-expression.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with (new import.source('')) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-source-no-rest-param.js new file mode 100644 index 000000000..cf4a63b95 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-import-source-no-rest-param.js @@ -0,0 +1,42 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +with (import.source(...[''])) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-new-call-expression.js new file mode 100644 index 000000000..f2f9bf564 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-new-call-expression.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +with (new import('')) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-rest-param.js new file mode 100644 index 000000000..bb705a744 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-no-rest-param.js @@ -0,0 +1,41 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +with (import(...[''])) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-not-extensible-args.js new file mode 100644 index 000000000..1a1f8934d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-not-extensible-args.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: ImportCall is not extensible - no arguments list (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +with (import('./empty_FIXTURE.js', {}, '')) {} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-typeof-import-call-source-property.js new file mode 100644 index 000000000..afa433abb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-typeof-import-call-source-property.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with (typeof import.source.UNKNOWN) {} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-typeof-import-source.js new file mode 100644 index 000000000..4c0cac89e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-typeof-import-source.js @@ -0,0 +1,36 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with (typeof import.source) {} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-typeof-import.js new file mode 100644 index 000000000..984de4d96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-expression-typeof-import.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-with-expression.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested with syntax in the expression position) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +with (typeof import) {} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-call-unknown.js new file mode 100644 index 000000000..c4d58005c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-call-unknown.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: It's a SyntaxError on unknown import call (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with ({}) { + import.UNKNOWN('./empty_FIXTURE.js'); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..ed4719441 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with ({}) { + import.defer(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..990418f49 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-defer-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with ({}) { + new import.defer('./empty_FIXTURE.js'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-defer-no-rest-param.js new file mode 100644 index 000000000..46f3d58e2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-defer-no-rest-param.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +with ({}) { + import.defer(...['./empty_FIXTURE.js']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..501815b25 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-source-assignment-expr-not-optional.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with ({}) { + import.source(); +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-source-no-new-call-expression.js new file mode 100644 index 000000000..6c5c2aded --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-source-no-new-call-expression.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with ({}) { + new import.source(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-source-no-rest-param.js new file mode 100644 index 000000000..50f0b5c33 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-import-source-no-rest-param.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +with ({}) { + import.source(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-no-new-call-expression.js new file mode 100644 index 000000000..f42ac710c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-no-new-call-expression.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +with ({}) { + new import(''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-no-rest-param.js new file mode 100644 index 000000000..aa6499125 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-no-rest-param.js @@ -0,0 +1,43 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: ImportCall is not extensible - no rest parameter (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +with ({}) { + import(...['']); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-not-extensible-args.js new file mode 100644 index 000000000..5f3fec655 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-not-extensible-args.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: ImportCall is not extensible - no arguments list (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +with ({}) { + import('./empty_FIXTURE.js', {}, ''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-typeof-import-call-source-property.js new file mode 100644 index 000000000..f4a8bbf23 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-typeof-import-call-source-property.js @@ -0,0 +1,39 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: It's a SyntaxError on unexpected import source property (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with ({}) { + typeof import.source.UNKNOWN; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-typeof-import-source.js new file mode 100644 index 000000000..dce995136 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-typeof-import-source.js @@ -0,0 +1,38 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +with ({}) { + typeof import.source; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-typeof-import.js new file mode 100644 index 000000000..c33fd3fdf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/nested-with-typeof-import.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/nested-with.template +/*--- +description: It's a SyntaxError if '()' is omitted (nested with syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated, noStrict] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + 1. Let referencingScriptOrModule be ! GetActiveScriptOrModule(). + 2. Assert: referencingScriptOrModule is a Script Record or Module Record (i.e. is not null). + 3. Let argRef be the result of evaluating AssignmentExpression. + 4. Let specifier be ? GetValue(argRef). + 5. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 6. Let specifierString be ToString(specifier). + 7. IfAbruptRejectPromise(specifierString, promiseCapability). + 8. Perform ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability). + 9. Return promiseCapability.[[Promise]]. + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +with ({}) { + typeof import; +} + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-assignment-expr-not-optional.js new file mode 100644 index 000000000..034ccd9ae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-assignment-expr-not-optional.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +import(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-call-unknown.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-call-unknown.js new file mode 100644 index 000000000..c01c1468e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-call-unknown.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-call-unknown.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: It's a SyntaxError on unknown import call (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +import.UNKNOWN('./empty_FIXTURE.js'); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-defer-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-defer-assignment-expr-not-optional.js new file mode 100644 index 000000000..52a01d89b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-defer-assignment-expr-not-optional.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall[Yield, Await] : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +import.defer(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-defer-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-defer-no-new-call-expression.js new file mode 100644 index 000000000..61c8bbecc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-defer-no-new-call-expression.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + CallExpression: + ImportCall + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +new import.defer('./empty_FIXTURE.js'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-defer-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-defer-no-rest-param.js new file mode 100644 index 000000000..253c66231 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-defer-no-rest-param.js @@ -0,0 +1,28 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-defer-no-rest-param.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: ImportCall is not extensible - no rest parameter (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [import-defer, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall : + import . defer ( AssignmentExpression[+In, ?Yield] ) + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +import.defer(...['./empty_FIXTURE.js']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-source-assignment-expr-not-optional.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-source-assignment-expr-not-optional.js new file mode 100644 index 000000000..c4cb9a6ab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-source-assignment-expr-not-optional.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-assignment-expr-not-optional.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: It's a SyntaxError if AssignmentExpression is omitted (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +import.source(); + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-source-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-source-no-new-call-expression.js new file mode 100644 index 000000000..3edffbfde --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-source-no-new-call-expression.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + CallExpression: + ImportCall + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +new import.source(''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-source-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-source-no-rest-param.js new file mode 100644 index 000000000..6a6d26bf5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-import-source-no-rest-param.js @@ -0,0 +1,32 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/import-source-no-rest-param.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: ImportCall is not extensible - no rest parameter (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, source-phase-imports-module-source, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall : + import . source ( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression + +---*/ + +$DONOTEVALUATE(); + +import.source(...['']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-no-new-call-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-no-new-call-expression.js new file mode 100644 index 000000000..77f70fe20 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-no-new-call-expression.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-new-call-expression.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: ImportCall is a CallExpression, it can't be preceded by the new keyword (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + CallExpression: + ImportCall + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) +---*/ + +$DONOTEVALUATE(); + +new import(''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-no-rest-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-no-rest-param.js new file mode 100644 index 000000000..2d4129309 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-no-rest-param.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/no-rest-param.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: ImportCall is not extensible - no rest parameter (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall : + import( AssignmentExpression[+In, ?Yield] ) + + Forbidden Extensions + + - ImportCall must not be extended. + + This production doesn't allow the following production from ArgumentsList: + + ... AssignmentExpression +---*/ + +$DONOTEVALUATE(); + +import(...['']); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-not-extensible-args.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-not-extensible-args.js new file mode 100644 index 000000000..e5a82fde5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-not-extensible-args.js @@ -0,0 +1,28 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/not-extensible-args.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: ImportCall is not extensible - no arguments list (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall : + import( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + import( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) + + Forbidden Extensions + + - ImportCall must not be extended. +---*/ + +$DONOTEVALUATE(); + +import('./empty_FIXTURE.js', {}, ''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-typeof-import-call-source-property.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-typeof-import-call-source-property.js new file mode 100644 index 000000000..041c0f48d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-typeof-import-call-source-property.js @@ -0,0 +1,27 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-call-source-property.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: It's a SyntaxError on unexpected import source property (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall[Yield, Await] : + import ( AssignmentExpression[+In, ?Yield, ?Await] ) + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +typeof import.source.UNKNOWN; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-typeof-import-source.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-typeof-import-source.js new file mode 100644 index 000000000..d19d99f70 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-typeof-import-source.js @@ -0,0 +1,26 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import-source.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: It's a SyntaxError if '()' is omitted (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [source-phase-imports, dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) + +---*/ + +$DONOTEVALUATE(); + +typeof import.source; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-typeof-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-typeof-import.js new file mode 100644 index 000000000..1d7305ecd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/syntax/invalid/top-level-typeof-import.js @@ -0,0 +1,25 @@ +// This file was procedurally generated from the following sources: +// - src/dynamic-import/typeof-import.case +// - src/dynamic-import/syntax/invalid/top-level.template +/*--- +description: It's a SyntaxError if '()' is omitted (top level syntax) +esid: sec-import-call-runtime-semantics-evaluation +features: [dynamic-import] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ImportCall : + import( AssignmentExpression ) + + + ImportCall[Yield, Await] : + import . source ( AssignmentExpression[+In, ?Yield, ?Await] ) +---*/ + +$DONOTEVALUATE(); + +typeof import; + +/* The params region intentionally empty */ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/update-to-dynamic-import-other_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/update-to-dynamic-import-other_FIXTURE.js new file mode 100644 index 000000000..0f16680f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/update-to-dynamic-import-other_FIXTURE.js @@ -0,0 +1,8 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +var global = Function('return this;')(); + +global.test262Update('other'); + +export default 42; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/update-to-dynamic-import_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/update-to-dynamic-import_FIXTURE.js new file mode 100644 index 000000000..01914d84b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/dynamic-import/update-to-dynamic-import_FIXTURE.js @@ -0,0 +1,10 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +Function('return this;')().test262Update = name => x = name; + +export default function() { + return import('./update-to-dynamic-import-other_FIXTURE.js'); +} + +export var x = 'first'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-bitnot-unary-expression-base.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-bitnot-unary-expression-base.js new file mode 100644 index 000000000..dcccd7bbf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-bitnot-unary-expression-base.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Rick Waldron +esid: sec-unary-operators +description: Exponentiation Expression syntax error, `~` UnaryExpression +info: | + ExponentiationExpression : + UnaryExpression + ... + + UnaryExpression : + ... + `~` UnaryExpression + ... +features: [exponentiation] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +~3 ** 2; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-delete-unary-expression-base.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-delete-unary-expression-base.js new file mode 100644 index 000000000..95b7003b1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-delete-unary-expression-base.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Rick Waldron +esid: sec-unary-operators +description: Exponentiation Expression syntax error, `delete` UnaryExpression +info: | + ExponentiationExpression : + UnaryExpression + ... + + UnaryExpression : + ... + `delete` UnaryExpression + ... +features: [exponentiation] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +delete o.p ** 2; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-logical-not-unary-expression-base.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-logical-not-unary-expression-base.js new file mode 100644 index 000000000..82f12d170 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-logical-not-unary-expression-base.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Rick Waldron +esid: sec-unary-operators +description: Exponentiation Expression syntax error, `!` UnaryExpression +info: | + ExponentiationExpression : + UnaryExpression + ... + + UnaryExpression : + ... + `!` UnaryExpression + ... +features: [exponentiation] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +!1 ** 2; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-negate-unary-expression-base.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-negate-unary-expression-base.js new file mode 100644 index 000000000..372ec1d50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-negate-unary-expression-base.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Rick Waldron +esid: sec-unary-operators +description: Exponentiation Expression syntax error, `-` UnaryExpression +info: | + ExponentiationExpression : + UnaryExpression + ... + + UnaryExpression : + ... + `-` UnaryExpression + ... +features: [exponentiation] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +-3 ** 2; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-plus-unary-expression-base.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-plus-unary-expression-base.js new file mode 100644 index 000000000..b959e0085 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-plus-unary-expression-base.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Rick Waldron +esid: sec-unary-operators +description: Exponentiation Expression syntax error, `+` UnaryExpression +info: | + ExponentiationExpression : + UnaryExpression + ... + + UnaryExpression : + ... + `+` UnaryExpression + ... +features: [exponentiation] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); ++1 ** 2; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-typeof-unary-expression-base.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-typeof-unary-expression-base.js new file mode 100644 index 000000000..3d901e969 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-typeof-unary-expression-base.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Rick Waldron +esid: sec-unary-operators +description: Exponentiation Expression syntax error, `typeof` UnaryExpression +info: | + ExponentiationExpression : + UnaryExpression + ... + + UnaryExpression : + ... + `typeof` UnaryExpression + ... +features: [exponentiation] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +typeof 1 ** 2; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-void-unary-expression-base.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-void-unary-expression-base.js new file mode 100644 index 000000000..ef515afe3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/exponentiation/exp-operator-syntax-error-void-unary-expression-base.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Rick Waldron +esid: sec-unary-operators +description: Exponentiation Expression syntax error, `void` UnaryExpression +info: | + ExponentiationExpression : + UnaryExpression + ... + + UnaryExpression : + ... + `void` UnaryExpression + ... +features: [exponentiation] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +void 1 ** 2; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..096d4e8a3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/array-destructuring-param-strict-body.js @@ -0,0 +1,132 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/func-expr.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, function([element]) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dflt-params-duplicates.js new file mode 100644 index 000000000..46c93e701 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dflt-params-duplicates.js @@ -0,0 +1,61 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/func-expr.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, function(x = 0, x) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dflt-params-rest.js new file mode 100644 index 000000000..81af424a3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dflt-params-rest.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/func-expr.template +/*--- +description: RestParameter does not support an initializer (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, function(...x = []) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..7c84ff325 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-init-ary.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/func-expr.template +/*--- +description: Rest element (nested array pattern) does not support initializer (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...[ x ] = []]) { + + callCount = callCount + 1; +}; + +f([]); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..bde627f4c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-init-id.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/func-expr.template +/*--- +description: Rest element (identifier) does not support initializer (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...x = []]) { + + callCount = callCount + 1; +}; + +f([]); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..4abfee44b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-init-obj.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/func-expr.template +/*--- +description: Rest element (nested object pattern) does not support initializer (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...{ x } = []]) { + + callCount = callCount + 1; +}; + +f([]); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..cfc91c25c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/func-expr.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...[x], y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..20f6f2c10 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-not-final-id.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/func-expr.template +/*--- +description: Rest element (identifier) may not be followed by any element (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...x, y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..43f08928c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/func-expr.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...{ x }, y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..151b3b15f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/func-expr-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (function expression (default parameter)) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...[ x ] = []] = []) { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..014003bd5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/func-expr-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (function expression (default parameter)) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...x = []] = []) { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..9c293a228 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/func-expr-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (function expression (default parameter)) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...{ x } = []] = []) { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..23d3c77f5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/func-expr-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (function expression (default parameter)) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..c37cd348c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/func-expr-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (function expression (default parameter)) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..53328f16e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/dstr/dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/func-expr-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (function expression (default parameter)) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f(); +assert.sameValue(callCount, 1, 'function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-body-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-body-super-call.js new file mode 100644 index 000000000..24a88c8b3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-body-super-call.js @@ -0,0 +1,18 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-function-definitions-static-semantics-early-errors +es6id: 14.1.2 +description: Body may not contain a "super" call +info: | + It is a Syntax Error if FunctionBody Contains SuperCall is true. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, function() { + super(); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-body-super-prop.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-body-super-prop.js new file mode 100644 index 000000000..74f70bede --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-body-super-prop.js @@ -0,0 +1,18 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-function-definitions-static-semantics-early-errors +es6id: 14.1.2 +description: Body may not contain a "super" property reference +info: | + It is a Syntax Error if FunctionBody Contains SuperProperty is true. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, function() { + super.x; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-call-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-call-expression-bad-reference.js new file mode 100644 index 000000000..7e9fbc6da --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-call-expression-bad-reference.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-bad-reference.case +// - src/invalid-private-names/default/function-expr.template +/*--- +description: bad reference in call expression (Invalid private names should throw a SyntaxError, inside function expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var fn = function() { (() => {})().#x }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-call-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-call-expression-this.js new file mode 100644 index 000000000..bffe459c2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-call-expression-this.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-this.case +// - src/invalid-private-names/default/function-expr.template +/*--- +description: this evaluated in call expression (Invalid private names should throw a SyntaxError, inside function expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var fn = function() { (() => this)().#x }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-member-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-member-expression-bad-reference.js new file mode 100644 index 000000000..9221b4114 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-member-expression-bad-reference.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-bad-reference.case +// - src/invalid-private-names/default/function-expr.template +/*--- +description: bad reference in member expression (Invalid private names should throw a SyntaxError, inside function expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var fn = function() { something.#x }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-member-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-member-expression-this.js new file mode 100644 index 000000000..4485da535 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-errors/invalid-names-member-expression-this.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-this.case +// - src/invalid-private-names/default/function-expr.template +/*--- +description: this reference in member expression (Invalid private names should throw a SyntaxError, inside function expression) +esid: sec-static-semantics-early-errors +features: [class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +var fn = function() { this.#x }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-params-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-params-super-call.js new file mode 100644 index 000000000..b2dd6a766 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-params-super-call.js @@ -0,0 +1,16 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-function-definitions-static-semantics-early-errors +es6id: 14.1.2 +description: Parameters may not contain a "super" call +info: | + It is a Syntax Error if FormalParameters Contains SuperProperty is true. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, function(x = super()) {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-params-super-prop.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-params-super-prop.js new file mode 100644 index 000000000..c7d247207 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/early-params-super-prop.js @@ -0,0 +1,16 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-function-definitions-static-semantics-early-errors +es6id: 14.1.2 +description: Parameters may not contain a "super" property reference +info: | + It is a Syntax Error if FunctionBody Contains SuperProperty is true. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, function(x = super.x) {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-arguments-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-arguments-strict-body.js new file mode 100644 index 000000000..28266383f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-arguments-strict-body.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 13.1-42-s +description: > + StrictMode - SyntaxError is thrown if 'arguments' occurs as the + Identifier of a FunctionExpression whose FunctionBody is contained + in strict code +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +(function arguments() {'use strict';}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-arguments-strict.js new file mode 100644 index 000000000..92f45a06b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-arguments-strict.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 13.1-14-s +description: > + StrictMode - SyntaxError is thrown if 'arguments' occurs as the + Identifier of a FunctionExpression in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +(function arguments() {}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-eval-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-eval-strict-body.js new file mode 100644 index 000000000..80b4bf5ab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-eval-strict-body.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 13.1-38-s +description: > + StrictMode - SyntaxError is thrown if 'eval' occurs as the + Identifier of a FunctionExpression whose FunctionBody is contained + in strict code +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +(function eval() {'use strict';}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-eval-strict.js new file mode 100644 index 000000000..1d2ba1ec9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/name-eval-strict.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 13.1-12-s +description: > + StrictMode - SyntaxError is thrown if 'eval' occurs as the + Identifier of a FunctionExpression in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +(function eval() {}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..3aab1c86f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/object-destructuring-param-strict-body.js @@ -0,0 +1,132 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/func-expr.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, function({property}) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-dflt-yield-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-dflt-yield-strict.js new file mode 100644 index 000000000..a59059202 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-dflt-yield-strict.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-function-definitions +es6id: 14.1 +description: > + The `yield` token is interpreted as an IdentifierReference within a generator + and outside of strict mode +info: | + FunctionExpression : + function BindingIdentifieropt ( FormalParameters ) { FunctionBody } +features: [generators, default-parameters] +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function *g() { + 0, function(x = yield) { + paramValue = x; + }; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-1.js new file mode 100644 index 000000000..88746b5b4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-1.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Refer 13.1; + It is a SyntaxError if any Identifier value occurs more than once within a FormalParameterList of a strict mode + FunctionDeclaration or FunctionExpression. +es5id: 13.1-8-s +description: > + Strict Mode - SyntaxError is thrown if a function is created in + 'strict mode' using a FunctionExpression and the function has two + identical parameters +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +(function (param, param) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-2.js new file mode 100644 index 000000000..6042ebce5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-2.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Refer 13.1; + It is a SyntaxError if any Identifier value occurs more than once within a FormalParameterList of a strict mode + FunctionDeclaration or FunctionExpression. +es5id: 13.1-9-s +description: > + Strict Mode - SyntaxError is thrown if a function is created in + 'strict mode' using a FunctionExpression and the function has two + identical parameters, which are separated by a unique parameter + name +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +(function (param1, param2, param1) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-3.js new file mode 100644 index 000000000..8d8e5ed12 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-3.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Refer 13.1; + It is a SyntaxError if any Identifier value occurs more than once within a FormalParameterList of a strict mode + FunctionDeclaration or FunctionExpression. +es5id: 13.1-10-s +description: > + Strict Mode - SyntaxError is thrown if a function is created in + 'strict mode' using a FunctionExpression and the function has + three identical parameters +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +(function (param, param, param) { }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-body-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-body-1.js new file mode 100644 index 000000000..c4c2025c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-body-1.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Refer 13.1; + It is a SyntaxError if any Identifier value occurs more than once within a FormalParameterList of a strict mode + FunctionDeclaration or FunctionExpression. +es5id: 13.1-30-s +description: > + Strict Mode - SyntaxError is thrown if a function is created using + a FunctionExpression whose FunctionBody is contained in strict + code and the function has two identical parameters +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +(function (param, param) { 'use strict'; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-body-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-body-2.js new file mode 100644 index 000000000..d50e8fcc2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-body-2.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Refer 13.1; + It is a SyntaxError if any Identifier value occurs more than once within a FormalParameterList of a strict mode + FunctionDeclaration or FunctionExpression. +es5id: 13.1-32-s +description: > + Strict Mode - SyntaxError is thrown if a function is created using + a FunctionExpression whose FunctionBody is strict and the function + has two identical parameters, which are separated by a unique + parameter name +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +(function (param1, param2, param1) { 'use strict'; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-body-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-body-3.js new file mode 100644 index 000000000..a575f0155 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-duplicated-strict-body-3.js @@ -0,0 +1,21 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Refer 13.1; + It is a SyntaxError if any Identifier value occurs more than once within a FormalParameterList of a strict mode + FunctionDeclaration or FunctionExpression. +es5id: 13.1-34-s +description: > + Strict Mode - SyntaxError is thrown if a function declaration has + three identical parameters with a strict mode body +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +(function (param, param, param) { 'use strict'; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-eval-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-eval-strict-body.js new file mode 100644 index 000000000..e4a600659 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/param-eval-strict-body.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Refer 13.1; + It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs within a FormalParameterList + of a strict mode FunctionDeclaration or FunctionExpression. +es5id: 13.1-18-s +description: > + StrictMode - SyntaxError is thrown if the identifier 'eval' + appears within a FormalParameterList of a strict mode + FunctionExpression when FuctionBody is strict code +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +(function (eval) { 'use strict'; }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/rest-param-strict-body.js new file mode 100644 index 000000000..67c2eb96a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/rest-param-strict-body.js @@ -0,0 +1,132 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/func-expr.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, function(a,...rest) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..8fd9b1ca5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/rest-params-trailing-comma-early-error.js @@ -0,0 +1,57 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/func-expr.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (function expression) +esid: sec-function-definitions-runtime-semantics-evaluation +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + FunctionExpression : function ( FormalParameters ) { FunctionBody } + + [...] + 3. Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, + scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, function(...a,) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/use-strict-with-non-simple-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/use-strict-with-non-simple-param.js new file mode 100644 index 000000000..b8317b67d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/function/use-strict-with-non-simple-param.js @@ -0,0 +1,21 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-function-definitions-static-semantics-early-errors +description: > + A SyntaxError is thrown if a function contains a non-simple parameter list and a UseStrict directive. +info: | + Static Semantics: Early Errors + + It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of FormalParameters is false. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var f = function(a = 0) { + "use strict"; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/array-destructuring-param-strict-body.js new file mode 100644 index 000000000..c5a7fc363 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/array-destructuring-param-strict-body.js @@ -0,0 +1,133 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/gen-func-expr.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, function*([element]) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dflt-params-duplicates.js new file mode 100644 index 000000000..45b476979 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dflt-params-duplicates.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/gen-func-expr.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [default-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, function*(x = 0, x) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dflt-params-rest.js new file mode 100644 index 000000000..e65fabd22 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dflt-params-rest.js @@ -0,0 +1,66 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/gen-func-expr.template +/*--- +description: RestParameter does not support an initializer (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [default-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, function*(...x = []) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..63370f4a8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-init-ary.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/gen-func-expr.template +/*--- +description: Rest element (nested array pattern) does not support initializer (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...[ x ] = []]) { + + callCount = callCount + 1; +}; + +f([]).next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..a40390af9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-init-id.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/gen-func-expr.template +/*--- +description: Rest element (identifier) does not support initializer (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...x = []]) { + + callCount = callCount + 1; +}; + +f([]).next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..af2a87948 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-init-obj.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/gen-func-expr.template +/*--- +description: Rest element (nested object pattern) does not support initializer (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...{ x } = []]) { + + callCount = callCount + 1; +}; + +f([]).next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..3fce6911a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/gen-func-expr.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...[x], y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..d2eb6329d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-not-final-id.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/gen-func-expr.template +/*--- +description: Rest element (identifier) may not be followed by any element (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...x, y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..483fa3164 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/gen-func-expr.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...{ x }, y]) { + + callCount = callCount + 1; +}; + +f([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..31f2da9c3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/gen-func-expr-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (generator function expression (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...[ x ] = []] = []) { + + callCount = callCount + 1; +}; + +f().next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..db4edebb6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/gen-func-expr-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (generator function expression (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...x = []] = []) { + + callCount = callCount + 1; +}; + +f().next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..3ef5e7758 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/gen-func-expr-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (generator function expression (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...{ x } = []] = []) { + + callCount = callCount + 1; +}; + +f().next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..0be2498fa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/gen-func-expr-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (generator function expression (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f().next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..86ee44795 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/gen-func-expr-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (generator function expression (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f().next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..c03d65f6a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/dstr/dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/gen-func-expr-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (generator function expression (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var f; +f = function*([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; +}; + +f().next(); +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..6494e8432 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-binding-identifier-escaped.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier-escaped.case +// - src/generators/syntax/expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Named generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *g() { + var yi\u0065ld; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-binding-identifier.js new file mode 100644 index 000000000..1d9357054 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-binding-identifier.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier.case +// - src/generators/syntax/expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Named generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *g() { + var yield; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..4d122fb06 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-identifier-reference-escaped.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference-escaped.case +// - src/generators/syntax/expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Named generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *g() { + void yi\u0065ld; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-identifier-reference.js new file mode 100644 index 000000000..2fd35f2cb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-identifier-reference.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference.case +// - src/generators/syntax/expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Named generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *g() { + void yield; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..fbe9ecf3e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-label-identifier-escaped.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier-escaped.case +// - src/generators/syntax/expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Named generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *g() { + yi\u0065ld: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-label-identifier.js new file mode 100644 index 000000000..1bc801cf8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-as-label-identifier.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier.case +// - src/generators/syntax/expression-named.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Named generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *g() { + yield: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-identifier-spread-strict.js new file mode 100644 index 000000000..9ea3df2e5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-identifier-spread-strict.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-spread-strict.case +// - src/generators/default/expression-named.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Named generator expression) +esid: prod-GeneratorExpression +features: [object-spread, generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var gen = function *g() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } +}; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-identifier-strict.js new file mode 100644 index 000000000..7bbe4e64d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/named-yield-identifier-strict.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-strict.case +// - src/generators/default/expression-named.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Named generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var gen = function *g() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) +}; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/object-destructuring-param-strict-body.js new file mode 100644 index 000000000..7a368e55f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/object-destructuring-param-strict-body.js @@ -0,0 +1,133 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/gen-func-expr.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, function*({property}) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/param-dflt-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/param-dflt-yield.js new file mode 100644 index 000000000..cfdd00f03 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/param-dflt-yield.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-generator-function-definitions +es6id: 14.4 +description: > + YieldExpression cannot be used within the FormalParameters of a generator + function +info: | + GeneratorExpression : + + function * BindingIdentifier[Yield]opt ( FormalParameters[Yield] ) { GeneratorBody } + + YieldExpression cannot be used within the FormalParameters of a generator + function because any expressions that are part of FormalParameters are + evaluated before the resulting generator object is in a resumable state. +features: [generators, default-parameters] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, function*(x = yield) {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/rest-param-strict-body.js new file mode 100644 index 000000000..8286d909e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/rest-param-strict-body.js @@ -0,0 +1,133 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/gen-func-expr.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, function*(a,...rest) { + "use strict"; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..aecf5c32b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/rest-params-trailing-comma-early-error.js @@ -0,0 +1,59 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/gen-func-expr.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (generator function expression) +esid: sec-generator-function-definitions-runtime-semantics-evaluation +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorExpression : function * ( FormalParameters ) { GeneratorBody } + + [...] + 3. Let closure be GeneratorFunctionCreate(Normal, FormalParameters, + GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, function*(...a,) { + +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/use-strict-with-non-simple-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/use-strict-with-non-simple-param.js new file mode 100644 index 000000000..64979d74f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/use-strict-with-non-simple-param.js @@ -0,0 +1,22 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-generator-function-definitions-static-semantics-early-errors +description: > + A SyntaxError is thrown if a generator contains a non-simple parameter list and a UseStrict directive. +info: | + Static Semantics: Early Errors + + It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and IsSimpleParameterList of FormalParameters is false. +negative: + phase: parse + type: SyntaxError +features: [generators] +---*/ + +$DONOTEVALUATE(); + +var f = function*(a = 0) { + "use strict"; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..c09efac65 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-binding-identifier-escaped.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier-escaped.case +// - src/generators/syntax/expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Unnamed generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *() { + var yi\u0065ld; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-binding-identifier.js new file mode 100644 index 000000000..7d88f95dd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-binding-identifier.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier.case +// - src/generators/syntax/expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Unnamed generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *() { + var yield; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-generator-expression-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-generator-expression-binding-identifier.js new file mode 100644 index 000000000..55edb36a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-generator-expression-binding-identifier.js @@ -0,0 +1,17 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + `yield` is not a valid BindingIdentifier for GeneratorExpressions. +es6id: 12.1.1 +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +features: [generators] +---*/ + +$DONOTEVALUATE(); + +var g = function* yield() {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..2010eb824 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-identifier-reference-escaped.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference-escaped.case +// - src/generators/syntax/expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Unnamed generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *() { + void yi\u0065ld; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-identifier-reference.js new file mode 100644 index 000000000..4d8b522cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-identifier-reference.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference.case +// - src/generators/syntax/expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Unnamed generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *() { + void yield; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..ed82d0341 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-label-identifier-escaped.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier-escaped.case +// - src/generators/syntax/expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Unnamed generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *() { + yi\u0065ld: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-label-identifier.js new file mode 100644 index 000000000..455f2447e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-label-identifier.js @@ -0,0 +1,29 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier.case +// - src/generators/syntax/expression.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Unnamed generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var gen = function *() { + yield: ; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-logical-or-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-logical-or-expression.js new file mode 100644 index 000000000..178a5a513 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-logical-or-expression.js @@ -0,0 +1,19 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + `yield` expressions are not LogicalOrExpressions. +es6id: 12.1.1 +negative: + phase: parse + type: SyntaxError +features: [generators] +---*/ + +$DONOTEVALUATE(); + + +var g = function*() { + yield ? yield : yield; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-parameter.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-parameter.js new file mode 100644 index 000000000..a8afd52b0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-as-parameter.js @@ -0,0 +1,17 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + `yield` is a reserved keyword within generator function bodies and may + not be used as the binding identifier of a parameter. +es6id: 12.1.1 +negative: + phase: parse + type: SyntaxError +features: [generators] +---*/ + +$DONOTEVALUATE(); + +var g = function*(yield) {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-identifier-spread-strict.js new file mode 100644 index 000000000..25cfa982c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-identifier-spread-strict.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-spread-strict.case +// - src/generators/default/expression.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Unnamed generator expression) +esid: prod-GeneratorExpression +features: [object-spread, generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var gen = function *() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } +}; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-identifier-strict.js new file mode 100644 index 000000000..accc02062 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-identifier-strict.js @@ -0,0 +1,35 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-strict.case +// - src/generators/default/expression.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Unnamed generator expression) +esid: prod-GeneratorExpression +features: [generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorExpression: + function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody } + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var gen = function *() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) +}; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-star-after-newline.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-star-after-newline.js new file mode 100644 index 000000000..6b256f857 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-star-after-newline.js @@ -0,0 +1,19 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + A newline may not precede the `*` token in a `yield` expression. +es6id: 14.4 +negative: + phase: parse + type: SyntaxError +features: [generators] +---*/ + +$DONOTEVALUATE(); + +var g = function*() { + yield + * 1 +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-weak-binding.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-weak-binding.js new file mode 100644 index 000000000..608f18968 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/generators/yield-weak-binding.js @@ -0,0 +1,16 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + `yield` expressions bind weakly +es6id: 14.4 +negative: + phase: parse + type: SyntaxError +features: [generators] +---*/ + +$DONOTEVALUATE(); + +var g = function*() { yield 3 + yield 4; }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/escape-sequence-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/escape-sequence-import.js new file mode 100644 index 000000000..4d06eea72 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/escape-sequence-import.js @@ -0,0 +1,34 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-left-hand-side-expressions +description: > + "import" in import.meta must not contain escape sequences. +info: | + 5.1.5 Grammar Notation + + Terminal symbols are shown in fixed width + font, both in the productions of the grammars and throughout this specification whenever the + text directly refers to such a terminal symbol. These are to appear in a script exactly as + written. All terminal symbol code points specified in this way are to be understood as the + appropriate Unicode code points from the Basic Latin range, as opposed to any similar-looking + code points from other Unicode ranges. + + 12.3 Left-Hand-Side Expressions + MetaProperty: + NewTarget + ImportMeta + + ImportMeta: + import.meta +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta] +---*/ + +$DONOTEVALUATE(); + +im\u0070ort.meta; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/escape-sequence-meta.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/escape-sequence-meta.js new file mode 100644 index 000000000..deb2ef150 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/escape-sequence-meta.js @@ -0,0 +1,34 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-left-hand-side-expressions +description: > + "meta" in import.meta must not contain escape sequences. +info: | + 5.1.5 Grammar Notation + + Terminal symbols are shown in fixed width + font, both in the productions of the grammars and throughout this specification whenever the + text directly refers to such a terminal symbol. These are to appear in a script exactly as + written. All terminal symbol code points specified in this way are to be understood as the + appropriate Unicode code points from the Basic Latin range, as opposed to any similar-looking + code points from other Unicode ranges. + + 12.3 Left-Hand-Side Expressions + MetaProperty: + NewTarget + ImportMeta + + ImportMeta: + import.meta +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta] +---*/ + +$DONOTEVALUATE(); + +import.m\u0065ta; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/goal-script.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/goal-script.js new file mode 100644 index 000000000..882cd4785 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/goal-script.js @@ -0,0 +1,18 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-left-hand-side-expressions-static-semantics-early-errors +description: > + An early Syntax Error is thrown when the syntactic goal symbol is Script. +info: | + It is an early Syntax Error if Module is not the syntactic goal symbol. +negative: + phase: parse + type: SyntaxError +features: [import.meta] +---*/ + +$DONOTEVALUATE(); + +import.meta; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-array-destructuring-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-array-destructuring-expr.js new file mode 100644 index 000000000..65c9dc4b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-array-destructuring-expr.js @@ -0,0 +1,31 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-static-semantics-static-semantics-assignmenttargettype +description: > + import.meta is not a valid assignment target. +info: | + Static Semantics: AssignmentTargetType + + ImportMeta: + import.meta + + Return invalid. + + 12.15.5.1 Static Semantics: Early Errors + + DestructuringAssignmentTarget : LeftHandSideExpression + + It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral + and AssignmentTargetType(LeftHandSideExpression) is not simple. +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta, destructuring-assignment] +---*/ + +$DONOTEVALUATE(); + +[import.meta] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-array-rest-destructuring-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-array-rest-destructuring-expr.js new file mode 100644 index 000000000..2bd4f477c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-array-rest-destructuring-expr.js @@ -0,0 +1,31 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-static-semantics-static-semantics-assignmenttargettype +description: > + import.meta is not a valid assignment target. +info: | + Static Semantics: AssignmentTargetType + + ImportMeta: + import.meta + + Return invalid. + + 12.15.5.1 Static Semantics: Early Errors + + DestructuringAssignmentTarget : LeftHandSideExpression + + It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral + and AssignmentTargetType(LeftHandSideExpression) is not simple. +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta, destructuring-assignment] +---*/ + +$DONOTEVALUATE(); + +[...import.meta] = []; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-assignment-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-assignment-expr.js new file mode 100644 index 000000000..65ca9098a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-assignment-expr.js @@ -0,0 +1,31 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-static-semantics-static-semantics-assignmenttargettype +description: > + import.meta is not a valid assignment target. +info: | + Static Semantics: AssignmentTargetType + + ImportMeta: + import.meta + + Return invalid. + + 12.15.1 Static Semantics: Early Errors + + AssignmentExpression : LeftHandSideExpression = AssignmentExpression + + It is an early Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an + ArrayLiteral and AssignmentTargetType of LeftHandSideExpression is invalid or strict. +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta] +---*/ + +$DONOTEVALUATE(); + +import.meta = 0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-for-await-of-loop.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-for-await-of-loop.js new file mode 100644 index 000000000..a5c28cb3a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-for-await-of-loop.js @@ -0,0 +1,32 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-static-semantics-static-semantics-assignmenttargettype +description: > + import.meta is not a valid assignment target. +info: | + Static Semantics: AssignmentTargetType + + ImportMeta: + import.meta + + Return invalid. + + 13.7.5.1 Static Semantics: Early Errors + IterationStatement: + for await ( LeftHandSideExpression of AssignmentExpression ) Statement + + It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta, async-iteration] +---*/ + +$DONOTEVALUATE(); + +async function* f() { + for await (import.meta of null) ; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-for-in-loop.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-for-in-loop.js new file mode 100644 index 000000000..84367470f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-for-in-loop.js @@ -0,0 +1,30 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-static-semantics-static-semantics-assignmenttargettype +description: > + import.meta is not a valid assignment target. +info: | + Static Semantics: AssignmentTargetType + + ImportMeta: + import.meta + + Return invalid. + + 13.7.5.1 Static Semantics: Early Errors + IterationStatement: + for ( LeftHandSideExpression in Expression ) Statement + + It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta] +---*/ + +$DONOTEVALUATE(); + +for (import.meta in null) ; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-for-of-loop.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-for-of-loop.js new file mode 100644 index 000000000..c7b3ea259 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-for-of-loop.js @@ -0,0 +1,30 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-static-semantics-static-semantics-assignmenttargettype +description: > + import.meta is not a valid assignment target. +info: | + Static Semantics: AssignmentTargetType + + ImportMeta: + import.meta + + Return invalid. + + 13.7.5.1 Static Semantics: Early Errors + IterationStatement: + for ( LeftHandSideExpression of AssignmentExpression ) Statement + + It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta] +---*/ + +$DONOTEVALUATE(); + +for (import.meta of null) ; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-object-destructuring-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-object-destructuring-expr.js new file mode 100644 index 000000000..1c6bc2101 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-object-destructuring-expr.js @@ -0,0 +1,31 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-static-semantics-static-semantics-assignmenttargettype +description: > + import.meta is not a valid assignment target. +info: | + Static Semantics: AssignmentTargetType + + ImportMeta: + import.meta + + Return invalid. + + 12.15.5.1 Static Semantics: Early Errors + + DestructuringAssignmentTarget : LeftHandSideExpression + + It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral + and AssignmentTargetType(LeftHandSideExpression) is not simple. +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta, destructuring-assignment] +---*/ + +$DONOTEVALUATE(); + +({a: import.meta} = {}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-object-rest-destructuring-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-object-rest-destructuring-expr.js new file mode 100644 index 000000000..b4fde0ec8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-object-rest-destructuring-expr.js @@ -0,0 +1,31 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-static-semantics-static-semantics-assignmenttargettype +description: > + import.meta is not a valid assignment target. +info: | + Static Semantics: AssignmentTargetType + + ImportMeta: + import.meta + + Return invalid. + + 12.15.5.1 Static Semantics: Early Errors + + DestructuringAssignmentTarget : LeftHandSideExpression + + It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral + and AssignmentTargetType(LeftHandSideExpression) is not simple. +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta, destructuring-assignment, object-rest] +---*/ + +$DONOTEVALUATE(); + +({...import.meta} = {}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-update-expr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-update-expr.js new file mode 100644 index 000000000..85bf62b34 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/import.meta/syntax/invalid-assignment-target-update-expr.js @@ -0,0 +1,32 @@ +// Copyright (C) 2018 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-static-semantics-static-semantics-assignmenttargettype +description: > + import.meta is not a valid assignment target. +info: | + Static Semantics: AssignmentTargetType + + ImportMeta: + import.meta + + Return invalid. + + 12.4.1 Static Semantics: Early Errors + + UpdateExpression: + LeftHandSideExpression++ + LeftHandSideExpression-- + + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is invalid or strict. +flags: [module] +negative: + phase: parse + type: SyntaxError +features: [import.meta] +---*/ + +$DONOTEVALUATE(); + +import.meta++; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-in-nested.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-in-nested.js new file mode 100644 index 000000000..60da762cb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-in-nested.js @@ -0,0 +1,27 @@ +// Copyright (C) 2021 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Can't nest `in` expressions when the left-hand side is PrivateIdentifier. +info: | + Syntax + RelationalExpression[In, Yield, Await]: + [...] + [+In]PrivateIdentifier in ShiftExpression[?Yield, ?Await] +esid: sec-relational-operators +negative: + phase: parse + type: SyntaxError +features: [class-fields-private, class-fields-private-in] +---*/ + +$DONOTEVALUATE(); + +class C { + #field; + + constructor() { + #field in #field in this; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-in.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-in.js new file mode 100644 index 000000000..e246c5c43 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-in.js @@ -0,0 +1,26 @@ +// Copyright 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Requires the `In` parsing parameter +info: | + Syntax + RelationalExpression[In, Yield, Await]: + [...] + [+In]PrivateIdentifier in ShiftExpression[?Yield, ?Await] +esid: sec-relational-operators-runtime-semantics-evaluation +negative: + phase: parse + type: SyntaxError +features: [class-fields-private, class-fields-private-in] +---*/ + +$DONOTEVALUATE(); + +class C { + #field; + + constructor() { + for (#field in value;;) break; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-assignment-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-assignment-reference.js new file mode 100644 index 000000000..bc5b5cb38 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-assignment-reference.js @@ -0,0 +1,25 @@ +// Copyright (C) 2021 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Private identifiers aren't valid simple assignment references. +info: | + Syntax + for ( LeftHandSideExpression in Expression ) Statement +esid: sec-for-in-and-for-of-statements-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [class-fields-private, class-fields-private-in] +---*/ + +$DONOTEVALUATE(); + +class C { + #field; + + m() { + for (#field in []) ; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-assignment-target.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-assignment-target.js new file mode 100644 index 000000000..df79191eb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-assignment-target.js @@ -0,0 +1,31 @@ +// Copyright 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Rejected as assignment target +info: | + 12.10.5 Static Semantics: AllPrivateIdentifiersValid + + AllPrivateIdentifiersValid is an abstract operation which takes names as an argument. + + RelationalExpression:PrivateIdentifierinShiftExpression + + 1. If StringValue of PrivateIdentifier is in names, return true. + 2. Return false. + +esid: sec-relational-operators-runtime-semantics-evaluation +negative: + phase: parse + type: SyntaxError +features: [class-fields-private, class-fields-private-in] +---*/ + +$DONOTEVALUATE(); + +class C { + #field; + + constructor() { + #field in {} = 0; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-identifier-complex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-identifier-complex.js new file mode 100644 index 000000000..d31fb0411 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-identifier-complex.js @@ -0,0 +1,31 @@ +// Copyright 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Invalid private identifier - complex case +info: | + 12.10.5 Static Semantics: AllPrivateIdentifiersValid + + AllPrivateIdentifiersValid is an abstract operation which takes names as an argument. + + RelationalExpression:PrivateIdentifierinShiftExpression + + 1. If StringValue of PrivateIdentifier is in names, return true. + 2. Return false. + +esid: sec-relational-operators-runtime-semantics-evaluation +negative: + phase: parse + type: SyntaxError +features: [class-fields-private, class-fields-private-in] +---*/ + +$DONOTEVALUATE(); + +class C { + #a; + + constructor() { + #b in {}; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-identifier-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-identifier-simple.js new file mode 100644 index 000000000..95933db38 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-identifier-simple.js @@ -0,0 +1,25 @@ +// Copyright 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Invalid private identifier - simple case +info: | + 12.10.5 Static Semantics: AllPrivateIdentifiersValid + + AllPrivateIdentifiersValid is an abstract operation which takes names as an argument. + + RelationalExpression:PrivateIdentifierinShiftExpression + + 1. If StringValue of PrivateIdentifier is in names, return true. + 2. Return false. + +esid: sec-relational-operators-runtime-semantics-evaluation +negative: + phase: parse + type: SyntaxError +features: [class-fields-private, class-fields-private-in] +---*/ + +$DONOTEVALUATE(); + +#name in {}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-rhs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-rhs.js new file mode 100644 index 000000000..a21e01251 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-invalid-rhs.js @@ -0,0 +1,26 @@ +// Copyright 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Syntactic grammar restricts right-hand side +info: | + Syntax + RelationalExpression[In, Yield, Await]: + [...] + [+In]PrivateIdentifier in ShiftExpression[?Yield, ?Await] +esid: sec-relational-operators-runtime-semantics-evaluation +negative: + phase: parse + type: SyntaxError +features: [class-fields-private, class-fields-private-in] +---*/ + +$DONOTEVALUATE(); + +class C { + #field; + + constructor() { + #field in () => {}; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-rhs-yield-absent.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-rhs-yield-absent.js new file mode 100644 index 000000000..682d13a87 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/private-field-rhs-yield-absent.js @@ -0,0 +1,33 @@ +// Copyright 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Parsing observes the `Yield` production parameter when present +info: | + Syntax + RelationalExpression[In, Yield, Await]: + [...] + [+In]PrivateIdentifier in ShiftExpression[?Yield, ?Await] + + [...] + + 1. Let privateIdentifier be the StringValue of PrivateIdentifier. + 2. Let rref be the result of evaluating ShiftExpression. + 3. Let rval be ? GetValue(rref). + 4. If Type(rval) is not Object, throw a TypeError exception. +esid: sec-relational-operators-runtime-semantics-evaluation +negative: + phase: parse + type: SyntaxError +features: [class-fields-private, class-fields-private-in] +---*/ + +$DONOTEVALUATE(); + +class C { + #field; + + static method() { + #field in yield; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/rhs-yield-absent-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/rhs-yield-absent-strict.js new file mode 100644 index 000000000..5bb2999fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/in/rhs-yield-absent-strict.js @@ -0,0 +1,20 @@ +// Copyright 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Parsing observes the `Yield` production parameter when absent (within strict mode) +info: | + Syntax + RelationalExpression[In, Yield, Await]: + [...] + [+In] RelationalExpression[+In, ?Yield, ?Await] in ShiftExpression[?Yield, ?Await] +esid: sec-relational-operators +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +'' in (yield); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-arguments-strict.js new file mode 100644 index 000000000..c23e4a88f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-arguments-strict.js @@ -0,0 +1,18 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Logical Assignment + operator(&&=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] +---*/ +$DONOTEVALUATE(); + +arguments &&= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-assignment-operator-non-simple-lhs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-assignment-operator-non-simple-lhs.js new file mode 100644 index 000000000..de37734ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-assignment-operator-non-simple-lhs.js @@ -0,0 +1,19 @@ +// Copyright (c) 2020 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: > + It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is + not simple. +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] + +---*/ + +$DONOTEVALUATE(); + +function test() {} +test() &&= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-eval-strict.js new file mode 100644 index 000000000..345ea960e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-eval-strict.js @@ -0,0 +1,17 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Logical Assignment operator(&&=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] +---*/ +$DONOTEVALUATE(); + +eval &&= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-non-simple.js new file mode 100644 index 000000000..977ace323 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-and-non-simple.js @@ -0,0 +1,17 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Logical "&&=" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] +---*/ +$DONOTEVALUATE(); + +1 &&= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-arguments-strict.js new file mode 100644 index 000000000..499f9ea04 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-arguments-strict.js @@ -0,0 +1,18 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Logical Assignment + operator(??=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] +---*/ +$DONOTEVALUATE(); + +arguments ??= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-assignment-operator-non-simple-lhs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-assignment-operator-non-simple-lhs.js new file mode 100644 index 000000000..ff2dd530a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-assignment-operator-non-simple-lhs.js @@ -0,0 +1,19 @@ +// Copyright (c) 2020 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: > + It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is + not simple. +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] + +---*/ + +$DONOTEVALUATE(); + +function test() {} +test() ??= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-eval-strict.js new file mode 100644 index 000000000..70cd3c9bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-eval-strict.js @@ -0,0 +1,17 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Logical Assignment operator(??=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] +---*/ +$DONOTEVALUATE(); + +eval ??= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-non-simple.js new file mode 100644 index 000000000..fe3121716 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-nullish-non-simple.js @@ -0,0 +1,17 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Logical "??=" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] +---*/ +$DONOTEVALUATE(); + +1 ??= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-arguments-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-arguments-strict.js new file mode 100644 index 000000000..c67b53550 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-arguments-strict.js @@ -0,0 +1,18 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier arguments + appear as the LeftHandSideExpression of a Logical Assignment + operator(||=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] +---*/ +$DONOTEVALUATE(); + +arguments ||= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-assignment-operator-non-simple-lhs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-assignment-operator-non-simple-lhs.js new file mode 100644 index 000000000..ba35c8964 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-assignment-operator-non-simple-lhs.js @@ -0,0 +1,19 @@ +// Copyright (c) 2020 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +description: > + It is a Syntax Error if AssignmentTargetType of LeftHandSideExpression is + not simple. +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] + +---*/ + +$DONOTEVALUATE(); + +function test() {} +test() ||= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-eval-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-eval-strict.js new file mode 100644 index 000000000..1d3a9e234 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-eval-strict.js @@ -0,0 +1,17 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators +description: > + Strict Mode - SyntaxError is thrown if the identifier eval appear + as the LeftHandSideExpression of a Logical Assignment operator(||=) +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] +---*/ +$DONOTEVALUATE(); + +eval ||= 20; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-non-simple.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-non-simple.js new file mode 100644 index 000000000..90639520e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/logical-assignment/lgcl-or-non-simple.js @@ -0,0 +1,17 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-assignment-operators-static-semantics-early-errors +info: | + It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. +description: Logical "||=" assignment with non-simple target +negative: + phase: parse + type: SyntaxError +features: [logical-assignment-operators] +---*/ +$DONOTEVALUATE(); + +1 ||= 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/new.target/escaped-new.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/new.target/escaped-new.js new file mode 100644 index 000000000..aeb9706d3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/new.target/escaped-new.js @@ -0,0 +1,25 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `new` keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function f() { + n\u0065w.target; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/new.target/escaped-target.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/new.target/escaped-target.js new file mode 100644 index 000000000..9c5cb7295 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/new.target/escaped-target.js @@ -0,0 +1,25 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `target` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function f() { + new.t\u0061rget; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/11.1.5-1gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/11.1.5-1gs.js new file mode 100644 index 000000000..2dfbee710 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/11.1.5-1gs.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.1.5-1gs +description: > + Strict Mode - SyntaxError is thrown when 'eval' occurs as the + Identifier in a PropertySetParameterList of a PropertyAssignment + that is contained in strict code +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var obj = { set _11_1_5_1_fun(eval) {}}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/__proto__-duplicate.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/__proto__-duplicate.js new file mode 100644 index 000000000..4a169471c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/__proto__-duplicate.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-__proto__-property-names-in-object-initializers +es6id: B.3.1 +description: Duplicate `__proto__` property +info: | + It is a Syntax Error if PropertyNameList of PropertyDefinitionList contains + any duplicate entries for "__proto__" and at least two of those entries + were obtained from productions of the form + PropertyDefinition : PropertyName : AssignmentExpression . +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + __proto__: null, + other: null, + '__proto__': null +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/cover-initialized-name.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/cover-initialized-name.js new file mode 100644 index 000000000..865795abb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/cover-initialized-name.js @@ -0,0 +1,32 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-object-initializer-static-semantics-early-errors +es6id: 12.2.6.1 +description: Initialized name is explicitly barred from object initializers +info: | + PropertyDefinition : CoverInitializedName + + - Always throw a Syntax Error if code matches this production. + + NOTE This production exists so that ObjectLiteral can serve as a cover + grammar for ObjectAssignmentPattern. It cannot occur in an actual object + initializer. + + 12.2.6 Object Initializer + + Syntax + + [...] + + CoverInitializedName[Yield]: + + IdentifierReference[?Yield] Initializer[+In, ?Yield] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ a = 1 }); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..89bc5cdd2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-ary.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/async-gen-meth.template +/*--- +description: Rest element (nested array pattern) does not support initializer (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...[ x ] = []]) { + + callCount = callCount + 1; + } +}; + +obj.method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..b890b1b69 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-id.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/async-gen-meth.template +/*--- +description: Rest element (identifier) does not support initializer (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...x = []]) { + + callCount = callCount + 1; + } +}; + +obj.method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..7c7081919 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-init-obj.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/async-gen-meth.template +/*--- +description: Rest element (nested object pattern) does not support initializer (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...{ x } = []]) { + + callCount = callCount + 1; + } +}; + +obj.method([]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..f9b514aac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/async-gen-meth.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...[x], y]) { + + callCount = callCount + 1; + } +}; + +obj.method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..82cd4585b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/async-gen-meth.template +/*--- +description: Rest element (identifier) may not be followed by any element (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...x, y]) { + + callCount = callCount + 1; + } +}; + +obj.method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..a3f3ccaeb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/async-gen-meth.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...{ x }, y]) { + + callCount = callCount + 1; + } +}; + +obj.method([1, 2, 3]).next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..3de25e93d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/async-gen-method-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (async generator method (default parameter)) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } +}; + +obj.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..d3431d9f4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/async-gen-method-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (async generator method (default parameter)) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...x = []] = []) { + + callCount = callCount + 1; + } +}; + +obj.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..ac4dd943e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/async-gen-method-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (async generator method (default parameter)) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...{ x } = []] = []) { + + callCount = callCount + 1; + } +}; + +obj.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..b58744ee9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/async-gen-method-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (async generator method (default parameter)) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +obj.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..8c316b163 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/async-gen-method-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (async generator method (default parameter)) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +obj.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..e0c5cd187 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/async-gen-method-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (async generator method (default parameter)) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + + +var callCount = 0; +var obj = { + async *method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +obj.method().next().then(() => { + assert.sameValue(callCount, 1, 'invoked exactly once'); +}).then($DONE, $DONE); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..92bd7ea9b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/gen-meth.template +/*--- +description: Rest element (nested array pattern) does not support initializer (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...[ x ] = []]) { + + callCount = callCount + 1; + } +}; + +obj.method([]).next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..de861f1e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/gen-meth.template +/*--- +description: Rest element (identifier) does not support initializer (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...x = []]) { + + callCount = callCount + 1; + } +}; + +obj.method([]).next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..3c36b6c10 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-init-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/gen-meth.template +/*--- +description: Rest element (nested object pattern) does not support initializer (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...{ x } = []]) { + + callCount = callCount + 1; + } +}; + +obj.method([]).next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..d302e9b30 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/gen-meth.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...[x], y]) { + + callCount = callCount + 1; + } +}; + +obj.method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..2a7e0b32e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/gen-meth.template +/*--- +description: Rest element (identifier) may not be followed by any element (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...x, y]) { + + callCount = callCount + 1; + } +}; + +obj.method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..523e75759 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/gen-meth.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...{ x }, y]) { + + callCount = callCount + 1; + } +}; + +obj.method([1, 2, 3]).next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..ed2c0ddab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/gen-method-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (generator method (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } +}; + +obj.method().next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..aac1e7a56 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/gen-method-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (generator method (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...x = []] = []) { + + callCount = callCount + 1; + } +}; + +obj.method().next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..09ffad3c0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/gen-method-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (generator method (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...{ x } = []] = []) { + + callCount = callCount + 1; + } +}; + +obj.method().next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..da2bc6d1f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/gen-method-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (generator method (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +obj.method().next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..000cf1c5d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/gen-method-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (generator method (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +obj.method().next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..89ca0909c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/gen-meth-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/gen-method-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (generator method (default parameter)) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators, destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + *method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +obj.method().next(); +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..a527f2590 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-init-ary.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/meth.template +/*--- +description: Rest element (nested array pattern) does not support initializer (method) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...[ x ] = []]) { + + callCount = callCount + 1; + } +}; + +obj.method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..1f06e5588 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-init-id.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/meth.template +/*--- +description: Rest element (identifier) does not support initializer (method) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...x = []]) { + + callCount = callCount + 1; + } +}; + +obj.method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..c1777716f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-init-obj.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/meth.template +/*--- +description: Rest element (nested object pattern) does not support initializer (method) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...{ x } = []]) { + + callCount = callCount + 1; + } +}; + +obj.method([]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..1d1a6807c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/meth.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (method) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...[x], y]) { + + callCount = callCount + 1; + } +}; + +obj.method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..16b7f768d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/meth.template +/*--- +description: Rest element (identifier) may not be followed by any element (method) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...x, y]) { + + callCount = callCount + 1; + } +}; + +obj.method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..7c7c77264 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/meth.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (method) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...{ x }, y]) { + + callCount = callCount + 1; + } +}; + +obj.method([1, 2, 3]); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-ary.js new file mode 100644 index 000000000..f564ab5f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-ary.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-ary.case +// - src/dstr-binding/default/meth-dflt.template +/*--- +description: Rest element (nested array pattern) does not support initializer (method (default parameter)) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...[ x ] = []] = []) { + + callCount = callCount + 1; + } +}; + +obj.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-id.js new file mode 100644 index 000000000..27ec5be01 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-id.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-id.case +// - src/dstr-binding/default/meth-dflt.template +/*--- +description: Rest element (identifier) does not support initializer (method (default parameter)) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...x = []] = []) { + + callCount = callCount + 1; + } +}; + +obj.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-obj.js new file mode 100644 index 000000000..35f9e514a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-init-obj.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-init-obj.case +// - src/dstr-binding/default/meth-dflt.template +/*--- +description: Rest element (nested object pattern) does not support initializer (method (default parameter)) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...{ x } = []] = []) { + + callCount = callCount + 1; + } +}; + +obj.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js new file mode 100644 index 000000000..699ec51ce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-ary.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case +// - src/dstr-binding/default/meth-dflt.template +/*--- +description: Rest element (array binding pattern) may not be followed by any element (method (default parameter)) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...[x], y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +obj.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js new file mode 100644 index 000000000..f8b637221 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-id.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-id.case +// - src/dstr-binding/default/meth-dflt.template +/*--- +description: Rest element (identifier) may not be followed by any element (method (default parameter)) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...x, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +obj.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js new file mode 100644 index 000000000..6a91946df --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/dstr/meth-dflt-ary-ptrn-rest-not-final-obj.js @@ -0,0 +1,62 @@ +// This file was procedurally generated from the following sources: +// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case +// - src/dstr-binding/default/meth-dflt.template +/*--- +description: Rest element (object binding pattern) may not be followed by any element (method (default parameter)) +esid: sec-runtime-semantics-definemethod +features: [destructuring-binding, default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3 Destructuring Binding Patterns + ArrayBindingPattern[Yield] : + [ Elisionopt BindingRestElement[?Yield]opt ] + [ BindingElementList[?Yield] ] + [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ] +---*/ +$DONOTEVALUATE(); + +var callCount = 0; +var obj = { + method([...{ x }, y] = [1, 2, 3]) { + + callCount = callCount + 1; + } +}; + +obj.method(); +assert.sameValue(callCount, 1, 'method invoked exactly once'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/getter-body-strict-inside.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/getter-body-strict-inside.js new file mode 100644 index 000000000..d888d6caf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/getter-body-strict-inside.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.1.5_6-2-2-s +description: > + Strict Mode - SyntaxError is thrown when an assignment to a + reserved word or a future reserved word is made inside a strict + mode FunctionBody of a PropertyAssignment +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +void { + get x() { + "use strict"; + public = 42; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/getter-body-strict-outside.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/getter-body-strict-outside.js new file mode 100644 index 000000000..edf31412e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/getter-body-strict-outside.js @@ -0,0 +1,20 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.1.5_6-2-1-s +description: > + Strict Mode - SyntaxError is thrown when an assignment to a + reserved word or a future reserved word is contained in strict code +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +void { + get x() { + public = 42; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/getter-param-dflt.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/getter-param-dflt.js new file mode 100644 index 000000000..8fcc61a40 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/getter-param-dflt.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-method-definitions +es6id: 14.3 +description: > + Get accessor method may not have a formal parameter (regardless of the + presence of an initializer) +info: | + Syntax + + MethodDefinition[Yield] : + + get PropertyName[?Yield] ( ) { FunctionBody } +features: [default-parameters] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0, { get a(param = null) {} }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-implements-invalid-strict-mode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-implements-invalid-strict-mode.js new file mode 100644 index 000000000..30eb84ba4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-implements-invalid-strict-mode.js @@ -0,0 +1,33 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are limited to valid identifier references. Future Reserved Words are disallowed in Strict Mode. (implements) +esid: sec-object-initializer +flags: [noStrict] +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + Identifier : IdentifierName but not ReservedWord + It is a Syntax Error if this phrase is contained in strict mode code and + the StringValue of IdentifierName is: "implements", "interface", "let", + "package", "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var implements = 1; +(function() { + "use strict"; + ({ + implements + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-interface-invalid-strict-mode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-interface-invalid-strict-mode.js new file mode 100644 index 000000000..559cb7797 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-interface-invalid-strict-mode.js @@ -0,0 +1,33 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are limited to valid identifier references. Future Reserved Words are disallowed in Strict Mode. (interface) +esid: sec-object-initializer +flags: [noStrict] +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + Identifier : IdentifierName but not ReservedWord + It is a Syntax Error if this phrase is contained in strict mode code and + the StringValue of IdentifierName is: "implements", "interface", "let", + "package", "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var interface = 1; +(function() { + "use strict"; + ({ + interface + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-invalid-computed-name.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-invalid-computed-name.js new file mode 100644 index 000000000..680350a36 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-invalid-computed-name.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 The V8 Project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are only valid with identifier references, + not computed property names. +esid: sec-object-initializer +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + PropertyName: + LiteralPropertyName + ComputedPropertyName +negative: + phase: parse + type: SyntaxError +---*/ + +var x = "y"; +var y = 42; + +$DONOTEVALUATE(); + +({[x]}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-invalid-zero.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-invalid-zero.js new file mode 100644 index 000000000..d08db2875 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-invalid-zero.js @@ -0,0 +1,22 @@ +// Copyright (C) 2017 The V8 Project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are only valid with identifier references, + not property names. (0) +esid: sec-object-initializer +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({0}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-let-invalid-strict-mode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-let-invalid-strict-mode.js new file mode 100644 index 000000000..6c59c1327 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-let-invalid-strict-mode.js @@ -0,0 +1,33 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are limited to valid identifier references. Future Reserved Words are disallowed in Strict Mode. (let) +esid: sec-object-initializer +flags: [noStrict] +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + Identifier : IdentifierName but not ReservedWord + It is a Syntax Error if this phrase is contained in strict mode code and + the StringValue of IdentifierName is: "implements", "interface", "let", + "package", "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var let = 1; +(function() { + "use strict"; + ({ + let + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-package-invalid-strict-mode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-package-invalid-strict-mode.js new file mode 100644 index 000000000..a23754178 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-package-invalid-strict-mode.js @@ -0,0 +1,33 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are limited to valid identifier references. Future Reserved Words are disallowed in Strict Mode. (package) +esid: sec-object-initializer +flags: [noStrict] +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + Identifier : IdentifierName but not ReservedWord + It is a Syntax Error if this phrase is contained in strict mode code and + the StringValue of IdentifierName is: "implements", "interface", "let", + "package", "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var package = 1; +(function() { + "use strict"; + ({ + package + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-private-invalid-strict-mode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-private-invalid-strict-mode.js new file mode 100644 index 000000000..8901acd67 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-private-invalid-strict-mode.js @@ -0,0 +1,33 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are limited to valid identifier references. Future Reserved Words are disallowed in Strict Mode. (private) +esid: sec-object-initializer +flags: [noStrict] +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + Identifier : IdentifierName but not ReservedWord + It is a Syntax Error if this phrase is contained in strict mode code and + the StringValue of IdentifierName is: "implements", "interface", "let", + "package", "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var private = 1; +(function() { + "use strict"; + ({ + private + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-protected-invalid-strict-mode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-protected-invalid-strict-mode.js new file mode 100644 index 000000000..22ddb72b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-protected-invalid-strict-mode.js @@ -0,0 +1,33 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are limited to valid identifier references. Future Reserved Words are disallowed in Strict Mode. (protected) +esid: sec-object-initializer +flags: [noStrict] +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + Identifier : IdentifierName but not ReservedWord + It is a Syntax Error if this phrase is contained in strict mode code and + the StringValue of IdentifierName is: "implements", "interface", "let", + "package", "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var protected = 1; +(function() { + "use strict"; + ({ + protected + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-public-invalid-strict-mode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-public-invalid-strict-mode.js new file mode 100644 index 000000000..e9fc80e86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-public-invalid-strict-mode.js @@ -0,0 +1,33 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are limited to valid identifier references. Future Reserved Words are disallowed in Strict Mode. (public) +esid: sec-object-initializer +flags: [noStrict] +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + Identifier : IdentifierName but not ReservedWord + It is a Syntax Error if this phrase is contained in strict mode code and + the StringValue of IdentifierName is: "implements", "interface", "let", + "package", "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var public = 1; +(function() { + "use strict"; + ({ + public + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-static-init-await-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-static-init-await-invalid.js new file mode 100644 index 000000000..2f693b46a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-static-init-await-invalid.js @@ -0,0 +1,26 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-class-definitions-static-semantics-early-errors +description: IdentifierReference may not be `await` within class static blocks +info: | + IdentifierReference : Identifier + + - It is a Syntax Error if the code matched by this production is nested, + directly or indirectly (but not crossing function or static initialization + block boundaries), within a ClassStaticBlock and the StringValue of + Identifier is "arguments" or "await". +negative: + phase: parse + type: SyntaxError +features: [class-static-block] +---*/ + +$DONOTEVALUATE(); + +class C { + static { + ({ await }); + } +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-static-invalid-strict-mode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-static-invalid-strict-mode.js new file mode 100644 index 000000000..85b469359 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-static-invalid-strict-mode.js @@ -0,0 +1,33 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are limited to valid identifier references. Future Reserved Words are disallowed in Strict Mode. (static) +esid: sec-object-initializer +flags: [noStrict] +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + Identifier : IdentifierName but not ReservedWord + It is a Syntax Error if this phrase is contained in strict mode code and + the StringValue of IdentifierName is: "implements", "interface", "let", + "package", "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var static = 1; +(function() { + "use strict"; + ({ + static + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-yield-invalid-strict-mode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-yield-invalid-strict-mode.js new file mode 100644 index 000000000..82eecffd6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/identifier-shorthand-yield-invalid-strict-mode.js @@ -0,0 +1,33 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Object literal shorthands are limited to valid identifier references. Future Reserved Words are disallowed in Strict Mode. (yield) +esid: sec-object-initializer +flags: [noStrict] +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + Identifier : IdentifierName but not ReservedWord + It is a Syntax Error if this phrase is contained in strict mode code and + the StringValue of IdentifierName is: "implements", "interface", "let", + "package", "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var yield = 1; +(function() { + "use strict"; + ({ + yield + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..09c5cc170 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-binding-identifier-escaped.js @@ -0,0 +1,32 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier-escaped.case +// - src/async-functions/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async method) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var obj = { + async method() { + var \u0061wait; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-binding-identifier.js new file mode 100644 index 000000000..f2c4499b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-binding-identifier.js @@ -0,0 +1,32 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-binding-identifier.case +// - src/async-functions/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async method) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var obj = { + async method() { + var await; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..a34e82120 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-identifier-reference-escaped.js @@ -0,0 +1,32 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference-escaped.case +// - src/async-functions/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async method) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var obj = { + async method() { + void \u0061wait; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-identifier-reference.js new file mode 100644 index 000000000..a201e8de2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-identifier-reference.js @@ -0,0 +1,32 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-identifier-reference.case +// - src/async-functions/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async method) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var obj = { + async method() { + void await; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-label-identifier-escaped.js new file mode 100644 index 000000000..a3a620295 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-label-identifier-escaped.js @@ -0,0 +1,32 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier-escaped.case +// - src/async-functions/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async method) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var obj = { + async method() { + \u0061wait: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-label-identifier.js new file mode 100644 index 000000000..4a2efe54a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-await-as-label-identifier.js @@ -0,0 +1,32 @@ +// This file was procedurally generated from the following sources: +// - src/async-functions/await-as-label-identifier.case +// - src/async-functions/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async method) +esid: prod-AsyncMethod +features: [async-functions] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Function Definitions + + AsyncMethod : + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + + +var obj = { + async method() { + await: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-binding-identifier-escaped.js new file mode 100644 index 000000000..6b55d7fbd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-binding-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + var \u0061wait; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-binding-identifier.js new file mode 100644 index 000000000..a641df871 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-binding-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-binding-identifier.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + var await; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-identifier-reference-escaped.js new file mode 100644 index 000000000..37afa09de --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-identifier-reference-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + void \u0061wait; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-identifier-reference.js new file mode 100644 index 000000000..8bacfc238 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-identifier-reference.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-identifier-reference.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + void await; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-label-identifier-escaped.js new file mode 100644 index 000000000..b93ff75c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-label-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + \u0061wait: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-label-identifier.js new file mode 100644 index 000000000..d61b3ae2b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-await-as-label-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/await-as-label-identifier.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: await is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Await] parameter and + StringValue of Identifier is "await". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + await: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-array-destructuring-param-strict-body.js new file mode 100644 index 000000000..799906467 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-array-destructuring-param-strict-body.js @@ -0,0 +1,118 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-gen-meth.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, { + async *method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-dflt-params-duplicates.js new file mode 100644 index 000000000..b76d0ba23 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-dflt-params-duplicates.js @@ -0,0 +1,47 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/async-gen-meth.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, { + async *method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-dflt-params-rest.js new file mode 100644 index 000000000..e2a7403bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-dflt-params-rest.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/async-gen-meth.template +/*--- +description: RestParameter does not support an initializer (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, { + async *method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-escaped-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-escaped-async.js new file mode 100644 index 000000000..2a80013fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-escaped-async.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `async` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +features: [async-iteration] +---*/ + +$DONOTEVALUATE(); + +({ + \u0061sync* m(){} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-object-destructuring-param-strict-body.js new file mode 100644 index 000000000..be0f6e6de --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-object-destructuring-param-strict-body.js @@ -0,0 +1,118 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-gen-meth.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, { + async *method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-rest-param-strict-body.js new file mode 100644 index 000000000..b4065e962 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-rest-param-strict-body.js @@ -0,0 +1,118 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/async-gen-meth.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, { + async *method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..bd8e8ccae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-meth-rest-params-trailing-comma-early-error.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/async-gen-meth.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, { + async *method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..87527724c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-binding-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier-escaped.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + var yi\u0065ld; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-binding-identifier.js new file mode 100644 index 000000000..49dd69fda --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-binding-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-binding-identifier.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + var yield; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..78bf52d9a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-identifier-reference-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference-escaped.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + void yi\u0065ld; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-identifier-reference.js new file mode 100644 index 000000000..3e42123ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-identifier-reference.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-identifier-reference.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + void yield; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..2355d3eaa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-label-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier-escaped.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + yi\u0065ld: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-label-identifier.js new file mode 100644 index 000000000..792178ffa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-as-label-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-as-label-identifier.case +// - src/async-generators/syntax/async-obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + async *method() { + yield: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-strict.js new file mode 100644 index 000000000..0f5d65376 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-strict.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-spread-strict.case +// - src/async-generators/default/async-obj-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [object-spread, async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var gen = { + async *method() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } + } +}.method; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-identifier-strict.js new file mode 100644 index 000000000..6e764d42d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-gen-yield-identifier-strict.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/async-generators/yield-identifier-strict.case +// - src/async-generators/default/async-obj-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Async generator method) +esid: prod-AsyncGeneratorMethod +features: [async-iteration] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + Async Generator Function Definitions + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var gen = { + async *method() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) + } +}.method; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-array-destructuring-param-strict-body.js new file mode 100644 index 000000000..12ad76ca1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-array-destructuring-param-strict-body.js @@ -0,0 +1,111 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-meth.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async method) +esid: sec-async-function-definitions +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncMethod : + async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +({ + async *method([element]) { + "use strict"; + } +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-dflt-params-duplicates.js new file mode 100644 index 000000000..e51bf7b81 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-dflt-params-duplicates.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/async-meth.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (async method) +esid: sec-async-function-definitions +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncMethod : + async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + + +({ + async *method(x = 0, x) { + + } +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-dflt-params-rest.js new file mode 100644 index 000000000..beb53da75 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-dflt-params-rest.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/async-meth.template +/*--- +description: RestParameter does not support an initializer (async method) +esid: sec-async-function-definitions +features: [default-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncMethod : + async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + + +({ + async *method(...x = []) { + + } +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-escaped-async.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-escaped-async.js new file mode 100644 index 000000000..131fa89ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-escaped-async.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `async` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); + +({ + \u0061sync m(){} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-object-destructuring-param-strict-body.js new file mode 100644 index 000000000..d091de3e0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-object-destructuring-param-strict-body.js @@ -0,0 +1,111 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/async-meth.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (async method) +esid: sec-async-function-definitions +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncMethod : + async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +({ + async *method({property}) { + "use strict"; + } +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-rest-param-strict-body.js new file mode 100644 index 000000000..fb537ba61 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-rest-param-strict-body.js @@ -0,0 +1,111 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/async-meth.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (async method) +esid: sec-async-function-definitions +features: [rest-parameters, async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncMethod : + async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + + +({ + async *method(a,...rest) { + "use strict"; + } +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..3325f322a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/async-meth-rest-params-trailing-comma-early-error.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/async-meth.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (async method) +esid: sec-async-function-definitions +features: [async-iteration] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.6 Async Function Definitions + + AsyncMethod : + async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + + +({ + async *method(...a,) { + + } +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-async-method-duplicate-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-async-method-duplicate-parameters.js new file mode 100644 index 000000000..bbf97846b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-async-method-duplicate-parameters.js @@ -0,0 +1,28 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: sec-async-function-definitions +description: Formal parameters may not contain duplicates +info: | + # 14.7 Async Function Definitions + + AsyncMethod[Yield, Await]: + async[no LineTerminator here]PropertyName[?Yield, ?Await](UniqueFormalParameters[~Yield, +Await]){AsyncFunctionBody} + + # 14.1.2 Static Semantics: Early Errors + + UniqueFormalParameters:FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +({ + async foo(a, a) { } +}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-NSPL-with-USD.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-NSPL-with-USD.js new file mode 100644 index 000000000..e9d60213e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-NSPL-with-USD.js @@ -0,0 +1,17 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: > + It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is *true* and IsSimpleParameterList of ArrowParameters is *false*. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +({ + foo(x = 1) {"use strict"} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-arguments-in-formal-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-arguments-in-formal-parameters.js new file mode 100644 index 000000000..1db990066 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-arguments-in-formal-parameters.js @@ -0,0 +1,18 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if FormalParameters contains arguments +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +features: [async-functions] +---*/ + +$DONOTEVALUATE(); +({ + async foo (arguments) { } +}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-async-lineterminator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-async-lineterminator.js new file mode 100644 index 000000000..753dc5a78 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-async-lineterminator.js @@ -0,0 +1,22 @@ +// Copyright (C) 2017 Mozilla Corporation. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-AsyncMethod +description: async methods cannot have a line terminator between "async" and the property name +info: | + 14.6 Async Function Definitions + + AsyncMethod: + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + async + foo() { } +}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-await-in-formals-default.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-await-in-formals-default.js new file mode 100644 index 000000000..71cda72d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-await-in-formals-default.js @@ -0,0 +1,18 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if FormalParameters' default expressions contains await +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); +({ + async foo (x = await) { } +}) + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-await-in-formals.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-await-in-formals.js new file mode 100644 index 000000000..37ade67a2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-await-in-formals.js @@ -0,0 +1,17 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if FormalParameters contains await +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); +({ + async foo (await) { } +}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-body-contains-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-body-contains-super-call.js new file mode 100644 index 000000000..7ecacdcfb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-body-contains-super-call.js @@ -0,0 +1,17 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if AsyncFunctionBody contains SuperCall is true +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); +({ + async foo () { super() } +}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-duplicate-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-duplicate-parameters.js new file mode 100644 index 000000000..dbd6eed49 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-duplicate-parameters.js @@ -0,0 +1,27 @@ +// Copyright 2019 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions +description: Formal parameters may not contain duplicates +info: | + # 14.3 Method Definitions + + MethodDefinition[Yield, Await]: + PropertyName[?Yield, ?Await](UniqueFormalParameters[~Yield, ~Await]){FunctionBody[~Yield, ~Await]} + + # 14.1.2 Static Semantics: Early Errors + + UniqueFormalParameters:FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +({ + foo(a, a) { } +}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-eval-in-formal-parameters.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-eval-in-formal-parameters.js new file mode 100644 index 000000000..fc68e9132 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-eval-in-formal-parameters.js @@ -0,0 +1,18 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if FormalParameters contains eval in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +features: [async-functions] +---*/ + +$DONOTEVALUATE(); +({ + async foo(eval) { } +}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-formals-body-duplicate.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-formals-body-duplicate.js new file mode 100644 index 000000000..a3a71f342 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-formals-body-duplicate.js @@ -0,0 +1,18 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a SyntaxError if BoundNames of FormalParameters also occurs in the LexicallyDeclaredNames of AsyncFunctionBody +negative: + phase: parse + type: SyntaxError +features: [async-functions] +---*/ + +$DONOTEVALUATE(); + +({ + async function foo(bar) { let bar; } +}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-formals-contains-super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-formals-contains-super-call.js new file mode 100644 index 000000000..536fe65d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/early-errors-object-method-formals-contains-super-call.js @@ -0,0 +1,16 @@ +// Copyright 2016 Microsoft, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Brian Terlson +esid: pending +description: It is a syntax error if FormalParameters contains SuperCall is true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); +({ + async foo(foo = super()) { } +}) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get-e.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get-e.js new file mode 100644 index 000000000..bb4d90d09 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get-e.js @@ -0,0 +1,25 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `get` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols of the lexical, RegExp, and numeric string grammars are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + g\u0065t m() {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get-g.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get-g.js new file mode 100644 index 000000000..5998b7cd0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get-g.js @@ -0,0 +1,25 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `get` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols of the lexical, RegExp, and numeric string grammars are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + \u0067et m() {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get-t.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get-t.js new file mode 100644 index 000000000..58b903663 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get-t.js @@ -0,0 +1,25 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `get` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols of the lexical, RegExp, and numeric string grammars are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + ge\u0074 m() {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get.js new file mode 100644 index 000000000..55a0bbdb1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-get.js @@ -0,0 +1,25 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `get` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + \u0067\u0065\u0074 m() {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set-e.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set-e.js new file mode 100644 index 000000000..47b07583b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set-e.js @@ -0,0 +1,25 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `set` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols of the lexical, RegExp, and numeric string grammars are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + s\u0065t m(v) {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set-s.js new file mode 100644 index 000000000..047d31817 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set-s.js @@ -0,0 +1,25 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `set` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols of the lexical, RegExp, and numeric string grammars are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + \u0073et m(v) {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set-t.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set-t.js new file mode 100644 index 000000000..dc10378f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set-t.js @@ -0,0 +1,25 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `set` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols of the lexical, RegExp, and numeric string grammars are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + se\u0074 m(v) {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set.js new file mode 100644 index 000000000..f2d349b03 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/escaped-set.js @@ -0,0 +1,25 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `set` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + \u0073\u0065\u0074 m(v) {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-array-destructuring-param-strict-body.js new file mode 100644 index 000000000..e1396419c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-array-destructuring-param-strict-body.js @@ -0,0 +1,140 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/gen-meth.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, { + *method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-dflt-params-duplicates.js new file mode 100644 index 000000000..ba9778576 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-dflt-params-duplicates.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/gen-meth.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [default-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, { + *method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-dflt-params-rest.js new file mode 100644 index 000000000..9023c962e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-dflt-params-rest.js @@ -0,0 +1,73 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/gen-meth.template +/*--- +description: RestParameter does not support an initializer (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [default-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, { + *method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-object-destructuring-param-strict-body.js new file mode 100644 index 000000000..1945ab26c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-object-destructuring-param-strict-body.js @@ -0,0 +1,140 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/gen-meth.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, { + *method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-rest-param-strict-body.js new file mode 100644 index 000000000..ea3c70095 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-rest-param-strict-body.js @@ -0,0 +1,140 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/gen-meth.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [rest-parameters, generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, { + *method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..085e9f99e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-meth-rest-params-trailing-comma-early-error.js @@ -0,0 +1,66 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/gen-meth.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (generator method) +esid: sec-generator-function-definitions-runtime-semantics-propertydefinitionevaluation +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + GeneratorMethod : + * PropertyName ( StrictFormalParameters ) { GeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this GeneratorMethod is strict mode code, + let strict be true. Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be GeneratorFunctionCreate(Method, + StrictFormalParameters, GeneratorBody, scope, strict). + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, { + *method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-binding-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-binding-identifier-escaped.js new file mode 100644 index 000000000..f86606013 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-binding-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier-escaped.case +// - src/generators/syntax/obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Generator method) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorMethod[Yield, Await]: + * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + *method() { + var yi\u0065ld; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-binding-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-binding-identifier.js new file mode 100644 index 000000000..5ca6a728f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-binding-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-binding-identifier.case +// - src/generators/syntax/obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a binding identifier. (Generator method) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorMethod[Yield, Await]: + * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody } + + + BindingIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + *method() { + var yield; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-identifier-reference-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-identifier-reference-escaped.js new file mode 100644 index 000000000..e77dd7d5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-identifier-reference-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference-escaped.case +// - src/generators/syntax/obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Generator method) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorMethod[Yield, Await]: + * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + *method() { + void yi\u0065ld; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-identifier-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-identifier-reference.js new file mode 100644 index 000000000..d609f97bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-identifier-reference.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-identifier-reference.case +// - src/generators/syntax/obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as an identifier reference. (Generator method) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorMethod[Yield, Await]: + * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody } + + + IdentifierReference : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + *method() { + void yield; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-label-identifier-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-label-identifier-escaped.js new file mode 100644 index 000000000..c49e20ec6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-label-identifier-escaped.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier-escaped.case +// - src/generators/syntax/obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Generator method) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorMethod[Yield, Await]: + * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + *method() { + yi\u0065ld: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-label-identifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-label-identifier.js new file mode 100644 index 000000000..5af165189 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-as-label-identifier.js @@ -0,0 +1,31 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-as-label-identifier.case +// - src/generators/syntax/obj-method.template +/*--- +description: yield is a reserved keyword within generator function bodies and may not be used as a label identifier. (Generator method) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorMethod[Yield, Await]: + * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody } + + + LabelIdentifier : Identifier + + It is a Syntax Error if this production has a [Yield] parameter and + StringValue of Identifier is "yield". + +---*/ +$DONOTEVALUATE(); + +var obj = { + *method() { + yield: ; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-identifier-spread-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-identifier-spread-strict.js new file mode 100644 index 000000000..da84d4d4a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-identifier-spread-strict.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-spread-strict.case +// - src/generators/default/obj-method.template +/*--- +description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Generator method) +esid: prod-GeneratorMethod +features: [object-spread, generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorMethod[Yield, Await]: + * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody } + + + Spread Properties + + PropertyDefinition[Yield]: + (...) + ...AssignmentExpression[In, ?Yield] + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var gen = { + *method() { + callCount += 1; + return { + ...(function() { + var yield; + throw new Test262Error(); + }()), + } + } +}.method; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-identifier-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-identifier-strict.js new file mode 100644 index 000000000..3bea70d7d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/gen-yield-identifier-strict.js @@ -0,0 +1,37 @@ +// This file was procedurally generated from the following sources: +// - src/generators/yield-identifier-strict.case +// - src/generators/default/obj-method.template +/*--- +description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Generator method) +esid: prod-GeneratorMethod +features: [generators] +flags: [generated, onlyStrict] +negative: + phase: parse + type: SyntaxError +info: | + 14.4 Generator Function Definitions + + GeneratorMethod[Yield, Await]: + * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody } + +---*/ +$DONOTEVALUATE(); + +var callCount = 0; + +var gen = { + *method() { + callCount += 1; + (function() { + var yield; + throw new Test262Error(); + }()) + } +}.method; + +var iter = gen(); + + + +assert.sameValue(callCount, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-id-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-id-yield.js new file mode 100644 index 000000000..8ac595b27 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-id-yield.js @@ -0,0 +1,20 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + The BindingIdentifier of a SingleNameBinding witihn the FormalParameters of + a GeneratorMethod may not be the `yield` keyword. +es6id: 14.4 +features: [generators] +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + *method(yield) {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-init-yield.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-init-yield.js new file mode 100644 index 000000000..4ae37d8ff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-init-yield.js @@ -0,0 +1,22 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + The Initializer of a SingleNameBinding witihn the FormalParameters of a + GeneratorMethod may not contain the `yield` keyword. +es6id: 14.4 +features: [generators] +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(function*() { + ({ + *method(x = yield) {} + }); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-redecl-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-redecl-const.js new file mode 100644 index 000000000..5a326b828 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-redecl-const.js @@ -0,0 +1,23 @@ +// Copyright 2015 Cubane Canada, Inc. All rights reserved. +// See LICENSE for details. + +/*--- +info: | + GeneratorMethod early SyntaxError when lexical declaration + inside generator shadows parameter name +features: [generators] +es6id: 14.4.1 +author: Sam Mikes +description: GeneratorMethod error with lexical shadowing +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var obj = { + *foo(a) { + const a = 3; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-redecl-let.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-redecl-let.js new file mode 100644 index 000000000..7039c8bc4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-param-redecl-let.js @@ -0,0 +1,23 @@ +// Copyright 2015 Cubane Canada, Inc. All rights reserved. +// See LICENSE for details. + +/*--- +info: | + GeneratorMethod early SyntaxError when lexical declaration + inside generator shadows parameter name +features: [generators] +es6id: 14.4.1 +author: Sam Mikes +description: GeneratorMethod error with lexical shadowing +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var obj = { + *foo(a) { + let a = 3; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-super-call-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-super-call-body.js new file mode 100644 index 000000000..f3d5da184 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-super-call-body.js @@ -0,0 +1,23 @@ +// Copyright 2015 Cubane Canada, Inc. All rights reserved. +// See LICENSE for details. + +/*--- +info: | + GeneratorMethod early SyntaxError when super is called + directly inside generator body +features: [generators] +es6id: 14.4.1 +author: Sam Mikes +description: GeneratorMethod error if HasDirectSuper in body +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var obj = { + *foo(a) { + super(); + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-super-call-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-super-call-param.js new file mode 100644 index 000000000..b3137040d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-super-call-param.js @@ -0,0 +1,22 @@ +// Copyright 2015 Cubane Canada, Inc. All rights reserved. +// See LICENSE for details. + +/*--- +info: | + GeneratorMethod early SyntaxError when super is called + directly inside generator args +features: [generators] +es6id: 14.4.1 +author: Sam Mikes +description: GeneratorMethod error if HasDirectSuper in args +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var obj = { + *foo(a = super()) { + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-use-strict-with-non-simple-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-use-strict-with-non-simple-param.js new file mode 100644 index 000000000..b340d9270 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/generator-use-strict-with-non-simple-param.js @@ -0,0 +1,24 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-generator-function-definitions-static-semantics-early-errors +description: > + A SyntaxError is thrown if a generator method contains a non-simple parameter list and a UseStrict directive. +info: | + Static Semantics: Early Errors + + It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and IsSimpleParameterList of StrictFormalParameters is false. +negative: + phase: parse + type: SyntaxError +features: [generators] +---*/ + +$DONOTEVALUATE(); + +var o = { + *m(a = 0) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-array-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-array-destructuring-param-strict-body.js new file mode 100644 index 000000000..f593bd106 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-array-destructuring-param-strict-body.js @@ -0,0 +1,136 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/array-destructuring-param-strict-body.case +// - src/function-forms/syntax/meth.template +/*--- +description: ArrayBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (method) +esid: sec-runtime-semantics-definemethod +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, { + method([element]) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-dflt-params-duplicates.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-dflt-params-duplicates.js new file mode 100644 index 000000000..fed6be76a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-dflt-params-duplicates.js @@ -0,0 +1,65 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-duplicates.case +// - src/function-forms/syntax/meth.template +/*--- +description: It is a Syntax Error if BoundNames of FormalParameters contains any duplicate elements. (method) +esid: sec-runtime-semantics-definemethod +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.2 Static Semantics: Early Errors + + StrictFormalParameters : FormalParameters + + - It is a Syntax Error if BoundNames of FormalParameters contains any + duplicate elements. + + FormalParameters : FormalParameterList + + - It is a Syntax Error if IsSimpleParameterList of FormalParameterList is + false and BoundNames of FormalParameterList contains any duplicate + elements. + +---*/ +$DONOTEVALUATE(); + +0, { + method(x = 0, x) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-dflt-params-rest.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-dflt-params-rest.js new file mode 100644 index 000000000..72d80c063 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-dflt-params-rest.js @@ -0,0 +1,69 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/dflt-params-rest.case +// - src/function-forms/syntax/meth.template +/*--- +description: RestParameter does not support an initializer (method) +esid: sec-runtime-semantics-definemethod +features: [default-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1 Function Definitions + + Syntax + + FunctionRestParameter[Yield] : + + BindingRestElement[?Yield] + + 13.3.3 Destructuring Binding Patterns + + Syntax + + BindingRestElement[Yield] : + + ...BindingIdentifier[?Yield] + ...BindingPattern[?Yield] + +---*/ +$DONOTEVALUATE(); + +0, { + method(...x = []) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-object-destructuring-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-object-destructuring-param-strict-body.js new file mode 100644 index 000000000..ea0b33aaf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-object-destructuring-param-strict-body.js @@ -0,0 +1,136 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/object-destructuring-param-strict-body.case +// - src/function-forms/syntax/meth.template +/*--- +description: ObjectBindingPattern and Use Strict Directive are not allowed to coexist for the same function. (method) +esid: sec-runtime-semantics-definemethod +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 13.3.3.4 Static Semantics: IsSimpleParameterList + + BindingElement : BindingPattern + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, { + method({property}) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-rest-param-strict-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-rest-param-strict-body.js new file mode 100644 index 000000000..3759c00ac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-rest-param-strict-body.js @@ -0,0 +1,136 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-param-strict-body.case +// - src/function-forms/syntax/meth.template +/*--- +description: RestParameter and Use Strict Directive are not allowed to coexist for the same function. (method) +esid: sec-runtime-semantics-definemethod +features: [rest-parameters] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + 14.1.13 Static Semantics: IsSimpleParameterList + + FormalParameters : FormalParameterList , FunctionRestParameter + + 1. Return false. + + 14.1.2 Static Semantics: Early Errors + + FunctionDeclaration : function BindingIdentifier ( FormalParameters ) { FunctionBody } + FunctionDeclaration : function ( FormalParameters ) { FunctionBody } + FunctionExpression : function BindingIdentifier ( FormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.2.1 Static Semantics: Early Errors + + ArrowFunction : ArrowParameters => ConciseBody + + - It is a Syntax Error if ContainsUseStrict of ConciseBody is true and + IsSimpleParameterList of ArrowParameters is false. + + 14.3.1 Static Semantics: Early Errors + + MethodDefinition : PropertyName ( UniqueFormalParameters ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + MethodDefinition : set PropertyName ( PropertySetParameterList ) { FunctionBody } + + - It is a Syntax Error if ContainsUseStrict of FunctionBody is true and + IsSimpleParameterList of PropertySetParameterList is false. + + 14.4.1 Static Semantics: Early Errors + + GeneratorMethod : * PropertyName ( UniqueFormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + GeneratorDeclaration : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody } + GeneratorExpression : function * BindingIdentifier ( FormalParameters ) { GeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of GeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + 14.5.1 Static Semantics: Early Errors + + AsyncGeneratorMethod : async * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncGeneratorDeclaration : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorDeclaration : async function * ( FormalParameters ) { AsyncGeneratorBody } + AsyncGeneratorExpression : async function * BindingIdentifier ( FormalParameters ) { AsyncGeneratorBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncGeneratorBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.7.1 Static Semantics: Early Errors + + AsyncMethod : async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of UniqueFormalParameters is false. + + AsyncFunctionDeclaration : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionDeclaration : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function ( FormalParameters ) { AsyncFunctionBody } + AsyncFunctionExpression : async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody } + + - It is a Syntax Error if ContainsUseStrict of AsyncFunctionBody is true and + IsSimpleParameterList of FormalParameters is false. + + 14.8.1 Static Semantics: Early Errors + + AsyncArrowFunction : CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody + + - It is a Syntax Error if ContainsUseStrict of AsyncConciseBody is true and + IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false. + +---*/ +$DONOTEVALUATE(); + +0, { + method(a,...rest) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-rest-params-trailing-comma-early-error.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-rest-params-trailing-comma-early-error.js new file mode 100644 index 000000000..b52038bc7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/meth-rest-params-trailing-comma-early-error.js @@ -0,0 +1,61 @@ +// This file was procedurally generated from the following sources: +// - src/function-forms/rest-params-trailing-comma-early-error.case +// - src/function-forms/syntax/meth.template +/*--- +description: It's a syntax error if a FunctionRestParameter is followed by a trailing comma (method) +esid: sec-runtime-semantics-definemethod +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody } + + [...] + 6. Let closure be FunctionCreate(kind, StrictFormalParameters, + FunctionBody, scope, strict). If functionPrototype was passed as a + parameter then pass its value as the functionPrototype optional argument + of FunctionCreate. + [...] + + 9.2.1 [[Call]] ( thisArgument, argumentsList) + + [...] + 7. Let result be OrdinaryCallEvaluateBody(F, argumentsList). + [...] + + 9.2.1.3 OrdinaryCallEvaluateBody ( F, argumentsList ) + + 1. Let status be FunctionDeclarationInstantiation(F, argumentsList). + [...] + + 9.2.12 FunctionDeclarationInstantiation(func, argumentsList) + + [...] + 23. Let iteratorRecord be Record {[[iterator]]: + CreateListIterator(argumentsList), [[done]]: false}. + 24. If hasDuplicates is true, then + [...] + 25. Else, + b. Let formalStatus be IteratorBindingInitialization for formals with + iteratorRecord and env as arguments. + [...] + + Trailing comma in the parameters list + + 14.1 Function Definitions + + FormalParameters[Yield, Await] : + [empty] + FunctionRestParameter[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] + FormalParameterList[?Yield, ?Await] , + FormalParameterList[?Yield, ?Await] , FunctionRestParameter[?Yield, ?Await] +---*/ +$DONOTEVALUATE(); + +0, { + method(...a,) { + + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/name-param-redecl.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/name-param-redecl.js new file mode 100644 index 000000000..27ff0d5ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/name-param-redecl.js @@ -0,0 +1,21 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + It is a Syntax Error if any element of the BoundNames of + StrictFormalParameters also occurs in the LexicallyDeclaredNames of + FunctionBody. +es6id: 14.3.1 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var obj = { + method(param) { + let param; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/name-super-call-body.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/name-super-call-body.js new file mode 100644 index 000000000..936c40969 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/name-super-call-body.js @@ -0,0 +1,19 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. +esid: sec-object-initializer-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + method() { + super(); + } +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/name-super-call-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/name-super-call-param.js new file mode 100644 index 000000000..0b9d25d5f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/name-super-call-param.js @@ -0,0 +1,17 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + It is a Syntax Error if HasDirectSuper of MethodDefinition is true. +esid: sec-object-initializer-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({ + method(param = super()) {} +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-fn-inside-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-fn-inside-class.js new file mode 100644 index 000000000..05ecd356a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-fn-inside-class.js @@ -0,0 +1,26 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name even + inside a class body (async method). +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private, async-functions, class, class-fields-public] +---*/ + +$DONOTEVALUATE(); + +class C { + field = { + async #m() {} + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-fn.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-fn.js new file mode 100644 index 000000000..28f0679e5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-fn.js @@ -0,0 +1,24 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name + (async method). +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private, async-functions] +---*/ + +$DONOTEVALUATE(); + +var o = { + async #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-gen-inside-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-gen-inside-class.js new file mode 100644 index 000000000..4cc8dead5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-gen-inside-class.js @@ -0,0 +1,26 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name even + inside a class body. (async generator) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private, async-iteration, class, class-fields-public] +---*/ + +$DONOTEVALUATE(); + +class C { + field = { + async * #m() {} + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-gen.js new file mode 100644 index 000000000..bb8f5ce0f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-async-gen.js @@ -0,0 +1,24 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name. + (async generator) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private, async-iteration] +---*/ + +$DONOTEVALUATE(); + +var o = { + async * #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-gen-inside-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-gen-inside-class.js new file mode 100644 index 000000000..5feaba2a3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-gen-inside-class.js @@ -0,0 +1,26 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name even + inside a class body. (generator) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private, generators, class, class-fields-public] +---*/ + +$DONOTEVALUATE(); + +class C { + field = { + * #m() {} + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-gen.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-gen.js new file mode 100644 index 000000000..6895176cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-gen.js @@ -0,0 +1,24 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name. + (generator) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private, generators] +---*/ + +$DONOTEVALUATE(); + +var o = { + * #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-get-method-inside-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-get-method-inside-class.js new file mode 100644 index 000000000..5c495a556 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-get-method-inside-class.js @@ -0,0 +1,26 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name even + inside a class body. (getter method) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private, class, class-fields-public] +---*/ + +$DONOTEVALUATE(); + +class C { + field = { + get #m() {} + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-get-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-get-method.js new file mode 100644 index 000000000..c784ccc7a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-get-method.js @@ -0,0 +1,24 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name. + (getter method) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private] +---*/ + +$DONOTEVALUATE(); + +var o = { + get #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-method-inside-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-method-inside-class.js new file mode 100644 index 000000000..2421ef317 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-method-inside-class.js @@ -0,0 +1,26 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name even + inside a class body. (ordinary method) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private, class, class-fields-public] +---*/ + +$DONOTEVALUATE(); + +class C { + field = { + #m() {} + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-method.js new file mode 100644 index 000000000..739649bfa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-method.js @@ -0,0 +1,24 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name. + (ordinary method) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private] +---*/ + +$DONOTEVALUATE(); + +var o = { + #m() {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-set-method-inside-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-set-method-inside-class.js new file mode 100644 index 000000000..7d2dcbb9d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-set-method-inside-class.js @@ -0,0 +1,26 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name even + inside a class body. (getter method) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private, class, class-fields-public] +---*/ + +$DONOTEVALUATE(); + +class C { + field = { + set #m(x) {} + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-set-method.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-set-method.js new file mode 100644 index 000000000..ed5640917 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/private-name-early-error-set-method.js @@ -0,0 +1,24 @@ +// Copyright (C) 2018 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + Throws an early SyntaxError if a method definition has a private name. + (getter method) +info: | + Static Semantics: Early Errors + + PropertyDefinition : MethodDefinition + It is a Syntax Error if PrivateBoundNames of MethodDefinition is non-empty. +negative: + phase: parse + type: SyntaxError +features: [class-methods-private] +---*/ + +$DONOTEVALUATE(); + +var o = { + set #m(x) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/setter-use-strict-with-non-simple-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/setter-use-strict-with-non-simple-param.js new file mode 100644 index 000000000..2a7c28a35 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/setter-use-strict-with-non-simple-param.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + A SyntaxError is thrown if a setter method contains a non-simple parameter list and a UseStrict directive. +info: | + Static Semantics: Early Errors + + It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of PropertySetParameterList is false. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var o = { + set m(a = 0) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/use-strict-with-non-simple-param.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/use-strict-with-non-simple-param.js new file mode 100644 index 000000000..535463790 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/use-strict-with-non-simple-param.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-method-definitions-static-semantics-early-errors +description: > + A SyntaxError is thrown if a method contains a non-simple parameter list and a UseStrict directive. +info: | + Static Semantics: Early Errors + + It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of StrictFormalParameters is false. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var o = { + m(a = 0) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-as-logical-or-expression.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-as-logical-or-expression.js new file mode 100644 index 000000000..8c2ceace0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-as-logical-or-expression.js @@ -0,0 +1,20 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + `yield` expressions are not LogicalOrExpressions. +features: [generators] +es6id: 12.1.1 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var obj = { + *g() { + yield ? yield : yield; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-as-parameter.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-as-parameter.js new file mode 100644 index 000000000..00245ffb9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-as-parameter.js @@ -0,0 +1,19 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + `yield` is a reserved keyword within generator function bodies and may + not be used as the binding identifier of a parameter. +features: [generators] +es6id: 12.1.1 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var obj = { + *g(yield) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-star-after-newline.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-star-after-newline.js new file mode 100644 index 000000000..fac9efb1e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-star-after-newline.js @@ -0,0 +1,21 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + A newline may not precede the `*` token in a `yield` expression. +features: [generators] +es6id: 14.4 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var obj = { + *g() { + yield + * 1 + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-weak-binding.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-weak-binding.js new file mode 100644 index 000000000..e95b1a733 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/method-definition/yield-weak-binding.js @@ -0,0 +1,18 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + `yield` expressions bind weakly +features: [generators] +es6id: 14.4 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var obj = { + *g() { yield 3 + yield 4; } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/prop-def-invalid-async-prefix.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/prop-def-invalid-async-prefix.js new file mode 100644 index 000000000..a2fe1eee9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/prop-def-invalid-async-prefix.js @@ -0,0 +1,35 @@ +// Copyright (C) 2017 Mozilla Corporation. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + async is not a valid prefix of an identifier reference +esid: sec-object-initializer +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition + + MethodDefinition: + PropertyName ( UniqueFormalParameters ) { FunctionBody } + AsyncMethod + + AsyncMethod: + async [no LineTerminator here] PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody } + VariableDeclaration : BindingPattern Initializer + + 1. Let rhs be the result of evaluating Initializer. + 2. Let rval be GetValue(rhs). + 3. ReturnIfAbrupt(rval). + 4. Return the result of performing BindingInitialization for + BindingPattern passing rval and undefined as arguments. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({async async}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/prop-def-invalid-star-prefix.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/prop-def-invalid-star-prefix.js new file mode 100644 index 000000000..15d7ad0f3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/prop-def-invalid-star-prefix.js @@ -0,0 +1,21 @@ +// Copyright (C) 2019 Tiancheng "Timothy" Gu. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + * is not a valid prefix of an identifier reference +esid: sec-object-initializer +info: | + PropertyDefinition: + IdentifierReference + CoverInitializedName + PropertyName : AssignmentExpression + MethodDefinition +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +({* foo}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-body-strict-inside.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-body-strict-inside.js new file mode 100644 index 000000000..2aace1442 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-body-strict-inside.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.1.5_7-2-2-s +description: > + Strict Mode - SyntaxError is thrown when an assignment to a + reserved word is made in a strict FunctionBody of a + PropertyAssignment +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +void { + set x(value) { + "use strict"; + public = 42; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-body-strict-outside.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-body-strict-outside.js new file mode 100644 index 000000000..27f5a5749 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-body-strict-outside.js @@ -0,0 +1,20 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.1.5_7-2-1-s +description: > + Strict Mode - SyntaxError is thrown when an assignment to a + reserved word is contained in strict code +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +void { + set x(value) { + public = 42; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-arguments-strict-inside.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-arguments-strict-inside.js new file mode 100644 index 000000000..8a5b4fe37 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-arguments-strict-inside.js @@ -0,0 +1,21 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.1.5-4-s +description: > + Strict Mode - SyntaxError is thrown when 'arguments' occurs as + the Identifier in a PropertySetParameterList of a + PropertyAssignment if its FunctionBody is strict code +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +void { + set x(arguments) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-arguments-strict-outside.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-arguments-strict-outside.js new file mode 100644 index 000000000..8209420d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-arguments-strict-outside.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.1.5-2-s +description: > + Strict Mode - SyntaxError is thrown when 'arguments' occurs as the + Identifier in a PropertySetParameterList of a PropertyAssignment + that is contained in strict code +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +void { + set x(arguments) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-eval-strict-inside.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-eval-strict-inside.js new file mode 100644 index 000000000..f86318ba2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-eval-strict-inside.js @@ -0,0 +1,21 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.1.5-3-s +description: > + Strict Mode - SyntaxError is thrown when 'evals' occurs as the + Identifier in a PropertySetParameterList of a PropertyAssignment + if its FunctionBody is strict code +negative: + phase: parse + type: SyntaxError +flags: [noStrict] +---*/ + +$DONOTEVALUATE(); + +void { + set x(eval) { + "use strict"; + } +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-eval-strict-outside.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-eval-strict-outside.js new file mode 100644 index 000000000..36aa2196f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/object/setter-param-eval-strict-outside.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es5id: 11.1.5-1-s +description: > + Strict Mode - SyntaxError is thrown when 'eval' occurs as the + Identifier in a PropertySetParameterList of a PropertyAssignment + that is contained in strict code +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +void { + set x(eval) {} +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/call-expression-super-no-base.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/call-expression-super-no-base.js new file mode 100644 index 000000000..4fe8403e0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/call-expression-super-no-base.js @@ -0,0 +1,23 @@ +// Copyright 2019 Google, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + should not suppress error if super called on class with no base +info: | + Left-Hand-Side Expressions + OptionalExpression: + SuperCall OptionalChain +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +class C { + constructor () { + super()?.a; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string-esi.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string-esi.js new file mode 100644 index 000000000..ef8a94578 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string-esi.js @@ -0,0 +1,25 @@ +// Copyright 2020 Salesforce.com, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + template string passed to tail position of optional chain +info: | + Static Semantics: Early Errors + OptionalChain: + ?.TemplateLiteral + OptionalChain TemplateLiteral + + It is a Syntax Error if any code matches this production. +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// This production exists in order to prevent automatic semicolon +// insertion rules. +null?. + `hello` diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string.js new file mode 100644 index 000000000..80ddad006 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-op-template-string.js @@ -0,0 +1,22 @@ +// Copyright 2020 Salesforce.com, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + template string passed to tail position of optional chain +info: | + Static Semantics: Early Errors + OptionalChain: + ?.TemplateLiteral + OptionalChain TemplateLiteral + + It is a Syntax Error if any code matches this production. +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +null?.`hello`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string-esi.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string-esi.js new file mode 100644 index 000000000..2e64334f6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string-esi.js @@ -0,0 +1,25 @@ +// Copyright 2020 Salesforce.com, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + template string passed to tail position of optional chain +info: | + Static Semantics: Early Errors + OptionalChain: + ?.TemplateLiteral + OptionalChain TemplateLiteral + + It is a Syntax Error if any code matches this production. +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// This production exists in order to prevent automatic semicolon +// insertion rules. +null?.fn + `hello` diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string.js new file mode 100644 index 000000000..087d1d4e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-null-optchain-template-string.js @@ -0,0 +1,22 @@ +// Copyright 2020 Salesforce.com, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + template string passed to tail position of optional chain +info: | + Static Semantics: Early Errors + OptionalChain: + ?.TemplateLiteral + OptionalChain TemplateLiteral + + It is a Syntax Error if any code matches this production. +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +null?.fn`hello`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-op-template-string-esi.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-op-template-string-esi.js new file mode 100644 index 000000000..6be0cc1c2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-op-template-string-esi.js @@ -0,0 +1,27 @@ +// Copyright 2020 Salesforce.com, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + template string passed to tail position of optional chain +info: | + Static Semantics: Early Errors + OptionalChain: + ?.TemplateLiteral + OptionalChain TemplateLiteral + + It is a Syntax Error if any code matches this production. +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +const a = function() {}; + +// This production exists in order to prevent automatic semicolon +// insertion rules. +a?. + `hello` diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-op-template-string.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-op-template-string.js new file mode 100644 index 000000000..6b47f3890 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-op-template-string.js @@ -0,0 +1,24 @@ +// Copyright 2020 Salesforce.com, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + template string passed to tail position of optional chain +info: | + Static Semantics: Early Errors + OptionalChain: + ?.TemplateLiteral + OptionalChain TemplateLiteral + + It is a Syntax Error if any code matches this production. +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +const a = function() {}; + +a?.`hello`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string-esi.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string-esi.js new file mode 100644 index 000000000..c92e1fc7a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string-esi.js @@ -0,0 +1,27 @@ +// Copyright 2019 Google, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + template string passed to tail position of optional chain +info: | + Static Semantics: Early Errors + OptionalChain: + ?.TemplateLiteral + OptionalChain TemplateLiteral + + It is a Syntax Error if any code matches this production. +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +const a = {fn() {}}; + +// This production exists in order to prevent automatic semicolon +// insertion rules. +a?.fn + `hello` diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string.js new file mode 100644 index 000000000..61e7a144e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/early-errors-tail-position-optchain-template-string.js @@ -0,0 +1,24 @@ +// Copyright 2019 Google, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + template string passed to tail position of optional chain +info: | + Static Semantics: Early Errors + OptionalChain: + ?.TemplateLiteral + OptionalChain TemplateLiteral + + It is a Syntax Error if any code matches this production. +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +const a = {fn() {}}; + +a?.fn`hello`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/static-semantics-simple-assignment.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/static-semantics-simple-assignment.js new file mode 100644 index 000000000..d233f1066 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/static-semantics-simple-assignment.js @@ -0,0 +1,23 @@ + +// Copyright 2019 Google, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + an optional expression cannot be target of assignment +info: | + Static Semantics: IsValidSimpleAssignmentTarget + LeftHandSideExpression: + OptionalExpression + Return false. +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +const obj = {}; + +obj?.a = 33; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/update-expression-postfix.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/update-expression-postfix.js new file mode 100644 index 000000000..3bbecf970 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/update-expression-postfix.js @@ -0,0 +1,23 @@ +// Copyright 2019 Google, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + optional chaining is forbidden in write contexts +info: | + UpdateExpression[Yield, Await]: + LeftHandSideExpression++ + LeftHandSideExpression-- + ++UnaryExpression + --UnaryExpression +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// LeftHandSideExpression ++ +const a = {}; +a?.b++; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/update-expression-prefix.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/update-expression-prefix.js new file mode 100644 index 000000000..407f1766e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/optional-chaining/update-expression-prefix.js @@ -0,0 +1,23 @@ +// Copyright 2019 Google, Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-OptionalExpression +description: > + optional chaining is forbidden in write contexts +info: | + UpdateExpression[Yield, Await]: + LeftHandSideExpression++ + LeftHandSideExpression-- + ++UnaryExpression + --UnaryExpression +features: [optional-chaining] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// --UnaryExpression +const a = {}; +--a?.b; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/arguments.js new file mode 100644 index 000000000..e212d5213 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/arguments.js @@ -0,0 +1,26 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions +description: > + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is strict. (arguments) +info: | + sec-identifiers-static-semantics-assignmenttargettype + + If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return strict. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: LeftHandSideExpression -- + + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is strict. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments--; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/eval.js new file mode 100644 index 000000000..7224090ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/eval.js @@ -0,0 +1,26 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions +description: > + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is strict. (eval) +info: | + sec-identifiers-static-semantics-assignmenttargettype + + If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return strict. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: LeftHandSideExpression -- + + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is strict. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval--; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-carriage-return.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-carriage-return.js new file mode 100644 index 000000000..e80699e90 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-carriage-return.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminator between LeftHandSideExpression and "--" is not allowed +es5id: 11.3.2_A1.1_T2 +esid: sec-postfix-decrement-operator +description: Checking Carriage Return +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +x +--; +// The preceding line contains an unprintable CARRIAGE RETURN character (U+000D) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-line-feed.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-line-feed.js new file mode 100644 index 000000000..11d580e63 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-line-feed.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminator (LINE FEED) between LeftHandSideExpression and "--" is not allowed +es5id: 11.3.2_A1.1_T1 +esid: sec-postfix-decrement-operator +description: Checking Line Feed +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +x +--; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-line-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-line-separator.js new file mode 100644 index 000000000..71fd80f37 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-line-separator.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminator between LeftHandSideExpression and "--" is not allowed +es5id: 11.3.2_A1.1_T3 +esid: sec-postfix-decrement-operator +description: Checking Line separator +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +x
--; +// The preceding line contains an unprintable LINE SEPARATOR character (U+2028) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-paragraph-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-paragraph-separator.js new file mode 100644 index 000000000..f77882a96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/line-terminator-paragraph-separator.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminator between LeftHandSideExpression and "--" is not allowed +es5id: 11.3.2_A1.1_T4 +esid: sec-postfix-decrement-operator +description: Checking Paragraph separator +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +x
--; +// The preceding line contains an unprintable PARAGRAPH SEPARATOR character +// (U+2029) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/target-cover-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/target-cover-newtarget.js new file mode 100644 index 000000000..07233bccc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/target-cover-newtarget.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to a "covered" new.target +info: | + UpdateExpression : + LeftHandSideExpression ++ + LeftHandSideExpression -- + + - It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + (new.target)--; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/target-cover-yieldexpr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/target-cover-yieldexpr.js new file mode 100644 index 000000000..73788d500 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/target-cover-yieldexpr.js @@ -0,0 +1,34 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to a "covered" YieldExpression +info: | + UpdateExpression : + LeftHandSideExpression ++ + LeftHandSideExpression -- + + - It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + + 12.15.3 Static Semantics: AssignmentTargetType + + AssignmentExpression: + YieldExpression + ArrowFunction + AsyncArrowFunction + LeftHandSideExpression = AssignmentExpression + LeftHandSideExpression AssignmentOperator AssignmentExpression + + 1. Return invalid. +features: [generators] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function* g() { + (yield)--; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/target-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/target-newtarget.js new file mode 100644 index 000000000..ddfe95e6a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/target-newtarget.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to new.target +info: | + UpdateExpression : + LeftHandSideExpression ++ + LeftHandSideExpression -- + + - It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + new.target--; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/this.js new file mode 100644 index 000000000..972be0030 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-decrement/this.js @@ -0,0 +1,27 @@ +// Copyright (C) 2023 Veera Sivarajan. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: > + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (this) +info: | + sec-static-semantics-assignmenttargettype + + PrimaryExpression: this + + Return invalid. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: LeftHandSideExpression -- + + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +this--; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/11.3.1-2-1gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/11.3.1-2-1gs.js new file mode 100644 index 000000000..ba56870f6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/11.3.1-2-1gs.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.3.1-2-1gs +description: > + Strict Mode - SyntaxError is throw if the identifier arguments + appear as a PostfixExpression(arguments++) +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +arguments++; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/arguments.js new file mode 100644 index 000000000..9d9c816f4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/arguments.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-assignmenttargettype +description: > + If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return strict. +info: | + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: LeftHandSideExpression ++ + + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is strict. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +arguments++; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/eval.js new file mode 100644 index 000000000..5ac730d33 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/eval.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-assignmenttargettype +description: > + If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return strict. +info: | + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: LeftHandSideExpression ++ + + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is strict. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +eval++; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-carriage-return.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-carriage-return.js new file mode 100644 index 000000000..a875207c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-carriage-return.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminator between LeftHandSideExpression and "++" is not allowed +es5id: 11.3.1_A1.1_T2 +esid: postfix-increment-operator +description: Carriage Return +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +x +++; +// The preceding line contains an unprintable CARRIAGE RETURN character (U+000D) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-line-feed.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-line-feed.js new file mode 100644 index 000000000..a3b10f191 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-line-feed.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminator between LeftHandSideExpression and "++" is not allowed +es5id: 11.3.1_A1.1_T1 +esid: postfix-increment-operator +description: Checking Line Feed +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +x +++; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-line-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-line-separator.js new file mode 100644 index 000000000..a70998219 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-line-separator.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminator between LeftHandSideExpression and "++" is not allowed +es5id: 11.3.1_A1.1_T3 +esid: postfix-increment-operator +description: Checking Line Separator +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +x
++; +// The preceding line contains an unprintable LINE SEPARATOR character (U+2028) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-paragraph-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-paragraph-separator.js new file mode 100644 index 000000000..76870f24f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/line-terminator-paragraph-separator.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminator between LeftHandSideExpression and "++" is not allowed +es5id: 11.3.1_A1.1_T4 +esid: postfix-increment-operator +description: Checking Paragraph separator +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +x
++; +// The preceding line contains an unprintable PARAGRAPH SEPARATOR character +// (U+2029) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/target-cover-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/target-cover-newtarget.js new file mode 100644 index 000000000..19d572888 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/target-cover-newtarget.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to a "covered" new.target +info: | + UpdateExpression : + LeftHandSideExpression ++ + LeftHandSideExpression -- + + - It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + (new.target)++; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/target-cover-yieldexpr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/target-cover-yieldexpr.js new file mode 100644 index 000000000..197773fd8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/target-cover-yieldexpr.js @@ -0,0 +1,34 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to a "covered" YieldExpression +info: | + UpdateExpression : + LeftHandSideExpression ++ + LeftHandSideExpression -- + + - It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + + 12.15.3 Static Semantics: AssignmentTargetType + + AssignmentExpression: + YieldExpression + ArrowFunction + AsyncArrowFunction + LeftHandSideExpression = AssignmentExpression + LeftHandSideExpression AssignmentOperator AssignmentExpression + + 1. Return invalid. +features: [generators] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function* g() { + (yield)++; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/target-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/target-newtarget.js new file mode 100644 index 000000000..54d4a04c3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/target-newtarget.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to new.target +info: | + UpdateExpression : + LeftHandSideExpression ++ + LeftHandSideExpression -- + + - It is an early Syntax Error if AssignmentTargetType of + LeftHandSideExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + new.target++; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/this.js new file mode 100644 index 000000000..41270d93b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/postfix-increment/this.js @@ -0,0 +1,27 @@ +// Copyright (C) 2023 Veera Sivarajan. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: > + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. (this) +info: | + sec-static-semantics-assignmenttargettype + + PrimaryExpression: this + + Return invalid. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: LeftHandSideExpression ++ + + It is an early Syntax Error if AssignmentTargetType of LeftHandSideExpression is not simple. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +this++; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/11.4.5-2-2gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/11.4.5-2-2gs.js new file mode 100644 index 000000000..37be005c6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/11.4.5-2-2gs.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 11.4.5-2-2gs +description: > + Strict Mode - SyntaxError is throw if the UnaryExpression operated + upon by a Prefix Decrement operator(--arguments) +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +--arguments; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/arguments.js new file mode 100644 index 000000000..d11f00630 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/arguments.js @@ -0,0 +1,26 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions +description: > + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is strict. (arguments) +info: | + sec-identifiers-static-semantics-assignmenttargettype + + If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return strict. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: -- UnaryExpression + + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is strict. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +--arguments; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/eval.js new file mode 100644 index 000000000..4048a6848 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/eval.js @@ -0,0 +1,26 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions +description: > + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is strict. (eval) +info: | + sec-identifiers-static-semantics-assignmenttargettype + + If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return strict. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: -- UnaryExpression + + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is strict. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +--eval; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/target-cover-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/target-cover-newtarget.js new file mode 100644 index 000000000..f11973414 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/target-cover-newtarget.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to a "covered" new.target +info: | + UnaryExpression : + ++ UnaryExpression + -- UnaryExpression + + - It is an early Syntax Error if IsValidSimpleAssignmentTarget of + UnaryExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + --(new.target); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/target-cover-yieldexpr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/target-cover-yieldexpr.js new file mode 100644 index 000000000..f78ed50b8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/target-cover-yieldexpr.js @@ -0,0 +1,34 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to a "covered" YieldExpression +info: | + UnaryExpression : + ++ UnaryExpression + -- UnaryExpression + + - It is an early Syntax Error if IsValidSimpleAssignmentTarget of + UnaryExpression is invalid or strict. + + 12.15.3 Static Semantics: AssignmentTargetType + + AssignmentExpression: + YieldExpression + ArrowFunction + AsyncArrowFunction + LeftHandSideExpression = AssignmentExpression + LeftHandSideExpression AssignmentOperator AssignmentExpression + + 1. Return invalid. +features: [generators] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function* g() { + --(yield); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/target-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/target-newtarget.js new file mode 100644 index 000000000..a27975751 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/target-newtarget.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to new.target +info: | + UnaryExpression : + ++ UnaryExpression + -- UnaryExpression + + - It is an early Syntax Error if IsValidSimpleAssignmentTarget of + UnaryExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + --new.target; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/this.js new file mode 100644 index 000000000..b0861d9cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-decrement/this.js @@ -0,0 +1,27 @@ +// Copyright (C) 2023 Veera Sivarajan. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: > + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. (this) +info: | + sec-static-semantics-assignmenttargettype + + PrimaryExpression: this + + Return invalid. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: -- UnaryExpression + + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +--this; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/arguments.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/arguments.js new file mode 100644 index 000000000..7a151928e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/arguments.js @@ -0,0 +1,26 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions +description: > + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is strict. (arguments) +info: | + sec-identifiers-static-semantics-assignmenttargettype + + If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return strict. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: ++ UnaryExpression + + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is strict. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +++arguments; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/eval.js new file mode 100644 index 000000000..241a27e45 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/eval.js @@ -0,0 +1,27 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions +description: > + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is strict. (eval) +info: | + sec-identifiers-static-semantics-assignmenttargettype + + If this IdentifierReference is contained in strict mode code and StringValue of Identifier is "eval" or "arguments", return strict. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: ++ UnaryExpression + + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is strict. + +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +++eval; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/target-cover-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/target-cover-newtarget.js new file mode 100644 index 000000000..13e5d94f5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/target-cover-newtarget.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to a "covered" new.target +info: | + UnaryExpression : + ++ UnaryExpression + -- UnaryExpression + + - It is an early Syntax Error if IsValidSimpleAssignmentTarget of + UnaryExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + ++(new.target); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/target-cover-yieldexpr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/target-cover-yieldexpr.js new file mode 100644 index 000000000..80d8848e4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/target-cover-yieldexpr.js @@ -0,0 +1,34 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to a "covered" YieldExpression +info: | + UnaryExpression : + ++ UnaryExpression + -- UnaryExpression + + - It is an early Syntax Error if IsValidSimpleAssignmentTarget of + UnaryExpression is invalid or strict. + + 12.15.3 Static Semantics: AssignmentTargetType + + AssignmentExpression: + YieldExpression + ArrowFunction + AsyncArrowFunction + LeftHandSideExpression = AssignmentExpression + LeftHandSideExpression AssignmentOperator AssignmentExpression + + 1. Return invalid. +features: [generators] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function* g() { + ++(yield); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/target-newtarget.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/target-newtarget.js new file mode 100644 index 000000000..a378cc363 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/target-newtarget.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: Applied to new.target +info: | + UnaryExpression : + ++ UnaryExpression + -- UnaryExpression + + - It is an early Syntax Error if IsValidSimpleAssignmentTarget of + UnaryExpression is invalid or strict. + + 12.3.1.6 Static Semantics: AssignmentTargetType + + NewTarget: + + new.target + + 1. Return invalid. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +function f() { + ++new.target; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/this.js new file mode 100644 index 000000000..625b38f34 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/prefix-increment/this.js @@ -0,0 +1,27 @@ +// Copyright (C) 2023 Veera Sivarajan. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-update-expressions-static-semantics-early-errors +description: > + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. (this) +info: | + sec-static-semantics-assignmenttargettype + + PrimaryExpression: this + + Return invalid. + + sec-update-expressions-static-semantics-early-errors + + UpdateExpression: ++ UnaryExpression + + It is an early Syntax Error if AssignmentTargetType of UnaryExpression is not simple. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +++this; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/property-accessors/non-identifier-name.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/property-accessors/non-identifier-name.js new file mode 100644 index 000000000..98c1a7fc7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/property-accessors/non-identifier-name.js @@ -0,0 +1,20 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-left-hand-side-expressions +info: | + Token following DOT must be a valid identifier-name, test with string literal. +description: > + 12.3 Left-Hand-Side Expressions + MemberExpression[Yield, Await]: + MemberExpression[?Yield, ?Await] . IdentifierName + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +unresolvableReference.""; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-1.js new file mode 100644 index 000000000..78123982b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-1.js @@ -0,0 +1,13 @@ +// Copyright (C) 2014 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid hexidecimal character escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\x0`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-2.js new file mode 100644 index 000000000..660a2d372 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-2.js @@ -0,0 +1,13 @@ +// Copyright (C) 2016 Tim Disney. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid hexidecimal character escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\x0G`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-3.js new file mode 100644 index 000000000..6af45b0a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-hexidecimal-character-escape-sequence-truncated-3.js @@ -0,0 +1,13 @@ +// Copyright (C) 2016 Tim Disney. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid hexidecimal character escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\xG`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-legacy-octal-escape-sequence-8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-legacy-octal-escape-sequence-8.js new file mode 100644 index 000000000..cd2fbb191 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-legacy-octal-escape-sequence-8.js @@ -0,0 +1,27 @@ +// Copyright (C) 2020 Sony Interactive Entertainment Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: > + Invalid octal escape sequence (regardless of the presence of Annex B) +info: | + TemplateCharacter :: + $ [lookahead ≠ {] + \ TemplateEscapeSequence + \ NotEscapeSequence + LineContinuation + LineTerminatorSequence + SourceCharacter but not one of ` or \ or $ or LineTerminator + TemplateEscapeSequence :: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\8`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-legacy-octal-escape-sequence-9.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-legacy-octal-escape-sequence-9.js new file mode 100644 index 000000000..f0be69b9e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-legacy-octal-escape-sequence-9.js @@ -0,0 +1,27 @@ +// Copyright (C) 2020 Sony Interactive Entertainment Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: > + Invalid octal escape sequence (regardless of the presence of Annex B) +info: | + TemplateCharacter :: + $ [lookahead ≠ {] + \ TemplateEscapeSequence + \ NotEscapeSequence + LineContinuation + LineTerminatorSequence + SourceCharacter but not one of ` or \ or $ or LineTerminator + TemplateEscapeSequence :: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\9`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-legacy-octal-escape-sequence.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-legacy-octal-escape-sequence.js new file mode 100644 index 000000000..d3793ed0e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-legacy-octal-escape-sequence.js @@ -0,0 +1,26 @@ +// Copyright (C) 2014 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 16.1 +description: Invalid octal escape sequence +info: | + TemplateCharacter :: + $ [lookahead ≠ {] + \ TemplateEscapeSequence + \ NotEscapeSequence + LineContinuation + LineTerminatorSequence + SourceCharacter but not one of ` or \ or $ or LineTerminator + TemplateEscapeSequence :: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\00`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-1.js new file mode 100644 index 000000000..8ac46bc9d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-1.js @@ -0,0 +1,13 @@ +// Copyright (C) 2014 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid unicode escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u0`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-2.js new file mode 100644 index 000000000..74dd33715 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-2.js @@ -0,0 +1,13 @@ +// Copyright (C) 2016 Tim Disney. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid unicode escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u0g`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-3.js new file mode 100644 index 000000000..d03231664 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-3.js @@ -0,0 +1,13 @@ +// Copyright (C) 2016 Tim Disney. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid unicode escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u00g`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-4.js new file mode 100644 index 000000000..54b0b77f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-4.js @@ -0,0 +1,13 @@ +// Copyright (C) 2016 Tim Disney. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid unicode escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u000g`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-5.js new file mode 100644 index 000000000..26a442f0f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-5.js @@ -0,0 +1,13 @@ +// Copyright (C) 2016 Tim Disney. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid unicode escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u{g`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-6.js new file mode 100644 index 000000000..eab2904df --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-6.js @@ -0,0 +1,13 @@ +// Copyright (C) 2016 Tim Disney. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid unicode escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u{0`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-7.js new file mode 100644 index 000000000..c3ed51b15 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-7.js @@ -0,0 +1,13 @@ +// Copyright (C) 2016 Tim Disney. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid unicode escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u{10FFFFF}`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-8.js new file mode 100644 index 000000000..5b6e0a4e4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/invalid-unicode-escape-sequence-8.js @@ -0,0 +1,13 @@ +// Copyright (C) 2016 Tim Disney. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: Invalid unicode escape sequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u{10FFFFF}${'inner'}right`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/unicode-escape-nls-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/unicode-escape-nls-err.js new file mode 100644 index 000000000..ed2006310 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/unicode-escape-nls-err.js @@ -0,0 +1,55 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-Template +description: NumericLiteralSeperator disallowed in unicode CodePoint sequence +info: | + Template :: + NoSubstitutionTemplate + TemplateHead + + NoSubstitutionTemplate :: + `TemplateCharactersopt` + + TemplateCharacters :: + TemplateCharacterTemplateCharactersopt + + TemplateCharacter :: + $[lookahead ≠ {] + \EscapeSequence + \NotEscapeSequence + LineContinuation + LineTerminatorSequence + SourceCharacterbut not one of ` or \ or $ or LineTerminator + + EscapeSequence :: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence + + UnicodeEscapeSequence :: + uHex4Digits + u{CodePoint} + + CodePoint :: + HexDigit but only if MV of HexDigits ≤ 0x10FFFF + CodePointDigits but only if MV of HexDigits ≤ 0x10FFFF + + CodePointDigits :: + HexDigit + CodePointDigitsHexDigit + + HexDigit :: one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u{1F_639}`; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/unicode-escape-no-hex-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/unicode-escape-no-hex-err.js new file mode 100644 index 000000000..a2abd2254 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/template-literal/unicode-escape-no-hex-err.js @@ -0,0 +1,50 @@ +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-Template +description: > + \u is at the end of string, Hex4Digits is required. +info: | + Template :: + NoSubstitutionTemplate + TemplateHead + + NoSubstitutionTemplate :: + ` TemplateCharacters_opt ` + + TemplateCharacters :: + TemplateCharacter TemplateCharacters_opt + + TemplateCharacter :: + $ [lookahead ≠ {] + \ EscapeSequence + \ NotEscapeSequence + LineContinuation + LineTerminatorSequence + SourceCharacter but not one of ` or \ or $ or LineTerminator + + EscapeSequence :: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence + + UnicodeEscapeSequence :: + u Hex4Digits + u{ CodePoint } + + Hex4Digits :: + HexDigit HexDigit HexDigit HexDigit + + HexDigit :: one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +`\u` diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/this/S11.1.1_A1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/this/S11.1.1_A1.js new file mode 100644 index 000000000..c0b34f336 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/this/S11.1.1_A1.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: The "this" is reserved word +es5id: 11.1.1_A1 +description: Checking if execution of "this=1" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +this = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/yield/in-iteration-stmt.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/yield/in-iteration-stmt.js new file mode 100644 index 000000000..0094586df --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/yield/in-iteration-stmt.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-generator-function-definitions +es6id: 14.4 +description: > + YieldExpression operand may not include the `in` keyword in contexts where it + is disallowed +info: | + Syntax + + yield [no LineTerminator here] AssignmentExpression[?In, +Yield] +negative: + phase: parse + type: SyntaxError +features: [generators] +---*/ + +$DONOTEVALUATE(); + +function* g() { + for (yield '' in {}; ; ) ; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/yield/invalid-left-hand-side.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/yield/invalid-left-hand-side.js new file mode 100644 index 000000000..049c14ab4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/yield/invalid-left-hand-side.js @@ -0,0 +1,28 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-generator-function-definitions +es6id: 14.4 +description: A YieldExpression is not a valid LeftHandSideExpression +info: | + AssignmentExpression[In, Yield] : + ConditionalExpression[?In, ?Yield] + [+Yield]YieldExpression[?In] + ArrowFunction[?In, ?Yield] + LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield] + LeftHandSideExpression[?Yield] AssignmentOperator AssignmentExpression[?In, ?Yield] + + LeftHandSideExpression[Yield] : + NewExpression[?Yield] + CallExpression[?Yield] +features: [generators] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function* g() { + yield = 1; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/yield/star-in-iteration-stmt.js b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/yield/star-in-iteration-stmt.js new file mode 100644 index 000000000..b458c9317 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/expressions/yield/star-in-iteration-stmt.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-generator-function-definitions +es6id: 14.4 +description: > + YieldExpression operand may not include the `in` keyword in contexts where it + is disallowed +info: | + Syntax + + yield [no LineTerminator here] * AssignmentExpression[?In, +Yield] +negative: + phase: parse + type: SyntaxError +features: [generators] +---*/ + +$DONOTEVALUATE(); + +function* g() { + for (yield * '' in {}; ; ) ; +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/_implements.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/_implements.js new file mode 100644 index 000000000..f8586032f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/_implements.js @@ -0,0 +1,12 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6.1.2-16-s +description: > + SyntaxError isn't thrown when '_implements' occurs +---*/ + +var _implements = 1; + +assert.sameValue(_implements, 1, '_implements'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/abstract.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/abstract.js new file mode 100644 index 000000000..b59f7449e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/abstract.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.1 +description: Checking if execution of "abstract=1" succeeds +info: | + `abstract` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var abstract = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/boolean.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/boolean.js new file mode 100644 index 000000000..1cf9f1270 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/boolean.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.2 +description: Checking if execution of "boolean=1" succeeds +info: | + `boolean` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var boolean = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/byte.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/byte.js new file mode 100644 index 000000000..99db5782a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/byte.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.3 +description: Checking if execution of "byte=1" succeeds +info: | + `byte` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var byte = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/char.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/char.js new file mode 100644 index 000000000..85b53782f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/char.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.4 +description: Checking if execution of "char=1" succeeds +info: | + `char` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var char = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/class.js new file mode 100644 index 000000000..c2ce8eeb9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/class.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2_A1.5 +description: Checking if execution of "class=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield and await. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var class = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/const.js new file mode 100644 index 000000000..d13519cb6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/const.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2_A1.6 +description: Checking if execution of "const=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield and await. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var const = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/debugger.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/debugger.js new file mode 100644 index 000000000..b6284e7fd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/debugger.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2_A1.7 +description: Checking if execution of "debugger=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield and await. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var debugger = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/double.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/double.js new file mode 100644 index 000000000..f6d958d3c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/double.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.8 +description: Checking if execution of "double=1" succeeds +info: | + `double` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var double = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/enum.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/enum.js new file mode 100644 index 000000000..aab782325 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/enum.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2_A1.9 +description: Checking if execution of "enum=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield and await. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var enum = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/export.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/export.js new file mode 100644 index 000000000..48393ad36 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/export.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2_A1.10 +description: Checking if execution of "export=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield and await. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var export = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/extends.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/extends.js new file mode 100644 index 000000000..b6185edc9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/extends.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2_A1.11 +description: Checking if execution of "extends=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield and await. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var extends = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/final.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/final.js new file mode 100644 index 000000000..53dbc40f2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/final.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.12 +description: Checking if execution of "final=1" succeeds +info: | + `final` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var final = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/float.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/float.js new file mode 100644 index 000000000..3194f05ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/float.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.13 +description: Checking if execution of "float=1" succeeds +info: | + `float` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var float = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/goto.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/goto.js new file mode 100644 index 000000000..bd81f3dfc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/goto.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.14 +description: Checking if execution of "goto=1" succeeds +info: | + `goto` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var goto = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implement.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implement.js new file mode 100644 index 000000000..82789235a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implement.js @@ -0,0 +1,12 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6.1.2-12-s +description: > + SyntaxError isn't thrown when 'implement' occurs +---*/ + +var implement = 1; + +assert.sameValue(implement, 1, 'implement'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-strict-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-strict-escaped.js new file mode 100644 index 000000000..83d508a84 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-strict-escaped.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1-17-s +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: implements (implements) +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var \u0069mplements = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-strict.js new file mode 100644 index 000000000..43ed0c631 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-strict.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2-1-s +description: > + Strict Mode - SyntaxError is thrown when 'implements' occurs in strict mode code +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var implements = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-titlecase.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-titlecase.js new file mode 100644 index 000000000..9fe6ec04f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-titlecase.js @@ -0,0 +1,12 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6.1.2-11-s +description: > + SyntaxError isn't thrown when 'Implements' occurs +---*/ + +var Implements = 1; + +assert.sameValue(Implements, 1, 'Implements'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-uppercase.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-uppercase.js new file mode 100644 index 000000000..d9484a66f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements-uppercase.js @@ -0,0 +1,12 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6.1.2-10-s +description: > + SyntaxError isn't thrown when 'IMPLEMENTS' occurs +---*/ + +var IMPLEMENTS = 1; + +assert.sameValue(IMPLEMENTS, 1, 'IMPLEMENTS'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements.js new file mode 100644 index 000000000..0c55ca6c4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements.js @@ -0,0 +1,19 @@ +// Copyright 2011 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +info: The "implements" token can be used as identifier in non-strict code +es5id: 7.6.1.2_A1.15ns +description: Checking if execution of "implements=1" succeeds in non-strict code +flags: [noStrict] +---*/ + +var implements = 1; +var impl\u0065ments = 2; + +{ let implements = 3; } +{ let impl\u0065ments = 4; } + +{ const implements = 5; } +{ const impl\u0065ments = 6; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements0.js new file mode 100644 index 000000000..7f57e6094 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implements0.js @@ -0,0 +1,12 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6.1.2-14-s +description: > + SyntaxError isn't thrown when 'implements0' occurs +---*/ + +var implements0 = 1; + +assert.sameValue(implements0, 1, 'implements0'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implementss.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implementss.js new file mode 100644 index 000000000..ba9933f7e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/implementss.js @@ -0,0 +1,12 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6.1.2-13-s +description: > + SyntaxError isn't thrown when 'implementss' occurs +---*/ + +var implementss = 1; + +assert.sameValue(implementss, 1, 'implementss'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/import.js new file mode 100644 index 000000000..a2d14672a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/import.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2_A1.16 +description: Checking if execution of "import=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield and await. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var import = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/int.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/int.js new file mode 100644 index 000000000..0aecb49bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/int.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.17 +description: Checking if execution of "int=1" succeeds +info: | + `int` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var int = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/interface-strict-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/interface-strict-escaped.js new file mode 100644 index 000000000..00833ec7e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/interface-strict-escaped.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1-22-s +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: inte\u0072face (interface) +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var inte\u0072face = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/interface-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/interface-strict.js new file mode 100644 index 000000000..a9d4db268 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/interface-strict.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2-6-s +description: > + Strict Mode - SyntaxError is thrown when 'interface' occurs in strict mode code +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var interface = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/interface.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/interface.js new file mode 100644 index 000000000..4d908a347 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/interface.js @@ -0,0 +1,23 @@ +// Copyright 2011 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +info: | + The "interface" token can be used as identifier in + non-strict code +es5id: 7.6.1.2_A1.18ns +description: > + Checking if execution of "interface = 1" succeeds in non-strict + code +flags: [noStrict] +---*/ + +var interface = 1; +var int\u0065rface = 2; + +{ let interface = 3; } +{ let int\u0065rface = 4; } + +{ const interface = 5; } +{ const int\u0065rface = 6; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/let-strict-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/let-strict-escaped.js new file mode 100644 index 000000000..89ec4c991 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/let-strict-escaped.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1-18-s +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: l\u0065t (let) +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var l\u0065t = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/let-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/let-strict.js new file mode 100644 index 000000000..630259427 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/let-strict.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2-2-s +description: > + Strict Mode - SyntaxError is thrown when 'let' occurs in strict mode code +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var let = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/long.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/long.js new file mode 100644 index 000000000..dc7664e6d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/long.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.19 +description: Checking if execution of "long=1" succeeds +info: | + `long` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var long = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/native.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/native.js new file mode 100644 index 000000000..07479d4fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/native.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.20 +description: Checking if execution of "native=1" succeeds +info: | + `native` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var native = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/package-strict-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/package-strict-escaped.js new file mode 100644 index 000000000..441a90def --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/package-strict-escaped.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1-23-s +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: packag\u0065 (package) +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var packag\u0065 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/package-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/package-strict.js new file mode 100644 index 000000000..f048b6b4d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/package-strict.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2-7-s +description: > + Strict Mode - SyntaxError is thrown when 'package' occurs in strict mode code +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var package = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/package.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/package.js new file mode 100644 index 000000000..241306c5d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/package.js @@ -0,0 +1,19 @@ +// Copyright 2011 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +info: The "package" token can be used as identifier in non-strict code +es5id: 7.6.1.2_A1.21ns +description: Checking if execution of "package=1" succeeds in non-strict code +flags: [noStrict] +---*/ + +var package = 1; +var pack\u0061ge = 2; + +{ let package = 3; } +{ let pack\u0061ge = 4; } + +{ const package = 5; } +{ const pack\u0061ge = 6; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/private-strict-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/private-strict-escaped.js new file mode 100644 index 000000000..2d4507e28 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/private-strict-escaped.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1-19-s +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: privat\u0065 (private) +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var privat\u0065 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/private-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/private-strict.js new file mode 100644 index 000000000..d23de9fe3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/private-strict.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2-3-s +description: > + Strict Mode - SyntaxError is thrown when 'private' occurs in strict mode code +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var private = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/private.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/private.js new file mode 100644 index 000000000..bb4fbd16c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/private.js @@ -0,0 +1,19 @@ +// Copyright 2011 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +info: The "private" token can be used as identifier in non-strict code +es5id: 7.6.1.2_A1.22ns +description: Checking if execution of "private=1" succeeds in non-strict code +flags: [noStrict] +---*/ + +var private = 1; +var priv\u0061te = 2; + +{ let private = 3; } +{ let priv\u0061te = 4; } + +{ const private = 5; } +{ const priv\u0061te = 6; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/protected-strict-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/protected-strict-escaped.js new file mode 100644 index 000000000..fd4cd23ce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/protected-strict-escaped.js @@ -0,0 +1,25 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1-24-s +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: + \u0070\u0072\u006f\u0074\u0065\u0063\u0074\u0065\u0064 (protected) +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var \u0070\u0072\u006f\u0074\u0065\u0063\u0074\u0065\u0064 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/protected-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/protected-strict.js new file mode 100644 index 000000000..5fbc17a91 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/protected-strict.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2-8-s +description: > + Strict Mode - SyntaxError is thrown when 'protected' occurs in strict mode code +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var protected = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/protected.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/protected.js new file mode 100644 index 000000000..6ab5bea0c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/protected.js @@ -0,0 +1,19 @@ +// Copyright 2011 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +info: The "protected" token can be used as identifier in non-strict code +es5id: 7.6.1.2_A1.23ns +description: Checking if execution of "protected=1" succeeds in non-strict code +flags: [noStrict] +---*/ + +var protected = 1; +var prot\u0065cted = 2; + +{ let protected = 3; } +{ let prot\u0065cted = 4; } + +{ const protected = 5; } +{ const prot\u0065cted = 6; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/public-strict-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/public-strict-escaped.js new file mode 100644 index 000000000..b3f99fabf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/public-strict-escaped.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1-20-s +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: \u0070\u0075\u0062\u006c\u0069\u0063 (public) +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var \u0070\u0075\u0062\u006c\u0069\u0063 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/public-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/public-strict.js new file mode 100644 index 000000000..383028028 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/public-strict.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2-4-s +description: > + Strict Mode - SyntaxError is thrown when 'public' occurs in strict mode code +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var public = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/public.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/public.js new file mode 100644 index 000000000..406321bb0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/public.js @@ -0,0 +1,19 @@ +// Copyright 2011 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +info: The "public" token can be used as identifier in non-strict code +es5id: 7.6.1.2_A1.24ns +description: Checking if execution of "public=1" succeeds in non-strict code +flags: [noStrict] +---*/ + +var public = 1; +var publi\u0063 = 2; + +{ let public = 3; } +{ let publi\u0063 = 4; } + +{ const public = 5; } +{ const publi\u0063 = 6; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/short.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/short.js new file mode 100644 index 000000000..f76a25d18 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/short.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.25 +description: Checking if execution of "short=1" succeeds +info: | + `short` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var short = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/static-strict-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/static-strict-escaped.js new file mode 100644 index 000000000..6693edd21 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/static-strict-escaped.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1-25-s +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: \u0073\u0074\u0061\u0074\u0069\u0063 (static) +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var \u0073\u0074\u0061\u0074\u0069\u0063 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/static-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/static-strict.js new file mode 100644 index 000000000..169b96601 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/static-strict.js @@ -0,0 +1,23 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2-9-s +description: > + Strict Mode - SyntaxError is thrown when 'static' occurs in strict mode code +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var static = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/static.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/static.js new file mode 100644 index 000000000..971fd1414 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/static.js @@ -0,0 +1,19 @@ +// Copyright 2011 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +info: The "static" token can be used as identifier in non-strict code +es5id: 7.6.1.2_A1.26ns +description: Checking if execution of "static=1" succeeds in non-strict code +flags: [noStrict] +---*/ + +var static = 1; +var st\u0061tic = 2; + +{ let static = 3; } +{ let st\u0061tic = 4; } + +{ const static = 5; } +{ const st\u0061tic = 6; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/super.js new file mode 100644 index 000000000..7b4e01835 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/super.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2_A1.27 +description: Checking if execution of "super=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield and await. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var super = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/synchronized.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/synchronized.js new file mode 100644 index 000000000..888d01402 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/synchronized.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.28 +description: Checking if execution of "synchronized=1" succeeds +info: | + `synchronized` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var synchronized = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/throws.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/throws.js new file mode 100644 index 000000000..f03369078 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/throws.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.29 +description: Checking if execution of "throws=1" succeeds +info: | + `throws` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var throws = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/transient.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/transient.js new file mode 100644 index 000000000..ff9777901 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/transient.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.30 +description: Checking if execution of "transient=1" succeeds +info: | + `transient` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var transient = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/volatile.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/volatile.js new file mode 100644 index 000000000..aa0ab5384 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/volatile.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-future-reserved-words +es5id: 7.6.1.2_A1.31 +description: Checking if execution of "volatile=1" succeeds +info: | + `volatile` was removed from the list of future reserved words in ECMAScript 5. +---*/ + +var volatile = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/yield-strict-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/yield-strict-escaped.js new file mode 100644 index 000000000..1276a92ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/yield-strict-escaped.js @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1-21-s +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: \u0079ield (yield) +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if this phrase is contained in strict mode code and the + StringValue of IdentifierName is: "implements", "interface", "let", "package", + "private", "protected", "public", "static", or "yield". +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var \u0079ield = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/yield-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/yield-strict.js new file mode 100644 index 000000000..ec21143c2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/future-reserved-words/yield-strict.js @@ -0,0 +1,22 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.2-5-s +description: > + Strict Mode - SyntaxError is thrown when ReservedWord + 'yield' occurs in strict mode code +info: | + BindingIdentifier : yield + + It is a Syntax Error if the code matched by this production is contained in strict mode code. +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var yield = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/decl-lex-restricted-global.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/decl-lex-restricted-global.js new file mode 100644 index 000000000..2834cecae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/decl-lex-restricted-global.js @@ -0,0 +1,18 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-globaldeclarationinstantiation +es6id: 15.1.8 +description: Lexical declaration collides with existing "restricted global" +info: | + [...] + 5. For each name in lexNames, do + [...] + c. Let hasRestrictedGlobal be ? envRec.HasRestrictedGlobalProperty(name). + d. If hasRestrictedGlobal is true, throw a SyntaxError exception. +negative: + phase: runtime + type: SyntaxError +---*/ + +let undefined; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/export.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/export.js new file mode 100644 index 000000000..ced638216 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/export.js @@ -0,0 +1,21 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: The `export` declaration may not appear within a ScriptBody +esid: sec-scripts +negative: + phase: parse + type: SyntaxError +info: | + A.5 Scripts and Modules + + Script: + ScriptBodyopt + + ScriptBody: + StatementList +---*/ + +$DONOTEVALUATE(); + +export default null; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/import.js new file mode 100644 index 000000000..e0557fae7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/import.js @@ -0,0 +1,21 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: The `import` declaration may not appear within a ScriptBody +esid: sec-scripts +negative: + phase: parse + type: SyntaxError +info: | + A.5 Scripts and Modules + + Script: + ScriptBodyopt + + ScriptBody: + StatementList +---*/ + +$DONOTEVALUATE(); + +import v from './import.js'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-call-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-call-expression-bad-reference.js new file mode 100644 index 000000000..b116eb500 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-call-expression-bad-reference.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-bad-reference.case +// - src/invalid-private-names/default/top-level-scriptbody.template +/*--- +description: bad reference in call expression (Invalid private names should throw a SyntaxError, top level of script body) +esid: sec-static-semantics-early-errors +features: [class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +(() => {})().#x diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-call-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-call-expression-this.js new file mode 100644 index 000000000..238934669 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-call-expression-this.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/call-expression-this.case +// - src/invalid-private-names/default/top-level-scriptbody.template +/*--- +description: this evaluated in call expression (Invalid private names should throw a SyntaxError, top level of script body) +esid: sec-static-semantics-early-errors +features: [class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +(() => this)().#x diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-member-expression-bad-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-member-expression-bad-reference.js new file mode 100644 index 000000000..e1ce1cb04 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-member-expression-bad-reference.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-bad-reference.case +// - src/invalid-private-names/default/top-level-scriptbody.template +/*--- +description: bad reference in member expression (Invalid private names should throw a SyntaxError, top level of script body) +esid: sec-static-semantics-early-errors +features: [class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +something.#x diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-member-expression-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-member-expression-this.js new file mode 100644 index 000000000..8fd333f28 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/invalid-private-names-member-expression-this.js @@ -0,0 +1,40 @@ +// This file was procedurally generated from the following sources: +// - src/invalid-private-names/member-expression-this.case +// - src/invalid-private-names/default/top-level-scriptbody.template +/*--- +description: this reference in member expression (Invalid private names should throw a SyntaxError, top level of script body) +esid: sec-static-semantics-early-errors +features: [class-fields-private] +flags: [generated] +negative: + phase: parse + type: SyntaxError +info: | + ScriptBody:StatementList + It is a Syntax Error if AllPrivateNamesValid of StatementList with an empty List + as an argument is false unless the source code is eval code that is being + processed by a direct eval. + + ModuleBody:ModuleItemList + It is a Syntax Error if AllPrivateNamesValid of ModuleItemList with an empty List + as an argument is false. + + + Static Semantics: AllPrivateNamesValid + + MemberExpression : MemberExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + + CallExpression : CallExpression . PrivateName + + 1. If StringValue of PrivateName is in names, return true. + 2. Return false. + +---*/ + + +$DONOTEVALUATE(); + +this.#x diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/new.target-arrow.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/new.target-arrow.js new file mode 100644 index 000000000..c818ce506 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/new.target-arrow.js @@ -0,0 +1,37 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-scripts-static-semantics-early-errors +es6id: 15.1.1 +description: An ArrowFunction in global code may not contain `new.target` +info: | + - It is a Syntax Error if StatementList Contains NewTarget unless the source + code containing NewTarget is eval code that is being processed by a direct + eval that is contained in function code that is not the function code of an + ArrowFunction. + + 14.2.3 Static Semantics: Contains + + With parameter symbol. + + ArrowFunction : ArrowParameters => ConciseBody + + 1. If symbol is not one of NewTarget, SuperProperty, SuperCall, super or + this, return false. + 2. If ArrowParameters Contains symbol is true, return true. + 3. Return ConciseBody Contains symbol. + + NOTE Normally, Contains does not look inside most function forms. However, + Contains is used to detect new.target, this, and super usage within an + ArrowFunction. +features: [arrow-function, new.target] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +() => { + new.target; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/new.target.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/new.target.js new file mode 100644 index 000000000..e8c55b1ce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/new.target.js @@ -0,0 +1,20 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-scripts-static-semantics-early-errors +es6id: 15.1.1 +description: Global code may not contain `new.target` +info: | + - It is a Syntax Error if StatementList Contains NewTarget unless the source + code containing NewTarget is eval code that is being processed by a direct + eval that is contained in function code that is not the function code of an + ArrowFunction. +negative: + phase: parse + type: SyntaxError +features: [new.target] +---*/ + +$DONOTEVALUATE(); + +new.target; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/return.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/return.js new file mode 100644 index 000000000..92835966a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/return.js @@ -0,0 +1,22 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-scripts +es6id: 15.1 +description: ReturnStatement may not be used directly within global code +info: | + Syntax + + Script : + ScriptBodyopt + + ScriptBody : + StatementList[~Yield, ~Return] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +return; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-call-arrow.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-call-arrow.js new file mode 100644 index 000000000..5c24ccea4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-call-arrow.js @@ -0,0 +1,37 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-scripts-static-semantics-early-errors +es6id: 15.1.1 +description: An ArrowFunction in global code may not contain SuperCall +info: | + - It is a Syntax Error if StatementList Contains super unless the source code + containing super is eval code that is being processed by a direct eval that + is contained in function code that is not the function code of an + ArrowFunction. + + 14.2.3 Static Semantics: Contains + + With parameter symbol. + + ArrowFunction : ArrowParameters => ConciseBody + + 1. If symbol is not one of NewTarget, SuperProperty, SuperCall, super or + this, return false. + 2. If ArrowParameters Contains symbol is true, return true. + 3. Return ConciseBody Contains symbol. + + NOTE Normally, Contains does not look inside most function forms. However, + Contains is used to detect new.target, this, and super usage within an + ArrowFunction. +features: [super, arrow-function] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +() => { + super(); +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-call.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-call.js new file mode 100644 index 000000000..5a9e9f1da --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-call.js @@ -0,0 +1,20 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-scripts-static-semantics-early-errors +es6id: 15.1.1 +description: Global code may not contain SuperCall +info: | + - It is a Syntax Error if StatementList Contains super unless the source code + containing super is eval code that is being processed by a direct eval that + is contained in function code that is not the function code of an + ArrowFunction. +negative: + phase: parse + type: SyntaxError +features: [super] +---*/ + +$DONOTEVALUATE(); + +super(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-prop-arrow.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-prop-arrow.js new file mode 100644 index 000000000..bc6518c48 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-prop-arrow.js @@ -0,0 +1,37 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-scripts-static-semantics-early-errors +es6id: 15.1.1 +description: An ArrowFunction in global code may not contain SuperProperty +info: | + - It is a Syntax Error if StatementList Contains super unless the source code + containing super is eval code that is being processed by a direct eval that + is contained in function code that is not the function code of an + ArrowFunction. + + 14.2.3 Static Semantics: Contains + + With parameter symbol. + + ArrowFunction : ArrowParameters => ConciseBody + + 1. If symbol is not one of NewTarget, SuperProperty, SuperCall, super or + this, return false. + 2. If ArrowParameters Contains symbol is true, return true. + 3. Return ConciseBody Contains symbol. + + NOTE Normally, Contains does not look inside most function forms. However, + Contains is used to detect new.target, this, and super usage within an + ArrowFunction. +features: [super, arrow-function] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +() => { + super.property; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-prop.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-prop.js new file mode 100644 index 000000000..c38179552 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/super-prop.js @@ -0,0 +1,20 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-scripts-static-semantics-early-errors +es6id: 15.1.1 +description: Global code may not contain SuperProperty +info: | + - It is a Syntax Error if StatementList Contains super unless the source code + containing super is eval code that is being processed by a direct eval that + is contained in function code that is not the function code of an + ArrowFunction. +negative: + phase: parse + type: SyntaxError +features: [super] +---*/ + +$DONOTEVALUATE(); + +super.property; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/yield-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/yield-strict.js new file mode 100644 index 000000000..ec6292b44 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/global-code/yield-strict.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-scripts +es6id: 15.1 +description: > + The `yield` token is interpreted as an Identifier when it appears in global + code (strict mode) +info: | + Syntax + + Script : + ScriptBodyopt + + ScriptBody : + StatementList[~Yield, ~Return] +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +yield; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T1.js new file mode 100644 index 000000000..4ae54bf0a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T1.js @@ -0,0 +1,25 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Every execution context has associated with it a scope chain. + A scope chain is a list of objects that are searched when evaluating an + Identifier +es5id: 10.2.2_A1_T1 +description: Checking scope chain containing function declarations +---*/ + +var x = 0; + +function f1(){ + var x = 1; + function f2(){ + return x; + }; + return f2(); +} + +if(!(f1() === 1)){ + throw new Test262Error("#1: Scope chain disturbed"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T2.js new file mode 100644 index 000000000..ede752104 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T2.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Every execution context has associated with it a scope chain. + A scope chain is a list of objects that are searched when evaluating an + Identifier +es5id: 10.2.2_A1_T2 +description: Checking scope chain containing function declarations +---*/ + +var x = 0; + +function f1(){ + function f2(){ + return x; + }; + return f2(); +} + +if(!(f1() === 0)){ + throw new Test262Error("#1: Scope chain disturbed"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T3.js new file mode 100644 index 000000000..f9092cf0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T3.js @@ -0,0 +1,26 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Every execution context has associated with it a scope chain. + A scope chain is a list of objects that are searched when evaluating an + Identifier +es5id: 10.2.2_A1_T3 +description: Checking scope chain containing function declarations +---*/ + +var x = 0; + +function f1(){ + function f2(){ + return x; + }; + return f2(); + + var x = 1; +} + +if(!(f1() === undefined)){ + throw new Test262Error("#1: Scope chain disturbed"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T4.js new file mode 100644 index 000000000..cb18e6a77 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T4.js @@ -0,0 +1,26 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Every execution context has associated with it a scope chain. + A scope chain is a list of objects that are searched when evaluating an + Identifier +es5id: 10.2.2_A1_T4 +description: Checking scope chain containing function declarations +---*/ + +var x = 0; + +function f1(){ + function f2(){ + return x; + }; + + var x = 1; + return f2(); +} + +if(!(f1() === 1)){ + throw new Test262Error("#1: Scope chain disturbed"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T5.js new file mode 100644 index 000000000..00ad7ae49 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T5.js @@ -0,0 +1,30 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Every execution context has associated with it a scope chain. + A scope chain is a list of objects that are searched when evaluating an + Identifier +es5id: 10.2.2_A1_T5 +description: Checking scope chain containing function declarations and "with" +flags: [noStrict] +---*/ + +var x = 0; + +var myObj = {x : "obj"}; + +function f1(){ + var x = 1; + function f2(){ + with(myObj){ + return x; + } + }; + return f2(); +} + +if(!(f1() === "obj")){ + throw new Test262Error("#1: Scope chain disturbed"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T6.js new file mode 100644 index 000000000..ea6d6cf41 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T6.js @@ -0,0 +1,29 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Every execution context has associated with it a scope chain. + A scope chain is a list of objects that are searched when evaluating an + Identifier +es5id: 10.2.2_A1_T6 +description: Checking scope chain containing function declarations and "with" +flags: [noStrict] +---*/ + +var x = 0; + +var myObj = {x : "obj"}; + +function f1(){ + function f2(){ + with(myObj){ + return x; + } + }; + return f2(); +} + +if(!(f1() === "obj")){ + throw new Test262Error("#1: Scope chain disturbed"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T7.js new file mode 100644 index 000000000..1e4b4aa1e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T7.js @@ -0,0 +1,31 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Every execution context has associated with it a scope chain. + A scope chain is a list of objects that are searched when evaluating an + Identifier +es5id: 10.2.2_A1_T7 +description: Checking scope chain containing function declarations and "with" +flags: [noStrict] +---*/ + +var x = 0; + +var myObj = {x : "obj"}; + +function f1(){ + function f2(){ + with(myObj){ + return x; + } + }; + return f2(); + + var x = 1; +} + +if(!(f1() === "obj")){ + throw new Test262Error("#1: Scope chain disturbed"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T8.js new file mode 100644 index 000000000..eb945853c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T8.js @@ -0,0 +1,31 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Every execution context has associated with it a scope chain. + A scope chain is a list of objects that are searched when evaluating an + Identifier +es5id: 10.2.2_A1_T8 +description: Checking scope chain containing function declarations and "with" +flags: [noStrict] +---*/ + +var x = 0; + +var myObj = {x : "obj"}; + +function f1(){ + function f2(){ + with(myObj){ + return x; + } + }; + + var x = 1; + return f2(); +} + +if(!(f1() === "obj")){ + throw new Test262Error("#1: Scope chain disturbed"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T9.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T9.js new file mode 100644 index 000000000..fdb68d24c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S10.2.2_A1_T9.js @@ -0,0 +1,26 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Every execution context has associated with it a scope chain. + A scope chain is a list of objects that are searched when evaluating an + Identifier +es5id: 10.2.2_A1_T9 +description: Checking scope chain containing function declarations and "with" +flags: [noStrict] +---*/ + +var x = 0; + +var myObj = {x : "obj"}; + +function f1(){ + with(myObj){ + return x; + } +} + +if(!(f1() === "obj")){ + throw new Test262Error("#1: Scope chain disturbed"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S11.1.2_A1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S11.1.2_A1_T1.js new file mode 100644 index 000000000..518bad9b8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S11.1.2_A1_T1.js @@ -0,0 +1,25 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: The result of evaluating an Identifier is always a value of type Reference +es5id: 11.1.2_A1_T1 +description: Creating variables without defining it +---*/ + +//CHECK#1 +if (this.x !== undefined) { + throw new Test262Error('#1: this.x === undefined. Actual: ' + (this.x)); +} + +//CHECK#2 +var object = new Object(); +if (object.prop !== undefined) { + throw new Test262Error('#2: var object = new Object(); object.prop === undefined. Actual: ' + (object.prop)); +} + +//CHECK#3 +this.y++; +if (isNaN(y) !== true) { + throw new Test262Error('#3: this.y++; y === Not-a-Number. Actual: ' + (y)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S11.1.2_A1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S11.1.2_A1_T2.js new file mode 100644 index 000000000..e27e5068f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/S11.1.2_A1_T2.js @@ -0,0 +1,19 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: The result of evaluating an Identifier is always a value of type Reference +es5id: 11.1.2_A1_T2 +description: Trying to generate ReferenceError +---*/ + +//CHECK#1 +try { + this.z; + z; + throw new Test262Error('#1.1: this.z; z === undefined throw ReferenceError. Actual: ' + (z)); +} catch(e) { + if ((e instanceof ReferenceError) !== true) { + throw new Test262Error('#1.2: this.z; z === undefined throw ReferenceError. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/assign-to-global-undefined.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/assign-to-global-undefined.js new file mode 100644 index 000000000..4d6da1438 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/assign-to-global-undefined.js @@ -0,0 +1,20 @@ +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-initializeboundname +description: > + In strict mode code, attempts to assign to an unresolvable reference must throw a ReferenceError exception +info: | + via sec-putvalue + + If IsUnresolvableReference(V) is true, then + If IsStrictReference(V) is true, then + Throw a ReferenceError exception. + +flags: [onlyStrict] +negative: + phase: runtime + type: ReferenceError +---*/ + +undeclared = (this.undeclared = 5); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/static-init-invalid-await.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/static-init-invalid-await.js new file mode 100644 index 000000000..61ddd625d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/static-init-invalid-await.js @@ -0,0 +1,25 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-class-definitions-static-semantics-early-errors +description: Restriction on `await` +info: | + IdentifierReference : Identifier + + - It is a Syntax Error if the code matched by this production is nested, + directly or indirectly (but not crossing function or static initialization + block boundaries), within a ClassStaticBlock and the StringValue of + Identifier is "arguments" or "await". +negative: + phase: parse + type: SyntaxError +features: [class-static-block] +---*/ + +$DONOTEVALUATE(); + +class C { + static { + await; + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/unscopables.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/unscopables.js new file mode 100644 index 000000000..ef581d444 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifier-resolution/unscopables.js @@ -0,0 +1,22 @@ +// Copyright 2015 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 8.1.1.4.1 +description: > + `Symbol.unscopables` is not referenced when finding bindings in global scope +info: | + 1. Let envRec be the global Environment Record for which the method was + invoked. + 2. Let DclRec be envRec.[[DeclarativeRecord]]. + 3. If DclRec.HasBinding(N) is true, return true. + 4. Let ObjRec be envRec.[[ObjectRecord]]. + 5. Return ObjRec.HasBinding(N). +features: [Symbol.unscopables] +---*/ + +var x = 86; +this[Symbol.unscopables] = { + x: true +}; +assert.sameValue(x, 86); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_continue-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_continue-escaped.js new file mode 100644 index 000000000..39c9ff627 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_continue-escaped.js @@ -0,0 +1,37 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-names-and-keywords +description: Test grandfathered characters of ID_Continue. +info: | + Grandfathered characters (Other_ID_Start + Other_ID_Continue) +---*/ + +// Other_ID_Start (Unicode 4.0) +var a\u2118; +var a\u212E; +var a\u309B; +var a\u309C; + +// Other_ID_Start (Unicode 9.0) +var a\u1885; +var a\u1886; + +// Other_ID_Continue (Unicode 4.1) +var a\u1369; +var a\u136A; +var a\u136B; +var a\u136C; +var a\u136D; +var a\u136E; +var a\u136F; +var a\u1370; +var a\u1371; + +// Other_ID_Continue (Unicode 5.1) +var a\u00B7; +var a\u0387; + +// Other_ID_Continue (Unicode 6.0) +var a\u19DA; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_continue.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_continue.js new file mode 100644 index 000000000..4fcd41aa9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_continue.js @@ -0,0 +1,37 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-names-and-keywords +description: Test grandfathered characters of ID_Continue. +info: | + Grandfathered characters (Other_ID_Start + Other_ID_Continue) +---*/ + +// Other_ID_Start (Unicode 4.0) +var a℘; // U+2118 +var a℮; // U+212E +var a゛; // U+309B +var a゜; // U+309C + +// Other_ID_Start (Unicode 9.0) +var aᢅ; // U+1885 +var aᢆ; // U+1886 + +// Other_ID_Continue (Unicode 4.1) +var a፩; // U+1369 +var a፪; // U+136A +var a፫; // U+136B +var a፬; // U+136C +var a፭; // U+136D +var a፮; // U+136E +var a፯; // U+136F +var a፰; // U+1370 +var a፱; // U+1371 + +// Other_ID_Continue (Unicode 5.1) +var a·; // U+00B7 +var a·; // U+0387 + +// Other_ID_Continue (Unicode 6.0) +var a᧚; // U+19DA diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_start-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_start-escaped.js new file mode 100644 index 000000000..c0122e262 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_start-escaped.js @@ -0,0 +1,19 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-names-and-keywords +description: Test grandfathered characters of ID_Start. +info: | + Grandfathered characters (Other_ID_Start) +---*/ + +// Other_ID_Start (Unicode 4.0) +var \u2118; +var \u212E; +var \u309B; +var \u309C; + +// Other_ID_Start (Unicode 9.0) +var \u1885; +var \u1886; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_start.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_start.js new file mode 100644 index 000000000..8e520cce4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/other_id_start.js @@ -0,0 +1,19 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-names-and-keywords +description: Test grandfathered characters of ID_Start. +info: | + Grandfathered characters (Other_ID_Start) +---*/ + +// Other_ID_Start (Unicode 4.0) +var ℘; // U+2118 +var ℮; // U+212E +var ゛; // U+309B +var ゜; // U+309C + +// Other_ID_Start (Unicode 9.0) +var ᢅ; // U+1885 +var ᢆ; // U+1886 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-digits-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-digits-via-escape-hex.js new file mode 100644 index 000000000..b53009cdf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-digits-via-escape-hex.js @@ -0,0 +1,38 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of DIGITS +es6id: 11.6 +description: Identifier is $+ANY_DIGIT +---*/ + +var $\u{30} = 0; +assert.sameValue($0, 0); + +var $\u{31} = 1; +assert.sameValue($1, 1); + +var $\u{32} = 2; +assert.sameValue($2, 2); + +var $\u{33} = 3; +assert.sameValue($3, 3); + +var $\u{34} = 4; +assert.sameValue($4, 4); + +var $\u{35} = 5; +assert.sameValue($5, 5); + +var $\u{36} = 6; +assert.sameValue($6, 6); + +var $\u{37} = 7; +assert.sameValue($7, 7); + +var $\u{38} = 8; +assert.sameValue($8, 8); + +var $\u{39} = 9; +assert.sameValue($9, 9); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-digits-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-digits-via-escape-hex4.js new file mode 100644 index 000000000..171143709 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-digits-via-escape-hex4.js @@ -0,0 +1,38 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of DIGITS +es5id: 7.6_A4.3_T1 +description: Identifier is $+ANY_DIGIT +---*/ + +var $\u0030 = 0; +assert.sameValue($0, 0); + +var $\u0031 = 1; +assert.sameValue($1, 1); + +var $\u0032 = 2; +assert.sameValue($2, 2); + +var $\u0033 = 3; +assert.sameValue($3, 3); + +var $\u0034 = 4; +assert.sameValue($4, 4); + +var $\u0035 = 5; +assert.sameValue($5, 5); + +var $\u0036 = 6; +assert.sameValue($6, 6); + +var $\u0037 = 7; +assert.sameValue($7, 7); + +var $\u0038 = 8; +assert.sameValue($8, 8); + +var $\u0039 = 9; +assert.sameValue($9, 9); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-digits.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-digits.js new file mode 100644 index 000000000..0acf1b484 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-digits.js @@ -0,0 +1,38 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of DIGITS +es6id: 11.6 +description: Identifier is $+ANY_DIGIT +---*/ + +var $0 = 0; +assert.sameValue($0, 0); + +var $1 = 1; +assert.sameValue($1, 1); + +var $2 = 2; +assert.sameValue($2, 2); + +var $3 = 3; +assert.sameValue($3, 3); + +var $4 = 4; +assert.sameValue($4, 4); + +var $5 = 5; +assert.sameValue($5, 5); + +var $6 = 6; +assert.sameValue($6, 6); + +var $7 = 7; +assert.sameValue($7, 7); + +var $8 = 8; +assert.sameValue($8, 8); + +var $9 = 9; +assert.sameValue($9, 9); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0-class-escaped.js new file mode 100644 index 000000000..ca383a75c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v10.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u0AFA\u0AFB\u0AFC\u0AFD\u0AFE\u0AFF\u0D00\u0D3B\u0D3C\u1CF7\u1DF6\u1DF7\u1DF8\u1DF9\u{11A01}\u{11A02}\u{11A03}\u{11A04}\u{11A05}\u{11A06}\u{11A07}\u{11A08}\u{11A09}\u{11A0A}\u{11A33}\u{11A34}\u{11A35}\u{11A36}\u{11A37}\u{11A38}\u{11A39}\u{11A3B}\u{11A3C}\u{11A3D}\u{11A3E}\u{11A47}\u{11A51}\u{11A52}\u{11A53}\u{11A54}\u{11A55}\u{11A56}\u{11A57}\u{11A58}\u{11A59}\u{11A5A}\u{11A5B}\u{11A8A}\u{11A8B}\u{11A8C}\u{11A8D}\u{11A8E}\u{11A8F}\u{11A90}\u{11A91}\u{11A92}\u{11A93}\u{11A94}\u{11A95}\u{11A96}\u{11A97}\u{11A98}\u{11A99}\u{11D31}\u{11D32}\u{11D33}\u{11D34}\u{11D35}\u{11D36}\u{11D3A}\u{11D3C}\u{11D3D}\u{11D3F}\u{11D40}\u{11D41}\u{11D42}\u{11D43}\u{11D44}\u{11D45}\u{11D47}\u{11D50}\u{11D51}\u{11D52}\u{11D53}\u{11D54}\u{11D55}\u{11D56}\u{11D57}\u{11D58}\u{11D59}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0-class.js new file mode 100644 index 000000000..e2f7f10e2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v10.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_ૺૻૼ૽૾૿ഀ഻഼᳷᷹᷷᷸᷶𑨁𑨂𑨃𑨄𑨅𑨆𑨇𑨈𑨉𑨊𑨳𑨴𑨵𑨶𑨷𑨸𑨹𑨻𑨼𑨽𑨾𑩇𑩑𑩒𑩓𑩔𑩕𑩖𑩗𑩘𑩙𑩚𑩛𑪊𑪋𑪌𑪍𑪎𑪏𑪐𑪑𑪒𑪓𑪔𑪕𑪖𑪗𑪘𑪙𑴱𑴲𑴳𑴴𑴵𑴶𑴺𑴼𑴽𑴿𑵀𑵁𑵂𑵃𑵄𑵅𑵇𑵐𑵑𑵒𑵓𑵔𑵕𑵖𑵗𑵘𑵙; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0-escaped.js new file mode 100644 index 000000000..139f27dcd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v10.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u0AFA\u0AFB\u0AFC\u0AFD\u0AFE\u0AFF\u0D00\u0D3B\u0D3C\u1CF7\u1DF6\u1DF7\u1DF8\u1DF9\u{11A01}\u{11A02}\u{11A03}\u{11A04}\u{11A05}\u{11A06}\u{11A07}\u{11A08}\u{11A09}\u{11A0A}\u{11A33}\u{11A34}\u{11A35}\u{11A36}\u{11A37}\u{11A38}\u{11A39}\u{11A3B}\u{11A3C}\u{11A3D}\u{11A3E}\u{11A47}\u{11A51}\u{11A52}\u{11A53}\u{11A54}\u{11A55}\u{11A56}\u{11A57}\u{11A58}\u{11A59}\u{11A5A}\u{11A5B}\u{11A8A}\u{11A8B}\u{11A8C}\u{11A8D}\u{11A8E}\u{11A8F}\u{11A90}\u{11A91}\u{11A92}\u{11A93}\u{11A94}\u{11A95}\u{11A96}\u{11A97}\u{11A98}\u{11A99}\u{11D31}\u{11D32}\u{11D33}\u{11D34}\u{11D35}\u{11D36}\u{11D3A}\u{11D3C}\u{11D3D}\u{11D3F}\u{11D40}\u{11D41}\u{11D42}\u{11D43}\u{11D44}\u{11D45}\u{11D47}\u{11D50}\u{11D51}\u{11D52}\u{11D53}\u{11D54}\u{11D55}\u{11D56}\u{11D57}\u{11D58}\u{11D59}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0.js new file mode 100644 index 000000000..f473025c3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-10.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v10.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _ૺૻૼ૽૾૿ഀ഻഼᳷᷹᷷᷸᷶𑨁𑨂𑨃𑨄𑨅𑨆𑨇𑨈𑨉𑨊𑨳𑨴𑨵𑨶𑨷𑨸𑨹𑨻𑨼𑨽𑨾𑩇𑩑𑩒𑩓𑩔𑩕𑩖𑩗𑩘𑩙𑩚𑩛𑪊𑪋𑪌𑪍𑪎𑪏𑪐𑪑𑪒𑪓𑪔𑪕𑪖𑪗𑪘𑪙𑴱𑴲𑴳𑴴𑴵𑴶𑴺𑴼𑴽𑴿𑵀𑵁𑵂𑵃𑵄𑵅𑵇𑵐𑵑𑵒𑵓𑵔𑵕𑵖𑵗𑵘𑵙; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0-class-escaped.js new file mode 100644 index 000000000..6ab1ed963 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v11.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u07FD\u08D3\u09FE\u0C04\uA8FF\u{10D24}\u{10D25}\u{10D26}\u{10D27}\u{10D30}\u{10D31}\u{10D32}\u{10D33}\u{10D34}\u{10D35}\u{10D36}\u{10D37}\u{10D38}\u{10D39}\u{10F46}\u{10F47}\u{10F48}\u{10F49}\u{10F4A}\u{10F4B}\u{10F4C}\u{10F4D}\u{10F4E}\u{10F4F}\u{10F50}\u{11145}\u{11146}\u{111C9}\u{1133B}\u{1145E}\u{1182C}\u{1182D}\u{1182E}\u{1182F}\u{11830}\u{11831}\u{11832}\u{11833}\u{11834}\u{11835}\u{11836}\u{11837}\u{11838}\u{11839}\u{1183A}\u{11D8A}\u{11D8B}\u{11D8C}\u{11D8D}\u{11D8E}\u{11D90}\u{11D91}\u{11D93}\u{11D94}\u{11D95}\u{11D96}\u{11D97}\u{11DA0}\u{11DA1}\u{11DA2}\u{11DA3}\u{11DA4}\u{11DA5}\u{11DA6}\u{11DA7}\u{11DA8}\u{11DA9}\u{11EF3}\u{11EF4}\u{11EF5}\u{11EF6}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0-class.js new file mode 100644 index 000000000..faab6cffe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v11.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_߽࣓৾ఄꣿ𐴤𐴥𐴦𐴧𐴰𐴱𐴲𐴳𐴴𐴵𐴶𐴷𐴸𐴹𐽆𐽇𐽋𐽍𐽎𐽏𐽐𐽈𐽉𐽊𐽌𑅅𑅆𑇉𑌻𑑞𑠬𑠭𑠮𑠯𑠰𑠱𑠲𑠳𑠴𑠵𑠶𑠷𑠸𑠺𑠹𑶊𑶋𑶌𑶍𑶎𑶐𑶑𑶓𑶔𑶕𑶖𑶗𑶠𑶡𑶢𑶣𑶤𑶥𑶦𑶧𑶨𑶩𑻳𑻴𑻵𑻶; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0-escaped.js new file mode 100644 index 000000000..ae8cfc6c3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v11.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u07FD\u08D3\u09FE\u0C04\uA8FF\u{10D24}\u{10D25}\u{10D26}\u{10D27}\u{10D30}\u{10D31}\u{10D32}\u{10D33}\u{10D34}\u{10D35}\u{10D36}\u{10D37}\u{10D38}\u{10D39}\u{10F46}\u{10F47}\u{10F48}\u{10F49}\u{10F4A}\u{10F4B}\u{10F4C}\u{10F4D}\u{10F4E}\u{10F4F}\u{10F50}\u{11145}\u{11146}\u{111C9}\u{1133B}\u{1145E}\u{1182C}\u{1182D}\u{1182E}\u{1182F}\u{11830}\u{11831}\u{11832}\u{11833}\u{11834}\u{11835}\u{11836}\u{11837}\u{11838}\u{11839}\u{1183A}\u{11D8A}\u{11D8B}\u{11D8C}\u{11D8D}\u{11D8E}\u{11D90}\u{11D91}\u{11D93}\u{11D94}\u{11D95}\u{11D96}\u{11D97}\u{11DA0}\u{11DA1}\u{11DA2}\u{11DA3}\u{11DA4}\u{11DA5}\u{11DA6}\u{11DA7}\u{11DA8}\u{11DA9}\u{11EF3}\u{11EF4}\u{11EF5}\u{11EF6}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0.js new file mode 100644 index 000000000..aeff8e37f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-11.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v11.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _߽࣓৾ఄꣿ𐴤𐴥𐴦𐴧𐴰𐴱𐴲𐴳𐴴𐴵𐴶𐴷𐴸𐴹𐽆𐽇𐽋𐽍𐽎𐽏𐽐𐽈𐽉𐽊𐽌𑅅𑅆𑇉𑌻𑑞𑠬𑠭𑠮𑠯𑠰𑠱𑠲𑠳𑠴𑠵𑠶𑠷𑠸𑠺𑠹𑶊𑶋𑶌𑶍𑶎𑶐𑶑𑶓𑶔𑶕𑶖𑶗𑶠𑶡𑶢𑶣𑶤𑶥𑶦𑶧𑶨𑶩𑻳𑻴𑻵𑻶; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0-class-escaped.js new file mode 100644 index 000000000..639f8df2a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v12.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u0EBA\u{119D1}\u{119D2}\u{119D3}\u{119D4}\u{119D5}\u{119D6}\u{119D7}\u{119DA}\u{119DB}\u{119DC}\u{119DD}\u{119DE}\u{119DF}\u{119E0}\u{119E4}\u{16F4F}\u{16F7F}\u{16F80}\u{16F81}\u{16F82}\u{16F83}\u{16F84}\u{16F85}\u{16F86}\u{16F87}\u{1E130}\u{1E131}\u{1E132}\u{1E133}\u{1E134}\u{1E135}\u{1E136}\u{1E140}\u{1E141}\u{1E142}\u{1E143}\u{1E144}\u{1E145}\u{1E146}\u{1E147}\u{1E148}\u{1E149}\u{1E2EC}\u{1E2ED}\u{1E2EE}\u{1E2EF}\u{1E2F0}\u{1E2F1}\u{1E2F2}\u{1E2F3}\u{1E2F4}\u{1E2F5}\u{1E2F6}\u{1E2F7}\u{1E2F8}\u{1E2F9}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0-class.js new file mode 100644 index 000000000..af55a33f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v12.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_຺𑧑𑧒𑧓𑧔𑧕𑧖𑧗𑧚𑧛𑧜𑧝𑧞𑧟𑧠𑧤𖽏𖽿𖾀𖾁𖾂𖾃𖾄𖾅𖾆𖾇𞄰𞄱𞄲𞄳𞄴𞄵𞄶𞅀𞅁𞅂𞅃𞅄𞅅𞅆𞅇𞅈𞅉𞋬𞋭𞋮𞋯𞋰𞋱𞋲𞋳𞋴𞋵𞋶𞋷𞋸𞋹; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0-escaped.js new file mode 100644 index 000000000..96d77fc1c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v12.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u0EBA\u{119D1}\u{119D2}\u{119D3}\u{119D4}\u{119D5}\u{119D6}\u{119D7}\u{119DA}\u{119DB}\u{119DC}\u{119DD}\u{119DE}\u{119DF}\u{119E0}\u{119E4}\u{16F4F}\u{16F7F}\u{16F80}\u{16F81}\u{16F82}\u{16F83}\u{16F84}\u{16F85}\u{16F86}\u{16F87}\u{1E130}\u{1E131}\u{1E132}\u{1E133}\u{1E134}\u{1E135}\u{1E136}\u{1E140}\u{1E141}\u{1E142}\u{1E143}\u{1E144}\u{1E145}\u{1E146}\u{1E147}\u{1E148}\u{1E149}\u{1E2EC}\u{1E2ED}\u{1E2EE}\u{1E2EF}\u{1E2F0}\u{1E2F1}\u{1E2F2}\u{1E2F3}\u{1E2F4}\u{1E2F5}\u{1E2F6}\u{1E2F7}\u{1E2F8}\u{1E2F9}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0.js new file mode 100644 index 000000000..b97c91961 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-12.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v12.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _຺𑧑𑧒𑧓𑧔𑧕𑧖𑧗𑧚𑧛𑧜𑧝𑧞𑧟𑧠𑧤𖽏𖽿𖾀𖾁𖾂𖾃𖾄𖾅𖾆𖾇𞄰𞄱𞄲𞄳𞄴𞄵𞄶𞅀𞅁𞅂𞅃𞅄𞅅𞅆𞅇𞅈𞅉𞋬𞋭𞋮𞋯𞋰𞋱𞋲𞋳𞋴𞋵𞋶𞋷𞋸𞋹; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0-class-escaped.js new file mode 100644 index 000000000..441fbc0b9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v13.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u0B55\u0D81\u1ABF\u1AC0\uA82C\u{10EAB}\u{10EAC}\u{111CE}\u{111CF}\u{11930}\u{11931}\u{11932}\u{11933}\u{11934}\u{11935}\u{11937}\u{11938}\u{1193B}\u{1193C}\u{1193D}\u{1193E}\u{11940}\u{11942}\u{11943}\u{11950}\u{11951}\u{11952}\u{11953}\u{11954}\u{11955}\u{11956}\u{11957}\u{11958}\u{11959}\u{16FE4}\u{16FF0}\u{16FF1}\u{1FBF0}\u{1FBF1}\u{1FBF2}\u{1FBF3}\u{1FBF4}\u{1FBF5}\u{1FBF6}\u{1FBF7}\u{1FBF8}\u{1FBF9}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0-class.js new file mode 100644 index 000000000..13f2df240 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v13.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_୕ඁ꠬ᪿᫀ𐺫𐺬𑇎𑇏𑤰𑤱𑤲𑤳𑤴𑤵𑤷𑤸𑤻𑤼𑤽𑤾𑥀𑥂𑥃𑥐𑥑𑥒𑥓𑥔𑥕𑥖𑥗𑥘𑥙𖿤𖿰𖿱🯰🯱🯲🯳🯴🯵🯶🯷🯸🯹; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0-escaped.js new file mode 100644 index 000000000..c87bb678c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v13.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u0B55\u0D81\u1ABF\u1AC0\uA82C\u{10EAB}\u{10EAC}\u{111CE}\u{111CF}\u{11930}\u{11931}\u{11932}\u{11933}\u{11934}\u{11935}\u{11937}\u{11938}\u{1193B}\u{1193C}\u{1193D}\u{1193E}\u{11940}\u{11942}\u{11943}\u{11950}\u{11951}\u{11952}\u{11953}\u{11954}\u{11955}\u{11956}\u{11957}\u{11958}\u{11959}\u{16FE4}\u{16FF0}\u{16FF1}\u{1FBF0}\u{1FBF1}\u{1FBF2}\u{1FBF3}\u{1FBF4}\u{1FBF5}\u{1FBF6}\u{1FBF7}\u{1FBF8}\u{1FBF9}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0.js new file mode 100644 index 000000000..0d85ecefa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-13.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v13.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _୕ඁ꠬ᪿᫀ𐺫𐺬𑇎𑇏𑤰𑤱𑤲𑤳𑤴𑤵𑤷𑤸𑤻𑤼𑤽𑤾𑥀𑥂𑥃𑥐𑥑𑥒𑥓𑥔𑥕𑥖𑥗𑥘𑥙𖿤𖿰𖿱🯰🯱🯲🯳🯴🯵🯶🯷🯸🯹; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0-class-escaped.js new file mode 100644 index 000000000..f7e928cd7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v14.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u0898\u0899\u089A\u089B\u089C\u089D\u089E\u089F\u08CA\u08CB\u08CC\u08CD\u08CE\u08CF\u08D0\u08D1\u08D2\u0C3C\u1715\u180F\u1AC1\u1AC2\u1AC3\u1AC4\u1AC5\u1AC6\u1AC7\u1AC8\u1AC9\u1ACA\u1ACB\u1ACC\u1ACD\u1ACE\u1DFA\u{10F82}\u{10F83}\u{10F84}\u{10F85}\u{11070}\u{11073}\u{11074}\u{110C2}\u{16AC0}\u{16AC1}\u{16AC2}\u{16AC3}\u{16AC4}\u{16AC5}\u{16AC6}\u{16AC7}\u{16AC8}\u{16AC9}\u{1CF00}\u{1CF01}\u{1CF02}\u{1CF03}\u{1CF04}\u{1CF05}\u{1CF06}\u{1CF07}\u{1CF08}\u{1CF09}\u{1CF0A}\u{1CF0B}\u{1CF0C}\u{1CF0D}\u{1CF0E}\u{1CF0F}\u{1CF10}\u{1CF11}\u{1CF12}\u{1CF13}\u{1CF14}\u{1CF15}\u{1CF16}\u{1CF17}\u{1CF18}\u{1CF19}\u{1CF1A}\u{1CF1B}\u{1CF1C}\u{1CF1D}\u{1CF1E}\u{1CF1F}\u{1CF20}\u{1CF21}\u{1CF22}\u{1CF23}\u{1CF24}\u{1CF25}\u{1CF26}\u{1CF27}\u{1CF28}\u{1CF29}\u{1CF2A}\u{1CF2B}\u{1CF2C}\u{1CF2D}\u{1CF30}\u{1CF31}\u{1CF32}\u{1CF33}\u{1CF34}\u{1CF35}\u{1CF36}\u{1CF37}\u{1CF38}\u{1CF39}\u{1CF3A}\u{1CF3B}\u{1CF3C}\u{1CF3D}\u{1CF3E}\u{1CF3F}\u{1CF40}\u{1CF41}\u{1CF42}\u{1CF43}\u{1CF44}\u{1CF45}\u{1CF46}\u{1E2AE}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0-class.js new file mode 100644 index 000000000..82f8cc7e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v14.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_఼᜕࢙࢚࢛࣏࣐࣑࣒࢘࢜࢝࢞࢟࣊࣋࣌࣍࣎᠏𑁰᷺᫃᫄᫊𐾃𐾅᫁᫂᫅᫆᫇᫈᫉᫋ᫌᫍᫎ𐾂𐾄𑁳𑁴𑃂𖫀𖫁𖫂𖫃𖫄𖫅𖫆𖫇𖫈𖫉𜼀𜼁𜼂𜼃𜼄𜼅𜼆𜼇𜼈𜼉𜼊𜼋𜼌𜼍𜼎𜼏𜼐𜼑𜼒𜼓𜼔𜼕𜼖𜼗𜼘𜼙𜼚𜼛𜼜𜼝𜼞𜼟𜼠𜼡𜼢𜼣𜼤𜼥𜼦𜼧𜼨𜼩𜼪𜼫𜼬𜼭𜼰𜼱𜼲𜼳𜼴𜼵𜼶𜼷𜼸𜼹𜼺𜼻𜼼𜼽𜼾𜼿𜽀𜽁𜽂𜽃𜽄𜽅𜽆𞊮; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0-escaped.js new file mode 100644 index 000000000..b7a9a583f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v14.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u0898\u0899\u089A\u089B\u089C\u089D\u089E\u089F\u08CA\u08CB\u08CC\u08CD\u08CE\u08CF\u08D0\u08D1\u08D2\u0C3C\u1715\u180F\u1AC1\u1AC2\u1AC3\u1AC4\u1AC5\u1AC6\u1AC7\u1AC8\u1AC9\u1ACA\u1ACB\u1ACC\u1ACD\u1ACE\u1DFA\u{10F82}\u{10F83}\u{10F84}\u{10F85}\u{11070}\u{11073}\u{11074}\u{110C2}\u{16AC0}\u{16AC1}\u{16AC2}\u{16AC3}\u{16AC4}\u{16AC5}\u{16AC6}\u{16AC7}\u{16AC8}\u{16AC9}\u{1CF00}\u{1CF01}\u{1CF02}\u{1CF03}\u{1CF04}\u{1CF05}\u{1CF06}\u{1CF07}\u{1CF08}\u{1CF09}\u{1CF0A}\u{1CF0B}\u{1CF0C}\u{1CF0D}\u{1CF0E}\u{1CF0F}\u{1CF10}\u{1CF11}\u{1CF12}\u{1CF13}\u{1CF14}\u{1CF15}\u{1CF16}\u{1CF17}\u{1CF18}\u{1CF19}\u{1CF1A}\u{1CF1B}\u{1CF1C}\u{1CF1D}\u{1CF1E}\u{1CF1F}\u{1CF20}\u{1CF21}\u{1CF22}\u{1CF23}\u{1CF24}\u{1CF25}\u{1CF26}\u{1CF27}\u{1CF28}\u{1CF29}\u{1CF2A}\u{1CF2B}\u{1CF2C}\u{1CF2D}\u{1CF30}\u{1CF31}\u{1CF32}\u{1CF33}\u{1CF34}\u{1CF35}\u{1CF36}\u{1CF37}\u{1CF38}\u{1CF39}\u{1CF3A}\u{1CF3B}\u{1CF3C}\u{1CF3D}\u{1CF3E}\u{1CF3F}\u{1CF40}\u{1CF41}\u{1CF42}\u{1CF43}\u{1CF44}\u{1CF45}\u{1CF46}\u{1E2AE}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0.js new file mode 100644 index 000000000..2d7154864 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-14.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v14.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _఼᜕࢙࢚࢛࣏࣐࣑࣒࢘࢜࢝࢞࢟࣊࣋࣌࣍࣎᠏𑁰᷺᫃᫄᫊𐾃𐾅᫁᫂᫅᫆᫇᫈᫉᫋ᫌᫍᫎ𐾂𐾄𑁳𑁴𑃂𖫀𖫁𖫂𖫃𖫄𖫅𖫆𖫇𖫈𖫉𜼀𜼁𜼂𜼃𜼄𜼅𜼆𜼇𜼈𜼉𜼊𜼋𜼌𜼍𜼎𜼏𜼐𜼑𜼒𜼓𜼔𜼕𜼖𜼗𜼘𜼙𜼚𜼛𜼜𜼝𜼞𜼟𜼠𜼡𜼢𜼣𜼤𜼥𜼦𜼧𜼨𜼩𜼪𜼫𜼬𜼭𜼰𜼱𜼲𜼳𜼴𜼵𜼶𜼷𜼸𜼹𜼺𜼻𜼼𜼽𜼾𜼿𜽀𜽁𜽂𜽃𜽄𜽅𜽆𞊮; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0-class-escaped.js new file mode 100644 index 000000000..887fb0c50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v15.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u0CF3\u0ECE\u{10EFD}\u{10EFE}\u{10EFF}\u{11241}\u{11F00}\u{11F01}\u{11F03}\u{11F34}\u{11F35}\u{11F36}\u{11F37}\u{11F38}\u{11F39}\u{11F3A}\u{11F3E}\u{11F3F}\u{11F40}\u{11F41}\u{11F42}\u{11F50}\u{11F51}\u{11F52}\u{11F53}\u{11F54}\u{11F55}\u{11F56}\u{11F57}\u{11F58}\u{11F59}\u{13440}\u{13447}\u{13448}\u{13449}\u{1344A}\u{1344B}\u{1344C}\u{1344D}\u{1344E}\u{1344F}\u{13450}\u{13451}\u{13452}\u{13453}\u{13454}\u{13455}\u{1E08F}\u{1E4EC}\u{1E4ED}\u{1E4EE}\u{1E4EF}\u{1E4F0}\u{1E4F1}\u{1E4F2}\u{1E4F3}\u{1E4F4}\u{1E4F5}\u{1E4F6}\u{1E4F7}\u{1E4F8}\u{1E4F9}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0-class.js new file mode 100644 index 000000000..3df93c13d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v15.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_ೳ໎𐻽𐻾𐻿𑉁𑼀𑼁𑼃𑼴𑼵𑼶𑼷𑼸𑼹𑼺𑼾𑼿𑽀𑽁𑽂𑽐𑽑𑽒𑽓𑽔𑽕𑽖𑽗𑽘𑽙𓑀𓑇𓑈𓑉𓑊𓑋𓑌𓑍𓑎𓑏𓑐𓑑𓑒𓑓𓑔𓑕𞓮𞂏𞓯𞓬𞓭𞓰𞓱𞓲𞓳𞓴𞓵𞓶𞓷𞓸𞓹; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0-escaped.js new file mode 100644 index 000000000..b60e26203 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v15.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u0CF3\u0ECE\u{10EFD}\u{10EFE}\u{10EFF}\u{11241}\u{11F00}\u{11F01}\u{11F03}\u{11F34}\u{11F35}\u{11F36}\u{11F37}\u{11F38}\u{11F39}\u{11F3A}\u{11F3E}\u{11F3F}\u{11F40}\u{11F41}\u{11F42}\u{11F50}\u{11F51}\u{11F52}\u{11F53}\u{11F54}\u{11F55}\u{11F56}\u{11F57}\u{11F58}\u{11F59}\u{13440}\u{13447}\u{13448}\u{13449}\u{1344A}\u{1344B}\u{1344C}\u{1344D}\u{1344E}\u{1344F}\u{13450}\u{13451}\u{13452}\u{13453}\u{13454}\u{13455}\u{1E08F}\u{1E4EC}\u{1E4ED}\u{1E4EE}\u{1E4EF}\u{1E4F0}\u{1E4F1}\u{1E4F2}\u{1E4F3}\u{1E4F4}\u{1E4F5}\u{1E4F6}\u{1E4F7}\u{1E4F8}\u{1E4F9}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0.js new file mode 100644 index 000000000..734166965 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v15.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _ೳ໎𐻽𐻾𐻿𑉁𑼀𑼁𑼃𑼴𑼵𑼶𑼷𑼸𑼹𑼺𑼾𑼿𑽀𑽁𑽂𑽐𑽑𑽒𑽓𑽔𑽕𑽖𑽗𑽘𑽙𓑀𓑇𓑈𓑉𓑊𓑋𓑌𓑍𓑎𓑏𓑐𓑑𓑒𓑓𓑔𓑕𞓮𞂏𞓯𞓬𞓭𞓰𞓱𞓲𞓳𞓴𞓵𞓶𞓷𞓸𞓹; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0-class-escaped.js new file mode 100644 index 000000000..245d8bdba --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v15.1.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u200C\u200D\u30FB\uFF65; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0-class.js new file mode 100644 index 000000000..e26db18d8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v15.1.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_‌‍・・; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0-escaped.js new file mode 100644 index 000000000..06f55dd0d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v15.1.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u200C\u200D\u30FB\uFF65; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0.js new file mode 100644 index 000000000..c048f5103 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-15.1.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v15.1.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _‌‍・・; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0-class-escaped.js new file mode 100644 index 000000000..1bce9ddb2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v16.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u0897\u{10D40}\u{10D41}\u{10D42}\u{10D43}\u{10D44}\u{10D45}\u{10D46}\u{10D47}\u{10D48}\u{10D49}\u{10D69}\u{10D6A}\u{10D6B}\u{10D6C}\u{10D6D}\u{10EFC}\u{113B8}\u{113B9}\u{113BA}\u{113BB}\u{113BC}\u{113BD}\u{113BE}\u{113BF}\u{113C0}\u{113C2}\u{113C5}\u{113C7}\u{113C8}\u{113C9}\u{113CA}\u{113CC}\u{113CD}\u{113CE}\u{113CF}\u{113D0}\u{113D2}\u{113E1}\u{113E2}\u{116D0}\u{116D1}\u{116D2}\u{116D3}\u{116D4}\u{116D5}\u{116D6}\u{116D7}\u{116D8}\u{116D9}\u{116DA}\u{116DB}\u{116DC}\u{116DD}\u{116DE}\u{116DF}\u{116E0}\u{116E1}\u{116E2}\u{116E3}\u{11BF0}\u{11BF1}\u{11BF2}\u{11BF3}\u{11BF4}\u{11BF5}\u{11BF6}\u{11BF7}\u{11BF8}\u{11BF9}\u{11F5A}\u{1611E}\u{1611F}\u{16120}\u{16121}\u{16122}\u{16123}\u{16124}\u{16125}\u{16126}\u{16127}\u{16128}\u{16129}\u{1612A}\u{1612B}\u{1612C}\u{1612D}\u{1612E}\u{1612F}\u{16130}\u{16131}\u{16132}\u{16133}\u{16134}\u{16135}\u{16136}\u{16137}\u{16138}\u{16139}\u{16D70}\u{16D71}\u{16D72}\u{16D73}\u{16D74}\u{16D75}\u{16D76}\u{16D77}\u{16D78}\u{16D79}\u{1CCF0}\u{1CCF1}\u{1CCF2}\u{1CCF3}\u{1CCF4}\u{1CCF5}\u{1CCF6}\u{1CCF7}\u{1CCF8}\u{1CCF9}\u{1E5EE}\u{1E5EF}\u{1E5F1}\u{1E5F2}\u{1E5F3}\u{1E5F4}\u{1E5F5}\u{1E5F6}\u{1E5F7}\u{1E5F8}\u{1E5F9}\u{1E5FA}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0-class.js new file mode 100644 index 000000000..62a7ad925 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v16.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_ࢗ𐵀𐵁𐵂𐵃𐵄𐵅𐵆𐵇𐵈𐵉𐵩𐵪𐵫𐵬𐵭𐻼𑎸𑎹𑎺𑎻𑎼𑎽𑎾𑎿𑏀𑏅𑏅𑎸𑏈𑏉𑏊𑏌𑏍𑏎𑏏𑏐𑏒𑏡𑏢𑛐𑛑𑛒𑛓𑛔𑛕𑛖𑛗𑛘𑛙𑛚𑛛𑛜𑛝𑛞𑛟𑛠𑛡𑛢𑛣𑯰𑯱𑯲𑯳𑯴𑯵𑯶𑯷𑯸𑯹𑽚𖄣𖄠𖄡𖄢𖄣𖄤𖄥𖄦𖄧𖄨𖄩𖄪𖄫𖄬𖄭𖄮𖄯𖄰𖄱𖄲𖄳𖄴𖄵𖄶𖄷𖄸𖄹𖵰𖵱𖵲𖵳𖵴𖵵𖵶𖵷𖵸𖵹𜳰𜳱𜳲𜳳𜳴𜳵𜳶𜳷𜳸𜳹𞗯𞗮𞗱𞗲𞗳𞗴𞗵𞗶𞗷𞗸𞗹𞗺; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0-escaped.js new file mode 100644 index 000000000..b4b5d89ad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v16.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u0897\u{10D40}\u{10D41}\u{10D42}\u{10D43}\u{10D44}\u{10D45}\u{10D46}\u{10D47}\u{10D48}\u{10D49}\u{10D69}\u{10D6A}\u{10D6B}\u{10D6C}\u{10D6D}\u{10EFC}\u{113B8}\u{113B9}\u{113BA}\u{113BB}\u{113BC}\u{113BD}\u{113BE}\u{113BF}\u{113C0}\u{113C2}\u{113C5}\u{113C7}\u{113C8}\u{113C9}\u{113CA}\u{113CC}\u{113CD}\u{113CE}\u{113CF}\u{113D0}\u{113D2}\u{113E1}\u{113E2}\u{116D0}\u{116D1}\u{116D2}\u{116D3}\u{116D4}\u{116D5}\u{116D6}\u{116D7}\u{116D8}\u{116D9}\u{116DA}\u{116DB}\u{116DC}\u{116DD}\u{116DE}\u{116DF}\u{116E0}\u{116E1}\u{116E2}\u{116E3}\u{11BF0}\u{11BF1}\u{11BF2}\u{11BF3}\u{11BF4}\u{11BF5}\u{11BF6}\u{11BF7}\u{11BF8}\u{11BF9}\u{11F5A}\u{1611E}\u{1611F}\u{16120}\u{16121}\u{16122}\u{16123}\u{16124}\u{16125}\u{16126}\u{16127}\u{16128}\u{16129}\u{1612A}\u{1612B}\u{1612C}\u{1612D}\u{1612E}\u{1612F}\u{16130}\u{16131}\u{16132}\u{16133}\u{16134}\u{16135}\u{16136}\u{16137}\u{16138}\u{16139}\u{16D70}\u{16D71}\u{16D72}\u{16D73}\u{16D74}\u{16D75}\u{16D76}\u{16D77}\u{16D78}\u{16D79}\u{1CCF0}\u{1CCF1}\u{1CCF2}\u{1CCF3}\u{1CCF4}\u{1CCF5}\u{1CCF6}\u{1CCF7}\u{1CCF8}\u{1CCF9}\u{1E5EE}\u{1E5EF}\u{1E5F1}\u{1E5F2}\u{1E5F3}\u{1E5F4}\u{1E5F5}\u{1E5F6}\u{1E5F7}\u{1E5F8}\u{1E5F9}\u{1E5FA}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0.js new file mode 100644 index 000000000..044ce1088 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-16.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v16.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _ࢗ𐵀𐵁𐵂𐵃𐵄𐵅𐵆𐵇𐵈𐵉𐵩𐵪𐵫𐵬𐵭𐻼𑎸𑎹𑎺𑎻𑎼𑎽𑎾𑎿𑏀𑏅𑏅𑎸𑏈𑏉𑏊𑏌𑏍𑏎𑏏𑏐𑏒𑏡𑏢𑛐𑛑𑛒𑛓𑛔𑛕𑛖𑛗𑛘𑛙𑛚𑛛𑛜𑛝𑛞𑛟𑛠𑛡𑛢𑛣𑯰𑯱𑯲𑯳𑯴𑯵𑯶𑯷𑯸𑯹𑽚𖄣𖄠𖄡𖄢𖄣𖄤𖄥𖄦𖄧𖄨𖄩𖄪𖄫𖄬𖄭𖄮𖄯𖄰𖄱𖄲𖄳𖄴𖄵𖄶𖄷𖄸𖄹𖵰𖵱𖵲𖵳𖵴𖵵𖵶𖵷𖵸𖵹𜳰𜳱𜳲𜳳𜳴𜳵𜳶𜳷𜳸𜳹𞗯𞗮𞗱𞗲𞗳𞗴𞗵𞗶𞗷𞗸𞗹𞗺; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0-class-escaped.js new file mode 100644 index 000000000..d47a47d50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2025 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v17.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u1ACF\u1AD0\u1AD1\u1AD2\u1AD3\u1AD4\u1AD5\u1AD6\u1AD7\u1AD8\u1AD9\u1ADA\u1ADB\u1ADC\u1ADD\u1AE0\u1AE1\u1AE2\u1AE3\u1AE4\u1AE5\u1AE6\u1AE7\u1AE8\u1AE9\u1AEA\u1AEB\u{10EFA}\u{10EFB}\u{11B60}\u{11B61}\u{11B62}\u{11B63}\u{11B64}\u{11B65}\u{11B66}\u{11B67}\u{11DE0}\u{11DE1}\u{11DE2}\u{11DE3}\u{11DE4}\u{11DE5}\u{11DE6}\u{11DE7}\u{11DE8}\u{11DE9}\u{1E6E3}\u{1E6E6}\u{1E6EE}\u{1E6EF}\u{1E6F5}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0-class.js new file mode 100644 index 000000000..73e213d2d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2025 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v17.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_᫏᫐᫑᫒᫓᫔᫕᫖᫗᫘᫙᫚᫛᫜᫝᫠᫡᫢᫣᫤᫥᫦᫧᫨᫩᫪᫫𐻺𐻻𑭠𑭡𑭢𑭣𑭤𑭥𑭦𑭧𑷠𑷡𑷢𑷣𑷤𑷥𑷦𑷧𑷨𑷩𞛣𞛦𞛮𞛯𞛵; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0-escaped.js new file mode 100644 index 000000000..f867a8a62 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2025 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v17.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u1ACF\u1AD0\u1AD1\u1AD2\u1AD3\u1AD4\u1AD5\u1AD6\u1AD7\u1AD8\u1AD9\u1ADA\u1ADB\u1ADC\u1ADD\u1AE0\u1AE1\u1AE2\u1AE3\u1AE4\u1AE5\u1AE6\u1AE7\u1AE8\u1AE9\u1AEA\u1AEB\u{10EFA}\u{10EFB}\u{11B60}\u{11B61}\u{11B62}\u{11B63}\u{11B64}\u{11B65}\u{11B66}\u{11B67}\u{11DE0}\u{11DE1}\u{11DE2}\u{11DE3}\u{11DE4}\u{11DE5}\u{11DE6}\u{11DE7}\u{11DE8}\u{11DE9}\u{1E6E3}\u{1E6E6}\u{1E6EE}\u{1E6EF}\u{1E6F5}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0.js new file mode 100644 index 000000000..4ad4b63df --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-17.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2025 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v17.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _᫏᫐᫑᫒᫓᫔᫕᫖᫗᫘᫙᫚᫛᫜᫝᫠᫡᫢᫣᫤᫥᫦᫧᫨᫩᫪᫫𐻺𐻻𑭠𑭡𑭢𑭣𑭤𑭥𑭦𑭧𑷠𑷡𑷢𑷣𑷤𑷥𑷦𑷧𑷨𑷩𞛣𞛦𞛮𞛯𞛵; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0-class-escaped.js new file mode 100644 index 000000000..8a2004dcf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v5.2.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u0816\u0817\u0818\u0819\u081B\u081C\u081D\u081E\u081F\u0820\u0821\u0822\u0823\u0825\u0826\u0827\u0829\u082A\u082B\u082C\u082D\u0900\u094E\u0955\u109A\u109B\u109C\u109D\u19DA\u1A55\u1A56\u1A57\u1A58\u1A59\u1A5A\u1A5B\u1A5C\u1A5D\u1A5E\u1A60\u1A61\u1A62\u1A63\u1A64\u1A65\u1A66\u1A67\u1A68\u1A69\u1A6A\u1A6B\u1A6C\u1A6D\u1A6E\u1A6F\u1A70\u1A71\u1A72\u1A73\u1A74\u1A75\u1A76\u1A77\u1A78\u1A79\u1A7A\u1A7B\u1A7C\u1A7F\u1A80\u1A81\u1A82\u1A83\u1A84\u1A85\u1A86\u1A87\u1A88\u1A89\u1A90\u1A91\u1A92\u1A93\u1A94\u1A95\u1A96\u1A97\u1A98\u1A99\u1CD0\u1CD1\u1CD2\u1CD4\u1CD5\u1CD6\u1CD7\u1CD8\u1CD9\u1CDA\u1CDB\u1CDC\u1CDD\u1CDE\u1CDF\u1CE0\u1CE1\u1CE2\u1CE3\u1CE4\u1CE5\u1CE6\u1CE7\u1CE8\u1CED\u1CF2\u1DFD\u2CEF\u2CF0\u2CF1\uA6F0\uA6F1\uA8E0\uA8E1\uA8E2\uA8E3\uA8E4\uA8E5\uA8E6\uA8E7\uA8E8\uA8E9\uA8EA\uA8EB\uA8EC\uA8ED\uA8EE\uA8EF\uA8F0\uA8F1\uA980\uA981\uA982\uA983\uA9B3\uA9B4\uA9B5\uA9B6\uA9B7\uA9B8\uA9B9\uA9BA\uA9BB\uA9BC\uA9BD\uA9BE\uA9BF\uA9C0\uA9D0\uA9D1\uA9D2\uA9D3\uA9D4\uA9D5\uA9D6\uA9D7\uA9D8\uA9D9\uAA7B\uAAB0\uAAB2\uAAB3\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uABE3\uABE4\uABE5\uABE6\uABE7\uABE8\uABE9\uABEA\uABEC\uABED\uABF0\uABF1\uABF2\uABF3\uABF4\uABF5\uABF6\uABF7\uABF8\uABF9\u{11080}\u{11081}\u{11082}\u{110B0}\u{110B1}\u{110B2}\u{110B3}\u{110B4}\u{110B5}\u{110B6}\u{110B7}\u{110B8}\u{110B9}\u{110BA}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0-class.js new file mode 100644 index 000000000..b46fc771f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v5.2.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_ࠖࠗ࠘࠙ࠛࠜࠝࠞࠟࠠࠡࠢࠣࠥࠦࠧࠩࠪࠫࠬ࠭ऀॎॕႚႛႜႝ᧚ᩕᩖᩗᩘᩙᩚᩛᩜᩝᩞ᩠ᩡᩢᩣᩤᩥᩦᩧᩨᩩᩪᩫᩬᩭᩮᩯᩰᩱᩲᩳᩴ᩿᩵᩶᩷᩸᩹᩺᩻᩼᪀᪁᪂᪃᪄᪅᪆᪇᪈᪉᪐᪑᪒᪓᪔᪕᪖᪗᪘᪙᳔᳕᳖᳗᳘᳙᳜᳝᳞᳟᳐᳑᳒᳚᳛᳠᳡᳢᳣᳤᳥᳦᳧᳨᳭ᳲ᷽⳯⳰⳱꛰꛱꣠꣡꣢꣣꣤꣥꣦꣧꣨꣩꣪꣫꣬꣭꣮꣯꣰꣱ꦀꦁꦂꦃ꦳ꦴꦵꦶꦷꦸꦹꦺꦻꦼꦽꦾꦿ꧀꧐꧑꧒꧓꧔꧕꧖꧗꧘꧙ꩻꪴꪰꪲꪳꪷꪸꪾ꪿꫁ꯣꯤꯥꯦꯧꯨꯩꯪ꯬꯭꯰꯱꯲꯳꯴꯵꯶꯷꯸꯹𑂀𑂁𑂂𑂰𑂱𑂲𑂳𑂴𑂵𑂶𑂷𑂸𑂺𑂹; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0-escaped.js new file mode 100644 index 000000000..cba8153d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v5.2.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u0816\u0817\u0818\u0819\u081B\u081C\u081D\u081E\u081F\u0820\u0821\u0822\u0823\u0825\u0826\u0827\u0829\u082A\u082B\u082C\u082D\u0900\u094E\u0955\u109A\u109B\u109C\u109D\u19DA\u1A55\u1A56\u1A57\u1A58\u1A59\u1A5A\u1A5B\u1A5C\u1A5D\u1A5E\u1A60\u1A61\u1A62\u1A63\u1A64\u1A65\u1A66\u1A67\u1A68\u1A69\u1A6A\u1A6B\u1A6C\u1A6D\u1A6E\u1A6F\u1A70\u1A71\u1A72\u1A73\u1A74\u1A75\u1A76\u1A77\u1A78\u1A79\u1A7A\u1A7B\u1A7C\u1A7F\u1A80\u1A81\u1A82\u1A83\u1A84\u1A85\u1A86\u1A87\u1A88\u1A89\u1A90\u1A91\u1A92\u1A93\u1A94\u1A95\u1A96\u1A97\u1A98\u1A99\u1CD0\u1CD1\u1CD2\u1CD4\u1CD5\u1CD6\u1CD7\u1CD8\u1CD9\u1CDA\u1CDB\u1CDC\u1CDD\u1CDE\u1CDF\u1CE0\u1CE1\u1CE2\u1CE3\u1CE4\u1CE5\u1CE6\u1CE7\u1CE8\u1CED\u1CF2\u1DFD\u2CEF\u2CF0\u2CF1\uA6F0\uA6F1\uA8E0\uA8E1\uA8E2\uA8E3\uA8E4\uA8E5\uA8E6\uA8E7\uA8E8\uA8E9\uA8EA\uA8EB\uA8EC\uA8ED\uA8EE\uA8EF\uA8F0\uA8F1\uA980\uA981\uA982\uA983\uA9B3\uA9B4\uA9B5\uA9B6\uA9B7\uA9B8\uA9B9\uA9BA\uA9BB\uA9BC\uA9BD\uA9BE\uA9BF\uA9C0\uA9D0\uA9D1\uA9D2\uA9D3\uA9D4\uA9D5\uA9D6\uA9D7\uA9D8\uA9D9\uAA7B\uAAB0\uAAB2\uAAB3\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uABE3\uABE4\uABE5\uABE6\uABE7\uABE8\uABE9\uABEA\uABEC\uABED\uABF0\uABF1\uABF2\uABF3\uABF4\uABF5\uABF6\uABF7\uABF8\uABF9\u{11080}\u{11081}\u{11082}\u{110B0}\u{110B1}\u{110B2}\u{110B3}\u{110B4}\u{110B5}\u{110B6}\u{110B7}\u{110B8}\u{110B9}\u{110BA}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0.js new file mode 100644 index 000000000..9737cb65e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-5.2.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v5.2.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _ࠖࠗ࠘࠙ࠛࠜࠝࠞࠟࠠࠡࠢࠣࠥࠦࠧࠩࠪࠫࠬ࠭ऀॎॕႚႛႜႝ᧚ᩕᩖᩗᩘᩙᩚᩛᩜᩝᩞ᩠ᩡᩢᩣᩤᩥᩦᩧᩨᩩᩪᩫᩬᩭᩮᩯᩰᩱᩲᩳᩴ᩿᩵᩶᩷᩸᩹᩺᩻᩼᪀᪁᪂᪃᪄᪅᪆᪇᪈᪉᪐᪑᪒᪓᪔᪕᪖᪗᪘᪙᳔᳕᳖᳗᳘᳙᳜᳝᳞᳟᳐᳑᳒᳚᳛᳠᳡᳢᳣᳤᳥᳦᳧᳨᳭ᳲ᷽⳯⳰⳱꛰꛱꣠꣡꣢꣣꣤꣥꣦꣧꣨꣩꣪꣫꣬꣭꣮꣯꣰꣱ꦀꦁꦂꦃ꦳ꦴꦵꦶꦷꦸꦹꦺꦻꦼꦽꦾꦿ꧀꧐꧑꧒꧓꧔꧕꧖꧗꧘꧙ꩻꪴꪰꪲꪳꪷꪸꪾ꪿꫁ꯣꯤꯥꯦꯧꯨꯩꯪ꯬꯭꯰꯱꯲꯳꯴꯵꯶꯷꯸꯹𑂀𑂁𑂂𑂰𑂱𑂲𑂳𑂴𑂵𑂶𑂷𑂸𑂺𑂹; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0-class-escaped.js new file mode 100644 index 000000000..d3b1c218e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v6.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u065F\u0859\u085A\u085B\u093A\u093B\u094F\u0956\u0957\u0F8D\u0F8E\u0F8F\u135D\u135E\u1BE6\u1BE7\u1BE8\u1BE9\u1BEA\u1BEB\u1BEC\u1BED\u1BEE\u1BEF\u1BF0\u1BF1\u1BF2\u1BF3\u1DFC\u2D7F\u{11000}\u{11001}\u{11002}\u{11038}\u{11039}\u{1103A}\u{1103B}\u{1103C}\u{1103D}\u{1103E}\u{1103F}\u{11040}\u{11041}\u{11042}\u{11043}\u{11044}\u{11045}\u{11046}\u{11066}\u{11067}\u{11068}\u{11069}\u{1106A}\u{1106B}\u{1106C}\u{1106D}\u{1106E}\u{1106F}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0-class.js new file mode 100644 index 000000000..d2dff4bad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v6.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_ٟ࡙࡚࡛ऺऻॏॖॗྍྎྏ᯦፝፞ᯧᯨᯩᯪᯫᯬᯭᯮᯯᯰᯱ᯲᯳⵿᷼𑀀𑀁𑀂𑀸𑀹𑀺𑀻𑀼𑀽𑀾𑀿𑁀𑁁𑁂𑁃𑁄𑁅𑁆𑁦𑁧𑁨𑁩𑁪𑁫𑁬𑁭𑁮𑁯; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0-escaped.js new file mode 100644 index 000000000..91a098704 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v6.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u065F\u0859\u085A\u085B\u093A\u093B\u094F\u0956\u0957\u0F8D\u0F8E\u0F8F\u135D\u135E\u1BE6\u1BE7\u1BE8\u1BE9\u1BEA\u1BEB\u1BEC\u1BED\u1BEE\u1BEF\u1BF0\u1BF1\u1BF2\u1BF3\u1DFC\u2D7F\u{11000}\u{11001}\u{11002}\u{11038}\u{11039}\u{1103A}\u{1103B}\u{1103C}\u{1103D}\u{1103E}\u{1103F}\u{11040}\u{11041}\u{11042}\u{11043}\u{11044}\u{11045}\u{11046}\u{11066}\u{11067}\u{11068}\u{11069}\u{1106A}\u{1106B}\u{1106C}\u{1106D}\u{1106E}\u{1106F}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0.js new file mode 100644 index 000000000..d123acf72 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v6.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _ٟ࡙࡚࡛ऺऻॏॖॗྍྎྏ᯦፝፞ᯧᯨᯩᯪᯫᯬᯭᯮᯯᯰᯱ᯲᯳⵿᷼𑀀𑀁𑀂𑀸𑀹𑀺𑀻𑀼𑀽𑀾𑀿𑁀𑁁𑁂𑁃𑁄𑁅𑁆𑁦𑁧𑁨𑁩𑁪𑁫𑁬𑁭𑁮𑁯; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0-class-escaped.js new file mode 100644 index 000000000..16f86ef1f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v6.1.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u08E4\u08E5\u08E6\u08E7\u08E8\u08E9\u08EA\u08EB\u08EC\u08ED\u08EE\u08EF\u08F0\u08F1\u08F2\u08F3\u08F4\u08F5\u08F6\u08F7\u08F8\u08F9\u08FA\u08FB\u08FC\u08FD\u08FE\u17B4\u17B5\u1BAB\u1BAC\u1BAD\u1CF3\u1CF4\uA674\uA675\uA676\uA677\uA678\uA679\uA67A\uA67B\uA69F\uAAEB\uAAEC\uAAED\uAAEE\uAAEF\uAAF5\uAAF6\u{110F0}\u{110F1}\u{110F2}\u{110F3}\u{110F4}\u{110F5}\u{110F6}\u{110F7}\u{110F8}\u{110F9}\u{11100}\u{11101}\u{11102}\u{11127}\u{11128}\u{11129}\u{1112A}\u{1112B}\u{1112C}\u{1112D}\u{1112E}\u{1112F}\u{11130}\u{11131}\u{11132}\u{11133}\u{11134}\u{11136}\u{11137}\u{11138}\u{11139}\u{1113A}\u{1113B}\u{1113C}\u{1113D}\u{1113E}\u{1113F}\u{11180}\u{11181}\u{11182}\u{111B3}\u{111B4}\u{111B5}\u{111B6}\u{111B7}\u{111B8}\u{111B9}\u{111BA}\u{111BB}\u{111BC}\u{111BD}\u{111BE}\u{111BF}\u{111C0}\u{111D0}\u{111D1}\u{111D2}\u{111D3}\u{111D4}\u{111D5}\u{111D6}\u{111D7}\u{111D8}\u{111D9}\u{116AB}\u{116AC}\u{116AD}\u{116AE}\u{116AF}\u{116B0}\u{116B1}\u{116B2}\u{116B3}\u{116B4}\u{116B5}\u{116B6}\u{116B7}\u{116C0}\u{116C1}\u{116C2}\u{116C3}\u{116C4}\u{116C5}\u{116C6}\u{116C7}\u{116C8}\u{116C9}\u{16F51}\u{16F52}\u{16F53}\u{16F54}\u{16F55}\u{16F56}\u{16F57}\u{16F58}\u{16F59}\u{16F5A}\u{16F5B}\u{16F5C}\u{16F5D}\u{16F5E}\u{16F5F}\u{16F60}\u{16F61}\u{16F62}\u{16F63}\u{16F64}\u{16F65}\u{16F66}\u{16F67}\u{16F68}\u{16F69}\u{16F6A}\u{16F6B}\u{16F6C}\u{16F6D}\u{16F6E}\u{16F6F}\u{16F70}\u{16F71}\u{16F72}\u{16F73}\u{16F74}\u{16F75}\u{16F76}\u{16F77}\u{16F78}\u{16F79}\u{16F7A}\u{16F7B}\u{16F7C}\u{16F7D}\u{16F7E}\u{16F8F}\u{16F90}\u{16F91}\u{16F92}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0-class.js new file mode 100644 index 000000000..0f2370648 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v6.1.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_ࣰࣱࣲࣦࣩ࣭࣮࣯ࣶࣹࣺࣤࣥࣧࣨ࣪࣫࣬ࣳࣴࣵࣷࣸࣻࣼࣽࣾ឴឵᮫ᮬᮭᳳ᳴ꙴꙵꙶꙷꙸꙹꙺꙻꚟꫫꫬꫭꫮꫯꫵ꫶𑃰𑃱𑃲𑃳𑃴𑃵𑃶𑃷𑃸𑃹𑄀𑄁𑄂𑄧𑄨𑄩𑄪𑄫𑄬𑄭𑄮𑄯𑄰𑄱𑄲𑄳𑄴𑄶𑄷𑄸𑄹𑄺𑄻𑄼𑄽𑄾𑄿𑆀𑆁𑆂𑆳𑆴𑆵𑆶𑆷𑆸𑆹𑆺𑆻𑆼𑆽𑆾𑆿𑇀𑇐𑇑𑇒𑇓𑇔𑇕𑇖𑇗𑇘𑇙𑚫𑚬𑚭𑚮𑚯𑚰𑚱𑚲𑚳𑚴𑚵𑚷𑚶𑛀𑛁𑛂𑛃𑛄𑛅𑛆𑛇𑛈𑛉𖽑𖽒𖽓𖽔𖽕𖽖𖽗𖽘𖽙𖽚𖽛𖽜𖽝𖽞𖽟𖽠𖽡𖽢𖽣𖽤𖽥𖽦𖽧𖽨𖽩𖽪𖽫𖽬𖽭𖽮𖽯𖽰𖽱𖽲𖽳𖽴𖽵𖽶𖽷𖽸𖽹𖽺𖽻𖽼𖽽𖽾𖾏𖾐𖾑𖾒; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0-escaped.js new file mode 100644 index 000000000..3017facd6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v6.1.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u08E4\u08E5\u08E6\u08E7\u08E8\u08E9\u08EA\u08EB\u08EC\u08ED\u08EE\u08EF\u08F0\u08F1\u08F2\u08F3\u08F4\u08F5\u08F6\u08F7\u08F8\u08F9\u08FA\u08FB\u08FC\u08FD\u08FE\u17B4\u17B5\u1BAB\u1BAC\u1BAD\u1CF3\u1CF4\uA674\uA675\uA676\uA677\uA678\uA679\uA67A\uA67B\uA69F\uAAEB\uAAEC\uAAED\uAAEE\uAAEF\uAAF5\uAAF6\u{110F0}\u{110F1}\u{110F2}\u{110F3}\u{110F4}\u{110F5}\u{110F6}\u{110F7}\u{110F8}\u{110F9}\u{11100}\u{11101}\u{11102}\u{11127}\u{11128}\u{11129}\u{1112A}\u{1112B}\u{1112C}\u{1112D}\u{1112E}\u{1112F}\u{11130}\u{11131}\u{11132}\u{11133}\u{11134}\u{11136}\u{11137}\u{11138}\u{11139}\u{1113A}\u{1113B}\u{1113C}\u{1113D}\u{1113E}\u{1113F}\u{11180}\u{11181}\u{11182}\u{111B3}\u{111B4}\u{111B5}\u{111B6}\u{111B7}\u{111B8}\u{111B9}\u{111BA}\u{111BB}\u{111BC}\u{111BD}\u{111BE}\u{111BF}\u{111C0}\u{111D0}\u{111D1}\u{111D2}\u{111D3}\u{111D4}\u{111D5}\u{111D6}\u{111D7}\u{111D8}\u{111D9}\u{116AB}\u{116AC}\u{116AD}\u{116AE}\u{116AF}\u{116B0}\u{116B1}\u{116B2}\u{116B3}\u{116B4}\u{116B5}\u{116B6}\u{116B7}\u{116C0}\u{116C1}\u{116C2}\u{116C3}\u{116C4}\u{116C5}\u{116C6}\u{116C7}\u{116C8}\u{116C9}\u{16F51}\u{16F52}\u{16F53}\u{16F54}\u{16F55}\u{16F56}\u{16F57}\u{16F58}\u{16F59}\u{16F5A}\u{16F5B}\u{16F5C}\u{16F5D}\u{16F5E}\u{16F5F}\u{16F60}\u{16F61}\u{16F62}\u{16F63}\u{16F64}\u{16F65}\u{16F66}\u{16F67}\u{16F68}\u{16F69}\u{16F6A}\u{16F6B}\u{16F6C}\u{16F6D}\u{16F6E}\u{16F6F}\u{16F70}\u{16F71}\u{16F72}\u{16F73}\u{16F74}\u{16F75}\u{16F76}\u{16F77}\u{16F78}\u{16F79}\u{16F7A}\u{16F7B}\u{16F7C}\u{16F7D}\u{16F7E}\u{16F8F}\u{16F90}\u{16F91}\u{16F92}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0.js new file mode 100644 index 000000000..cf360caa7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-6.1.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v6.1.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _ࣰࣱࣲࣦࣩ࣭࣮࣯ࣶࣹࣺࣤࣥࣧࣨ࣪࣫࣬ࣳࣴࣵࣷࣸࣻࣼࣽࣾ឴឵᮫ᮬᮭᳳ᳴ꙴꙵꙶꙷꙸꙹꙺꙻꚟꫫꫬꫭꫮꫯꫵ꫶𑃰𑃱𑃲𑃳𑃴𑃵𑃶𑃷𑃸𑃹𑄀𑄁𑄂𑄧𑄨𑄩𑄪𑄫𑄬𑄭𑄮𑄯𑄰𑄱𑄲𑄳𑄴𑄶𑄷𑄸𑄹𑄺𑄻𑄼𑄽𑄾𑄿𑆀𑆁𑆂𑆳𑆴𑆵𑆶𑆷𑆸𑆹𑆺𑆻𑆼𑆽𑆾𑆿𑇀𑇐𑇑𑇒𑇓𑇔𑇕𑇖𑇗𑇘𑇙𑚫𑚬𑚭𑚮𑚯𑚰𑚱𑚲𑚳𑚴𑚵𑚷𑚶𑛀𑛁𑛂𑛃𑛄𑛅𑛆𑛇𑛈𑛉𖽑𖽒𖽓𖽔𖽕𖽖𖽗𖽘𖽙𖽚𖽛𖽜𖽝𖽞𖽟𖽠𖽡𖽢𖽣𖽤𖽥𖽦𖽧𖽨𖽩𖽪𖽫𖽬𖽭𖽮𖽯𖽰𖽱𖽲𖽳𖽴𖽵𖽶𖽷𖽸𖽹𖽺𖽻𖽼𖽽𖽾𖾏𖾐𖾑𖾒; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0-class-escaped.js new file mode 100644 index 000000000..59115d92d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v7.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u08FF\u0C00\u0C81\u0D01\u0DE6\u0DE7\u0DE8\u0DE9\u0DEA\u0DEB\u0DEC\u0DED\u0DEE\u0DEF\u1AB0\u1AB1\u1AB2\u1AB3\u1AB4\u1AB5\u1AB6\u1AB7\u1AB8\u1AB9\u1ABA\u1ABB\u1ABC\u1ABD\u1CF8\u1CF9\u1DE7\u1DE8\u1DE9\u1DEA\u1DEB\u1DEC\u1DED\u1DEE\u1DEF\u1DF0\u1DF1\u1DF2\u1DF3\u1DF4\u1DF5\uA9E5\uA9F0\uA9F1\uA9F2\uA9F3\uA9F4\uA9F5\uA9F6\uA9F7\uA9F8\uA9F9\uAA7C\uAA7D\uFE27\uFE28\uFE29\uFE2A\uFE2B\uFE2C\uFE2D\u{102E0}\u{10376}\u{10377}\u{10378}\u{10379}\u{1037A}\u{10AE5}\u{10AE6}\u{1107F}\u{11173}\u{1122C}\u{1122D}\u{1122E}\u{1122F}\u{11230}\u{11231}\u{11232}\u{11233}\u{11234}\u{11235}\u{11236}\u{11237}\u{112DF}\u{112E0}\u{112E1}\u{112E2}\u{112E3}\u{112E4}\u{112E5}\u{112E6}\u{112E7}\u{112E8}\u{112E9}\u{112EA}\u{112F0}\u{112F1}\u{112F2}\u{112F3}\u{112F4}\u{112F5}\u{112F6}\u{112F7}\u{112F8}\u{112F9}\u{11301}\u{11302}\u{11303}\u{1133C}\u{1133E}\u{1133F}\u{11340}\u{11341}\u{11342}\u{11343}\u{11344}\u{11347}\u{11348}\u{1134B}\u{1134C}\u{1134D}\u{11357}\u{11362}\u{11363}\u{11366}\u{11367}\u{11368}\u{11369}\u{1136A}\u{1136B}\u{1136C}\u{11370}\u{11371}\u{11372}\u{11373}\u{11374}\u{114B0}\u{114B1}\u{114B2}\u{114B3}\u{114B4}\u{114B5}\u{114B6}\u{114B7}\u{114B8}\u{114B9}\u{114BA}\u{114BB}\u{114BC}\u{114BD}\u{114BE}\u{114BF}\u{114C0}\u{114C1}\u{114C2}\u{114C3}\u{114D0}\u{114D1}\u{114D2}\u{114D3}\u{114D4}\u{114D5}\u{114D6}\u{114D7}\u{114D8}\u{114D9}\u{115AF}\u{115B0}\u{115B1}\u{115B2}\u{115B3}\u{115B4}\u{115B5}\u{115B8}\u{115B9}\u{115BA}\u{115BB}\u{115BC}\u{115BD}\u{115BE}\u{115BF}\u{115C0}\u{11630}\u{11631}\u{11632}\u{11633}\u{11634}\u{11635}\u{11636}\u{11637}\u{11638}\u{11639}\u{1163A}\u{1163B}\u{1163C}\u{1163D}\u{1163E}\u{1163F}\u{11640}\u{11650}\u{11651}\u{11652}\u{11653}\u{11654}\u{11655}\u{11656}\u{11657}\u{11658}\u{11659}\u{118E0}\u{118E1}\u{118E2}\u{118E3}\u{118E4}\u{118E5}\u{118E6}\u{118E7}\u{118E8}\u{118E9}\u{16A60}\u{16A61}\u{16A62}\u{16A63}\u{16A64}\u{16A65}\u{16A66}\u{16A67}\u{16A68}\u{16A69}\u{16AF0}\u{16AF1}\u{16AF2}\u{16AF3}\u{16AF4}\u{16B30}\u{16B31}\u{16B32}\u{16B33}\u{16B34}\u{16B35}\u{16B36}\u{16B50}\u{16B51}\u{16B52}\u{16B53}\u{16B54}\u{16B55}\u{16B56}\u{16B57}\u{16B58}\u{16B59}\u{1BC9D}\u{1BC9E}\u{1E8D0}\u{1E8D1}\u{1E8D2}\u{1E8D3}\u{1E8D4}\u{1E8D5}\u{1E8D6}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0-class.js new file mode 100644 index 000000000..b8cacfbeb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v7.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_ࣿఀಁഁ෦෧෨෩෪෫෬෭෮෯᪵᪶᪷᪸᪹᪺᪽᪰᪱᪲᪳᪴᪻᪼᳸᳹ᷧᷨᷩᷪᷫᷬᷭᷮᷯᷰᷱᷲᷳᷴ᷵ꧥ꧰꧱꧲꧳꧴꧵꧶꧷꧸꧹ꩼꩽ𑅳𑁿︧︨︩︪︫︬︭𐋠𐫦𐍶𐍷𐍸𐍹𐍺𐫥𑈬𑈭𑈮𑈯𑈰𑈱𑈲𑈳𑈴𑈶𑈵𑈷𑋟𑋠𑋡𑋢𑋣𑋤𑋥𑋦𑋧𑋨𑋩𑋪𑋰𑋱𑋲𑋳𑋴𑋵𑋶𑋷𑋸𑋹𑌁𑌂𑌃𑌼𑌾𑌿𑍀𑍁𑍂𑍃𑍄𑍇𑍈𑍋𑍌𑍍𑍗𑍢𑍣𑍦𑍧𑍨𑍩𑍪𑍫𑍬𑍰𑍱𑍲𑍳𑍴𑒰𑒱𑒲𑒳𑒴𑒵𑒶𑒷𑒸𑒻𑒻𑒼𑒽𑒾𑒿𑓀𑓁𑓃𑓂𑓐𑓑𑓒𑓓𑓔𑓕𑓖𑓗𑓘𑓙𑖯𑖰𑖱𑖲𑖳𑖴𑖵𑖸𑖹𑖺𑖻𑖼𑖽𑖾𑗀𑖿𑘰𑘱𑘲𑘳𑘴𑘵𑘶𑘷𑘸𑘹𑘺𑘻𑘼𑘽𑘾𑘿𑙀𑙐𑙑𑙒𑙓𑙔𑙕𑙖𑙗𑙘𑙙𑣠𑣡𑣢𑣣𑣤𑣥𑣦𑣧𑣨𑣩𖩠𖩡𖩢𖩣𖩤𖩥𖩦𖩧𖩨𖩩𖫰𖫱𖫲𖫳𖫴𖬰𖬱𖬲𖬳𖬴𖬵𖬶𖭐𖭑𖭒𖭓𖭔𖭕𖭖𖭗𖭘𖭙𛲝𛲞𞣐𞣑𞣒𞣓𞣔𞣕𞣖; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0-escaped.js new file mode 100644 index 000000000..48578660b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v7.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u08FF\u0C00\u0C81\u0D01\u0DE6\u0DE7\u0DE8\u0DE9\u0DEA\u0DEB\u0DEC\u0DED\u0DEE\u0DEF\u1AB0\u1AB1\u1AB2\u1AB3\u1AB4\u1AB5\u1AB6\u1AB7\u1AB8\u1AB9\u1ABA\u1ABB\u1ABC\u1ABD\u1CF8\u1CF9\u1DE7\u1DE8\u1DE9\u1DEA\u1DEB\u1DEC\u1DED\u1DEE\u1DEF\u1DF0\u1DF1\u1DF2\u1DF3\u1DF4\u1DF5\uA9E5\uA9F0\uA9F1\uA9F2\uA9F3\uA9F4\uA9F5\uA9F6\uA9F7\uA9F8\uA9F9\uAA7C\uAA7D\uFE27\uFE28\uFE29\uFE2A\uFE2B\uFE2C\uFE2D\u{102E0}\u{10376}\u{10377}\u{10378}\u{10379}\u{1037A}\u{10AE5}\u{10AE6}\u{1107F}\u{11173}\u{1122C}\u{1122D}\u{1122E}\u{1122F}\u{11230}\u{11231}\u{11232}\u{11233}\u{11234}\u{11235}\u{11236}\u{11237}\u{112DF}\u{112E0}\u{112E1}\u{112E2}\u{112E3}\u{112E4}\u{112E5}\u{112E6}\u{112E7}\u{112E8}\u{112E9}\u{112EA}\u{112F0}\u{112F1}\u{112F2}\u{112F3}\u{112F4}\u{112F5}\u{112F6}\u{112F7}\u{112F8}\u{112F9}\u{11301}\u{11302}\u{11303}\u{1133C}\u{1133E}\u{1133F}\u{11340}\u{11341}\u{11342}\u{11343}\u{11344}\u{11347}\u{11348}\u{1134B}\u{1134C}\u{1134D}\u{11357}\u{11362}\u{11363}\u{11366}\u{11367}\u{11368}\u{11369}\u{1136A}\u{1136B}\u{1136C}\u{11370}\u{11371}\u{11372}\u{11373}\u{11374}\u{114B0}\u{114B1}\u{114B2}\u{114B3}\u{114B4}\u{114B5}\u{114B6}\u{114B7}\u{114B8}\u{114B9}\u{114BA}\u{114BB}\u{114BC}\u{114BD}\u{114BE}\u{114BF}\u{114C0}\u{114C1}\u{114C2}\u{114C3}\u{114D0}\u{114D1}\u{114D2}\u{114D3}\u{114D4}\u{114D5}\u{114D6}\u{114D7}\u{114D8}\u{114D9}\u{115AF}\u{115B0}\u{115B1}\u{115B2}\u{115B3}\u{115B4}\u{115B5}\u{115B8}\u{115B9}\u{115BA}\u{115BB}\u{115BC}\u{115BD}\u{115BE}\u{115BF}\u{115C0}\u{11630}\u{11631}\u{11632}\u{11633}\u{11634}\u{11635}\u{11636}\u{11637}\u{11638}\u{11639}\u{1163A}\u{1163B}\u{1163C}\u{1163D}\u{1163E}\u{1163F}\u{11640}\u{11650}\u{11651}\u{11652}\u{11653}\u{11654}\u{11655}\u{11656}\u{11657}\u{11658}\u{11659}\u{118E0}\u{118E1}\u{118E2}\u{118E3}\u{118E4}\u{118E5}\u{118E6}\u{118E7}\u{118E8}\u{118E9}\u{16A60}\u{16A61}\u{16A62}\u{16A63}\u{16A64}\u{16A65}\u{16A66}\u{16A67}\u{16A68}\u{16A69}\u{16AF0}\u{16AF1}\u{16AF2}\u{16AF3}\u{16AF4}\u{16B30}\u{16B31}\u{16B32}\u{16B33}\u{16B34}\u{16B35}\u{16B36}\u{16B50}\u{16B51}\u{16B52}\u{16B53}\u{16B54}\u{16B55}\u{16B56}\u{16B57}\u{16B58}\u{16B59}\u{1BC9D}\u{1BC9E}\u{1E8D0}\u{1E8D1}\u{1E8D2}\u{1E8D3}\u{1E8D4}\u{1E8D5}\u{1E8D6}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0.js new file mode 100644 index 000000000..96f0499f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-7.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v7.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _ࣿఀಁഁ෦෧෨෩෪෫෬෭෮෯᪵᪶᪷᪸᪹᪺᪽᪰᪱᪲᪳᪴᪻᪼᳸᳹ᷧᷨᷩᷪᷫᷬᷭᷮᷯᷰᷱᷲᷳᷴ᷵ꧥ꧰꧱꧲꧳꧴꧵꧶꧷꧸꧹ꩼꩽ𑅳𑁿︧︨︩︪︫︬︭𐋠𐫦𐍶𐍷𐍸𐍹𐍺𐫥𑈬𑈭𑈮𑈯𑈰𑈱𑈲𑈳𑈴𑈶𑈵𑈷𑋟𑋠𑋡𑋢𑋣𑋤𑋥𑋦𑋧𑋨𑋩𑋪𑋰𑋱𑋲𑋳𑋴𑋵𑋶𑋷𑋸𑋹𑌁𑌂𑌃𑌼𑌾𑌿𑍀𑍁𑍂𑍃𑍄𑍇𑍈𑍋𑍌𑍍𑍗𑍢𑍣𑍦𑍧𑍨𑍩𑍪𑍫𑍬𑍰𑍱𑍲𑍳𑍴𑒰𑒱𑒲𑒳𑒴𑒵𑒶𑒷𑒸𑒻𑒻𑒼𑒽𑒾𑒿𑓀𑓁𑓃𑓂𑓐𑓑𑓒𑓓𑓔𑓕𑓖𑓗𑓘𑓙𑖯𑖰𑖱𑖲𑖳𑖴𑖵𑖸𑖹𑖺𑖻𑖼𑖽𑖾𑗀𑖿𑘰𑘱𑘲𑘳𑘴𑘵𑘶𑘷𑘸𑘹𑘺𑘻𑘼𑘽𑘾𑘿𑙀𑙐𑙑𑙒𑙓𑙔𑙕𑙖𑙗𑙘𑙙𑣠𑣡𑣢𑣣𑣤𑣥𑣦𑣧𑣨𑣩𖩠𖩡𖩢𖩣𖩤𖩥𖩦𖩧𖩨𖩩𖫰𖫱𖫲𖫳𖫴𖬰𖬱𖬲𖬳𖬴𖬵𖬶𖭐𖭑𖭒𖭓𖭔𖭕𖭖𖭗𖭘𖭙𛲝𛲞𞣐𞣑𞣒𞣓𞣔𞣕𞣖; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0-class-escaped.js new file mode 100644 index 000000000..8cef6957c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v8.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u08E3\uA69E\uFE2E\uFE2F\u{111CA}\u{111CB}\u{111CC}\u{11300}\u{115DC}\u{115DD}\u{1171D}\u{1171E}\u{1171F}\u{11720}\u{11721}\u{11722}\u{11723}\u{11724}\u{11725}\u{11726}\u{11727}\u{11728}\u{11729}\u{1172A}\u{1172B}\u{11730}\u{11731}\u{11732}\u{11733}\u{11734}\u{11735}\u{11736}\u{11737}\u{11738}\u{11739}\u{1DA00}\u{1DA01}\u{1DA02}\u{1DA03}\u{1DA04}\u{1DA05}\u{1DA06}\u{1DA07}\u{1DA08}\u{1DA09}\u{1DA0A}\u{1DA0B}\u{1DA0C}\u{1DA0D}\u{1DA0E}\u{1DA0F}\u{1DA10}\u{1DA11}\u{1DA12}\u{1DA13}\u{1DA14}\u{1DA15}\u{1DA16}\u{1DA17}\u{1DA18}\u{1DA19}\u{1DA1A}\u{1DA1B}\u{1DA1C}\u{1DA1D}\u{1DA1E}\u{1DA1F}\u{1DA20}\u{1DA21}\u{1DA22}\u{1DA23}\u{1DA24}\u{1DA25}\u{1DA26}\u{1DA27}\u{1DA28}\u{1DA29}\u{1DA2A}\u{1DA2B}\u{1DA2C}\u{1DA2D}\u{1DA2E}\u{1DA2F}\u{1DA30}\u{1DA31}\u{1DA32}\u{1DA33}\u{1DA34}\u{1DA35}\u{1DA36}\u{1DA3B}\u{1DA3C}\u{1DA3D}\u{1DA3E}\u{1DA3F}\u{1DA40}\u{1DA41}\u{1DA42}\u{1DA43}\u{1DA44}\u{1DA45}\u{1DA46}\u{1DA47}\u{1DA48}\u{1DA49}\u{1DA4A}\u{1DA4B}\u{1DA4C}\u{1DA4D}\u{1DA4E}\u{1DA4F}\u{1DA50}\u{1DA51}\u{1DA52}\u{1DA53}\u{1DA54}\u{1DA55}\u{1DA56}\u{1DA57}\u{1DA58}\u{1DA59}\u{1DA5A}\u{1DA5B}\u{1DA5C}\u{1DA5D}\u{1DA5E}\u{1DA5F}\u{1DA60}\u{1DA61}\u{1DA62}\u{1DA63}\u{1DA64}\u{1DA65}\u{1DA66}\u{1DA67}\u{1DA68}\u{1DA69}\u{1DA6A}\u{1DA6B}\u{1DA6C}\u{1DA75}\u{1DA84}\u{1DA9B}\u{1DA9C}\u{1DA9D}\u{1DA9E}\u{1DA9F}\u{1DAA1}\u{1DAA2}\u{1DAA3}\u{1DAA4}\u{1DAA5}\u{1DAA6}\u{1DAA7}\u{1DAA8}\u{1DAA9}\u{1DAAA}\u{1DAAB}\u{1DAAC}\u{1DAAD}\u{1DAAE}\u{1DAAF}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0-class.js new file mode 100644 index 000000000..a602af605 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v8.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_𑇊ࣣꚞ︮︯𑇋𑇌𑌀𑗜𑗝𑜝𑜞𑜟𑜠𑜡𑜢𑜣𑜤𑜥𑜦𑜧𑜨𑜩𑜪𑜫𑜰𑜱𑜲𑜳𑜴𑜵𑜶𑜷𑜸𑜹𝨀𝨁𝨂𝨃𝨄𝨅𝨆𝨇𝨈𝨉𝨊𝨋𝨌𝨍𝨎𝨏𝨐𝨑𝨒𝨓𝨔𝨕𝨖𝨗𝨘𝨙𝨚𝨛𝨜𝨝𝨞𝨟𝨠𝨡𝨢𝨣𝨤𝨥𝨦𝨧𝨨𝨩𝨪𝨫𝨬𝨭𝨮𝨯𝨰𝨱𝨲𝨳𝨴𝨵𝨶𝨻𝨼𝨽𝨾𝨿𝩀𝩁𝩂𝩃𝩄𝩅𝩆𝩇𝩈𝩉𝩊𝩋𝩌𝩍𝩎𝩏𝩐𝩑𝩒𝩓𝩔𝩕𝩖𝩗𝩘𝩙𝩚𝩛𝩜𝩝𝩞𝩟𝩠𝩡𝩢𝩣𝩤𝩥𝩦𝩧𝩨𝩩𝩪𝩫𝩬𝩵𝪄𝪛𝪜𝪝𝪞𝪟𝪡𝪢𝪣𝪤𝪥𝪦𝪧𝪨𝪩𝪪𝪫𝪬𝪭𝪮𝪯; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0-escaped.js new file mode 100644 index 000000000..625b94eff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v8.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u08E3\uA69E\uFE2E\uFE2F\u{111CA}\u{111CB}\u{111CC}\u{11300}\u{115DC}\u{115DD}\u{1171D}\u{1171E}\u{1171F}\u{11720}\u{11721}\u{11722}\u{11723}\u{11724}\u{11725}\u{11726}\u{11727}\u{11728}\u{11729}\u{1172A}\u{1172B}\u{11730}\u{11731}\u{11732}\u{11733}\u{11734}\u{11735}\u{11736}\u{11737}\u{11738}\u{11739}\u{1DA00}\u{1DA01}\u{1DA02}\u{1DA03}\u{1DA04}\u{1DA05}\u{1DA06}\u{1DA07}\u{1DA08}\u{1DA09}\u{1DA0A}\u{1DA0B}\u{1DA0C}\u{1DA0D}\u{1DA0E}\u{1DA0F}\u{1DA10}\u{1DA11}\u{1DA12}\u{1DA13}\u{1DA14}\u{1DA15}\u{1DA16}\u{1DA17}\u{1DA18}\u{1DA19}\u{1DA1A}\u{1DA1B}\u{1DA1C}\u{1DA1D}\u{1DA1E}\u{1DA1F}\u{1DA20}\u{1DA21}\u{1DA22}\u{1DA23}\u{1DA24}\u{1DA25}\u{1DA26}\u{1DA27}\u{1DA28}\u{1DA29}\u{1DA2A}\u{1DA2B}\u{1DA2C}\u{1DA2D}\u{1DA2E}\u{1DA2F}\u{1DA30}\u{1DA31}\u{1DA32}\u{1DA33}\u{1DA34}\u{1DA35}\u{1DA36}\u{1DA3B}\u{1DA3C}\u{1DA3D}\u{1DA3E}\u{1DA3F}\u{1DA40}\u{1DA41}\u{1DA42}\u{1DA43}\u{1DA44}\u{1DA45}\u{1DA46}\u{1DA47}\u{1DA48}\u{1DA49}\u{1DA4A}\u{1DA4B}\u{1DA4C}\u{1DA4D}\u{1DA4E}\u{1DA4F}\u{1DA50}\u{1DA51}\u{1DA52}\u{1DA53}\u{1DA54}\u{1DA55}\u{1DA56}\u{1DA57}\u{1DA58}\u{1DA59}\u{1DA5A}\u{1DA5B}\u{1DA5C}\u{1DA5D}\u{1DA5E}\u{1DA5F}\u{1DA60}\u{1DA61}\u{1DA62}\u{1DA63}\u{1DA64}\u{1DA65}\u{1DA66}\u{1DA67}\u{1DA68}\u{1DA69}\u{1DA6A}\u{1DA6B}\u{1DA6C}\u{1DA75}\u{1DA84}\u{1DA9B}\u{1DA9C}\u{1DA9D}\u{1DA9E}\u{1DA9F}\u{1DAA1}\u{1DAA2}\u{1DAA3}\u{1DAA4}\u{1DAA5}\u{1DAA6}\u{1DAA7}\u{1DAA8}\u{1DAA9}\u{1DAAA}\u{1DAAB}\u{1DAAC}\u{1DAAD}\u{1DAAE}\u{1DAAF}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0.js new file mode 100644 index 000000000..a6e365b95 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-8.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v8.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _𑇊ࣣꚞ︮︯𑇋𑇌𑌀𑗜𑗝𑜝𑜞𑜟𑜠𑜡𑜢𑜣𑜤𑜥𑜦𑜧𑜨𑜩𑜪𑜫𑜰𑜱𑜲𑜳𑜴𑜵𑜶𑜷𑜸𑜹𝨀𝨁𝨂𝨃𝨄𝨅𝨆𝨇𝨈𝨉𝨊𝨋𝨌𝨍𝨎𝨏𝨐𝨑𝨒𝨓𝨔𝨕𝨖𝨗𝨘𝨙𝨚𝨛𝨜𝨝𝨞𝨟𝨠𝨡𝨢𝨣𝨤𝨥𝨦𝨧𝨨𝨩𝨪𝨫𝨬𝨭𝨮𝨯𝨰𝨱𝨲𝨳𝨴𝨵𝨶𝨻𝨼𝨽𝨾𝨿𝩀𝩁𝩂𝩃𝩄𝩅𝩆𝩇𝩈𝩉𝩊𝩋𝩌𝩍𝩎𝩏𝩐𝩑𝩒𝩓𝩔𝩕𝩖𝩗𝩘𝩙𝩚𝩛𝩜𝩝𝩞𝩟𝩠𝩡𝩢𝩣𝩤𝩥𝩦𝩧𝩨𝩩𝩪𝩫𝩬𝩵𝪄𝪛𝪜𝪝𝪞𝪟𝪡𝪢𝪣𝪤𝪥𝪦𝪧𝪨𝪩𝪪𝪫𝪬𝪭𝪮𝪯; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0-class-escaped.js new file mode 100644 index 000000000..2a4a5601b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0-class-escaped.js @@ -0,0 +1,20 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v9.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_\u08D4\u08D5\u08D6\u08D7\u08D8\u08D9\u08DA\u08DB\u08DC\u08DD\u08DE\u08DF\u08E0\u08E1\u1DFB\uA8C5\u{1123E}\u{11435}\u{11436}\u{11437}\u{11438}\u{11439}\u{1143A}\u{1143B}\u{1143C}\u{1143D}\u{1143E}\u{1143F}\u{11440}\u{11441}\u{11442}\u{11443}\u{11444}\u{11445}\u{11446}\u{11450}\u{11451}\u{11452}\u{11453}\u{11454}\u{11455}\u{11456}\u{11457}\u{11458}\u{11459}\u{11C2F}\u{11C30}\u{11C31}\u{11C32}\u{11C33}\u{11C34}\u{11C35}\u{11C36}\u{11C38}\u{11C39}\u{11C3A}\u{11C3B}\u{11C3C}\u{11C3D}\u{11C3E}\u{11C3F}\u{11C50}\u{11C51}\u{11C52}\u{11C53}\u{11C54}\u{11C55}\u{11C56}\u{11C57}\u{11C58}\u{11C59}\u{11C92}\u{11C93}\u{11C94}\u{11C95}\u{11C96}\u{11C97}\u{11C98}\u{11C99}\u{11C9A}\u{11C9B}\u{11C9C}\u{11C9D}\u{11C9E}\u{11C9F}\u{11CA0}\u{11CA1}\u{11CA2}\u{11CA3}\u{11CA4}\u{11CA5}\u{11CA6}\u{11CA7}\u{11CA9}\u{11CAA}\u{11CAB}\u{11CAC}\u{11CAD}\u{11CAE}\u{11CAF}\u{11CB0}\u{11CB1}\u{11CB2}\u{11CB3}\u{11CB4}\u{11CB5}\u{11CB6}\u{1E000}\u{1E001}\u{1E002}\u{1E003}\u{1E004}\u{1E005}\u{1E006}\u{1E008}\u{1E009}\u{1E00A}\u{1E00B}\u{1E00C}\u{1E00D}\u{1E00E}\u{1E00F}\u{1E010}\u{1E011}\u{1E012}\u{1E013}\u{1E014}\u{1E015}\u{1E016}\u{1E017}\u{1E018}\u{1E01B}\u{1E01C}\u{1E01D}\u{1E01E}\u{1E01F}\u{1E020}\u{1E021}\u{1E023}\u{1E024}\u{1E026}\u{1E027}\u{1E028}\u{1E029}\u{1E02A}\u{1E944}\u{1E945}\u{1E946}\u{1E947}\u{1E948}\u{1E949}\u{1E94A}\u{1E950}\u{1E951}\u{1E952}\u{1E953}\u{1E954}\u{1E955}\u{1E956}\u{1E957}\u{1E958}\u{1E959}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0-class.js new file mode 100644 index 000000000..daf65cf53 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0-class.js @@ -0,0 +1,17 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v9.0.0 ID_Continue characters are accepted as + identifier part characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #_ࣔࣕࣖࣗࣘࣙࣚࣛࣜࣝࣞࣟ࣠࣡᷻ꣅ𑈾𑐵𑐶𑐷𑐸𑐹𑐺𑐻𑐼𑐽𑐾𑐿𑑀𑑁𑑂𑑃𑑄𑑅𑑆𑑐𑑑𑑒𑑓𑑔𑑕𑑖𑑗𑑘𑑙𑰯𑰰𑰱𑰲𑰳𑰴𑰵𑰶𑰸𑰹𑰺𑰻𑰼𑰽𑰾𑰿𑱐𑱑𑱒𑱓𑱔𑱕𑱖𑱗𑱘𑱙𑲒𑲓𑲔𑲕𑲖𑲗𑲘𑲙𑲚𑲛𑲜𑲝𑲞𑲟𑲠𑲡𑲢𑲣𑲤𑲥𑲦𑲧𑲩𑲪𑲫𑲬𑲭𑲮𑲯𑲰𑲱𑲲𑲳𑲴𑲵𑲶𞥊𞀀𞀁𞀂𞀃𞀄𞀅𞀆𞀈𞀉𞀊𞀋𞀌𞀍𞀎𞀏𞀐𞀑𞀒𞀓𞀔𞀕𞀖𞀗𞀘𞀛𞀜𞀝𞀞𞀟𞀠𞀡𞀣𞀤𞀦𞀧𞀨𞀩𞀪𞥄𞥅𞥆𞥇𞥈𞥉𞥐𞥑𞥒𞥓𞥔𞥕𞥖𞥗𞥘𞥙; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0-escaped.js new file mode 100644 index 000000000..0d3466c84 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0-escaped.js @@ -0,0 +1,16 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v9.0.0 ID_Continue characters are accepted as + identifier part characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _\u08D4\u08D5\u08D6\u08D7\u08D8\u08D9\u08DA\u08DB\u08DC\u08DD\u08DE\u08DF\u08E0\u08E1\u1DFB\uA8C5\u{1123E}\u{11435}\u{11436}\u{11437}\u{11438}\u{11439}\u{1143A}\u{1143B}\u{1143C}\u{1143D}\u{1143E}\u{1143F}\u{11440}\u{11441}\u{11442}\u{11443}\u{11444}\u{11445}\u{11446}\u{11450}\u{11451}\u{11452}\u{11453}\u{11454}\u{11455}\u{11456}\u{11457}\u{11458}\u{11459}\u{11C2F}\u{11C30}\u{11C31}\u{11C32}\u{11C33}\u{11C34}\u{11C35}\u{11C36}\u{11C38}\u{11C39}\u{11C3A}\u{11C3B}\u{11C3C}\u{11C3D}\u{11C3E}\u{11C3F}\u{11C50}\u{11C51}\u{11C52}\u{11C53}\u{11C54}\u{11C55}\u{11C56}\u{11C57}\u{11C58}\u{11C59}\u{11C92}\u{11C93}\u{11C94}\u{11C95}\u{11C96}\u{11C97}\u{11C98}\u{11C99}\u{11C9A}\u{11C9B}\u{11C9C}\u{11C9D}\u{11C9E}\u{11C9F}\u{11CA0}\u{11CA1}\u{11CA2}\u{11CA3}\u{11CA4}\u{11CA5}\u{11CA6}\u{11CA7}\u{11CA9}\u{11CAA}\u{11CAB}\u{11CAC}\u{11CAD}\u{11CAE}\u{11CAF}\u{11CB0}\u{11CB1}\u{11CB2}\u{11CB3}\u{11CB4}\u{11CB5}\u{11CB6}\u{1E000}\u{1E001}\u{1E002}\u{1E003}\u{1E004}\u{1E005}\u{1E006}\u{1E008}\u{1E009}\u{1E00A}\u{1E00B}\u{1E00C}\u{1E00D}\u{1E00E}\u{1E00F}\u{1E010}\u{1E011}\u{1E012}\u{1E013}\u{1E014}\u{1E015}\u{1E016}\u{1E017}\u{1E018}\u{1E01B}\u{1E01C}\u{1E01D}\u{1E01E}\u{1E01F}\u{1E020}\u{1E021}\u{1E023}\u{1E024}\u{1E026}\u{1E027}\u{1E028}\u{1E029}\u{1E02A}\u{1E944}\u{1E945}\u{1E946}\u{1E947}\u{1E948}\u{1E949}\u{1E94A}\u{1E950}\u{1E951}\u{1E952}\u{1E953}\u{1E954}\u{1E955}\u{1E956}\u{1E957}\u{1E958}\u{1E959}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0.js new file mode 100644 index 000000000..a34933422 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-unicode-9.0.0.js @@ -0,0 +1,14 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v9.0.0 ID_Continue characters are accepted as + identifier part characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var _ࣔࣕࣖࣗࣘࣙࣚࣛࣜࣝࣞࣟ࣠࣡᷻ꣅ𑈾𑐵𑐶𑐷𑐸𑐹𑐺𑐻𑐼𑐽𑐾𑐿𑑀𑑁𑑂𑑃𑑄𑑅𑑆𑑐𑑑𑑒𑑓𑑔𑑕𑑖𑑗𑑘𑑙𑰯𑰰𑰱𑰲𑰳𑰴𑰵𑰶𑰸𑰹𑰺𑰻𑰼𑰽𑰾𑰿𑱐𑱑𑱒𑱓𑱔𑱕𑱖𑱗𑱘𑱙𑲒𑲓𑲔𑲕𑲖𑲗𑲘𑲙𑲚𑲛𑲜𑲝𑲞𑲟𑲠𑲡𑲢𑲣𑲤𑲥𑲦𑲧𑲩𑲪𑲫𑲬𑲭𑲮𑲯𑲰𑲱𑲲𑲳𑲴𑲵𑲶𞥊𞀀𞀁𞀂𞀃𞀄𞀅𞀆𞀈𞀉𞀊𞀋𞀌𞀍𞀎𞀏𞀐𞀑𞀒𞀓𞀔𞀕𞀖𞀗𞀘𞀛𞀜𞀝𞀞𞀟𞀠𞀡𞀣𞀤𞀦𞀧𞀨𞀩𞀪𞥄𞥅𞥆𞥇𞥈𞥉𞥐𞥑𞥒𞥓𞥔𞥕𞥖𞥗𞥘𞥙; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-zwj-zwnj-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-zwj-zwnj-escaped.js new file mode 100644 index 000000000..934b311ba --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/part-zwj-zwnj-escaped.js @@ -0,0 +1,16 @@ +// Copyright (C) 2020 Adam Kluball. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Adam Kluball +esid: sec-names-and-keywords +description: zero width joiner and zero width non-joiner are valid identifier parts +---*/ + +var $ = 1; +var $\u200D = 2; +var $\u200C = 3; + +assert.sameValue($, 1); +assert.sameValue($\u200D, 2); +assert.sameValue($\u200C, 3); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-dollar-sign.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-dollar-sign.js new file mode 100644 index 000000000..b54080cbd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-dollar-sign.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierPart :: IdentifierStart" +es5id: 7.6_A2.1_T2 +description: "IdentifierStart :: $" +---*/ + +var $ = 1; +assert.sameValue($, 1); + +var $x = 2; +assert.sameValue($x, 2); + +var $$ = 3; +assert.sameValue($$, 3); + +var $_ = 4; +assert.sameValue($_, 4); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-escape-seq.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-escape-seq.js new file mode 100644 index 000000000..775d51764 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-escape-seq.js @@ -0,0 +1,38 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierPart :: IdentifierStart" +es5id: 7.6_A2.1_T4 +description: "IdentifierStart :: \\UnicodeEscapeSequence" +---*/ + +var \u0078 = 1; +assert.sameValue(x, 1); + +var \u0078\u0078 = 2; +assert.sameValue(xx, 2); + +var \u0024 = 3; +assert.sameValue($, 3); + +var \u0024x = 4; +assert.sameValue($x, 4); + +var \u0024\u0024 = 5; +assert.sameValue($$, 5); + +var \u0024_ = 6; +assert.sameValue($_, 6); + +var \u005F = 7; +assert.sameValue(_, 7); + +var \u005Fx = 8; +assert.sameValue(_x, 8); + +var \u005F$ = 9; +assert.sameValue(_$, 9); + +var \u005F\u005F = 10; +assert.sameValue(__, 10); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-underscore.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-underscore.js new file mode 100644 index 000000000..cba4e956c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-underscore.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierPart :: IdentifierStart" +es5id: 7.6_A2.1_T3 +description: "IdentifierStart :: _" +---*/ + +var _ = 1; +assert.sameValue(_, 1); + +var _x = 2; +assert.sameValue(_x, 2); + +var _$ = 3; +assert.sameValue(_$, 3); + +var __ = 4; +assert.sameValue(__, 4); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0-class-escaped.js new file mode 100644 index 000000000..dbff4e6c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0-class-escaped.js @@ -0,0 +1,8346 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v10.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u0860; + #\u0861; + #\u0862; + #\u0863; + #\u0864; + #\u0865; + #\u0866; + #\u0867; + #\u0868; + #\u0869; + #\u086A; + #\u09FC; + #\u312E; + #\u9FD6; + #\u9FD7; + #\u9FD8; + #\u9FD9; + #\u9FDA; + #\u9FDB; + #\u9FDC; + #\u9FDD; + #\u9FDE; + #\u9FDF; + #\u9FE0; + #\u9FE1; + #\u9FE2; + #\u9FE3; + #\u9FE4; + #\u9FE5; + #\u9FE6; + #\u9FE7; + #\u9FE8; + #\u9FE9; + #\u9FEA; + #\u{1032D}; + #\u{1032E}; + #\u{1032F}; + #\u{11A00}; + #\u{11A0B}; + #\u{11A0C}; + #\u{11A0D}; + #\u{11A0E}; + #\u{11A0F}; + #\u{11A10}; + #\u{11A11}; + #\u{11A12}; + #\u{11A13}; + #\u{11A14}; + #\u{11A15}; + #\u{11A16}; + #\u{11A17}; + #\u{11A18}; + #\u{11A19}; + #\u{11A1A}; + #\u{11A1B}; + #\u{11A1C}; + #\u{11A1D}; + #\u{11A1E}; + #\u{11A1F}; + #\u{11A20}; + #\u{11A21}; + #\u{11A22}; + #\u{11A23}; + #\u{11A24}; + #\u{11A25}; + #\u{11A26}; + #\u{11A27}; + #\u{11A28}; + #\u{11A29}; + #\u{11A2A}; + #\u{11A2B}; + #\u{11A2C}; + #\u{11A2D}; + #\u{11A2E}; + #\u{11A2F}; + #\u{11A30}; + #\u{11A31}; + #\u{11A32}; + #\u{11A3A}; + #\u{11A50}; + #\u{11A5C}; + #\u{11A5D}; + #\u{11A5E}; + #\u{11A5F}; + #\u{11A60}; + #\u{11A61}; + #\u{11A62}; + #\u{11A63}; + #\u{11A64}; + #\u{11A65}; + #\u{11A66}; + #\u{11A67}; + #\u{11A68}; + #\u{11A69}; + #\u{11A6A}; + #\u{11A6B}; + #\u{11A6C}; + #\u{11A6D}; + #\u{11A6E}; + #\u{11A6F}; + #\u{11A70}; + #\u{11A71}; + #\u{11A72}; + #\u{11A73}; + #\u{11A74}; + #\u{11A75}; + #\u{11A76}; + #\u{11A77}; + #\u{11A78}; + #\u{11A79}; + #\u{11A7A}; + #\u{11A7B}; + #\u{11A7C}; + #\u{11A7D}; + #\u{11A7E}; + #\u{11A7F}; + #\u{11A80}; + #\u{11A81}; + #\u{11A82}; + #\u{11A83}; + #\u{11A86}; + #\u{11A87}; + #\u{11A88}; + #\u{11A89}; + #\u{11D00}; + #\u{11D01}; + #\u{11D02}; + #\u{11D03}; + #\u{11D04}; + #\u{11D05}; + #\u{11D06}; + #\u{11D08}; + #\u{11D09}; + #\u{11D0B}; + #\u{11D0C}; + #\u{11D0D}; + #\u{11D0E}; + #\u{11D0F}; + #\u{11D10}; + #\u{11D11}; + #\u{11D12}; + #\u{11D13}; + #\u{11D14}; + #\u{11D15}; + #\u{11D16}; + #\u{11D17}; + #\u{11D18}; + #\u{11D19}; + #\u{11D1A}; + #\u{11D1B}; + #\u{11D1C}; + #\u{11D1D}; + #\u{11D1E}; + #\u{11D1F}; + #\u{11D20}; + #\u{11D21}; + #\u{11D22}; + #\u{11D23}; + #\u{11D24}; + #\u{11D25}; + #\u{11D26}; + #\u{11D27}; + #\u{11D28}; + #\u{11D29}; + #\u{11D2A}; + #\u{11D2B}; + #\u{11D2C}; + #\u{11D2D}; + #\u{11D2E}; + #\u{11D2F}; + #\u{11D30}; + #\u{11D46}; + #\u{16FE1}; + #\u{1B002}; + #\u{1B003}; + #\u{1B004}; + #\u{1B005}; + #\u{1B006}; + #\u{1B007}; + #\u{1B008}; + #\u{1B009}; + #\u{1B00A}; + #\u{1B00B}; + #\u{1B00C}; + #\u{1B00D}; + #\u{1B00E}; + #\u{1B00F}; + #\u{1B010}; + #\u{1B011}; + #\u{1B012}; + #\u{1B013}; + #\u{1B014}; + #\u{1B015}; + #\u{1B016}; + #\u{1B017}; + #\u{1B018}; + #\u{1B019}; + #\u{1B01A}; + #\u{1B01B}; + #\u{1B01C}; + #\u{1B01D}; + #\u{1B01E}; + #\u{1B01F}; + #\u{1B020}; + #\u{1B021}; + #\u{1B022}; + #\u{1B023}; + #\u{1B024}; + #\u{1B025}; + #\u{1B026}; + #\u{1B027}; + #\u{1B028}; + #\u{1B029}; + #\u{1B02A}; + #\u{1B02B}; + #\u{1B02C}; + #\u{1B02D}; + #\u{1B02E}; + #\u{1B02F}; + #\u{1B030}; + #\u{1B031}; + #\u{1B032}; + #\u{1B033}; + #\u{1B034}; + #\u{1B035}; + #\u{1B036}; + #\u{1B037}; + #\u{1B038}; + #\u{1B039}; + #\u{1B03A}; + #\u{1B03B}; + #\u{1B03C}; + #\u{1B03D}; + #\u{1B03E}; + #\u{1B03F}; + #\u{1B040}; + #\u{1B041}; + #\u{1B042}; + #\u{1B043}; + #\u{1B044}; + #\u{1B045}; + #\u{1B046}; + #\u{1B047}; + #\u{1B048}; + #\u{1B049}; + #\u{1B04A}; + #\u{1B04B}; + #\u{1B04C}; + #\u{1B04D}; + #\u{1B04E}; + #\u{1B04F}; + #\u{1B050}; + #\u{1B051}; + #\u{1B052}; + #\u{1B053}; + #\u{1B054}; + #\u{1B055}; + #\u{1B056}; + #\u{1B057}; + #\u{1B058}; + #\u{1B059}; + #\u{1B05A}; + #\u{1B05B}; + #\u{1B05C}; + #\u{1B05D}; + #\u{1B05E}; + #\u{1B05F}; + #\u{1B060}; + #\u{1B061}; + #\u{1B062}; + #\u{1B063}; + #\u{1B064}; + #\u{1B065}; + #\u{1B066}; + #\u{1B067}; + #\u{1B068}; + #\u{1B069}; + #\u{1B06A}; + #\u{1B06B}; + #\u{1B06C}; + #\u{1B06D}; + #\u{1B06E}; + #\u{1B06F}; + #\u{1B070}; + #\u{1B071}; + #\u{1B072}; + #\u{1B073}; + #\u{1B074}; + #\u{1B075}; + #\u{1B076}; + #\u{1B077}; + #\u{1B078}; + #\u{1B079}; + #\u{1B07A}; + #\u{1B07B}; + #\u{1B07C}; + #\u{1B07D}; + #\u{1B07E}; + #\u{1B07F}; + #\u{1B080}; + #\u{1B081}; + #\u{1B082}; + #\u{1B083}; + #\u{1B084}; + #\u{1B085}; + #\u{1B086}; + #\u{1B087}; + #\u{1B088}; + #\u{1B089}; + #\u{1B08A}; + #\u{1B08B}; + #\u{1B08C}; + #\u{1B08D}; + #\u{1B08E}; + #\u{1B08F}; + #\u{1B090}; + #\u{1B091}; + #\u{1B092}; + #\u{1B093}; + #\u{1B094}; + #\u{1B095}; + #\u{1B096}; + #\u{1B097}; + #\u{1B098}; + #\u{1B099}; + #\u{1B09A}; + #\u{1B09B}; + #\u{1B09C}; + #\u{1B09D}; + #\u{1B09E}; + #\u{1B09F}; + #\u{1B0A0}; + #\u{1B0A1}; + #\u{1B0A2}; + #\u{1B0A3}; + #\u{1B0A4}; + #\u{1B0A5}; + #\u{1B0A6}; + #\u{1B0A7}; + #\u{1B0A8}; + #\u{1B0A9}; + #\u{1B0AA}; + #\u{1B0AB}; + #\u{1B0AC}; + #\u{1B0AD}; + #\u{1B0AE}; + #\u{1B0AF}; + #\u{1B0B0}; + #\u{1B0B1}; + #\u{1B0B2}; + #\u{1B0B3}; + #\u{1B0B4}; + #\u{1B0B5}; + #\u{1B0B6}; + #\u{1B0B7}; + #\u{1B0B8}; + #\u{1B0B9}; + #\u{1B0BA}; + #\u{1B0BB}; + #\u{1B0BC}; + #\u{1B0BD}; + #\u{1B0BE}; + #\u{1B0BF}; + #\u{1B0C0}; + #\u{1B0C1}; + #\u{1B0C2}; + #\u{1B0C3}; + #\u{1B0C4}; + #\u{1B0C5}; + #\u{1B0C6}; + #\u{1B0C7}; + #\u{1B0C8}; + #\u{1B0C9}; + #\u{1B0CA}; + #\u{1B0CB}; + #\u{1B0CC}; + #\u{1B0CD}; + #\u{1B0CE}; + #\u{1B0CF}; + #\u{1B0D0}; + #\u{1B0D1}; + #\u{1B0D2}; + #\u{1B0D3}; + #\u{1B0D4}; + #\u{1B0D5}; + #\u{1B0D6}; + #\u{1B0D7}; + #\u{1B0D8}; + #\u{1B0D9}; + #\u{1B0DA}; + #\u{1B0DB}; + #\u{1B0DC}; + #\u{1B0DD}; + #\u{1B0DE}; + #\u{1B0DF}; + #\u{1B0E0}; + #\u{1B0E1}; + #\u{1B0E2}; + #\u{1B0E3}; + #\u{1B0E4}; + #\u{1B0E5}; + #\u{1B0E6}; + #\u{1B0E7}; + #\u{1B0E8}; + #\u{1B0E9}; + #\u{1B0EA}; + #\u{1B0EB}; + #\u{1B0EC}; + #\u{1B0ED}; + #\u{1B0EE}; + #\u{1B0EF}; + #\u{1B0F0}; + #\u{1B0F1}; + #\u{1B0F2}; + #\u{1B0F3}; + #\u{1B0F4}; + #\u{1B0F5}; + #\u{1B0F6}; + #\u{1B0F7}; + #\u{1B0F8}; + #\u{1B0F9}; + #\u{1B0FA}; + #\u{1B0FB}; + #\u{1B0FC}; + #\u{1B0FD}; + #\u{1B0FE}; + #\u{1B0FF}; + #\u{1B100}; + #\u{1B101}; + #\u{1B102}; + #\u{1B103}; + #\u{1B104}; + #\u{1B105}; + #\u{1B106}; + #\u{1B107}; + #\u{1B108}; + #\u{1B109}; + #\u{1B10A}; + #\u{1B10B}; + #\u{1B10C}; + #\u{1B10D}; + #\u{1B10E}; + #\u{1B10F}; + #\u{1B110}; + #\u{1B111}; + #\u{1B112}; + #\u{1B113}; + #\u{1B114}; + #\u{1B115}; + #\u{1B116}; + #\u{1B117}; + #\u{1B118}; + #\u{1B119}; + #\u{1B11A}; + #\u{1B11B}; + #\u{1B11C}; + #\u{1B11D}; + #\u{1B11E}; + #\u{1B170}; + #\u{1B171}; + #\u{1B172}; + #\u{1B173}; + #\u{1B174}; + #\u{1B175}; + #\u{1B176}; + #\u{1B177}; + #\u{1B178}; + #\u{1B179}; + #\u{1B17A}; + #\u{1B17B}; + #\u{1B17C}; + #\u{1B17D}; + #\u{1B17E}; + #\u{1B17F}; + #\u{1B180}; + #\u{1B181}; + #\u{1B182}; + #\u{1B183}; + #\u{1B184}; + #\u{1B185}; + #\u{1B186}; + #\u{1B187}; + #\u{1B188}; + #\u{1B189}; + #\u{1B18A}; + #\u{1B18B}; + #\u{1B18C}; + #\u{1B18D}; + #\u{1B18E}; + #\u{1B18F}; + #\u{1B190}; + #\u{1B191}; + #\u{1B192}; + #\u{1B193}; + #\u{1B194}; + #\u{1B195}; + #\u{1B196}; + #\u{1B197}; + #\u{1B198}; + #\u{1B199}; + #\u{1B19A}; + #\u{1B19B}; + #\u{1B19C}; + #\u{1B19D}; + #\u{1B19E}; + #\u{1B19F}; + #\u{1B1A0}; + #\u{1B1A1}; + #\u{1B1A2}; + #\u{1B1A3}; + #\u{1B1A4}; + #\u{1B1A5}; + #\u{1B1A6}; + #\u{1B1A7}; + #\u{1B1A8}; + #\u{1B1A9}; + #\u{1B1AA}; + #\u{1B1AB}; + #\u{1B1AC}; + #\u{1B1AD}; + #\u{1B1AE}; + #\u{1B1AF}; + #\u{1B1B0}; + #\u{1B1B1}; + #\u{1B1B2}; + #\u{1B1B3}; + #\u{1B1B4}; + #\u{1B1B5}; + #\u{1B1B6}; + #\u{1B1B7}; + #\u{1B1B8}; + #\u{1B1B9}; + #\u{1B1BA}; + #\u{1B1BB}; + #\u{1B1BC}; + #\u{1B1BD}; + #\u{1B1BE}; + #\u{1B1BF}; + #\u{1B1C0}; + #\u{1B1C1}; + #\u{1B1C2}; + #\u{1B1C3}; + #\u{1B1C4}; + #\u{1B1C5}; + #\u{1B1C6}; + #\u{1B1C7}; + #\u{1B1C8}; + #\u{1B1C9}; + #\u{1B1CA}; + #\u{1B1CB}; + #\u{1B1CC}; + #\u{1B1CD}; + #\u{1B1CE}; + #\u{1B1CF}; + #\u{1B1D0}; + #\u{1B1D1}; + #\u{1B1D2}; + #\u{1B1D3}; + #\u{1B1D4}; + #\u{1B1D5}; + #\u{1B1D6}; + #\u{1B1D7}; + #\u{1B1D8}; + #\u{1B1D9}; + #\u{1B1DA}; + #\u{1B1DB}; + #\u{1B1DC}; + #\u{1B1DD}; + #\u{1B1DE}; + #\u{1B1DF}; + #\u{1B1E0}; + #\u{1B1E1}; + #\u{1B1E2}; + #\u{1B1E3}; + #\u{1B1E4}; + #\u{1B1E5}; + #\u{1B1E6}; + #\u{1B1E7}; + #\u{1B1E8}; + #\u{1B1E9}; + #\u{1B1EA}; + #\u{1B1EB}; + #\u{1B1EC}; + #\u{1B1ED}; + #\u{1B1EE}; + #\u{1B1EF}; + #\u{1B1F0}; + #\u{1B1F1}; + #\u{1B1F2}; + #\u{1B1F3}; + #\u{1B1F4}; + #\u{1B1F5}; + #\u{1B1F6}; + #\u{1B1F7}; + #\u{1B1F8}; + #\u{1B1F9}; + #\u{1B1FA}; + #\u{1B1FB}; + #\u{1B1FC}; + #\u{1B1FD}; + #\u{1B1FE}; + #\u{1B1FF}; + #\u{1B200}; + #\u{1B201}; + #\u{1B202}; + #\u{1B203}; + #\u{1B204}; + #\u{1B205}; + #\u{1B206}; + #\u{1B207}; + #\u{1B208}; + #\u{1B209}; + #\u{1B20A}; + #\u{1B20B}; + #\u{1B20C}; + #\u{1B20D}; + #\u{1B20E}; + #\u{1B20F}; + #\u{1B210}; + #\u{1B211}; + #\u{1B212}; + #\u{1B213}; + #\u{1B214}; + #\u{1B215}; + #\u{1B216}; + #\u{1B217}; + #\u{1B218}; + #\u{1B219}; + #\u{1B21A}; + #\u{1B21B}; + #\u{1B21C}; + #\u{1B21D}; + #\u{1B21E}; + #\u{1B21F}; + #\u{1B220}; + #\u{1B221}; + #\u{1B222}; + #\u{1B223}; + #\u{1B224}; + #\u{1B225}; + #\u{1B226}; + #\u{1B227}; + #\u{1B228}; + #\u{1B229}; + #\u{1B22A}; + #\u{1B22B}; + #\u{1B22C}; + #\u{1B22D}; + #\u{1B22E}; + #\u{1B22F}; + #\u{1B230}; + #\u{1B231}; + #\u{1B232}; + #\u{1B233}; + #\u{1B234}; + #\u{1B235}; + #\u{1B236}; + #\u{1B237}; + #\u{1B238}; + #\u{1B239}; + #\u{1B23A}; + #\u{1B23B}; + #\u{1B23C}; + #\u{1B23D}; + #\u{1B23E}; + #\u{1B23F}; + #\u{1B240}; + #\u{1B241}; + #\u{1B242}; + #\u{1B243}; + #\u{1B244}; + #\u{1B245}; + #\u{1B246}; + #\u{1B247}; + #\u{1B248}; + #\u{1B249}; + #\u{1B24A}; + #\u{1B24B}; + #\u{1B24C}; + #\u{1B24D}; + #\u{1B24E}; + #\u{1B24F}; + #\u{1B250}; + #\u{1B251}; + #\u{1B252}; + #\u{1B253}; + #\u{1B254}; + #\u{1B255}; + #\u{1B256}; + #\u{1B257}; + #\u{1B258}; + #\u{1B259}; + #\u{1B25A}; + #\u{1B25B}; + #\u{1B25C}; + #\u{1B25D}; + #\u{1B25E}; + #\u{1B25F}; + #\u{1B260}; + #\u{1B261}; + #\u{1B262}; + #\u{1B263}; + #\u{1B264}; + #\u{1B265}; + #\u{1B266}; + #\u{1B267}; + #\u{1B268}; + #\u{1B269}; + #\u{1B26A}; + #\u{1B26B}; + #\u{1B26C}; + #\u{1B26D}; + #\u{1B26E}; + #\u{1B26F}; + #\u{1B270}; + #\u{1B271}; + #\u{1B272}; + #\u{1B273}; + #\u{1B274}; + #\u{1B275}; + #\u{1B276}; + #\u{1B277}; + #\u{1B278}; + #\u{1B279}; + #\u{1B27A}; + #\u{1B27B}; + #\u{1B27C}; + #\u{1B27D}; + #\u{1B27E}; + #\u{1B27F}; + #\u{1B280}; + #\u{1B281}; + #\u{1B282}; + #\u{1B283}; + #\u{1B284}; + #\u{1B285}; + #\u{1B286}; + #\u{1B287}; + #\u{1B288}; + #\u{1B289}; + #\u{1B28A}; + #\u{1B28B}; + #\u{1B28C}; + #\u{1B28D}; + #\u{1B28E}; + #\u{1B28F}; + #\u{1B290}; + #\u{1B291}; + #\u{1B292}; + #\u{1B293}; + #\u{1B294}; + #\u{1B295}; + #\u{1B296}; + #\u{1B297}; + #\u{1B298}; + #\u{1B299}; + #\u{1B29A}; + #\u{1B29B}; + #\u{1B29C}; + #\u{1B29D}; + #\u{1B29E}; + #\u{1B29F}; + #\u{1B2A0}; + #\u{1B2A1}; + #\u{1B2A2}; + #\u{1B2A3}; + #\u{1B2A4}; + #\u{1B2A5}; + #\u{1B2A6}; + #\u{1B2A7}; + #\u{1B2A8}; + #\u{1B2A9}; + #\u{1B2AA}; + #\u{1B2AB}; + #\u{1B2AC}; + #\u{1B2AD}; + #\u{1B2AE}; + #\u{1B2AF}; + #\u{1B2B0}; + #\u{1B2B1}; + #\u{1B2B2}; + #\u{1B2B3}; + #\u{1B2B4}; + #\u{1B2B5}; + #\u{1B2B6}; + #\u{1B2B7}; + #\u{1B2B8}; + #\u{1B2B9}; + #\u{1B2BA}; + #\u{1B2BB}; + #\u{1B2BC}; + #\u{1B2BD}; + #\u{1B2BE}; + #\u{1B2BF}; + #\u{1B2C0}; + #\u{1B2C1}; + #\u{1B2C2}; + #\u{1B2C3}; + #\u{1B2C4}; + #\u{1B2C5}; + #\u{1B2C6}; + #\u{1B2C7}; + #\u{1B2C8}; + #\u{1B2C9}; + #\u{1B2CA}; + #\u{1B2CB}; + #\u{1B2CC}; + #\u{1B2CD}; + #\u{1B2CE}; + #\u{1B2CF}; + #\u{1B2D0}; + #\u{1B2D1}; + #\u{1B2D2}; + #\u{1B2D3}; + #\u{1B2D4}; + #\u{1B2D5}; + #\u{1B2D6}; + #\u{1B2D7}; + #\u{1B2D8}; + #\u{1B2D9}; + #\u{1B2DA}; + #\u{1B2DB}; + #\u{1B2DC}; + #\u{1B2DD}; + #\u{1B2DE}; + #\u{1B2DF}; + #\u{1B2E0}; + #\u{1B2E1}; + #\u{1B2E2}; + #\u{1B2E3}; + #\u{1B2E4}; + #\u{1B2E5}; + #\u{1B2E6}; + #\u{1B2E7}; + #\u{1B2E8}; + #\u{1B2E9}; + #\u{1B2EA}; + #\u{1B2EB}; + #\u{1B2EC}; + #\u{1B2ED}; + #\u{1B2EE}; + #\u{1B2EF}; + #\u{1B2F0}; + #\u{1B2F1}; + #\u{1B2F2}; + #\u{1B2F3}; + #\u{1B2F4}; + #\u{1B2F5}; + #\u{1B2F6}; + #\u{1B2F7}; + #\u{1B2F8}; + #\u{1B2F9}; + #\u{1B2FA}; + #\u{1B2FB}; + #\u{2CEB0}; + #\u{2CEB1}; + #\u{2CEB2}; + #\u{2CEB3}; + #\u{2CEB4}; + #\u{2CEB5}; + #\u{2CEB6}; + #\u{2CEB7}; + #\u{2CEB8}; + #\u{2CEB9}; + #\u{2CEBA}; + #\u{2CEBB}; + #\u{2CEBC}; + #\u{2CEBD}; + #\u{2CEBE}; + #\u{2CEBF}; + #\u{2CEC0}; + #\u{2CEC1}; + #\u{2CEC2}; + #\u{2CEC3}; + #\u{2CEC4}; + #\u{2CEC5}; + #\u{2CEC6}; + #\u{2CEC7}; + #\u{2CEC8}; + #\u{2CEC9}; + #\u{2CECA}; + #\u{2CECB}; + #\u{2CECC}; + #\u{2CECD}; + #\u{2CECE}; + #\u{2CECF}; + #\u{2CED0}; + #\u{2CED1}; + #\u{2CED2}; + #\u{2CED3}; + #\u{2CED4}; + #\u{2CED5}; + #\u{2CED6}; + #\u{2CED7}; + #\u{2CED8}; + #\u{2CED9}; + #\u{2CEDA}; + #\u{2CEDB}; + #\u{2CEDC}; + #\u{2CEDD}; + #\u{2CEDE}; + #\u{2CEDF}; + #\u{2CEE0}; + #\u{2CEE1}; + #\u{2CEE2}; + #\u{2CEE3}; + #\u{2CEE4}; + #\u{2CEE5}; + #\u{2CEE6}; + #\u{2CEE7}; + #\u{2CEE8}; + #\u{2CEE9}; + #\u{2CEEA}; + #\u{2CEEB}; + #\u{2CEEC}; + #\u{2CEED}; + #\u{2CEEE}; + #\u{2CEEF}; + #\u{2CEF0}; + #\u{2CEF1}; + #\u{2CEF2}; + #\u{2CEF3}; + #\u{2CEF4}; + #\u{2CEF5}; + #\u{2CEF6}; + #\u{2CEF7}; + #\u{2CEF8}; + #\u{2CEF9}; + #\u{2CEFA}; + #\u{2CEFB}; + #\u{2CEFC}; + #\u{2CEFD}; + #\u{2CEFE}; + #\u{2CEFF}; + #\u{2CF00}; + #\u{2CF01}; + #\u{2CF02}; + #\u{2CF03}; + #\u{2CF04}; + #\u{2CF05}; + #\u{2CF06}; + #\u{2CF07}; + #\u{2CF08}; + #\u{2CF09}; + #\u{2CF0A}; + #\u{2CF0B}; + #\u{2CF0C}; + #\u{2CF0D}; + #\u{2CF0E}; + #\u{2CF0F}; + #\u{2CF10}; + #\u{2CF11}; + #\u{2CF12}; + #\u{2CF13}; + #\u{2CF14}; + #\u{2CF15}; + #\u{2CF16}; + #\u{2CF17}; + #\u{2CF18}; + #\u{2CF19}; + #\u{2CF1A}; + #\u{2CF1B}; + #\u{2CF1C}; + #\u{2CF1D}; + #\u{2CF1E}; + #\u{2CF1F}; + #\u{2CF20}; + #\u{2CF21}; + #\u{2CF22}; + #\u{2CF23}; + #\u{2CF24}; + #\u{2CF25}; + #\u{2CF26}; + #\u{2CF27}; + #\u{2CF28}; + #\u{2CF29}; + #\u{2CF2A}; + #\u{2CF2B}; + #\u{2CF2C}; + #\u{2CF2D}; + #\u{2CF2E}; + #\u{2CF2F}; + #\u{2CF30}; + #\u{2CF31}; + #\u{2CF32}; + #\u{2CF33}; + #\u{2CF34}; + #\u{2CF35}; + #\u{2CF36}; + #\u{2CF37}; + #\u{2CF38}; + #\u{2CF39}; + #\u{2CF3A}; + #\u{2CF3B}; + #\u{2CF3C}; + #\u{2CF3D}; + #\u{2CF3E}; + #\u{2CF3F}; + #\u{2CF40}; + #\u{2CF41}; + #\u{2CF42}; + #\u{2CF43}; + #\u{2CF44}; + #\u{2CF45}; + #\u{2CF46}; + #\u{2CF47}; + #\u{2CF48}; + #\u{2CF49}; + #\u{2CF4A}; + #\u{2CF4B}; + #\u{2CF4C}; + #\u{2CF4D}; + #\u{2CF4E}; + #\u{2CF4F}; + #\u{2CF50}; + #\u{2CF51}; + #\u{2CF52}; + #\u{2CF53}; + #\u{2CF54}; + #\u{2CF55}; + #\u{2CF56}; + #\u{2CF57}; + #\u{2CF58}; + #\u{2CF59}; + #\u{2CF5A}; + #\u{2CF5B}; + #\u{2CF5C}; + #\u{2CF5D}; + #\u{2CF5E}; + #\u{2CF5F}; + #\u{2CF60}; + #\u{2CF61}; + #\u{2CF62}; + #\u{2CF63}; + #\u{2CF64}; + #\u{2CF65}; + #\u{2CF66}; + #\u{2CF67}; + #\u{2CF68}; + #\u{2CF69}; + #\u{2CF6A}; + #\u{2CF6B}; + #\u{2CF6C}; + #\u{2CF6D}; + #\u{2CF6E}; + #\u{2CF6F}; + #\u{2CF70}; + #\u{2CF71}; + #\u{2CF72}; + #\u{2CF73}; + #\u{2CF74}; + #\u{2CF75}; + #\u{2CF76}; + #\u{2CF77}; + #\u{2CF78}; + #\u{2CF79}; + #\u{2CF7A}; + #\u{2CF7B}; + #\u{2CF7C}; + #\u{2CF7D}; + #\u{2CF7E}; + #\u{2CF7F}; + #\u{2CF80}; + #\u{2CF81}; + #\u{2CF82}; + #\u{2CF83}; + #\u{2CF84}; + #\u{2CF85}; + #\u{2CF86}; + #\u{2CF87}; + #\u{2CF88}; + #\u{2CF89}; + #\u{2CF8A}; + #\u{2CF8B}; + #\u{2CF8C}; + #\u{2CF8D}; + #\u{2CF8E}; + #\u{2CF8F}; + #\u{2CF90}; + #\u{2CF91}; + #\u{2CF92}; + #\u{2CF93}; + #\u{2CF94}; + #\u{2CF95}; + #\u{2CF96}; + #\u{2CF97}; + #\u{2CF98}; + #\u{2CF99}; + #\u{2CF9A}; + #\u{2CF9B}; + #\u{2CF9C}; + #\u{2CF9D}; + #\u{2CF9E}; + #\u{2CF9F}; + #\u{2CFA0}; + #\u{2CFA1}; + #\u{2CFA2}; + #\u{2CFA3}; + #\u{2CFA4}; + #\u{2CFA5}; + #\u{2CFA6}; + #\u{2CFA7}; + #\u{2CFA8}; + #\u{2CFA9}; + #\u{2CFAA}; + #\u{2CFAB}; + #\u{2CFAC}; + #\u{2CFAD}; + #\u{2CFAE}; + #\u{2CFAF}; + #\u{2CFB0}; + #\u{2CFB1}; + #\u{2CFB2}; + #\u{2CFB3}; + #\u{2CFB4}; + #\u{2CFB5}; + #\u{2CFB6}; + #\u{2CFB7}; + #\u{2CFB8}; + #\u{2CFB9}; + #\u{2CFBA}; + #\u{2CFBB}; + #\u{2CFBC}; + #\u{2CFBD}; + #\u{2CFBE}; + #\u{2CFBF}; + #\u{2CFC0}; + #\u{2CFC1}; + #\u{2CFC2}; + #\u{2CFC3}; + #\u{2CFC4}; + #\u{2CFC5}; + #\u{2CFC6}; + #\u{2CFC7}; + #\u{2CFC8}; + #\u{2CFC9}; + #\u{2CFCA}; + #\u{2CFCB}; + #\u{2CFCC}; + #\u{2CFCD}; + #\u{2CFCE}; + #\u{2CFCF}; + #\u{2CFD0}; + #\u{2CFD1}; + #\u{2CFD2}; + #\u{2CFD3}; + #\u{2CFD4}; + #\u{2CFD5}; + #\u{2CFD6}; + #\u{2CFD7}; + #\u{2CFD8}; + #\u{2CFD9}; + #\u{2CFDA}; + #\u{2CFDB}; + #\u{2CFDC}; + #\u{2CFDD}; + #\u{2CFDE}; + #\u{2CFDF}; + #\u{2CFE0}; + #\u{2CFE1}; + #\u{2CFE2}; + #\u{2CFE3}; + #\u{2CFE4}; + #\u{2CFE5}; + #\u{2CFE6}; + #\u{2CFE7}; + #\u{2CFE8}; + #\u{2CFE9}; + #\u{2CFEA}; + #\u{2CFEB}; + #\u{2CFEC}; + #\u{2CFED}; + #\u{2CFEE}; + #\u{2CFEF}; + #\u{2CFF0}; + #\u{2CFF1}; + #\u{2CFF2}; + #\u{2CFF3}; + #\u{2CFF4}; + #\u{2CFF5}; + #\u{2CFF6}; + #\u{2CFF7}; + #\u{2CFF8}; + #\u{2CFF9}; + #\u{2CFFA}; + #\u{2CFFB}; + #\u{2CFFC}; + #\u{2CFFD}; + #\u{2CFFE}; + #\u{2CFFF}; + #\u{2D000}; + #\u{2D001}; + #\u{2D002}; + #\u{2D003}; + #\u{2D004}; + #\u{2D005}; + #\u{2D006}; + #\u{2D007}; + #\u{2D008}; + #\u{2D009}; + #\u{2D00A}; + #\u{2D00B}; + #\u{2D00C}; + #\u{2D00D}; + #\u{2D00E}; + #\u{2D00F}; + #\u{2D010}; + #\u{2D011}; + #\u{2D012}; + #\u{2D013}; + #\u{2D014}; + #\u{2D015}; + #\u{2D016}; + #\u{2D017}; + #\u{2D018}; + #\u{2D019}; + #\u{2D01A}; + #\u{2D01B}; + #\u{2D01C}; + #\u{2D01D}; + #\u{2D01E}; + #\u{2D01F}; + #\u{2D020}; + #\u{2D021}; + #\u{2D022}; + #\u{2D023}; + #\u{2D024}; + #\u{2D025}; + #\u{2D026}; + #\u{2D027}; + #\u{2D028}; + #\u{2D029}; + #\u{2D02A}; + #\u{2D02B}; + #\u{2D02C}; + #\u{2D02D}; + #\u{2D02E}; + #\u{2D02F}; + #\u{2D030}; + #\u{2D031}; + #\u{2D032}; + #\u{2D033}; + #\u{2D034}; + #\u{2D035}; + #\u{2D036}; + #\u{2D037}; + #\u{2D038}; + #\u{2D039}; + #\u{2D03A}; + #\u{2D03B}; + #\u{2D03C}; + #\u{2D03D}; + #\u{2D03E}; + #\u{2D03F}; + #\u{2D040}; + #\u{2D041}; + #\u{2D042}; + #\u{2D043}; + #\u{2D044}; + #\u{2D045}; + #\u{2D046}; + #\u{2D047}; + #\u{2D048}; + #\u{2D049}; + #\u{2D04A}; + #\u{2D04B}; + #\u{2D04C}; + #\u{2D04D}; + #\u{2D04E}; + #\u{2D04F}; + #\u{2D050}; + #\u{2D051}; + #\u{2D052}; + #\u{2D053}; + #\u{2D054}; + #\u{2D055}; + #\u{2D056}; + #\u{2D057}; + #\u{2D058}; + #\u{2D059}; + #\u{2D05A}; + #\u{2D05B}; + #\u{2D05C}; + #\u{2D05D}; + #\u{2D05E}; + #\u{2D05F}; + #\u{2D060}; + #\u{2D061}; + #\u{2D062}; + #\u{2D063}; + #\u{2D064}; + #\u{2D065}; + #\u{2D066}; + #\u{2D067}; + #\u{2D068}; + #\u{2D069}; + #\u{2D06A}; + #\u{2D06B}; + #\u{2D06C}; + #\u{2D06D}; + #\u{2D06E}; + #\u{2D06F}; + #\u{2D070}; + #\u{2D071}; + #\u{2D072}; + #\u{2D073}; + #\u{2D074}; + #\u{2D075}; + #\u{2D076}; + #\u{2D077}; + #\u{2D078}; + #\u{2D079}; + #\u{2D07A}; + #\u{2D07B}; + #\u{2D07C}; + #\u{2D07D}; + #\u{2D07E}; + #\u{2D07F}; + #\u{2D080}; + #\u{2D081}; + #\u{2D082}; + #\u{2D083}; + #\u{2D084}; + #\u{2D085}; + #\u{2D086}; + #\u{2D087}; + #\u{2D088}; + #\u{2D089}; + #\u{2D08A}; + #\u{2D08B}; + #\u{2D08C}; + #\u{2D08D}; + #\u{2D08E}; + #\u{2D08F}; + #\u{2D090}; + #\u{2D091}; + #\u{2D092}; + #\u{2D093}; + #\u{2D094}; + #\u{2D095}; + #\u{2D096}; + #\u{2D097}; + #\u{2D098}; + #\u{2D099}; + #\u{2D09A}; + #\u{2D09B}; + #\u{2D09C}; + #\u{2D09D}; + #\u{2D09E}; + #\u{2D09F}; + #\u{2D0A0}; + #\u{2D0A1}; + #\u{2D0A2}; + #\u{2D0A3}; + #\u{2D0A4}; + #\u{2D0A5}; + #\u{2D0A6}; + #\u{2D0A7}; + #\u{2D0A8}; + #\u{2D0A9}; + #\u{2D0AA}; + #\u{2D0AB}; + #\u{2D0AC}; + #\u{2D0AD}; + #\u{2D0AE}; + #\u{2D0AF}; + #\u{2D0B0}; + #\u{2D0B1}; + #\u{2D0B2}; + #\u{2D0B3}; + #\u{2D0B4}; + #\u{2D0B5}; + #\u{2D0B6}; + #\u{2D0B7}; + #\u{2D0B8}; + #\u{2D0B9}; + #\u{2D0BA}; + #\u{2D0BB}; + #\u{2D0BC}; + #\u{2D0BD}; + #\u{2D0BE}; + #\u{2D0BF}; + #\u{2D0C0}; + #\u{2D0C1}; + #\u{2D0C2}; + #\u{2D0C3}; + #\u{2D0C4}; + #\u{2D0C5}; + #\u{2D0C6}; + #\u{2D0C7}; + #\u{2D0C8}; + #\u{2D0C9}; + #\u{2D0CA}; + #\u{2D0CB}; + #\u{2D0CC}; + #\u{2D0CD}; + #\u{2D0CE}; + #\u{2D0CF}; + #\u{2D0D0}; + #\u{2D0D1}; + #\u{2D0D2}; + #\u{2D0D3}; + #\u{2D0D4}; + #\u{2D0D5}; + #\u{2D0D6}; + #\u{2D0D7}; + #\u{2D0D8}; + #\u{2D0D9}; + #\u{2D0DA}; + #\u{2D0DB}; + #\u{2D0DC}; + #\u{2D0DD}; + #\u{2D0DE}; + #\u{2D0DF}; + #\u{2D0E0}; + #\u{2D0E1}; + #\u{2D0E2}; + #\u{2D0E3}; + #\u{2D0E4}; + #\u{2D0E5}; + #\u{2D0E6}; + #\u{2D0E7}; + #\u{2D0E8}; + #\u{2D0E9}; + #\u{2D0EA}; + #\u{2D0EB}; + #\u{2D0EC}; + #\u{2D0ED}; + #\u{2D0EE}; + #\u{2D0EF}; + #\u{2D0F0}; + #\u{2D0F1}; + #\u{2D0F2}; + #\u{2D0F3}; + #\u{2D0F4}; + #\u{2D0F5}; + #\u{2D0F6}; + #\u{2D0F7}; + #\u{2D0F8}; + #\u{2D0F9}; + #\u{2D0FA}; + #\u{2D0FB}; + #\u{2D0FC}; + #\u{2D0FD}; + #\u{2D0FE}; + #\u{2D0FF}; + #\u{2D100}; + #\u{2D101}; + #\u{2D102}; + #\u{2D103}; + #\u{2D104}; + #\u{2D105}; + #\u{2D106}; + #\u{2D107}; + #\u{2D108}; + #\u{2D109}; + #\u{2D10A}; + #\u{2D10B}; + #\u{2D10C}; + #\u{2D10D}; + #\u{2D10E}; + #\u{2D10F}; + #\u{2D110}; + #\u{2D111}; + #\u{2D112}; + #\u{2D113}; + #\u{2D114}; + #\u{2D115}; + #\u{2D116}; + #\u{2D117}; + #\u{2D118}; + #\u{2D119}; + #\u{2D11A}; + #\u{2D11B}; + #\u{2D11C}; + #\u{2D11D}; + #\u{2D11E}; + #\u{2D11F}; + #\u{2D120}; + #\u{2D121}; + #\u{2D122}; + #\u{2D123}; + #\u{2D124}; + #\u{2D125}; + #\u{2D126}; + #\u{2D127}; + #\u{2D128}; + #\u{2D129}; + #\u{2D12A}; + #\u{2D12B}; + #\u{2D12C}; + #\u{2D12D}; + #\u{2D12E}; + #\u{2D12F}; + #\u{2D130}; + #\u{2D131}; + #\u{2D132}; + #\u{2D133}; + #\u{2D134}; + #\u{2D135}; + #\u{2D136}; + #\u{2D137}; + #\u{2D138}; + #\u{2D139}; + #\u{2D13A}; + #\u{2D13B}; + #\u{2D13C}; + #\u{2D13D}; + #\u{2D13E}; + #\u{2D13F}; + #\u{2D140}; + #\u{2D141}; + #\u{2D142}; + #\u{2D143}; + #\u{2D144}; + #\u{2D145}; + #\u{2D146}; + #\u{2D147}; + #\u{2D148}; + #\u{2D149}; + #\u{2D14A}; + #\u{2D14B}; + #\u{2D14C}; + #\u{2D14D}; + #\u{2D14E}; + #\u{2D14F}; + #\u{2D150}; + #\u{2D151}; + #\u{2D152}; + #\u{2D153}; + #\u{2D154}; + #\u{2D155}; + #\u{2D156}; + #\u{2D157}; + #\u{2D158}; + #\u{2D159}; + #\u{2D15A}; + #\u{2D15B}; + #\u{2D15C}; + #\u{2D15D}; + #\u{2D15E}; + #\u{2D15F}; + #\u{2D160}; + #\u{2D161}; + #\u{2D162}; + #\u{2D163}; + #\u{2D164}; + #\u{2D165}; + #\u{2D166}; + #\u{2D167}; + #\u{2D168}; + #\u{2D169}; + #\u{2D16A}; + #\u{2D16B}; + #\u{2D16C}; + #\u{2D16D}; + #\u{2D16E}; + #\u{2D16F}; + #\u{2D170}; + #\u{2D171}; + #\u{2D172}; + #\u{2D173}; + #\u{2D174}; + #\u{2D175}; + #\u{2D176}; + #\u{2D177}; + #\u{2D178}; + #\u{2D179}; + #\u{2D17A}; + #\u{2D17B}; + #\u{2D17C}; + #\u{2D17D}; + #\u{2D17E}; + #\u{2D17F}; + #\u{2D180}; + #\u{2D181}; + #\u{2D182}; + #\u{2D183}; + #\u{2D184}; + #\u{2D185}; + #\u{2D186}; + #\u{2D187}; + #\u{2D188}; + #\u{2D189}; + #\u{2D18A}; + #\u{2D18B}; + #\u{2D18C}; + #\u{2D18D}; + #\u{2D18E}; + #\u{2D18F}; + #\u{2D190}; + #\u{2D191}; + #\u{2D192}; + #\u{2D193}; + #\u{2D194}; + #\u{2D195}; + #\u{2D196}; + #\u{2D197}; + #\u{2D198}; + #\u{2D199}; + #\u{2D19A}; + #\u{2D19B}; + #\u{2D19C}; + #\u{2D19D}; + #\u{2D19E}; + #\u{2D19F}; + #\u{2D1A0}; + #\u{2D1A1}; + #\u{2D1A2}; + #\u{2D1A3}; + #\u{2D1A4}; + #\u{2D1A5}; + #\u{2D1A6}; + #\u{2D1A7}; + #\u{2D1A8}; + #\u{2D1A9}; + #\u{2D1AA}; + #\u{2D1AB}; + #\u{2D1AC}; + #\u{2D1AD}; + #\u{2D1AE}; + #\u{2D1AF}; + #\u{2D1B0}; + #\u{2D1B1}; + #\u{2D1B2}; + #\u{2D1B3}; + #\u{2D1B4}; + #\u{2D1B5}; + #\u{2D1B6}; + #\u{2D1B7}; + #\u{2D1B8}; + #\u{2D1B9}; + #\u{2D1BA}; + #\u{2D1BB}; + #\u{2D1BC}; + #\u{2D1BD}; + #\u{2D1BE}; + #\u{2D1BF}; + #\u{2D1C0}; + #\u{2D1C1}; + #\u{2D1C2}; + #\u{2D1C3}; + #\u{2D1C4}; + #\u{2D1C5}; + #\u{2D1C6}; + #\u{2D1C7}; + #\u{2D1C8}; + #\u{2D1C9}; + #\u{2D1CA}; + #\u{2D1CB}; + #\u{2D1CC}; + #\u{2D1CD}; + #\u{2D1CE}; + #\u{2D1CF}; + #\u{2D1D0}; + #\u{2D1D1}; + #\u{2D1D2}; + #\u{2D1D3}; + #\u{2D1D4}; + #\u{2D1D5}; + #\u{2D1D6}; + #\u{2D1D7}; + #\u{2D1D8}; + #\u{2D1D9}; + #\u{2D1DA}; + #\u{2D1DB}; + #\u{2D1DC}; + #\u{2D1DD}; + #\u{2D1DE}; + #\u{2D1DF}; + #\u{2D1E0}; + #\u{2D1E1}; + #\u{2D1E2}; + #\u{2D1E3}; + #\u{2D1E4}; + #\u{2D1E5}; + #\u{2D1E6}; + #\u{2D1E7}; + #\u{2D1E8}; + #\u{2D1E9}; + #\u{2D1EA}; + #\u{2D1EB}; + #\u{2D1EC}; + #\u{2D1ED}; + #\u{2D1EE}; + #\u{2D1EF}; + #\u{2D1F0}; + #\u{2D1F1}; + #\u{2D1F2}; + #\u{2D1F3}; + #\u{2D1F4}; + #\u{2D1F5}; + #\u{2D1F6}; + #\u{2D1F7}; + #\u{2D1F8}; + #\u{2D1F9}; + #\u{2D1FA}; + #\u{2D1FB}; + #\u{2D1FC}; + #\u{2D1FD}; + #\u{2D1FE}; + #\u{2D1FF}; + #\u{2D200}; + #\u{2D201}; + #\u{2D202}; + #\u{2D203}; + #\u{2D204}; + #\u{2D205}; + #\u{2D206}; + #\u{2D207}; + #\u{2D208}; + #\u{2D209}; + #\u{2D20A}; + #\u{2D20B}; + #\u{2D20C}; + #\u{2D20D}; + #\u{2D20E}; + #\u{2D20F}; + #\u{2D210}; + #\u{2D211}; + #\u{2D212}; + #\u{2D213}; + #\u{2D214}; + #\u{2D215}; + #\u{2D216}; + #\u{2D217}; + #\u{2D218}; + #\u{2D219}; + #\u{2D21A}; + #\u{2D21B}; + #\u{2D21C}; + #\u{2D21D}; + #\u{2D21E}; + #\u{2D21F}; + #\u{2D220}; + #\u{2D221}; + #\u{2D222}; + #\u{2D223}; + #\u{2D224}; + #\u{2D225}; + #\u{2D226}; + #\u{2D227}; + #\u{2D228}; + #\u{2D229}; + #\u{2D22A}; + #\u{2D22B}; + #\u{2D22C}; + #\u{2D22D}; + #\u{2D22E}; + #\u{2D22F}; + #\u{2D230}; + #\u{2D231}; + #\u{2D232}; + #\u{2D233}; + #\u{2D234}; + #\u{2D235}; + #\u{2D236}; + #\u{2D237}; + #\u{2D238}; + #\u{2D239}; + #\u{2D23A}; + #\u{2D23B}; + #\u{2D23C}; + #\u{2D23D}; + #\u{2D23E}; + #\u{2D23F}; + #\u{2D240}; + #\u{2D241}; + #\u{2D242}; + #\u{2D243}; + #\u{2D244}; + #\u{2D245}; + #\u{2D246}; + #\u{2D247}; + #\u{2D248}; + #\u{2D249}; + #\u{2D24A}; + #\u{2D24B}; + #\u{2D24C}; + #\u{2D24D}; + #\u{2D24E}; + #\u{2D24F}; + #\u{2D250}; + #\u{2D251}; + #\u{2D252}; + #\u{2D253}; + #\u{2D254}; + #\u{2D255}; + #\u{2D256}; + #\u{2D257}; + #\u{2D258}; + #\u{2D259}; + #\u{2D25A}; + #\u{2D25B}; + #\u{2D25C}; + #\u{2D25D}; + #\u{2D25E}; + #\u{2D25F}; + #\u{2D260}; + #\u{2D261}; + #\u{2D262}; + #\u{2D263}; + #\u{2D264}; + #\u{2D265}; + #\u{2D266}; + #\u{2D267}; + #\u{2D268}; + #\u{2D269}; + #\u{2D26A}; + #\u{2D26B}; + #\u{2D26C}; + #\u{2D26D}; + #\u{2D26E}; + #\u{2D26F}; + #\u{2D270}; + #\u{2D271}; + #\u{2D272}; + #\u{2D273}; + #\u{2D274}; + #\u{2D275}; + #\u{2D276}; + #\u{2D277}; + #\u{2D278}; + #\u{2D279}; + #\u{2D27A}; + #\u{2D27B}; + #\u{2D27C}; + #\u{2D27D}; + #\u{2D27E}; + #\u{2D27F}; + #\u{2D280}; + #\u{2D281}; + #\u{2D282}; + #\u{2D283}; + #\u{2D284}; + #\u{2D285}; + #\u{2D286}; + #\u{2D287}; + #\u{2D288}; + #\u{2D289}; + #\u{2D28A}; + #\u{2D28B}; + #\u{2D28C}; + #\u{2D28D}; + #\u{2D28E}; + #\u{2D28F}; + #\u{2D290}; + #\u{2D291}; + #\u{2D292}; + #\u{2D293}; + #\u{2D294}; + #\u{2D295}; + #\u{2D296}; + #\u{2D297}; + #\u{2D298}; + #\u{2D299}; + #\u{2D29A}; + #\u{2D29B}; + #\u{2D29C}; + #\u{2D29D}; + #\u{2D29E}; + #\u{2D29F}; + #\u{2D2A0}; + #\u{2D2A1}; + #\u{2D2A2}; + #\u{2D2A3}; + #\u{2D2A4}; + #\u{2D2A5}; + #\u{2D2A6}; + #\u{2D2A7}; + #\u{2D2A8}; + #\u{2D2A9}; + #\u{2D2AA}; + #\u{2D2AB}; + #\u{2D2AC}; + #\u{2D2AD}; + #\u{2D2AE}; + #\u{2D2AF}; + #\u{2D2B0}; + #\u{2D2B1}; + #\u{2D2B2}; + #\u{2D2B3}; + #\u{2D2B4}; + #\u{2D2B5}; + #\u{2D2B6}; + #\u{2D2B7}; + #\u{2D2B8}; + #\u{2D2B9}; + #\u{2D2BA}; + #\u{2D2BB}; + #\u{2D2BC}; + #\u{2D2BD}; + #\u{2D2BE}; + #\u{2D2BF}; + #\u{2D2C0}; + #\u{2D2C1}; + #\u{2D2C2}; + #\u{2D2C3}; + #\u{2D2C4}; + #\u{2D2C5}; + #\u{2D2C6}; + #\u{2D2C7}; + #\u{2D2C8}; + #\u{2D2C9}; + #\u{2D2CA}; + #\u{2D2CB}; + #\u{2D2CC}; + #\u{2D2CD}; + #\u{2D2CE}; + #\u{2D2CF}; + #\u{2D2D0}; + #\u{2D2D1}; + #\u{2D2D2}; + #\u{2D2D3}; + #\u{2D2D4}; + #\u{2D2D5}; + #\u{2D2D6}; + #\u{2D2D7}; + #\u{2D2D8}; + #\u{2D2D9}; + #\u{2D2DA}; + #\u{2D2DB}; + #\u{2D2DC}; + #\u{2D2DD}; + #\u{2D2DE}; + #\u{2D2DF}; + #\u{2D2E0}; + #\u{2D2E1}; + #\u{2D2E2}; + #\u{2D2E3}; + #\u{2D2E4}; + #\u{2D2E5}; + #\u{2D2E6}; + #\u{2D2E7}; + #\u{2D2E8}; + #\u{2D2E9}; + #\u{2D2EA}; + #\u{2D2EB}; + #\u{2D2EC}; + #\u{2D2ED}; + #\u{2D2EE}; + #\u{2D2EF}; + #\u{2D2F0}; + #\u{2D2F1}; + #\u{2D2F2}; + #\u{2D2F3}; + #\u{2D2F4}; + #\u{2D2F5}; + #\u{2D2F6}; + #\u{2D2F7}; + #\u{2D2F8}; + #\u{2D2F9}; + #\u{2D2FA}; + #\u{2D2FB}; + #\u{2D2FC}; + #\u{2D2FD}; + #\u{2D2FE}; + #\u{2D2FF}; + #\u{2D300}; + #\u{2D301}; + #\u{2D302}; + #\u{2D303}; + #\u{2D304}; + #\u{2D305}; + #\u{2D306}; + #\u{2D307}; + #\u{2D308}; + #\u{2D309}; + #\u{2D30A}; + #\u{2D30B}; + #\u{2D30C}; + #\u{2D30D}; + #\u{2D30E}; + #\u{2D30F}; + #\u{2D310}; + #\u{2D311}; + #\u{2D312}; + #\u{2D313}; + #\u{2D314}; + #\u{2D315}; + #\u{2D316}; + #\u{2D317}; + #\u{2D318}; + #\u{2D319}; + #\u{2D31A}; + #\u{2D31B}; + #\u{2D31C}; + #\u{2D31D}; + #\u{2D31E}; + #\u{2D31F}; + #\u{2D320}; + #\u{2D321}; + #\u{2D322}; + #\u{2D323}; + #\u{2D324}; + #\u{2D325}; + #\u{2D326}; + #\u{2D327}; + #\u{2D328}; + #\u{2D329}; + #\u{2D32A}; + #\u{2D32B}; + #\u{2D32C}; + #\u{2D32D}; + #\u{2D32E}; + #\u{2D32F}; + #\u{2D330}; + #\u{2D331}; + #\u{2D332}; + #\u{2D333}; + #\u{2D334}; + #\u{2D335}; + #\u{2D336}; + #\u{2D337}; + #\u{2D338}; + #\u{2D339}; + #\u{2D33A}; + #\u{2D33B}; + #\u{2D33C}; + #\u{2D33D}; + #\u{2D33E}; + #\u{2D33F}; + #\u{2D340}; + #\u{2D341}; + #\u{2D342}; + #\u{2D343}; + #\u{2D344}; + #\u{2D345}; + #\u{2D346}; + #\u{2D347}; + #\u{2D348}; + #\u{2D349}; + #\u{2D34A}; + #\u{2D34B}; + #\u{2D34C}; + #\u{2D34D}; + #\u{2D34E}; + #\u{2D34F}; + #\u{2D350}; + #\u{2D351}; + #\u{2D352}; + #\u{2D353}; + #\u{2D354}; + #\u{2D355}; + #\u{2D356}; + #\u{2D357}; + #\u{2D358}; + #\u{2D359}; + #\u{2D35A}; + #\u{2D35B}; + #\u{2D35C}; + #\u{2D35D}; + #\u{2D35E}; + #\u{2D35F}; + #\u{2D360}; + #\u{2D361}; + #\u{2D362}; + #\u{2D363}; + #\u{2D364}; + #\u{2D365}; + #\u{2D366}; + #\u{2D367}; + #\u{2D368}; + #\u{2D369}; + #\u{2D36A}; + #\u{2D36B}; + #\u{2D36C}; + #\u{2D36D}; + #\u{2D36E}; + #\u{2D36F}; + #\u{2D370}; + #\u{2D371}; + #\u{2D372}; + #\u{2D373}; + #\u{2D374}; + #\u{2D375}; + #\u{2D376}; + #\u{2D377}; + #\u{2D378}; + #\u{2D379}; + #\u{2D37A}; + #\u{2D37B}; + #\u{2D37C}; + #\u{2D37D}; + #\u{2D37E}; + #\u{2D37F}; + #\u{2D380}; + #\u{2D381}; + #\u{2D382}; + #\u{2D383}; + #\u{2D384}; + #\u{2D385}; + #\u{2D386}; + #\u{2D387}; + #\u{2D388}; + #\u{2D389}; + #\u{2D38A}; + #\u{2D38B}; + #\u{2D38C}; + #\u{2D38D}; + #\u{2D38E}; + #\u{2D38F}; + #\u{2D390}; + #\u{2D391}; + #\u{2D392}; + #\u{2D393}; + #\u{2D394}; + #\u{2D395}; + #\u{2D396}; + #\u{2D397}; + #\u{2D398}; + #\u{2D399}; + #\u{2D39A}; + #\u{2D39B}; + #\u{2D39C}; + #\u{2D39D}; + #\u{2D39E}; + #\u{2D39F}; + #\u{2D3A0}; + #\u{2D3A1}; + #\u{2D3A2}; + #\u{2D3A3}; + #\u{2D3A4}; + #\u{2D3A5}; + #\u{2D3A6}; + #\u{2D3A7}; + #\u{2D3A8}; + #\u{2D3A9}; + #\u{2D3AA}; + #\u{2D3AB}; + #\u{2D3AC}; + #\u{2D3AD}; + #\u{2D3AE}; + #\u{2D3AF}; + #\u{2D3B0}; + #\u{2D3B1}; + #\u{2D3B2}; + #\u{2D3B3}; + #\u{2D3B4}; + #\u{2D3B5}; + #\u{2D3B6}; + #\u{2D3B7}; + #\u{2D3B8}; + #\u{2D3B9}; + #\u{2D3BA}; + #\u{2D3BB}; + #\u{2D3BC}; + #\u{2D3BD}; + #\u{2D3BE}; + #\u{2D3BF}; + #\u{2D3C0}; + #\u{2D3C1}; + #\u{2D3C2}; + #\u{2D3C3}; + #\u{2D3C4}; + #\u{2D3C5}; + #\u{2D3C6}; + #\u{2D3C7}; + #\u{2D3C8}; + #\u{2D3C9}; + #\u{2D3CA}; + #\u{2D3CB}; + #\u{2D3CC}; + #\u{2D3CD}; + #\u{2D3CE}; + #\u{2D3CF}; + #\u{2D3D0}; + #\u{2D3D1}; + #\u{2D3D2}; + #\u{2D3D3}; + #\u{2D3D4}; + #\u{2D3D5}; + #\u{2D3D6}; + #\u{2D3D7}; + #\u{2D3D8}; + #\u{2D3D9}; + #\u{2D3DA}; + #\u{2D3DB}; + #\u{2D3DC}; + #\u{2D3DD}; + #\u{2D3DE}; + #\u{2D3DF}; + #\u{2D3E0}; + #\u{2D3E1}; + #\u{2D3E2}; + #\u{2D3E3}; + #\u{2D3E4}; + #\u{2D3E5}; + #\u{2D3E6}; + #\u{2D3E7}; + #\u{2D3E8}; + #\u{2D3E9}; + #\u{2D3EA}; + #\u{2D3EB}; + #\u{2D3EC}; + #\u{2D3ED}; + #\u{2D3EE}; + #\u{2D3EF}; + #\u{2D3F0}; + #\u{2D3F1}; + #\u{2D3F2}; + #\u{2D3F3}; + #\u{2D3F4}; + #\u{2D3F5}; + #\u{2D3F6}; + #\u{2D3F7}; + #\u{2D3F8}; + #\u{2D3F9}; + #\u{2D3FA}; + #\u{2D3FB}; + #\u{2D3FC}; + #\u{2D3FD}; + #\u{2D3FE}; + #\u{2D3FF}; + #\u{2D400}; + #\u{2D401}; + #\u{2D402}; + #\u{2D403}; + #\u{2D404}; + #\u{2D405}; + #\u{2D406}; + #\u{2D407}; + #\u{2D408}; + #\u{2D409}; + #\u{2D40A}; + #\u{2D40B}; + #\u{2D40C}; + #\u{2D40D}; + #\u{2D40E}; + #\u{2D40F}; + #\u{2D410}; + #\u{2D411}; + #\u{2D412}; + #\u{2D413}; + #\u{2D414}; + #\u{2D415}; + #\u{2D416}; + #\u{2D417}; + #\u{2D418}; + #\u{2D419}; + #\u{2D41A}; + #\u{2D41B}; + #\u{2D41C}; + #\u{2D41D}; + #\u{2D41E}; + #\u{2D41F}; + #\u{2D420}; + #\u{2D421}; + #\u{2D422}; + #\u{2D423}; + #\u{2D424}; + #\u{2D425}; + #\u{2D426}; + #\u{2D427}; + #\u{2D428}; + #\u{2D429}; + #\u{2D42A}; + #\u{2D42B}; + #\u{2D42C}; + #\u{2D42D}; + #\u{2D42E}; + #\u{2D42F}; + #\u{2D430}; + #\u{2D431}; + #\u{2D432}; + #\u{2D433}; + #\u{2D434}; + #\u{2D435}; + #\u{2D436}; + #\u{2D437}; + #\u{2D438}; + #\u{2D439}; + #\u{2D43A}; + #\u{2D43B}; + #\u{2D43C}; + #\u{2D43D}; + #\u{2D43E}; + #\u{2D43F}; + #\u{2D440}; + #\u{2D441}; + #\u{2D442}; + #\u{2D443}; + #\u{2D444}; + #\u{2D445}; + #\u{2D446}; + #\u{2D447}; + #\u{2D448}; + #\u{2D449}; + #\u{2D44A}; + #\u{2D44B}; + #\u{2D44C}; + #\u{2D44D}; + #\u{2D44E}; + #\u{2D44F}; + #\u{2D450}; + #\u{2D451}; + #\u{2D452}; + #\u{2D453}; + #\u{2D454}; + #\u{2D455}; + #\u{2D456}; + #\u{2D457}; + #\u{2D458}; + #\u{2D459}; + #\u{2D45A}; + #\u{2D45B}; + #\u{2D45C}; + #\u{2D45D}; + #\u{2D45E}; + #\u{2D45F}; + #\u{2D460}; + #\u{2D461}; + #\u{2D462}; + #\u{2D463}; + #\u{2D464}; + #\u{2D465}; + #\u{2D466}; + #\u{2D467}; + #\u{2D468}; + #\u{2D469}; + #\u{2D46A}; + #\u{2D46B}; + #\u{2D46C}; + #\u{2D46D}; + #\u{2D46E}; + #\u{2D46F}; + #\u{2D470}; + #\u{2D471}; + #\u{2D472}; + #\u{2D473}; + #\u{2D474}; + #\u{2D475}; + #\u{2D476}; + #\u{2D477}; + #\u{2D478}; + #\u{2D479}; + #\u{2D47A}; + #\u{2D47B}; + #\u{2D47C}; + #\u{2D47D}; + #\u{2D47E}; + #\u{2D47F}; + #\u{2D480}; + #\u{2D481}; + #\u{2D482}; + #\u{2D483}; + #\u{2D484}; + #\u{2D485}; + #\u{2D486}; + #\u{2D487}; + #\u{2D488}; + #\u{2D489}; + #\u{2D48A}; + #\u{2D48B}; + #\u{2D48C}; + #\u{2D48D}; + #\u{2D48E}; + #\u{2D48F}; + #\u{2D490}; + #\u{2D491}; + #\u{2D492}; + #\u{2D493}; + #\u{2D494}; + #\u{2D495}; + #\u{2D496}; + #\u{2D497}; + #\u{2D498}; + #\u{2D499}; + #\u{2D49A}; + #\u{2D49B}; + #\u{2D49C}; + #\u{2D49D}; + #\u{2D49E}; + #\u{2D49F}; + #\u{2D4A0}; + #\u{2D4A1}; + #\u{2D4A2}; + #\u{2D4A3}; + #\u{2D4A4}; + #\u{2D4A5}; + #\u{2D4A6}; + #\u{2D4A7}; + #\u{2D4A8}; + #\u{2D4A9}; + #\u{2D4AA}; + #\u{2D4AB}; + #\u{2D4AC}; + #\u{2D4AD}; + #\u{2D4AE}; + #\u{2D4AF}; + #\u{2D4B0}; + #\u{2D4B1}; + #\u{2D4B2}; + #\u{2D4B3}; + #\u{2D4B4}; + #\u{2D4B5}; + #\u{2D4B6}; + #\u{2D4B7}; + #\u{2D4B8}; + #\u{2D4B9}; + #\u{2D4BA}; + #\u{2D4BB}; + #\u{2D4BC}; + #\u{2D4BD}; + #\u{2D4BE}; + #\u{2D4BF}; + #\u{2D4C0}; + #\u{2D4C1}; + #\u{2D4C2}; + #\u{2D4C3}; + #\u{2D4C4}; + #\u{2D4C5}; + #\u{2D4C6}; + #\u{2D4C7}; + #\u{2D4C8}; + #\u{2D4C9}; + #\u{2D4CA}; + #\u{2D4CB}; + #\u{2D4CC}; + #\u{2D4CD}; + #\u{2D4CE}; + #\u{2D4CF}; + #\u{2D4D0}; + #\u{2D4D1}; + #\u{2D4D2}; + #\u{2D4D3}; + #\u{2D4D4}; + #\u{2D4D5}; + #\u{2D4D6}; + #\u{2D4D7}; + #\u{2D4D8}; + #\u{2D4D9}; + #\u{2D4DA}; + #\u{2D4DB}; + #\u{2D4DC}; + #\u{2D4DD}; + #\u{2D4DE}; + #\u{2D4DF}; + #\u{2D4E0}; + #\u{2D4E1}; + #\u{2D4E2}; + #\u{2D4E3}; + #\u{2D4E4}; + #\u{2D4E5}; + #\u{2D4E6}; + #\u{2D4E7}; + #\u{2D4E8}; + #\u{2D4E9}; + #\u{2D4EA}; + #\u{2D4EB}; + #\u{2D4EC}; + #\u{2D4ED}; + #\u{2D4EE}; + #\u{2D4EF}; + #\u{2D4F0}; + #\u{2D4F1}; + #\u{2D4F2}; + #\u{2D4F3}; + #\u{2D4F4}; + #\u{2D4F5}; + #\u{2D4F6}; + #\u{2D4F7}; + #\u{2D4F8}; + #\u{2D4F9}; + #\u{2D4FA}; + #\u{2D4FB}; + #\u{2D4FC}; + #\u{2D4FD}; + #\u{2D4FE}; + #\u{2D4FF}; + #\u{2D500}; + #\u{2D501}; + #\u{2D502}; + #\u{2D503}; + #\u{2D504}; + #\u{2D505}; + #\u{2D506}; + #\u{2D507}; + #\u{2D508}; + #\u{2D509}; + #\u{2D50A}; + #\u{2D50B}; + #\u{2D50C}; + #\u{2D50D}; + #\u{2D50E}; + #\u{2D50F}; + #\u{2D510}; + #\u{2D511}; + #\u{2D512}; + #\u{2D513}; + #\u{2D514}; + #\u{2D515}; + #\u{2D516}; + #\u{2D517}; + #\u{2D518}; + #\u{2D519}; + #\u{2D51A}; + #\u{2D51B}; + #\u{2D51C}; + #\u{2D51D}; + #\u{2D51E}; + #\u{2D51F}; + #\u{2D520}; + #\u{2D521}; + #\u{2D522}; + #\u{2D523}; + #\u{2D524}; + #\u{2D525}; + #\u{2D526}; + #\u{2D527}; + #\u{2D528}; + #\u{2D529}; + #\u{2D52A}; + #\u{2D52B}; + #\u{2D52C}; + #\u{2D52D}; + #\u{2D52E}; + #\u{2D52F}; + #\u{2D530}; + #\u{2D531}; + #\u{2D532}; + #\u{2D533}; + #\u{2D534}; + #\u{2D535}; + #\u{2D536}; + #\u{2D537}; + #\u{2D538}; + #\u{2D539}; + #\u{2D53A}; + #\u{2D53B}; + #\u{2D53C}; + #\u{2D53D}; + #\u{2D53E}; + #\u{2D53F}; + #\u{2D540}; + #\u{2D541}; + #\u{2D542}; + #\u{2D543}; + #\u{2D544}; + #\u{2D545}; + #\u{2D546}; + #\u{2D547}; + #\u{2D548}; + #\u{2D549}; + #\u{2D54A}; + #\u{2D54B}; + #\u{2D54C}; + #\u{2D54D}; + #\u{2D54E}; + #\u{2D54F}; + #\u{2D550}; + #\u{2D551}; + #\u{2D552}; + #\u{2D553}; + #\u{2D554}; + #\u{2D555}; + #\u{2D556}; + #\u{2D557}; + #\u{2D558}; + #\u{2D559}; + #\u{2D55A}; + #\u{2D55B}; + #\u{2D55C}; + #\u{2D55D}; + #\u{2D55E}; + #\u{2D55F}; + #\u{2D560}; + #\u{2D561}; + #\u{2D562}; + #\u{2D563}; + #\u{2D564}; + #\u{2D565}; + #\u{2D566}; + #\u{2D567}; + #\u{2D568}; + #\u{2D569}; + #\u{2D56A}; + #\u{2D56B}; + #\u{2D56C}; + #\u{2D56D}; + #\u{2D56E}; + #\u{2D56F}; + #\u{2D570}; + #\u{2D571}; + #\u{2D572}; + #\u{2D573}; + #\u{2D574}; + #\u{2D575}; + #\u{2D576}; + #\u{2D577}; + #\u{2D578}; + #\u{2D579}; + #\u{2D57A}; + #\u{2D57B}; + #\u{2D57C}; + #\u{2D57D}; + #\u{2D57E}; + #\u{2D57F}; + #\u{2D580}; + #\u{2D581}; + #\u{2D582}; + #\u{2D583}; + #\u{2D584}; + #\u{2D585}; + #\u{2D586}; + #\u{2D587}; + #\u{2D588}; + #\u{2D589}; + #\u{2D58A}; + #\u{2D58B}; + #\u{2D58C}; + #\u{2D58D}; + #\u{2D58E}; + #\u{2D58F}; + #\u{2D590}; + #\u{2D591}; + #\u{2D592}; + #\u{2D593}; + #\u{2D594}; + #\u{2D595}; + #\u{2D596}; + #\u{2D597}; + #\u{2D598}; + #\u{2D599}; + #\u{2D59A}; + #\u{2D59B}; + #\u{2D59C}; + #\u{2D59D}; + #\u{2D59E}; + #\u{2D59F}; + #\u{2D5A0}; + #\u{2D5A1}; + #\u{2D5A2}; + #\u{2D5A3}; + #\u{2D5A4}; + #\u{2D5A5}; + #\u{2D5A6}; + #\u{2D5A7}; + #\u{2D5A8}; + #\u{2D5A9}; + #\u{2D5AA}; + #\u{2D5AB}; + #\u{2D5AC}; + #\u{2D5AD}; + #\u{2D5AE}; + #\u{2D5AF}; + #\u{2D5B0}; + #\u{2D5B1}; + #\u{2D5B2}; + #\u{2D5B3}; + #\u{2D5B4}; + #\u{2D5B5}; + #\u{2D5B6}; + #\u{2D5B7}; + #\u{2D5B8}; + #\u{2D5B9}; + #\u{2D5BA}; + #\u{2D5BB}; + #\u{2D5BC}; + #\u{2D5BD}; + #\u{2D5BE}; + #\u{2D5BF}; + #\u{2D5C0}; + #\u{2D5C1}; + #\u{2D5C2}; + #\u{2D5C3}; + #\u{2D5C4}; + #\u{2D5C5}; + #\u{2D5C6}; + #\u{2D5C7}; + #\u{2D5C8}; + #\u{2D5C9}; + #\u{2D5CA}; + #\u{2D5CB}; + #\u{2D5CC}; + #\u{2D5CD}; + #\u{2D5CE}; + #\u{2D5CF}; + #\u{2D5D0}; + #\u{2D5D1}; + #\u{2D5D2}; + #\u{2D5D3}; + #\u{2D5D4}; + #\u{2D5D5}; + #\u{2D5D6}; + #\u{2D5D7}; + #\u{2D5D8}; + #\u{2D5D9}; + #\u{2D5DA}; + #\u{2D5DB}; + #\u{2D5DC}; + #\u{2D5DD}; + #\u{2D5DE}; + #\u{2D5DF}; + #\u{2D5E0}; + #\u{2D5E1}; + #\u{2D5E2}; + #\u{2D5E3}; + #\u{2D5E4}; + #\u{2D5E5}; + #\u{2D5E6}; + #\u{2D5E7}; + #\u{2D5E8}; + #\u{2D5E9}; + #\u{2D5EA}; + #\u{2D5EB}; + #\u{2D5EC}; + #\u{2D5ED}; + #\u{2D5EE}; + #\u{2D5EF}; + #\u{2D5F0}; + #\u{2D5F1}; + #\u{2D5F2}; + #\u{2D5F3}; + #\u{2D5F4}; + #\u{2D5F5}; + #\u{2D5F6}; + #\u{2D5F7}; + #\u{2D5F8}; + #\u{2D5F9}; + #\u{2D5FA}; + #\u{2D5FB}; + #\u{2D5FC}; + #\u{2D5FD}; + #\u{2D5FE}; + #\u{2D5FF}; + #\u{2D600}; + #\u{2D601}; + #\u{2D602}; + #\u{2D603}; + #\u{2D604}; + #\u{2D605}; + #\u{2D606}; + #\u{2D607}; + #\u{2D608}; + #\u{2D609}; + #\u{2D60A}; + #\u{2D60B}; + #\u{2D60C}; + #\u{2D60D}; + #\u{2D60E}; + #\u{2D60F}; + #\u{2D610}; + #\u{2D611}; + #\u{2D612}; + #\u{2D613}; + #\u{2D614}; + #\u{2D615}; + #\u{2D616}; + #\u{2D617}; + #\u{2D618}; + #\u{2D619}; + #\u{2D61A}; + #\u{2D61B}; + #\u{2D61C}; + #\u{2D61D}; + #\u{2D61E}; + #\u{2D61F}; + #\u{2D620}; + #\u{2D621}; + #\u{2D622}; + #\u{2D623}; + #\u{2D624}; + #\u{2D625}; + #\u{2D626}; + #\u{2D627}; + #\u{2D628}; + #\u{2D629}; + #\u{2D62A}; + #\u{2D62B}; + #\u{2D62C}; + #\u{2D62D}; + #\u{2D62E}; + #\u{2D62F}; + #\u{2D630}; + #\u{2D631}; + #\u{2D632}; + #\u{2D633}; + #\u{2D634}; + #\u{2D635}; + #\u{2D636}; + #\u{2D637}; + #\u{2D638}; + #\u{2D639}; + #\u{2D63A}; + #\u{2D63B}; + #\u{2D63C}; + #\u{2D63D}; + #\u{2D63E}; + #\u{2D63F}; + #\u{2D640}; + #\u{2D641}; + #\u{2D642}; + #\u{2D643}; + #\u{2D644}; + #\u{2D645}; + #\u{2D646}; + #\u{2D647}; + #\u{2D648}; + #\u{2D649}; + #\u{2D64A}; + #\u{2D64B}; + #\u{2D64C}; + #\u{2D64D}; + #\u{2D64E}; + #\u{2D64F}; + #\u{2D650}; + #\u{2D651}; + #\u{2D652}; + #\u{2D653}; + #\u{2D654}; + #\u{2D655}; + #\u{2D656}; + #\u{2D657}; + #\u{2D658}; + #\u{2D659}; + #\u{2D65A}; + #\u{2D65B}; + #\u{2D65C}; + #\u{2D65D}; + #\u{2D65E}; + #\u{2D65F}; + #\u{2D660}; + #\u{2D661}; + #\u{2D662}; + #\u{2D663}; + #\u{2D664}; + #\u{2D665}; + #\u{2D666}; + #\u{2D667}; + #\u{2D668}; + #\u{2D669}; + #\u{2D66A}; + #\u{2D66B}; + #\u{2D66C}; + #\u{2D66D}; + #\u{2D66E}; + #\u{2D66F}; + #\u{2D670}; + #\u{2D671}; + #\u{2D672}; + #\u{2D673}; + #\u{2D674}; + #\u{2D675}; + #\u{2D676}; + #\u{2D677}; + #\u{2D678}; + #\u{2D679}; + #\u{2D67A}; + #\u{2D67B}; + #\u{2D67C}; + #\u{2D67D}; + #\u{2D67E}; + #\u{2D67F}; + #\u{2D680}; + #\u{2D681}; + #\u{2D682}; + #\u{2D683}; + #\u{2D684}; + #\u{2D685}; + #\u{2D686}; + #\u{2D687}; + #\u{2D688}; + #\u{2D689}; + #\u{2D68A}; + #\u{2D68B}; + #\u{2D68C}; + #\u{2D68D}; + #\u{2D68E}; + #\u{2D68F}; + #\u{2D690}; + #\u{2D691}; + #\u{2D692}; + #\u{2D693}; + #\u{2D694}; + #\u{2D695}; + #\u{2D696}; + #\u{2D697}; + #\u{2D698}; + #\u{2D699}; + #\u{2D69A}; + #\u{2D69B}; + #\u{2D69C}; + #\u{2D69D}; + #\u{2D69E}; + #\u{2D69F}; + #\u{2D6A0}; + #\u{2D6A1}; + #\u{2D6A2}; + #\u{2D6A3}; + #\u{2D6A4}; + #\u{2D6A5}; + #\u{2D6A6}; + #\u{2D6A7}; + #\u{2D6A8}; + #\u{2D6A9}; + #\u{2D6AA}; + #\u{2D6AB}; + #\u{2D6AC}; + #\u{2D6AD}; + #\u{2D6AE}; + #\u{2D6AF}; + #\u{2D6B0}; + #\u{2D6B1}; + #\u{2D6B2}; + #\u{2D6B3}; + #\u{2D6B4}; + #\u{2D6B5}; + #\u{2D6B6}; + #\u{2D6B7}; + #\u{2D6B8}; + #\u{2D6B9}; + #\u{2D6BA}; + #\u{2D6BB}; + #\u{2D6BC}; + #\u{2D6BD}; + #\u{2D6BE}; + #\u{2D6BF}; + #\u{2D6C0}; + #\u{2D6C1}; + #\u{2D6C2}; + #\u{2D6C3}; + #\u{2D6C4}; + #\u{2D6C5}; + #\u{2D6C6}; + #\u{2D6C7}; + #\u{2D6C8}; + #\u{2D6C9}; + #\u{2D6CA}; + #\u{2D6CB}; + #\u{2D6CC}; + #\u{2D6CD}; + #\u{2D6CE}; + #\u{2D6CF}; + #\u{2D6D0}; + #\u{2D6D1}; + #\u{2D6D2}; + #\u{2D6D3}; + #\u{2D6D4}; + #\u{2D6D5}; + #\u{2D6D6}; + #\u{2D6D7}; + #\u{2D6D8}; + #\u{2D6D9}; + #\u{2D6DA}; + #\u{2D6DB}; + #\u{2D6DC}; + #\u{2D6DD}; + #\u{2D6DE}; + #\u{2D6DF}; + #\u{2D6E0}; + #\u{2D6E1}; + #\u{2D6E2}; + #\u{2D6E3}; + #\u{2D6E4}; + #\u{2D6E5}; + #\u{2D6E6}; + #\u{2D6E7}; + #\u{2D6E8}; + #\u{2D6E9}; + #\u{2D6EA}; + #\u{2D6EB}; + #\u{2D6EC}; + #\u{2D6ED}; + #\u{2D6EE}; + #\u{2D6EF}; + #\u{2D6F0}; + #\u{2D6F1}; + #\u{2D6F2}; + #\u{2D6F3}; + #\u{2D6F4}; + #\u{2D6F5}; + #\u{2D6F6}; + #\u{2D6F7}; + #\u{2D6F8}; + #\u{2D6F9}; + #\u{2D6FA}; + #\u{2D6FB}; + #\u{2D6FC}; + #\u{2D6FD}; + #\u{2D6FE}; + #\u{2D6FF}; + #\u{2D700}; + #\u{2D701}; + #\u{2D702}; + #\u{2D703}; + #\u{2D704}; + #\u{2D705}; + #\u{2D706}; + #\u{2D707}; + #\u{2D708}; + #\u{2D709}; + #\u{2D70A}; + #\u{2D70B}; + #\u{2D70C}; + #\u{2D70D}; + #\u{2D70E}; + #\u{2D70F}; + #\u{2D710}; + #\u{2D711}; + #\u{2D712}; + #\u{2D713}; + #\u{2D714}; + #\u{2D715}; + #\u{2D716}; + #\u{2D717}; + #\u{2D718}; + #\u{2D719}; + #\u{2D71A}; + #\u{2D71B}; + #\u{2D71C}; + #\u{2D71D}; + #\u{2D71E}; + #\u{2D71F}; + #\u{2D720}; + #\u{2D721}; + #\u{2D722}; + #\u{2D723}; + #\u{2D724}; + #\u{2D725}; + #\u{2D726}; + #\u{2D727}; + #\u{2D728}; + #\u{2D729}; + #\u{2D72A}; + #\u{2D72B}; + #\u{2D72C}; + #\u{2D72D}; + #\u{2D72E}; + #\u{2D72F}; + #\u{2D730}; + #\u{2D731}; + #\u{2D732}; + #\u{2D733}; + #\u{2D734}; + #\u{2D735}; + #\u{2D736}; + #\u{2D737}; + #\u{2D738}; + #\u{2D739}; + #\u{2D73A}; + #\u{2D73B}; + #\u{2D73C}; + #\u{2D73D}; + #\u{2D73E}; + #\u{2D73F}; + #\u{2D740}; + #\u{2D741}; + #\u{2D742}; + #\u{2D743}; + #\u{2D744}; + #\u{2D745}; + #\u{2D746}; + #\u{2D747}; + #\u{2D748}; + #\u{2D749}; + #\u{2D74A}; + #\u{2D74B}; + #\u{2D74C}; + #\u{2D74D}; + #\u{2D74E}; + #\u{2D74F}; + #\u{2D750}; + #\u{2D751}; + #\u{2D752}; + #\u{2D753}; + #\u{2D754}; + #\u{2D755}; + #\u{2D756}; + #\u{2D757}; + #\u{2D758}; + #\u{2D759}; + #\u{2D75A}; + #\u{2D75B}; + #\u{2D75C}; + #\u{2D75D}; + #\u{2D75E}; + #\u{2D75F}; + #\u{2D760}; + #\u{2D761}; + #\u{2D762}; + #\u{2D763}; + #\u{2D764}; + #\u{2D765}; + #\u{2D766}; + #\u{2D767}; + #\u{2D768}; + #\u{2D769}; + #\u{2D76A}; + #\u{2D76B}; + #\u{2D76C}; + #\u{2D76D}; + #\u{2D76E}; + #\u{2D76F}; + #\u{2D770}; + #\u{2D771}; + #\u{2D772}; + #\u{2D773}; + #\u{2D774}; + #\u{2D775}; + #\u{2D776}; + #\u{2D777}; + #\u{2D778}; + #\u{2D779}; + #\u{2D77A}; + #\u{2D77B}; + #\u{2D77C}; + #\u{2D77D}; + #\u{2D77E}; + #\u{2D77F}; + #\u{2D780}; + #\u{2D781}; + #\u{2D782}; + #\u{2D783}; + #\u{2D784}; + #\u{2D785}; + #\u{2D786}; + #\u{2D787}; + #\u{2D788}; + #\u{2D789}; + #\u{2D78A}; + #\u{2D78B}; + #\u{2D78C}; + #\u{2D78D}; + #\u{2D78E}; + #\u{2D78F}; + #\u{2D790}; + #\u{2D791}; + #\u{2D792}; + #\u{2D793}; + #\u{2D794}; + #\u{2D795}; + #\u{2D796}; + #\u{2D797}; + #\u{2D798}; + #\u{2D799}; + #\u{2D79A}; + #\u{2D79B}; + #\u{2D79C}; + #\u{2D79D}; + #\u{2D79E}; + #\u{2D79F}; + #\u{2D7A0}; + #\u{2D7A1}; + #\u{2D7A2}; + #\u{2D7A3}; + #\u{2D7A4}; + #\u{2D7A5}; + #\u{2D7A6}; + #\u{2D7A7}; + #\u{2D7A8}; + #\u{2D7A9}; + #\u{2D7AA}; + #\u{2D7AB}; + #\u{2D7AC}; + #\u{2D7AD}; + #\u{2D7AE}; + #\u{2D7AF}; + #\u{2D7B0}; + #\u{2D7B1}; + #\u{2D7B2}; + #\u{2D7B3}; + #\u{2D7B4}; + #\u{2D7B5}; + #\u{2D7B6}; + #\u{2D7B7}; + #\u{2D7B8}; + #\u{2D7B9}; + #\u{2D7BA}; + #\u{2D7BB}; + #\u{2D7BC}; + #\u{2D7BD}; + #\u{2D7BE}; + #\u{2D7BF}; + #\u{2D7C0}; + #\u{2D7C1}; + #\u{2D7C2}; + #\u{2D7C3}; + #\u{2D7C4}; + #\u{2D7C5}; + #\u{2D7C6}; + #\u{2D7C7}; + #\u{2D7C8}; + #\u{2D7C9}; + #\u{2D7CA}; + #\u{2D7CB}; + #\u{2D7CC}; + #\u{2D7CD}; + #\u{2D7CE}; + #\u{2D7CF}; + #\u{2D7D0}; + #\u{2D7D1}; + #\u{2D7D2}; + #\u{2D7D3}; + #\u{2D7D4}; + #\u{2D7D5}; + #\u{2D7D6}; + #\u{2D7D7}; + #\u{2D7D8}; + #\u{2D7D9}; + #\u{2D7DA}; + #\u{2D7DB}; + #\u{2D7DC}; + #\u{2D7DD}; + #\u{2D7DE}; + #\u{2D7DF}; + #\u{2D7E0}; + #\u{2D7E1}; + #\u{2D7E2}; + #\u{2D7E3}; + #\u{2D7E4}; + #\u{2D7E5}; + #\u{2D7E6}; + #\u{2D7E7}; + #\u{2D7E8}; + #\u{2D7E9}; + #\u{2D7EA}; + #\u{2D7EB}; + #\u{2D7EC}; + #\u{2D7ED}; + #\u{2D7EE}; + #\u{2D7EF}; + #\u{2D7F0}; + #\u{2D7F1}; + #\u{2D7F2}; + #\u{2D7F3}; + #\u{2D7F4}; + #\u{2D7F5}; + #\u{2D7F6}; + #\u{2D7F7}; + #\u{2D7F8}; + #\u{2D7F9}; + #\u{2D7FA}; + #\u{2D7FB}; + #\u{2D7FC}; + #\u{2D7FD}; + #\u{2D7FE}; + #\u{2D7FF}; + #\u{2D800}; + #\u{2D801}; + #\u{2D802}; + #\u{2D803}; + #\u{2D804}; + #\u{2D805}; + #\u{2D806}; + #\u{2D807}; + #\u{2D808}; + #\u{2D809}; + #\u{2D80A}; + #\u{2D80B}; + #\u{2D80C}; + #\u{2D80D}; + #\u{2D80E}; + #\u{2D80F}; + #\u{2D810}; + #\u{2D811}; + #\u{2D812}; + #\u{2D813}; + #\u{2D814}; + #\u{2D815}; + #\u{2D816}; + #\u{2D817}; + #\u{2D818}; + #\u{2D819}; + #\u{2D81A}; + #\u{2D81B}; + #\u{2D81C}; + #\u{2D81D}; + #\u{2D81E}; + #\u{2D81F}; + #\u{2D820}; + #\u{2D821}; + #\u{2D822}; + #\u{2D823}; + #\u{2D824}; + #\u{2D825}; + #\u{2D826}; + #\u{2D827}; + #\u{2D828}; + #\u{2D829}; + #\u{2D82A}; + #\u{2D82B}; + #\u{2D82C}; + #\u{2D82D}; + #\u{2D82E}; + #\u{2D82F}; + #\u{2D830}; + #\u{2D831}; + #\u{2D832}; + #\u{2D833}; + #\u{2D834}; + #\u{2D835}; + #\u{2D836}; + #\u{2D837}; + #\u{2D838}; + #\u{2D839}; + #\u{2D83A}; + #\u{2D83B}; + #\u{2D83C}; + #\u{2D83D}; + #\u{2D83E}; + #\u{2D83F}; + #\u{2D840}; + #\u{2D841}; + #\u{2D842}; + #\u{2D843}; + #\u{2D844}; + #\u{2D845}; + #\u{2D846}; + #\u{2D847}; + #\u{2D848}; + #\u{2D849}; + #\u{2D84A}; + #\u{2D84B}; + #\u{2D84C}; + #\u{2D84D}; + #\u{2D84E}; + #\u{2D84F}; + #\u{2D850}; + #\u{2D851}; + #\u{2D852}; + #\u{2D853}; + #\u{2D854}; + #\u{2D855}; + #\u{2D856}; + #\u{2D857}; + #\u{2D858}; + #\u{2D859}; + #\u{2D85A}; + #\u{2D85B}; + #\u{2D85C}; + #\u{2D85D}; + #\u{2D85E}; + #\u{2D85F}; + #\u{2D860}; + #\u{2D861}; + #\u{2D862}; + #\u{2D863}; + #\u{2D864}; + #\u{2D865}; + #\u{2D866}; + #\u{2D867}; + #\u{2D868}; + #\u{2D869}; + #\u{2D86A}; + #\u{2D86B}; + #\u{2D86C}; + #\u{2D86D}; + #\u{2D86E}; + #\u{2D86F}; + #\u{2D870}; + #\u{2D871}; + #\u{2D872}; + #\u{2D873}; + #\u{2D874}; + #\u{2D875}; + #\u{2D876}; + #\u{2D877}; + #\u{2D878}; + #\u{2D879}; + #\u{2D87A}; + #\u{2D87B}; + #\u{2D87C}; + #\u{2D87D}; + #\u{2D87E}; + #\u{2D87F}; + #\u{2D880}; + #\u{2D881}; + #\u{2D882}; + #\u{2D883}; + #\u{2D884}; + #\u{2D885}; + #\u{2D886}; + #\u{2D887}; + #\u{2D888}; + #\u{2D889}; + #\u{2D88A}; + #\u{2D88B}; + #\u{2D88C}; + #\u{2D88D}; + #\u{2D88E}; + #\u{2D88F}; + #\u{2D890}; + #\u{2D891}; + #\u{2D892}; + #\u{2D893}; + #\u{2D894}; + #\u{2D895}; + #\u{2D896}; + #\u{2D897}; + #\u{2D898}; + #\u{2D899}; + #\u{2D89A}; + #\u{2D89B}; + #\u{2D89C}; + #\u{2D89D}; + #\u{2D89E}; + #\u{2D89F}; + #\u{2D8A0}; + #\u{2D8A1}; + #\u{2D8A2}; + #\u{2D8A3}; + #\u{2D8A4}; + #\u{2D8A5}; + #\u{2D8A6}; + #\u{2D8A7}; + #\u{2D8A8}; + #\u{2D8A9}; + #\u{2D8AA}; + #\u{2D8AB}; + #\u{2D8AC}; + #\u{2D8AD}; + #\u{2D8AE}; + #\u{2D8AF}; + #\u{2D8B0}; + #\u{2D8B1}; + #\u{2D8B2}; + #\u{2D8B3}; + #\u{2D8B4}; + #\u{2D8B5}; + #\u{2D8B6}; + #\u{2D8B7}; + #\u{2D8B8}; + #\u{2D8B9}; + #\u{2D8BA}; + #\u{2D8BB}; + #\u{2D8BC}; + #\u{2D8BD}; + #\u{2D8BE}; + #\u{2D8BF}; + #\u{2D8C0}; + #\u{2D8C1}; + #\u{2D8C2}; + #\u{2D8C3}; + #\u{2D8C4}; + #\u{2D8C5}; + #\u{2D8C6}; + #\u{2D8C7}; + #\u{2D8C8}; + #\u{2D8C9}; + #\u{2D8CA}; + #\u{2D8CB}; + #\u{2D8CC}; + #\u{2D8CD}; + #\u{2D8CE}; + #\u{2D8CF}; + #\u{2D8D0}; + #\u{2D8D1}; + #\u{2D8D2}; + #\u{2D8D3}; + #\u{2D8D4}; + #\u{2D8D5}; + #\u{2D8D6}; + #\u{2D8D7}; + #\u{2D8D8}; + #\u{2D8D9}; + #\u{2D8DA}; + #\u{2D8DB}; + #\u{2D8DC}; + #\u{2D8DD}; + #\u{2D8DE}; + #\u{2D8DF}; + #\u{2D8E0}; + #\u{2D8E1}; + #\u{2D8E2}; + #\u{2D8E3}; + #\u{2D8E4}; + #\u{2D8E5}; + #\u{2D8E6}; + #\u{2D8E7}; + #\u{2D8E8}; + #\u{2D8E9}; + #\u{2D8EA}; + #\u{2D8EB}; + #\u{2D8EC}; + #\u{2D8ED}; + #\u{2D8EE}; + #\u{2D8EF}; + #\u{2D8F0}; + #\u{2D8F1}; + #\u{2D8F2}; + #\u{2D8F3}; + #\u{2D8F4}; + #\u{2D8F5}; + #\u{2D8F6}; + #\u{2D8F7}; + #\u{2D8F8}; + #\u{2D8F9}; + #\u{2D8FA}; + #\u{2D8FB}; + #\u{2D8FC}; + #\u{2D8FD}; + #\u{2D8FE}; + #\u{2D8FF}; + #\u{2D900}; + #\u{2D901}; + #\u{2D902}; + #\u{2D903}; + #\u{2D904}; + #\u{2D905}; + #\u{2D906}; + #\u{2D907}; + #\u{2D908}; + #\u{2D909}; + #\u{2D90A}; + #\u{2D90B}; + #\u{2D90C}; + #\u{2D90D}; + #\u{2D90E}; + #\u{2D90F}; + #\u{2D910}; + #\u{2D911}; + #\u{2D912}; + #\u{2D913}; + #\u{2D914}; + #\u{2D915}; + #\u{2D916}; + #\u{2D917}; + #\u{2D918}; + #\u{2D919}; + #\u{2D91A}; + #\u{2D91B}; + #\u{2D91C}; + #\u{2D91D}; + #\u{2D91E}; + #\u{2D91F}; + #\u{2D920}; + #\u{2D921}; + #\u{2D922}; + #\u{2D923}; + #\u{2D924}; + #\u{2D925}; + #\u{2D926}; + #\u{2D927}; + #\u{2D928}; + #\u{2D929}; + #\u{2D92A}; + #\u{2D92B}; + #\u{2D92C}; + #\u{2D92D}; + #\u{2D92E}; + #\u{2D92F}; + #\u{2D930}; + #\u{2D931}; + #\u{2D932}; + #\u{2D933}; + #\u{2D934}; + #\u{2D935}; + #\u{2D936}; + #\u{2D937}; + #\u{2D938}; + #\u{2D939}; + #\u{2D93A}; + #\u{2D93B}; + #\u{2D93C}; + #\u{2D93D}; + #\u{2D93E}; + #\u{2D93F}; + #\u{2D940}; + #\u{2D941}; + #\u{2D942}; + #\u{2D943}; + #\u{2D944}; + #\u{2D945}; + #\u{2D946}; + #\u{2D947}; + #\u{2D948}; + #\u{2D949}; + #\u{2D94A}; + #\u{2D94B}; + #\u{2D94C}; + #\u{2D94D}; + #\u{2D94E}; + #\u{2D94F}; + #\u{2D950}; + #\u{2D951}; + #\u{2D952}; + #\u{2D953}; + #\u{2D954}; + #\u{2D955}; + #\u{2D956}; + #\u{2D957}; + #\u{2D958}; + #\u{2D959}; + #\u{2D95A}; + #\u{2D95B}; + #\u{2D95C}; + #\u{2D95D}; + #\u{2D95E}; + #\u{2D95F}; + #\u{2D960}; + #\u{2D961}; + #\u{2D962}; + #\u{2D963}; + #\u{2D964}; + #\u{2D965}; + #\u{2D966}; + #\u{2D967}; + #\u{2D968}; + #\u{2D969}; + #\u{2D96A}; + #\u{2D96B}; + #\u{2D96C}; + #\u{2D96D}; + #\u{2D96E}; + #\u{2D96F}; + #\u{2D970}; + #\u{2D971}; + #\u{2D972}; + #\u{2D973}; + #\u{2D974}; + #\u{2D975}; + #\u{2D976}; + #\u{2D977}; + #\u{2D978}; + #\u{2D979}; + #\u{2D97A}; + #\u{2D97B}; + #\u{2D97C}; + #\u{2D97D}; + #\u{2D97E}; + #\u{2D97F}; + #\u{2D980}; + #\u{2D981}; + #\u{2D982}; + #\u{2D983}; + #\u{2D984}; + #\u{2D985}; + #\u{2D986}; + #\u{2D987}; + #\u{2D988}; + #\u{2D989}; + #\u{2D98A}; + #\u{2D98B}; + #\u{2D98C}; + #\u{2D98D}; + #\u{2D98E}; + #\u{2D98F}; + #\u{2D990}; + #\u{2D991}; + #\u{2D992}; + #\u{2D993}; + #\u{2D994}; + #\u{2D995}; + #\u{2D996}; + #\u{2D997}; + #\u{2D998}; + #\u{2D999}; + #\u{2D99A}; + #\u{2D99B}; + #\u{2D99C}; + #\u{2D99D}; + #\u{2D99E}; + #\u{2D99F}; + #\u{2D9A0}; + #\u{2D9A1}; + #\u{2D9A2}; + #\u{2D9A3}; + #\u{2D9A4}; + #\u{2D9A5}; + #\u{2D9A6}; + #\u{2D9A7}; + #\u{2D9A8}; + #\u{2D9A9}; + #\u{2D9AA}; + #\u{2D9AB}; + #\u{2D9AC}; + #\u{2D9AD}; + #\u{2D9AE}; + #\u{2D9AF}; + #\u{2D9B0}; + #\u{2D9B1}; + #\u{2D9B2}; + #\u{2D9B3}; + #\u{2D9B4}; + #\u{2D9B5}; + #\u{2D9B6}; + #\u{2D9B7}; + #\u{2D9B8}; + #\u{2D9B9}; + #\u{2D9BA}; + #\u{2D9BB}; + #\u{2D9BC}; + #\u{2D9BD}; + #\u{2D9BE}; + #\u{2D9BF}; + #\u{2D9C0}; + #\u{2D9C1}; + #\u{2D9C2}; + #\u{2D9C3}; + #\u{2D9C4}; + #\u{2D9C5}; + #\u{2D9C6}; + #\u{2D9C7}; + #\u{2D9C8}; + #\u{2D9C9}; + #\u{2D9CA}; + #\u{2D9CB}; + #\u{2D9CC}; + #\u{2D9CD}; + #\u{2D9CE}; + #\u{2D9CF}; + #\u{2D9D0}; + #\u{2D9D1}; + #\u{2D9D2}; + #\u{2D9D3}; + #\u{2D9D4}; + #\u{2D9D5}; + #\u{2D9D6}; + #\u{2D9D7}; + #\u{2D9D8}; + #\u{2D9D9}; + #\u{2D9DA}; + #\u{2D9DB}; + #\u{2D9DC}; + #\u{2D9DD}; + #\u{2D9DE}; + #\u{2D9DF}; + #\u{2D9E0}; + #\u{2D9E1}; + #\u{2D9E2}; + #\u{2D9E3}; + #\u{2D9E4}; + #\u{2D9E5}; + #\u{2D9E6}; + #\u{2D9E7}; + #\u{2D9E8}; + #\u{2D9E9}; + #\u{2D9EA}; + #\u{2D9EB}; + #\u{2D9EC}; + #\u{2D9ED}; + #\u{2D9EE}; + #\u{2D9EF}; + #\u{2D9F0}; + #\u{2D9F1}; + #\u{2D9F2}; + #\u{2D9F3}; + #\u{2D9F4}; + #\u{2D9F5}; + #\u{2D9F6}; + #\u{2D9F7}; + #\u{2D9F8}; + #\u{2D9F9}; + #\u{2D9FA}; + #\u{2D9FB}; + #\u{2D9FC}; + #\u{2D9FD}; + #\u{2D9FE}; + #\u{2D9FF}; + #\u{2DA00}; + #\u{2DA01}; + #\u{2DA02}; + #\u{2DA03}; + #\u{2DA04}; + #\u{2DA05}; + #\u{2DA06}; + #\u{2DA07}; + #\u{2DA08}; + #\u{2DA09}; + #\u{2DA0A}; + #\u{2DA0B}; + #\u{2DA0C}; + #\u{2DA0D}; + #\u{2DA0E}; + #\u{2DA0F}; + #\u{2DA10}; + #\u{2DA11}; + #\u{2DA12}; + #\u{2DA13}; + #\u{2DA14}; + #\u{2DA15}; + #\u{2DA16}; + #\u{2DA17}; + #\u{2DA18}; + #\u{2DA19}; + #\u{2DA1A}; + #\u{2DA1B}; + #\u{2DA1C}; + #\u{2DA1D}; + #\u{2DA1E}; + #\u{2DA1F}; + #\u{2DA20}; + #\u{2DA21}; + #\u{2DA22}; + #\u{2DA23}; + #\u{2DA24}; + #\u{2DA25}; + #\u{2DA26}; + #\u{2DA27}; + #\u{2DA28}; + #\u{2DA29}; + #\u{2DA2A}; + #\u{2DA2B}; + #\u{2DA2C}; + #\u{2DA2D}; + #\u{2DA2E}; + #\u{2DA2F}; + #\u{2DA30}; + #\u{2DA31}; + #\u{2DA32}; + #\u{2DA33}; + #\u{2DA34}; + #\u{2DA35}; + #\u{2DA36}; + #\u{2DA37}; + #\u{2DA38}; + #\u{2DA39}; + #\u{2DA3A}; + #\u{2DA3B}; + #\u{2DA3C}; + #\u{2DA3D}; + #\u{2DA3E}; + #\u{2DA3F}; + #\u{2DA40}; + #\u{2DA41}; + #\u{2DA42}; + #\u{2DA43}; + #\u{2DA44}; + #\u{2DA45}; + #\u{2DA46}; + #\u{2DA47}; + #\u{2DA48}; + #\u{2DA49}; + #\u{2DA4A}; + #\u{2DA4B}; + #\u{2DA4C}; + #\u{2DA4D}; + #\u{2DA4E}; + #\u{2DA4F}; + #\u{2DA50}; + #\u{2DA51}; + #\u{2DA52}; + #\u{2DA53}; + #\u{2DA54}; + #\u{2DA55}; + #\u{2DA56}; + #\u{2DA57}; + #\u{2DA58}; + #\u{2DA59}; + #\u{2DA5A}; + #\u{2DA5B}; + #\u{2DA5C}; + #\u{2DA5D}; + #\u{2DA5E}; + #\u{2DA5F}; + #\u{2DA60}; + #\u{2DA61}; + #\u{2DA62}; + #\u{2DA63}; + #\u{2DA64}; + #\u{2DA65}; + #\u{2DA66}; + #\u{2DA67}; + #\u{2DA68}; + #\u{2DA69}; + #\u{2DA6A}; + #\u{2DA6B}; + #\u{2DA6C}; + #\u{2DA6D}; + #\u{2DA6E}; + #\u{2DA6F}; + #\u{2DA70}; + #\u{2DA71}; + #\u{2DA72}; + #\u{2DA73}; + #\u{2DA74}; + #\u{2DA75}; + #\u{2DA76}; + #\u{2DA77}; + #\u{2DA78}; + #\u{2DA79}; + #\u{2DA7A}; + #\u{2DA7B}; + #\u{2DA7C}; + #\u{2DA7D}; + #\u{2DA7E}; + #\u{2DA7F}; + #\u{2DA80}; + #\u{2DA81}; + #\u{2DA82}; + #\u{2DA83}; + #\u{2DA84}; + #\u{2DA85}; + #\u{2DA86}; + #\u{2DA87}; + #\u{2DA88}; + #\u{2DA89}; + #\u{2DA8A}; + #\u{2DA8B}; + #\u{2DA8C}; + #\u{2DA8D}; + #\u{2DA8E}; + #\u{2DA8F}; + #\u{2DA90}; + #\u{2DA91}; + #\u{2DA92}; + #\u{2DA93}; + #\u{2DA94}; + #\u{2DA95}; + #\u{2DA96}; + #\u{2DA97}; + #\u{2DA98}; + #\u{2DA99}; + #\u{2DA9A}; + #\u{2DA9B}; + #\u{2DA9C}; + #\u{2DA9D}; + #\u{2DA9E}; + #\u{2DA9F}; + #\u{2DAA0}; + #\u{2DAA1}; + #\u{2DAA2}; + #\u{2DAA3}; + #\u{2DAA4}; + #\u{2DAA5}; + #\u{2DAA6}; + #\u{2DAA7}; + #\u{2DAA8}; + #\u{2DAA9}; + #\u{2DAAA}; + #\u{2DAAB}; + #\u{2DAAC}; + #\u{2DAAD}; + #\u{2DAAE}; + #\u{2DAAF}; + #\u{2DAB0}; + #\u{2DAB1}; + #\u{2DAB2}; + #\u{2DAB3}; + #\u{2DAB4}; + #\u{2DAB5}; + #\u{2DAB6}; + #\u{2DAB7}; + #\u{2DAB8}; + #\u{2DAB9}; + #\u{2DABA}; + #\u{2DABB}; + #\u{2DABC}; + #\u{2DABD}; + #\u{2DABE}; + #\u{2DABF}; + #\u{2DAC0}; + #\u{2DAC1}; + #\u{2DAC2}; + #\u{2DAC3}; + #\u{2DAC4}; + #\u{2DAC5}; + #\u{2DAC6}; + #\u{2DAC7}; + #\u{2DAC8}; + #\u{2DAC9}; + #\u{2DACA}; + #\u{2DACB}; + #\u{2DACC}; + #\u{2DACD}; + #\u{2DACE}; + #\u{2DACF}; + #\u{2DAD0}; + #\u{2DAD1}; + #\u{2DAD2}; + #\u{2DAD3}; + #\u{2DAD4}; + #\u{2DAD5}; + #\u{2DAD6}; + #\u{2DAD7}; + #\u{2DAD8}; + #\u{2DAD9}; + #\u{2DADA}; + #\u{2DADB}; + #\u{2DADC}; + #\u{2DADD}; + #\u{2DADE}; + #\u{2DADF}; + #\u{2DAE0}; + #\u{2DAE1}; + #\u{2DAE2}; + #\u{2DAE3}; + #\u{2DAE4}; + #\u{2DAE5}; + #\u{2DAE6}; + #\u{2DAE7}; + #\u{2DAE8}; + #\u{2DAE9}; + #\u{2DAEA}; + #\u{2DAEB}; + #\u{2DAEC}; + #\u{2DAED}; + #\u{2DAEE}; + #\u{2DAEF}; + #\u{2DAF0}; + #\u{2DAF1}; + #\u{2DAF2}; + #\u{2DAF3}; + #\u{2DAF4}; + #\u{2DAF5}; + #\u{2DAF6}; + #\u{2DAF7}; + #\u{2DAF8}; + #\u{2DAF9}; + #\u{2DAFA}; + #\u{2DAFB}; + #\u{2DAFC}; + #\u{2DAFD}; + #\u{2DAFE}; + #\u{2DAFF}; + #\u{2DB00}; + #\u{2DB01}; + #\u{2DB02}; + #\u{2DB03}; + #\u{2DB04}; + #\u{2DB05}; + #\u{2DB06}; + #\u{2DB07}; + #\u{2DB08}; + #\u{2DB09}; + #\u{2DB0A}; + #\u{2DB0B}; + #\u{2DB0C}; + #\u{2DB0D}; + #\u{2DB0E}; + #\u{2DB0F}; + #\u{2DB10}; + #\u{2DB11}; + #\u{2DB12}; + #\u{2DB13}; + #\u{2DB14}; + #\u{2DB15}; + #\u{2DB16}; + #\u{2DB17}; + #\u{2DB18}; + #\u{2DB19}; + #\u{2DB1A}; + #\u{2DB1B}; + #\u{2DB1C}; + #\u{2DB1D}; + #\u{2DB1E}; + #\u{2DB1F}; + #\u{2DB20}; + #\u{2DB21}; + #\u{2DB22}; + #\u{2DB23}; + #\u{2DB24}; + #\u{2DB25}; + #\u{2DB26}; + #\u{2DB27}; + #\u{2DB28}; + #\u{2DB29}; + #\u{2DB2A}; + #\u{2DB2B}; + #\u{2DB2C}; + #\u{2DB2D}; + #\u{2DB2E}; + #\u{2DB2F}; + #\u{2DB30}; + #\u{2DB31}; + #\u{2DB32}; + #\u{2DB33}; + #\u{2DB34}; + #\u{2DB35}; + #\u{2DB36}; + #\u{2DB37}; + #\u{2DB38}; + #\u{2DB39}; + #\u{2DB3A}; + #\u{2DB3B}; + #\u{2DB3C}; + #\u{2DB3D}; + #\u{2DB3E}; + #\u{2DB3F}; + #\u{2DB40}; + #\u{2DB41}; + #\u{2DB42}; + #\u{2DB43}; + #\u{2DB44}; + #\u{2DB45}; + #\u{2DB46}; + #\u{2DB47}; + #\u{2DB48}; + #\u{2DB49}; + #\u{2DB4A}; + #\u{2DB4B}; + #\u{2DB4C}; + #\u{2DB4D}; + #\u{2DB4E}; + #\u{2DB4F}; + #\u{2DB50}; + #\u{2DB51}; + #\u{2DB52}; + #\u{2DB53}; + #\u{2DB54}; + #\u{2DB55}; + #\u{2DB56}; + #\u{2DB57}; + #\u{2DB58}; + #\u{2DB59}; + #\u{2DB5A}; + #\u{2DB5B}; + #\u{2DB5C}; + #\u{2DB5D}; + #\u{2DB5E}; + #\u{2DB5F}; + #\u{2DB60}; + #\u{2DB61}; + #\u{2DB62}; + #\u{2DB63}; + #\u{2DB64}; + #\u{2DB65}; + #\u{2DB66}; + #\u{2DB67}; + #\u{2DB68}; + #\u{2DB69}; + #\u{2DB6A}; + #\u{2DB6B}; + #\u{2DB6C}; + #\u{2DB6D}; + #\u{2DB6E}; + #\u{2DB6F}; + #\u{2DB70}; + #\u{2DB71}; + #\u{2DB72}; + #\u{2DB73}; + #\u{2DB74}; + #\u{2DB75}; + #\u{2DB76}; + #\u{2DB77}; + #\u{2DB78}; + #\u{2DB79}; + #\u{2DB7A}; + #\u{2DB7B}; + #\u{2DB7C}; + #\u{2DB7D}; + #\u{2DB7E}; + #\u{2DB7F}; + #\u{2DB80}; + #\u{2DB81}; + #\u{2DB82}; + #\u{2DB83}; + #\u{2DB84}; + #\u{2DB85}; + #\u{2DB86}; + #\u{2DB87}; + #\u{2DB88}; + #\u{2DB89}; + #\u{2DB8A}; + #\u{2DB8B}; + #\u{2DB8C}; + #\u{2DB8D}; + #\u{2DB8E}; + #\u{2DB8F}; + #\u{2DB90}; + #\u{2DB91}; + #\u{2DB92}; + #\u{2DB93}; + #\u{2DB94}; + #\u{2DB95}; + #\u{2DB96}; + #\u{2DB97}; + #\u{2DB98}; + #\u{2DB99}; + #\u{2DB9A}; + #\u{2DB9B}; + #\u{2DB9C}; + #\u{2DB9D}; + #\u{2DB9E}; + #\u{2DB9F}; + #\u{2DBA0}; + #\u{2DBA1}; + #\u{2DBA2}; + #\u{2DBA3}; + #\u{2DBA4}; + #\u{2DBA5}; + #\u{2DBA6}; + #\u{2DBA7}; + #\u{2DBA8}; + #\u{2DBA9}; + #\u{2DBAA}; + #\u{2DBAB}; + #\u{2DBAC}; + #\u{2DBAD}; + #\u{2DBAE}; + #\u{2DBAF}; + #\u{2DBB0}; + #\u{2DBB1}; + #\u{2DBB2}; + #\u{2DBB3}; + #\u{2DBB4}; + #\u{2DBB5}; + #\u{2DBB6}; + #\u{2DBB7}; + #\u{2DBB8}; + #\u{2DBB9}; + #\u{2DBBA}; + #\u{2DBBB}; + #\u{2DBBC}; + #\u{2DBBD}; + #\u{2DBBE}; + #\u{2DBBF}; + #\u{2DBC0}; + #\u{2DBC1}; + #\u{2DBC2}; + #\u{2DBC3}; + #\u{2DBC4}; + #\u{2DBC5}; + #\u{2DBC6}; + #\u{2DBC7}; + #\u{2DBC8}; + #\u{2DBC9}; + #\u{2DBCA}; + #\u{2DBCB}; + #\u{2DBCC}; + #\u{2DBCD}; + #\u{2DBCE}; + #\u{2DBCF}; + #\u{2DBD0}; + #\u{2DBD1}; + #\u{2DBD2}; + #\u{2DBD3}; + #\u{2DBD4}; + #\u{2DBD5}; + #\u{2DBD6}; + #\u{2DBD7}; + #\u{2DBD8}; + #\u{2DBD9}; + #\u{2DBDA}; + #\u{2DBDB}; + #\u{2DBDC}; + #\u{2DBDD}; + #\u{2DBDE}; + #\u{2DBDF}; + #\u{2DBE0}; + #\u{2DBE1}; + #\u{2DBE2}; + #\u{2DBE3}; + #\u{2DBE4}; + #\u{2DBE5}; + #\u{2DBE6}; + #\u{2DBE7}; + #\u{2DBE8}; + #\u{2DBE9}; + #\u{2DBEA}; + #\u{2DBEB}; + #\u{2DBEC}; + #\u{2DBED}; + #\u{2DBEE}; + #\u{2DBEF}; + #\u{2DBF0}; + #\u{2DBF1}; + #\u{2DBF2}; + #\u{2DBF3}; + #\u{2DBF4}; + #\u{2DBF5}; + #\u{2DBF6}; + #\u{2DBF7}; + #\u{2DBF8}; + #\u{2DBF9}; + #\u{2DBFA}; + #\u{2DBFB}; + #\u{2DBFC}; + #\u{2DBFD}; + #\u{2DBFE}; + #\u{2DBFF}; + #\u{2DC00}; + #\u{2DC01}; + #\u{2DC02}; + #\u{2DC03}; + #\u{2DC04}; + #\u{2DC05}; + #\u{2DC06}; + #\u{2DC07}; + #\u{2DC08}; + #\u{2DC09}; + #\u{2DC0A}; + #\u{2DC0B}; + #\u{2DC0C}; + #\u{2DC0D}; + #\u{2DC0E}; + #\u{2DC0F}; + #\u{2DC10}; + #\u{2DC11}; + #\u{2DC12}; + #\u{2DC13}; + #\u{2DC14}; + #\u{2DC15}; + #\u{2DC16}; + #\u{2DC17}; + #\u{2DC18}; + #\u{2DC19}; + #\u{2DC1A}; + #\u{2DC1B}; + #\u{2DC1C}; + #\u{2DC1D}; + #\u{2DC1E}; + #\u{2DC1F}; + #\u{2DC20}; + #\u{2DC21}; + #\u{2DC22}; + #\u{2DC23}; + #\u{2DC24}; + #\u{2DC25}; + #\u{2DC26}; + #\u{2DC27}; + #\u{2DC28}; + #\u{2DC29}; + #\u{2DC2A}; + #\u{2DC2B}; + #\u{2DC2C}; + #\u{2DC2D}; + #\u{2DC2E}; + #\u{2DC2F}; + #\u{2DC30}; + #\u{2DC31}; + #\u{2DC32}; + #\u{2DC33}; + #\u{2DC34}; + #\u{2DC35}; + #\u{2DC36}; + #\u{2DC37}; + #\u{2DC38}; + #\u{2DC39}; + #\u{2DC3A}; + #\u{2DC3B}; + #\u{2DC3C}; + #\u{2DC3D}; + #\u{2DC3E}; + #\u{2DC3F}; + #\u{2DC40}; + #\u{2DC41}; + #\u{2DC42}; + #\u{2DC43}; + #\u{2DC44}; + #\u{2DC45}; + #\u{2DC46}; + #\u{2DC47}; + #\u{2DC48}; + #\u{2DC49}; + #\u{2DC4A}; + #\u{2DC4B}; + #\u{2DC4C}; + #\u{2DC4D}; + #\u{2DC4E}; + #\u{2DC4F}; + #\u{2DC50}; + #\u{2DC51}; + #\u{2DC52}; + #\u{2DC53}; + #\u{2DC54}; + #\u{2DC55}; + #\u{2DC56}; + #\u{2DC57}; + #\u{2DC58}; + #\u{2DC59}; + #\u{2DC5A}; + #\u{2DC5B}; + #\u{2DC5C}; + #\u{2DC5D}; + #\u{2DC5E}; + #\u{2DC5F}; + #\u{2DC60}; + #\u{2DC61}; + #\u{2DC62}; + #\u{2DC63}; + #\u{2DC64}; + #\u{2DC65}; + #\u{2DC66}; + #\u{2DC67}; + #\u{2DC68}; + #\u{2DC69}; + #\u{2DC6A}; + #\u{2DC6B}; + #\u{2DC6C}; + #\u{2DC6D}; + #\u{2DC6E}; + #\u{2DC6F}; + #\u{2DC70}; + #\u{2DC71}; + #\u{2DC72}; + #\u{2DC73}; + #\u{2DC74}; + #\u{2DC75}; + #\u{2DC76}; + #\u{2DC77}; + #\u{2DC78}; + #\u{2DC79}; + #\u{2DC7A}; + #\u{2DC7B}; + #\u{2DC7C}; + #\u{2DC7D}; + #\u{2DC7E}; + #\u{2DC7F}; + #\u{2DC80}; + #\u{2DC81}; + #\u{2DC82}; + #\u{2DC83}; + #\u{2DC84}; + #\u{2DC85}; + #\u{2DC86}; + #\u{2DC87}; + #\u{2DC88}; + #\u{2DC89}; + #\u{2DC8A}; + #\u{2DC8B}; + #\u{2DC8C}; + #\u{2DC8D}; + #\u{2DC8E}; + #\u{2DC8F}; + #\u{2DC90}; + #\u{2DC91}; + #\u{2DC92}; + #\u{2DC93}; + #\u{2DC94}; + #\u{2DC95}; + #\u{2DC96}; + #\u{2DC97}; + #\u{2DC98}; + #\u{2DC99}; + #\u{2DC9A}; + #\u{2DC9B}; + #\u{2DC9C}; + #\u{2DC9D}; + #\u{2DC9E}; + #\u{2DC9F}; + #\u{2DCA0}; + #\u{2DCA1}; + #\u{2DCA2}; + #\u{2DCA3}; + #\u{2DCA4}; + #\u{2DCA5}; + #\u{2DCA6}; + #\u{2DCA7}; + #\u{2DCA8}; + #\u{2DCA9}; + #\u{2DCAA}; + #\u{2DCAB}; + #\u{2DCAC}; + #\u{2DCAD}; + #\u{2DCAE}; + #\u{2DCAF}; + #\u{2DCB0}; + #\u{2DCB1}; + #\u{2DCB2}; + #\u{2DCB3}; + #\u{2DCB4}; + #\u{2DCB5}; + #\u{2DCB6}; + #\u{2DCB7}; + #\u{2DCB8}; + #\u{2DCB9}; + #\u{2DCBA}; + #\u{2DCBB}; + #\u{2DCBC}; + #\u{2DCBD}; + #\u{2DCBE}; + #\u{2DCBF}; + #\u{2DCC0}; + #\u{2DCC1}; + #\u{2DCC2}; + #\u{2DCC3}; + #\u{2DCC4}; + #\u{2DCC5}; + #\u{2DCC6}; + #\u{2DCC7}; + #\u{2DCC8}; + #\u{2DCC9}; + #\u{2DCCA}; + #\u{2DCCB}; + #\u{2DCCC}; + #\u{2DCCD}; + #\u{2DCCE}; + #\u{2DCCF}; + #\u{2DCD0}; + #\u{2DCD1}; + #\u{2DCD2}; + #\u{2DCD3}; + #\u{2DCD4}; + #\u{2DCD5}; + #\u{2DCD6}; + #\u{2DCD7}; + #\u{2DCD8}; + #\u{2DCD9}; + #\u{2DCDA}; + #\u{2DCDB}; + #\u{2DCDC}; + #\u{2DCDD}; + #\u{2DCDE}; + #\u{2DCDF}; + #\u{2DCE0}; + #\u{2DCE1}; + #\u{2DCE2}; + #\u{2DCE3}; + #\u{2DCE4}; + #\u{2DCE5}; + #\u{2DCE6}; + #\u{2DCE7}; + #\u{2DCE8}; + #\u{2DCE9}; + #\u{2DCEA}; + #\u{2DCEB}; + #\u{2DCEC}; + #\u{2DCED}; + #\u{2DCEE}; + #\u{2DCEF}; + #\u{2DCF0}; + #\u{2DCF1}; + #\u{2DCF2}; + #\u{2DCF3}; + #\u{2DCF4}; + #\u{2DCF5}; + #\u{2DCF6}; + #\u{2DCF7}; + #\u{2DCF8}; + #\u{2DCF9}; + #\u{2DCFA}; + #\u{2DCFB}; + #\u{2DCFC}; + #\u{2DCFD}; + #\u{2DCFE}; + #\u{2DCFF}; + #\u{2DD00}; + #\u{2DD01}; + #\u{2DD02}; + #\u{2DD03}; + #\u{2DD04}; + #\u{2DD05}; + #\u{2DD06}; + #\u{2DD07}; + #\u{2DD08}; + #\u{2DD09}; + #\u{2DD0A}; + #\u{2DD0B}; + #\u{2DD0C}; + #\u{2DD0D}; + #\u{2DD0E}; + #\u{2DD0F}; + #\u{2DD10}; + #\u{2DD11}; + #\u{2DD12}; + #\u{2DD13}; + #\u{2DD14}; + #\u{2DD15}; + #\u{2DD16}; + #\u{2DD17}; + #\u{2DD18}; + #\u{2DD19}; + #\u{2DD1A}; + #\u{2DD1B}; + #\u{2DD1C}; + #\u{2DD1D}; + #\u{2DD1E}; + #\u{2DD1F}; + #\u{2DD20}; + #\u{2DD21}; + #\u{2DD22}; + #\u{2DD23}; + #\u{2DD24}; + #\u{2DD25}; + #\u{2DD26}; + #\u{2DD27}; + #\u{2DD28}; + #\u{2DD29}; + #\u{2DD2A}; + #\u{2DD2B}; + #\u{2DD2C}; + #\u{2DD2D}; + #\u{2DD2E}; + #\u{2DD2F}; + #\u{2DD30}; + #\u{2DD31}; + #\u{2DD32}; + #\u{2DD33}; + #\u{2DD34}; + #\u{2DD35}; + #\u{2DD36}; + #\u{2DD37}; + #\u{2DD38}; + #\u{2DD39}; + #\u{2DD3A}; + #\u{2DD3B}; + #\u{2DD3C}; + #\u{2DD3D}; + #\u{2DD3E}; + #\u{2DD3F}; + #\u{2DD40}; + #\u{2DD41}; + #\u{2DD42}; + #\u{2DD43}; + #\u{2DD44}; + #\u{2DD45}; + #\u{2DD46}; + #\u{2DD47}; + #\u{2DD48}; + #\u{2DD49}; + #\u{2DD4A}; + #\u{2DD4B}; + #\u{2DD4C}; + #\u{2DD4D}; + #\u{2DD4E}; + #\u{2DD4F}; + #\u{2DD50}; + #\u{2DD51}; + #\u{2DD52}; + #\u{2DD53}; + #\u{2DD54}; + #\u{2DD55}; + #\u{2DD56}; + #\u{2DD57}; + #\u{2DD58}; + #\u{2DD59}; + #\u{2DD5A}; + #\u{2DD5B}; + #\u{2DD5C}; + #\u{2DD5D}; + #\u{2DD5E}; + #\u{2DD5F}; + #\u{2DD60}; + #\u{2DD61}; + #\u{2DD62}; + #\u{2DD63}; + #\u{2DD64}; + #\u{2DD65}; + #\u{2DD66}; + #\u{2DD67}; + #\u{2DD68}; + #\u{2DD69}; + #\u{2DD6A}; + #\u{2DD6B}; + #\u{2DD6C}; + #\u{2DD6D}; + #\u{2DD6E}; + #\u{2DD6F}; + #\u{2DD70}; + #\u{2DD71}; + #\u{2DD72}; + #\u{2DD73}; + #\u{2DD74}; + #\u{2DD75}; + #\u{2DD76}; + #\u{2DD77}; + #\u{2DD78}; + #\u{2DD79}; + #\u{2DD7A}; + #\u{2DD7B}; + #\u{2DD7C}; + #\u{2DD7D}; + #\u{2DD7E}; + #\u{2DD7F}; + #\u{2DD80}; + #\u{2DD81}; + #\u{2DD82}; + #\u{2DD83}; + #\u{2DD84}; + #\u{2DD85}; + #\u{2DD86}; + #\u{2DD87}; + #\u{2DD88}; + #\u{2DD89}; + #\u{2DD8A}; + #\u{2DD8B}; + #\u{2DD8C}; + #\u{2DD8D}; + #\u{2DD8E}; + #\u{2DD8F}; + #\u{2DD90}; + #\u{2DD91}; + #\u{2DD92}; + #\u{2DD93}; + #\u{2DD94}; + #\u{2DD95}; + #\u{2DD96}; + #\u{2DD97}; + #\u{2DD98}; + #\u{2DD99}; + #\u{2DD9A}; + #\u{2DD9B}; + #\u{2DD9C}; + #\u{2DD9D}; + #\u{2DD9E}; + #\u{2DD9F}; + #\u{2DDA0}; + #\u{2DDA1}; + #\u{2DDA2}; + #\u{2DDA3}; + #\u{2DDA4}; + #\u{2DDA5}; + #\u{2DDA6}; + #\u{2DDA7}; + #\u{2DDA8}; + #\u{2DDA9}; + #\u{2DDAA}; + #\u{2DDAB}; + #\u{2DDAC}; + #\u{2DDAD}; + #\u{2DDAE}; + #\u{2DDAF}; + #\u{2DDB0}; + #\u{2DDB1}; + #\u{2DDB2}; + #\u{2DDB3}; + #\u{2DDB4}; + #\u{2DDB5}; + #\u{2DDB6}; + #\u{2DDB7}; + #\u{2DDB8}; + #\u{2DDB9}; + #\u{2DDBA}; + #\u{2DDBB}; + #\u{2DDBC}; + #\u{2DDBD}; + #\u{2DDBE}; + #\u{2DDBF}; + #\u{2DDC0}; + #\u{2DDC1}; + #\u{2DDC2}; + #\u{2DDC3}; + #\u{2DDC4}; + #\u{2DDC5}; + #\u{2DDC6}; + #\u{2DDC7}; + #\u{2DDC8}; + #\u{2DDC9}; + #\u{2DDCA}; + #\u{2DDCB}; + #\u{2DDCC}; + #\u{2DDCD}; + #\u{2DDCE}; + #\u{2DDCF}; + #\u{2DDD0}; + #\u{2DDD1}; + #\u{2DDD2}; + #\u{2DDD3}; + #\u{2DDD4}; + #\u{2DDD5}; + #\u{2DDD6}; + #\u{2DDD7}; + #\u{2DDD8}; + #\u{2DDD9}; + #\u{2DDDA}; + #\u{2DDDB}; + #\u{2DDDC}; + #\u{2DDDD}; + #\u{2DDDE}; + #\u{2DDDF}; + #\u{2DDE0}; + #\u{2DDE1}; + #\u{2DDE2}; + #\u{2DDE3}; + #\u{2DDE4}; + #\u{2DDE5}; + #\u{2DDE6}; + #\u{2DDE7}; + #\u{2DDE8}; + #\u{2DDE9}; + #\u{2DDEA}; + #\u{2DDEB}; + #\u{2DDEC}; + #\u{2DDED}; + #\u{2DDEE}; + #\u{2DDEF}; + #\u{2DDF0}; + #\u{2DDF1}; + #\u{2DDF2}; + #\u{2DDF3}; + #\u{2DDF4}; + #\u{2DDF5}; + #\u{2DDF6}; + #\u{2DDF7}; + #\u{2DDF8}; + #\u{2DDF9}; + #\u{2DDFA}; + #\u{2DDFB}; + #\u{2DDFC}; + #\u{2DDFD}; + #\u{2DDFE}; + #\u{2DDFF}; + #\u{2DE00}; + #\u{2DE01}; + #\u{2DE02}; + #\u{2DE03}; + #\u{2DE04}; + #\u{2DE05}; + #\u{2DE06}; + #\u{2DE07}; + #\u{2DE08}; + #\u{2DE09}; + #\u{2DE0A}; + #\u{2DE0B}; + #\u{2DE0C}; + #\u{2DE0D}; + #\u{2DE0E}; + #\u{2DE0F}; + #\u{2DE10}; + #\u{2DE11}; + #\u{2DE12}; + #\u{2DE13}; + #\u{2DE14}; + #\u{2DE15}; + #\u{2DE16}; + #\u{2DE17}; + #\u{2DE18}; + #\u{2DE19}; + #\u{2DE1A}; + #\u{2DE1B}; + #\u{2DE1C}; + #\u{2DE1D}; + #\u{2DE1E}; + #\u{2DE1F}; + #\u{2DE20}; + #\u{2DE21}; + #\u{2DE22}; + #\u{2DE23}; + #\u{2DE24}; + #\u{2DE25}; + #\u{2DE26}; + #\u{2DE27}; + #\u{2DE28}; + #\u{2DE29}; + #\u{2DE2A}; + #\u{2DE2B}; + #\u{2DE2C}; + #\u{2DE2D}; + #\u{2DE2E}; + #\u{2DE2F}; + #\u{2DE30}; + #\u{2DE31}; + #\u{2DE32}; + #\u{2DE33}; + #\u{2DE34}; + #\u{2DE35}; + #\u{2DE36}; + #\u{2DE37}; + #\u{2DE38}; + #\u{2DE39}; + #\u{2DE3A}; + #\u{2DE3B}; + #\u{2DE3C}; + #\u{2DE3D}; + #\u{2DE3E}; + #\u{2DE3F}; + #\u{2DE40}; + #\u{2DE41}; + #\u{2DE42}; + #\u{2DE43}; + #\u{2DE44}; + #\u{2DE45}; + #\u{2DE46}; + #\u{2DE47}; + #\u{2DE48}; + #\u{2DE49}; + #\u{2DE4A}; + #\u{2DE4B}; + #\u{2DE4C}; + #\u{2DE4D}; + #\u{2DE4E}; + #\u{2DE4F}; + #\u{2DE50}; + #\u{2DE51}; + #\u{2DE52}; + #\u{2DE53}; + #\u{2DE54}; + #\u{2DE55}; + #\u{2DE56}; + #\u{2DE57}; + #\u{2DE58}; + #\u{2DE59}; + #\u{2DE5A}; + #\u{2DE5B}; + #\u{2DE5C}; + #\u{2DE5D}; + #\u{2DE5E}; + #\u{2DE5F}; + #\u{2DE60}; + #\u{2DE61}; + #\u{2DE62}; + #\u{2DE63}; + #\u{2DE64}; + #\u{2DE65}; + #\u{2DE66}; + #\u{2DE67}; + #\u{2DE68}; + #\u{2DE69}; + #\u{2DE6A}; + #\u{2DE6B}; + #\u{2DE6C}; + #\u{2DE6D}; + #\u{2DE6E}; + #\u{2DE6F}; + #\u{2DE70}; + #\u{2DE71}; + #\u{2DE72}; + #\u{2DE73}; + #\u{2DE74}; + #\u{2DE75}; + #\u{2DE76}; + #\u{2DE77}; + #\u{2DE78}; + #\u{2DE79}; + #\u{2DE7A}; + #\u{2DE7B}; + #\u{2DE7C}; + #\u{2DE7D}; + #\u{2DE7E}; + #\u{2DE7F}; + #\u{2DE80}; + #\u{2DE81}; + #\u{2DE82}; + #\u{2DE83}; + #\u{2DE84}; + #\u{2DE85}; + #\u{2DE86}; + #\u{2DE87}; + #\u{2DE88}; + #\u{2DE89}; + #\u{2DE8A}; + #\u{2DE8B}; + #\u{2DE8C}; + #\u{2DE8D}; + #\u{2DE8E}; + #\u{2DE8F}; + #\u{2DE90}; + #\u{2DE91}; + #\u{2DE92}; + #\u{2DE93}; + #\u{2DE94}; + #\u{2DE95}; + #\u{2DE96}; + #\u{2DE97}; + #\u{2DE98}; + #\u{2DE99}; + #\u{2DE9A}; + #\u{2DE9B}; + #\u{2DE9C}; + #\u{2DE9D}; + #\u{2DE9E}; + #\u{2DE9F}; + #\u{2DEA0}; + #\u{2DEA1}; + #\u{2DEA2}; + #\u{2DEA3}; + #\u{2DEA4}; + #\u{2DEA5}; + #\u{2DEA6}; + #\u{2DEA7}; + #\u{2DEA8}; + #\u{2DEA9}; + #\u{2DEAA}; + #\u{2DEAB}; + #\u{2DEAC}; + #\u{2DEAD}; + #\u{2DEAE}; + #\u{2DEAF}; + #\u{2DEB0}; + #\u{2DEB1}; + #\u{2DEB2}; + #\u{2DEB3}; + #\u{2DEB4}; + #\u{2DEB5}; + #\u{2DEB6}; + #\u{2DEB7}; + #\u{2DEB8}; + #\u{2DEB9}; + #\u{2DEBA}; + #\u{2DEBB}; + #\u{2DEBC}; + #\u{2DEBD}; + #\u{2DEBE}; + #\u{2DEBF}; + #\u{2DEC0}; + #\u{2DEC1}; + #\u{2DEC2}; + #\u{2DEC3}; + #\u{2DEC4}; + #\u{2DEC5}; + #\u{2DEC6}; + #\u{2DEC7}; + #\u{2DEC8}; + #\u{2DEC9}; + #\u{2DECA}; + #\u{2DECB}; + #\u{2DECC}; + #\u{2DECD}; + #\u{2DECE}; + #\u{2DECF}; + #\u{2DED0}; + #\u{2DED1}; + #\u{2DED2}; + #\u{2DED3}; + #\u{2DED4}; + #\u{2DED5}; + #\u{2DED6}; + #\u{2DED7}; + #\u{2DED8}; + #\u{2DED9}; + #\u{2DEDA}; + #\u{2DEDB}; + #\u{2DEDC}; + #\u{2DEDD}; + #\u{2DEDE}; + #\u{2DEDF}; + #\u{2DEE0}; + #\u{2DEE1}; + #\u{2DEE2}; + #\u{2DEE3}; + #\u{2DEE4}; + #\u{2DEE5}; + #\u{2DEE6}; + #\u{2DEE7}; + #\u{2DEE8}; + #\u{2DEE9}; + #\u{2DEEA}; + #\u{2DEEB}; + #\u{2DEEC}; + #\u{2DEED}; + #\u{2DEEE}; + #\u{2DEEF}; + #\u{2DEF0}; + #\u{2DEF1}; + #\u{2DEF2}; + #\u{2DEF3}; + #\u{2DEF4}; + #\u{2DEF5}; + #\u{2DEF6}; + #\u{2DEF7}; + #\u{2DEF8}; + #\u{2DEF9}; + #\u{2DEFA}; + #\u{2DEFB}; + #\u{2DEFC}; + #\u{2DEFD}; + #\u{2DEFE}; + #\u{2DEFF}; + #\u{2DF00}; + #\u{2DF01}; + #\u{2DF02}; + #\u{2DF03}; + #\u{2DF04}; + #\u{2DF05}; + #\u{2DF06}; + #\u{2DF07}; + #\u{2DF08}; + #\u{2DF09}; + #\u{2DF0A}; + #\u{2DF0B}; + #\u{2DF0C}; + #\u{2DF0D}; + #\u{2DF0E}; + #\u{2DF0F}; + #\u{2DF10}; + #\u{2DF11}; + #\u{2DF12}; + #\u{2DF13}; + #\u{2DF14}; + #\u{2DF15}; + #\u{2DF16}; + #\u{2DF17}; + #\u{2DF18}; + #\u{2DF19}; + #\u{2DF1A}; + #\u{2DF1B}; + #\u{2DF1C}; + #\u{2DF1D}; + #\u{2DF1E}; + #\u{2DF1F}; + #\u{2DF20}; + #\u{2DF21}; + #\u{2DF22}; + #\u{2DF23}; + #\u{2DF24}; + #\u{2DF25}; + #\u{2DF26}; + #\u{2DF27}; + #\u{2DF28}; + #\u{2DF29}; + #\u{2DF2A}; + #\u{2DF2B}; + #\u{2DF2C}; + #\u{2DF2D}; + #\u{2DF2E}; + #\u{2DF2F}; + #\u{2DF30}; + #\u{2DF31}; + #\u{2DF32}; + #\u{2DF33}; + #\u{2DF34}; + #\u{2DF35}; + #\u{2DF36}; + #\u{2DF37}; + #\u{2DF38}; + #\u{2DF39}; + #\u{2DF3A}; + #\u{2DF3B}; + #\u{2DF3C}; + #\u{2DF3D}; + #\u{2DF3E}; + #\u{2DF3F}; + #\u{2DF40}; + #\u{2DF41}; + #\u{2DF42}; + #\u{2DF43}; + #\u{2DF44}; + #\u{2DF45}; + #\u{2DF46}; + #\u{2DF47}; + #\u{2DF48}; + #\u{2DF49}; + #\u{2DF4A}; + #\u{2DF4B}; + #\u{2DF4C}; + #\u{2DF4D}; + #\u{2DF4E}; + #\u{2DF4F}; + #\u{2DF50}; + #\u{2DF51}; + #\u{2DF52}; + #\u{2DF53}; + #\u{2DF54}; + #\u{2DF55}; + #\u{2DF56}; + #\u{2DF57}; + #\u{2DF58}; + #\u{2DF59}; + #\u{2DF5A}; + #\u{2DF5B}; + #\u{2DF5C}; + #\u{2DF5D}; + #\u{2DF5E}; + #\u{2DF5F}; + #\u{2DF60}; + #\u{2DF61}; + #\u{2DF62}; + #\u{2DF63}; + #\u{2DF64}; + #\u{2DF65}; + #\u{2DF66}; + #\u{2DF67}; + #\u{2DF68}; + #\u{2DF69}; + #\u{2DF6A}; + #\u{2DF6B}; + #\u{2DF6C}; + #\u{2DF6D}; + #\u{2DF6E}; + #\u{2DF6F}; + #\u{2DF70}; + #\u{2DF71}; + #\u{2DF72}; + #\u{2DF73}; + #\u{2DF74}; + #\u{2DF75}; + #\u{2DF76}; + #\u{2DF77}; + #\u{2DF78}; + #\u{2DF79}; + #\u{2DF7A}; + #\u{2DF7B}; + #\u{2DF7C}; + #\u{2DF7D}; + #\u{2DF7E}; + #\u{2DF7F}; + #\u{2DF80}; + #\u{2DF81}; + #\u{2DF82}; + #\u{2DF83}; + #\u{2DF84}; + #\u{2DF85}; + #\u{2DF86}; + #\u{2DF87}; + #\u{2DF88}; + #\u{2DF89}; + #\u{2DF8A}; + #\u{2DF8B}; + #\u{2DF8C}; + #\u{2DF8D}; + #\u{2DF8E}; + #\u{2DF8F}; + #\u{2DF90}; + #\u{2DF91}; + #\u{2DF92}; + #\u{2DF93}; + #\u{2DF94}; + #\u{2DF95}; + #\u{2DF96}; + #\u{2DF97}; + #\u{2DF98}; + #\u{2DF99}; + #\u{2DF9A}; + #\u{2DF9B}; + #\u{2DF9C}; + #\u{2DF9D}; + #\u{2DF9E}; + #\u{2DF9F}; + #\u{2DFA0}; + #\u{2DFA1}; + #\u{2DFA2}; + #\u{2DFA3}; + #\u{2DFA4}; + #\u{2DFA5}; + #\u{2DFA6}; + #\u{2DFA7}; + #\u{2DFA8}; + #\u{2DFA9}; + #\u{2DFAA}; + #\u{2DFAB}; + #\u{2DFAC}; + #\u{2DFAD}; + #\u{2DFAE}; + #\u{2DFAF}; + #\u{2DFB0}; + #\u{2DFB1}; + #\u{2DFB2}; + #\u{2DFB3}; + #\u{2DFB4}; + #\u{2DFB5}; + #\u{2DFB6}; + #\u{2DFB7}; + #\u{2DFB8}; + #\u{2DFB9}; + #\u{2DFBA}; + #\u{2DFBB}; + #\u{2DFBC}; + #\u{2DFBD}; + #\u{2DFBE}; + #\u{2DFBF}; + #\u{2DFC0}; + #\u{2DFC1}; + #\u{2DFC2}; + #\u{2DFC3}; + #\u{2DFC4}; + #\u{2DFC5}; + #\u{2DFC6}; + #\u{2DFC7}; + #\u{2DFC8}; + #\u{2DFC9}; + #\u{2DFCA}; + #\u{2DFCB}; + #\u{2DFCC}; + #\u{2DFCD}; + #\u{2DFCE}; + #\u{2DFCF}; + #\u{2DFD0}; + #\u{2DFD1}; + #\u{2DFD2}; + #\u{2DFD3}; + #\u{2DFD4}; + #\u{2DFD5}; + #\u{2DFD6}; + #\u{2DFD7}; + #\u{2DFD8}; + #\u{2DFD9}; + #\u{2DFDA}; + #\u{2DFDB}; + #\u{2DFDC}; + #\u{2DFDD}; + #\u{2DFDE}; + #\u{2DFDF}; + #\u{2DFE0}; + #\u{2DFE1}; + #\u{2DFE2}; + #\u{2DFE3}; + #\u{2DFE4}; + #\u{2DFE5}; + #\u{2DFE6}; + #\u{2DFE7}; + #\u{2DFE8}; + #\u{2DFE9}; + #\u{2DFEA}; + #\u{2DFEB}; + #\u{2DFEC}; + #\u{2DFED}; + #\u{2DFEE}; + #\u{2DFEF}; + #\u{2DFF0}; + #\u{2DFF1}; + #\u{2DFF2}; + #\u{2DFF3}; + #\u{2DFF4}; + #\u{2DFF5}; + #\u{2DFF6}; + #\u{2DFF7}; + #\u{2DFF8}; + #\u{2DFF9}; + #\u{2DFFA}; + #\u{2DFFB}; + #\u{2DFFC}; + #\u{2DFFD}; + #\u{2DFFE}; + #\u{2DFFF}; + #\u{2E000}; + #\u{2E001}; + #\u{2E002}; + #\u{2E003}; + #\u{2E004}; + #\u{2E005}; + #\u{2E006}; + #\u{2E007}; + #\u{2E008}; + #\u{2E009}; + #\u{2E00A}; + #\u{2E00B}; + #\u{2E00C}; + #\u{2E00D}; + #\u{2E00E}; + #\u{2E00F}; + #\u{2E010}; + #\u{2E011}; + #\u{2E012}; + #\u{2E013}; + #\u{2E014}; + #\u{2E015}; + #\u{2E016}; + #\u{2E017}; + #\u{2E018}; + #\u{2E019}; + #\u{2E01A}; + #\u{2E01B}; + #\u{2E01C}; + #\u{2E01D}; + #\u{2E01E}; + #\u{2E01F}; + #\u{2E020}; + #\u{2E021}; + #\u{2E022}; + #\u{2E023}; + #\u{2E024}; + #\u{2E025}; + #\u{2E026}; + #\u{2E027}; + #\u{2E028}; + #\u{2E029}; + #\u{2E02A}; + #\u{2E02B}; + #\u{2E02C}; + #\u{2E02D}; + #\u{2E02E}; + #\u{2E02F}; + #\u{2E030}; + #\u{2E031}; + #\u{2E032}; + #\u{2E033}; + #\u{2E034}; + #\u{2E035}; + #\u{2E036}; + #\u{2E037}; + #\u{2E038}; + #\u{2E039}; + #\u{2E03A}; + #\u{2E03B}; + #\u{2E03C}; + #\u{2E03D}; + #\u{2E03E}; + #\u{2E03F}; + #\u{2E040}; + #\u{2E041}; + #\u{2E042}; + #\u{2E043}; + #\u{2E044}; + #\u{2E045}; + #\u{2E046}; + #\u{2E047}; + #\u{2E048}; + #\u{2E049}; + #\u{2E04A}; + #\u{2E04B}; + #\u{2E04C}; + #\u{2E04D}; + #\u{2E04E}; + #\u{2E04F}; + #\u{2E050}; + #\u{2E051}; + #\u{2E052}; + #\u{2E053}; + #\u{2E054}; + #\u{2E055}; + #\u{2E056}; + #\u{2E057}; + #\u{2E058}; + #\u{2E059}; + #\u{2E05A}; + #\u{2E05B}; + #\u{2E05C}; + #\u{2E05D}; + #\u{2E05E}; + #\u{2E05F}; + #\u{2E060}; + #\u{2E061}; + #\u{2E062}; + #\u{2E063}; + #\u{2E064}; + #\u{2E065}; + #\u{2E066}; + #\u{2E067}; + #\u{2E068}; + #\u{2E069}; + #\u{2E06A}; + #\u{2E06B}; + #\u{2E06C}; + #\u{2E06D}; + #\u{2E06E}; + #\u{2E06F}; + #\u{2E070}; + #\u{2E071}; + #\u{2E072}; + #\u{2E073}; + #\u{2E074}; + #\u{2E075}; + #\u{2E076}; + #\u{2E077}; + #\u{2E078}; + #\u{2E079}; + #\u{2E07A}; + #\u{2E07B}; + #\u{2E07C}; + #\u{2E07D}; + #\u{2E07E}; + #\u{2E07F}; + #\u{2E080}; + #\u{2E081}; + #\u{2E082}; + #\u{2E083}; + #\u{2E084}; + #\u{2E085}; + #\u{2E086}; + #\u{2E087}; + #\u{2E088}; + #\u{2E089}; + #\u{2E08A}; + #\u{2E08B}; + #\u{2E08C}; + #\u{2E08D}; + #\u{2E08E}; + #\u{2E08F}; + #\u{2E090}; + #\u{2E091}; + #\u{2E092}; + #\u{2E093}; + #\u{2E094}; + #\u{2E095}; + #\u{2E096}; + #\u{2E097}; + #\u{2E098}; + #\u{2E099}; + #\u{2E09A}; + #\u{2E09B}; + #\u{2E09C}; + #\u{2E09D}; + #\u{2E09E}; + #\u{2E09F}; + #\u{2E0A0}; + #\u{2E0A1}; + #\u{2E0A2}; + #\u{2E0A3}; + #\u{2E0A4}; + #\u{2E0A5}; + #\u{2E0A6}; + #\u{2E0A7}; + #\u{2E0A8}; + #\u{2E0A9}; + #\u{2E0AA}; + #\u{2E0AB}; + #\u{2E0AC}; + #\u{2E0AD}; + #\u{2E0AE}; + #\u{2E0AF}; + #\u{2E0B0}; + #\u{2E0B1}; + #\u{2E0B2}; + #\u{2E0B3}; + #\u{2E0B4}; + #\u{2E0B5}; + #\u{2E0B6}; + #\u{2E0B7}; + #\u{2E0B8}; + #\u{2E0B9}; + #\u{2E0BA}; + #\u{2E0BB}; + #\u{2E0BC}; + #\u{2E0BD}; + #\u{2E0BE}; + #\u{2E0BF}; + #\u{2E0C0}; + #\u{2E0C1}; + #\u{2E0C2}; + #\u{2E0C3}; + #\u{2E0C4}; + #\u{2E0C5}; + #\u{2E0C6}; + #\u{2E0C7}; + #\u{2E0C8}; + #\u{2E0C9}; + #\u{2E0CA}; + #\u{2E0CB}; + #\u{2E0CC}; + #\u{2E0CD}; + #\u{2E0CE}; + #\u{2E0CF}; + #\u{2E0D0}; + #\u{2E0D1}; + #\u{2E0D2}; + #\u{2E0D3}; + #\u{2E0D4}; + #\u{2E0D5}; + #\u{2E0D6}; + #\u{2E0D7}; + #\u{2E0D8}; + #\u{2E0D9}; + #\u{2E0DA}; + #\u{2E0DB}; + #\u{2E0DC}; + #\u{2E0DD}; + #\u{2E0DE}; + #\u{2E0DF}; + #\u{2E0E0}; + #\u{2E0E1}; + #\u{2E0E2}; + #\u{2E0E3}; + #\u{2E0E4}; + #\u{2E0E5}; + #\u{2E0E6}; + #\u{2E0E7}; + #\u{2E0E8}; + #\u{2E0E9}; + #\u{2E0EA}; + #\u{2E0EB}; + #\u{2E0EC}; + #\u{2E0ED}; + #\u{2E0EE}; + #\u{2E0EF}; + #\u{2E0F0}; + #\u{2E0F1}; + #\u{2E0F2}; + #\u{2E0F3}; + #\u{2E0F4}; + #\u{2E0F5}; + #\u{2E0F6}; + #\u{2E0F7}; + #\u{2E0F8}; + #\u{2E0F9}; + #\u{2E0FA}; + #\u{2E0FB}; + #\u{2E0FC}; + #\u{2E0FD}; + #\u{2E0FE}; + #\u{2E0FF}; + #\u{2E100}; + #\u{2E101}; + #\u{2E102}; + #\u{2E103}; + #\u{2E104}; + #\u{2E105}; + #\u{2E106}; + #\u{2E107}; + #\u{2E108}; + #\u{2E109}; + #\u{2E10A}; + #\u{2E10B}; + #\u{2E10C}; + #\u{2E10D}; + #\u{2E10E}; + #\u{2E10F}; + #\u{2E110}; + #\u{2E111}; + #\u{2E112}; + #\u{2E113}; + #\u{2E114}; + #\u{2E115}; + #\u{2E116}; + #\u{2E117}; + #\u{2E118}; + #\u{2E119}; + #\u{2E11A}; + #\u{2E11B}; + #\u{2E11C}; + #\u{2E11D}; + #\u{2E11E}; + #\u{2E11F}; + #\u{2E120}; + #\u{2E121}; + #\u{2E122}; + #\u{2E123}; + #\u{2E124}; + #\u{2E125}; + #\u{2E126}; + #\u{2E127}; + #\u{2E128}; + #\u{2E129}; + #\u{2E12A}; + #\u{2E12B}; + #\u{2E12C}; + #\u{2E12D}; + #\u{2E12E}; + #\u{2E12F}; + #\u{2E130}; + #\u{2E131}; + #\u{2E132}; + #\u{2E133}; + #\u{2E134}; + #\u{2E135}; + #\u{2E136}; + #\u{2E137}; + #\u{2E138}; + #\u{2E139}; + #\u{2E13A}; + #\u{2E13B}; + #\u{2E13C}; + #\u{2E13D}; + #\u{2E13E}; + #\u{2E13F}; + #\u{2E140}; + #\u{2E141}; + #\u{2E142}; + #\u{2E143}; + #\u{2E144}; + #\u{2E145}; + #\u{2E146}; + #\u{2E147}; + #\u{2E148}; + #\u{2E149}; + #\u{2E14A}; + #\u{2E14B}; + #\u{2E14C}; + #\u{2E14D}; + #\u{2E14E}; + #\u{2E14F}; + #\u{2E150}; + #\u{2E151}; + #\u{2E152}; + #\u{2E153}; + #\u{2E154}; + #\u{2E155}; + #\u{2E156}; + #\u{2E157}; + #\u{2E158}; + #\u{2E159}; + #\u{2E15A}; + #\u{2E15B}; + #\u{2E15C}; + #\u{2E15D}; + #\u{2E15E}; + #\u{2E15F}; + #\u{2E160}; + #\u{2E161}; + #\u{2E162}; + #\u{2E163}; + #\u{2E164}; + #\u{2E165}; + #\u{2E166}; + #\u{2E167}; + #\u{2E168}; + #\u{2E169}; + #\u{2E16A}; + #\u{2E16B}; + #\u{2E16C}; + #\u{2E16D}; + #\u{2E16E}; + #\u{2E16F}; + #\u{2E170}; + #\u{2E171}; + #\u{2E172}; + #\u{2E173}; + #\u{2E174}; + #\u{2E175}; + #\u{2E176}; + #\u{2E177}; + #\u{2E178}; + #\u{2E179}; + #\u{2E17A}; + #\u{2E17B}; + #\u{2E17C}; + #\u{2E17D}; + #\u{2E17E}; + #\u{2E17F}; + #\u{2E180}; + #\u{2E181}; + #\u{2E182}; + #\u{2E183}; + #\u{2E184}; + #\u{2E185}; + #\u{2E186}; + #\u{2E187}; + #\u{2E188}; + #\u{2E189}; + #\u{2E18A}; + #\u{2E18B}; + #\u{2E18C}; + #\u{2E18D}; + #\u{2E18E}; + #\u{2E18F}; + #\u{2E190}; + #\u{2E191}; + #\u{2E192}; + #\u{2E193}; + #\u{2E194}; + #\u{2E195}; + #\u{2E196}; + #\u{2E197}; + #\u{2E198}; + #\u{2E199}; + #\u{2E19A}; + #\u{2E19B}; + #\u{2E19C}; + #\u{2E19D}; + #\u{2E19E}; + #\u{2E19F}; + #\u{2E1A0}; + #\u{2E1A1}; + #\u{2E1A2}; + #\u{2E1A3}; + #\u{2E1A4}; + #\u{2E1A5}; + #\u{2E1A6}; + #\u{2E1A7}; + #\u{2E1A8}; + #\u{2E1A9}; + #\u{2E1AA}; + #\u{2E1AB}; + #\u{2E1AC}; + #\u{2E1AD}; + #\u{2E1AE}; + #\u{2E1AF}; + #\u{2E1B0}; + #\u{2E1B1}; + #\u{2E1B2}; + #\u{2E1B3}; + #\u{2E1B4}; + #\u{2E1B5}; + #\u{2E1B6}; + #\u{2E1B7}; + #\u{2E1B8}; + #\u{2E1B9}; + #\u{2E1BA}; + #\u{2E1BB}; + #\u{2E1BC}; + #\u{2E1BD}; + #\u{2E1BE}; + #\u{2E1BF}; + #\u{2E1C0}; + #\u{2E1C1}; + #\u{2E1C2}; + #\u{2E1C3}; + #\u{2E1C4}; + #\u{2E1C5}; + #\u{2E1C6}; + #\u{2E1C7}; + #\u{2E1C8}; + #\u{2E1C9}; + #\u{2E1CA}; + #\u{2E1CB}; + #\u{2E1CC}; + #\u{2E1CD}; + #\u{2E1CE}; + #\u{2E1CF}; + #\u{2E1D0}; + #\u{2E1D1}; + #\u{2E1D2}; + #\u{2E1D3}; + #\u{2E1D4}; + #\u{2E1D5}; + #\u{2E1D6}; + #\u{2E1D7}; + #\u{2E1D8}; + #\u{2E1D9}; + #\u{2E1DA}; + #\u{2E1DB}; + #\u{2E1DC}; + #\u{2E1DD}; + #\u{2E1DE}; + #\u{2E1DF}; + #\u{2E1E0}; + #\u{2E1E1}; + #\u{2E1E2}; + #\u{2E1E3}; + #\u{2E1E4}; + #\u{2E1E5}; + #\u{2E1E6}; + #\u{2E1E7}; + #\u{2E1E8}; + #\u{2E1E9}; + #\u{2E1EA}; + #\u{2E1EB}; + #\u{2E1EC}; + #\u{2E1ED}; + #\u{2E1EE}; + #\u{2E1EF}; + #\u{2E1F0}; + #\u{2E1F1}; + #\u{2E1F2}; + #\u{2E1F3}; + #\u{2E1F4}; + #\u{2E1F5}; + #\u{2E1F6}; + #\u{2E1F7}; + #\u{2E1F8}; + #\u{2E1F9}; + #\u{2E1FA}; + #\u{2E1FB}; + #\u{2E1FC}; + #\u{2E1FD}; + #\u{2E1FE}; + #\u{2E1FF}; + #\u{2E200}; + #\u{2E201}; + #\u{2E202}; + #\u{2E203}; + #\u{2E204}; + #\u{2E205}; + #\u{2E206}; + #\u{2E207}; + #\u{2E208}; + #\u{2E209}; + #\u{2E20A}; + #\u{2E20B}; + #\u{2E20C}; + #\u{2E20D}; + #\u{2E20E}; + #\u{2E20F}; + #\u{2E210}; + #\u{2E211}; + #\u{2E212}; + #\u{2E213}; + #\u{2E214}; + #\u{2E215}; + #\u{2E216}; + #\u{2E217}; + #\u{2E218}; + #\u{2E219}; + #\u{2E21A}; + #\u{2E21B}; + #\u{2E21C}; + #\u{2E21D}; + #\u{2E21E}; + #\u{2E21F}; + #\u{2E220}; + #\u{2E221}; + #\u{2E222}; + #\u{2E223}; + #\u{2E224}; + #\u{2E225}; + #\u{2E226}; + #\u{2E227}; + #\u{2E228}; + #\u{2E229}; + #\u{2E22A}; + #\u{2E22B}; + #\u{2E22C}; + #\u{2E22D}; + #\u{2E22E}; + #\u{2E22F}; + #\u{2E230}; + #\u{2E231}; + #\u{2E232}; + #\u{2E233}; + #\u{2E234}; + #\u{2E235}; + #\u{2E236}; + #\u{2E237}; + #\u{2E238}; + #\u{2E239}; + #\u{2E23A}; + #\u{2E23B}; + #\u{2E23C}; + #\u{2E23D}; + #\u{2E23E}; + #\u{2E23F}; + #\u{2E240}; + #\u{2E241}; + #\u{2E242}; + #\u{2E243}; + #\u{2E244}; + #\u{2E245}; + #\u{2E246}; + #\u{2E247}; + #\u{2E248}; + #\u{2E249}; + #\u{2E24A}; + #\u{2E24B}; + #\u{2E24C}; + #\u{2E24D}; + #\u{2E24E}; + #\u{2E24F}; + #\u{2E250}; + #\u{2E251}; + #\u{2E252}; + #\u{2E253}; + #\u{2E254}; + #\u{2E255}; + #\u{2E256}; + #\u{2E257}; + #\u{2E258}; + #\u{2E259}; + #\u{2E25A}; + #\u{2E25B}; + #\u{2E25C}; + #\u{2E25D}; + #\u{2E25E}; + #\u{2E25F}; + #\u{2E260}; + #\u{2E261}; + #\u{2E262}; + #\u{2E263}; + #\u{2E264}; + #\u{2E265}; + #\u{2E266}; + #\u{2E267}; + #\u{2E268}; + #\u{2E269}; + #\u{2E26A}; + #\u{2E26B}; + #\u{2E26C}; + #\u{2E26D}; + #\u{2E26E}; + #\u{2E26F}; + #\u{2E270}; + #\u{2E271}; + #\u{2E272}; + #\u{2E273}; + #\u{2E274}; + #\u{2E275}; + #\u{2E276}; + #\u{2E277}; + #\u{2E278}; + #\u{2E279}; + #\u{2E27A}; + #\u{2E27B}; + #\u{2E27C}; + #\u{2E27D}; + #\u{2E27E}; + #\u{2E27F}; + #\u{2E280}; + #\u{2E281}; + #\u{2E282}; + #\u{2E283}; + #\u{2E284}; + #\u{2E285}; + #\u{2E286}; + #\u{2E287}; + #\u{2E288}; + #\u{2E289}; + #\u{2E28A}; + #\u{2E28B}; + #\u{2E28C}; + #\u{2E28D}; + #\u{2E28E}; + #\u{2E28F}; + #\u{2E290}; + #\u{2E291}; + #\u{2E292}; + #\u{2E293}; + #\u{2E294}; + #\u{2E295}; + #\u{2E296}; + #\u{2E297}; + #\u{2E298}; + #\u{2E299}; + #\u{2E29A}; + #\u{2E29B}; + #\u{2E29C}; + #\u{2E29D}; + #\u{2E29E}; + #\u{2E29F}; + #\u{2E2A0}; + #\u{2E2A1}; + #\u{2E2A2}; + #\u{2E2A3}; + #\u{2E2A4}; + #\u{2E2A5}; + #\u{2E2A6}; + #\u{2E2A7}; + #\u{2E2A8}; + #\u{2E2A9}; + #\u{2E2AA}; + #\u{2E2AB}; + #\u{2E2AC}; + #\u{2E2AD}; + #\u{2E2AE}; + #\u{2E2AF}; + #\u{2E2B0}; + #\u{2E2B1}; + #\u{2E2B2}; + #\u{2E2B3}; + #\u{2E2B4}; + #\u{2E2B5}; + #\u{2E2B6}; + #\u{2E2B7}; + #\u{2E2B8}; + #\u{2E2B9}; + #\u{2E2BA}; + #\u{2E2BB}; + #\u{2E2BC}; + #\u{2E2BD}; + #\u{2E2BE}; + #\u{2E2BF}; + #\u{2E2C0}; + #\u{2E2C1}; + #\u{2E2C2}; + #\u{2E2C3}; + #\u{2E2C4}; + #\u{2E2C5}; + #\u{2E2C6}; + #\u{2E2C7}; + #\u{2E2C8}; + #\u{2E2C9}; + #\u{2E2CA}; + #\u{2E2CB}; + #\u{2E2CC}; + #\u{2E2CD}; + #\u{2E2CE}; + #\u{2E2CF}; + #\u{2E2D0}; + #\u{2E2D1}; + #\u{2E2D2}; + #\u{2E2D3}; + #\u{2E2D4}; + #\u{2E2D5}; + #\u{2E2D6}; + #\u{2E2D7}; + #\u{2E2D8}; + #\u{2E2D9}; + #\u{2E2DA}; + #\u{2E2DB}; + #\u{2E2DC}; + #\u{2E2DD}; + #\u{2E2DE}; + #\u{2E2DF}; + #\u{2E2E0}; + #\u{2E2E1}; + #\u{2E2E2}; + #\u{2E2E3}; + #\u{2E2E4}; + #\u{2E2E5}; + #\u{2E2E6}; + #\u{2E2E7}; + #\u{2E2E8}; + #\u{2E2E9}; + #\u{2E2EA}; + #\u{2E2EB}; + #\u{2E2EC}; + #\u{2E2ED}; + #\u{2E2EE}; + #\u{2E2EF}; + #\u{2E2F0}; + #\u{2E2F1}; + #\u{2E2F2}; + #\u{2E2F3}; + #\u{2E2F4}; + #\u{2E2F5}; + #\u{2E2F6}; + #\u{2E2F7}; + #\u{2E2F8}; + #\u{2E2F9}; + #\u{2E2FA}; + #\u{2E2FB}; + #\u{2E2FC}; + #\u{2E2FD}; + #\u{2E2FE}; + #\u{2E2FF}; + #\u{2E300}; + #\u{2E301}; + #\u{2E302}; + #\u{2E303}; + #\u{2E304}; + #\u{2E305}; + #\u{2E306}; + #\u{2E307}; + #\u{2E308}; + #\u{2E309}; + #\u{2E30A}; + #\u{2E30B}; + #\u{2E30C}; + #\u{2E30D}; + #\u{2E30E}; + #\u{2E30F}; + #\u{2E310}; + #\u{2E311}; + #\u{2E312}; + #\u{2E313}; + #\u{2E314}; + #\u{2E315}; + #\u{2E316}; + #\u{2E317}; + #\u{2E318}; + #\u{2E319}; + #\u{2E31A}; + #\u{2E31B}; + #\u{2E31C}; + #\u{2E31D}; + #\u{2E31E}; + #\u{2E31F}; + #\u{2E320}; + #\u{2E321}; + #\u{2E322}; + #\u{2E323}; + #\u{2E324}; + #\u{2E325}; + #\u{2E326}; + #\u{2E327}; + #\u{2E328}; + #\u{2E329}; + #\u{2E32A}; + #\u{2E32B}; + #\u{2E32C}; + #\u{2E32D}; + #\u{2E32E}; + #\u{2E32F}; + #\u{2E330}; + #\u{2E331}; + #\u{2E332}; + #\u{2E333}; + #\u{2E334}; + #\u{2E335}; + #\u{2E336}; + #\u{2E337}; + #\u{2E338}; + #\u{2E339}; + #\u{2E33A}; + #\u{2E33B}; + #\u{2E33C}; + #\u{2E33D}; + #\u{2E33E}; + #\u{2E33F}; + #\u{2E340}; + #\u{2E341}; + #\u{2E342}; + #\u{2E343}; + #\u{2E344}; + #\u{2E345}; + #\u{2E346}; + #\u{2E347}; + #\u{2E348}; + #\u{2E349}; + #\u{2E34A}; + #\u{2E34B}; + #\u{2E34C}; + #\u{2E34D}; + #\u{2E34E}; + #\u{2E34F}; + #\u{2E350}; + #\u{2E351}; + #\u{2E352}; + #\u{2E353}; + #\u{2E354}; + #\u{2E355}; + #\u{2E356}; + #\u{2E357}; + #\u{2E358}; + #\u{2E359}; + #\u{2E35A}; + #\u{2E35B}; + #\u{2E35C}; + #\u{2E35D}; + #\u{2E35E}; + #\u{2E35F}; + #\u{2E360}; + #\u{2E361}; + #\u{2E362}; + #\u{2E363}; + #\u{2E364}; + #\u{2E365}; + #\u{2E366}; + #\u{2E367}; + #\u{2E368}; + #\u{2E369}; + #\u{2E36A}; + #\u{2E36B}; + #\u{2E36C}; + #\u{2E36D}; + #\u{2E36E}; + #\u{2E36F}; + #\u{2E370}; + #\u{2E371}; + #\u{2E372}; + #\u{2E373}; + #\u{2E374}; + #\u{2E375}; + #\u{2E376}; + #\u{2E377}; + #\u{2E378}; + #\u{2E379}; + #\u{2E37A}; + #\u{2E37B}; + #\u{2E37C}; + #\u{2E37D}; + #\u{2E37E}; + #\u{2E37F}; + #\u{2E380}; + #\u{2E381}; + #\u{2E382}; + #\u{2E383}; + #\u{2E384}; + #\u{2E385}; + #\u{2E386}; + #\u{2E387}; + #\u{2E388}; + #\u{2E389}; + #\u{2E38A}; + #\u{2E38B}; + #\u{2E38C}; + #\u{2E38D}; + #\u{2E38E}; + #\u{2E38F}; + #\u{2E390}; + #\u{2E391}; + #\u{2E392}; + #\u{2E393}; + #\u{2E394}; + #\u{2E395}; + #\u{2E396}; + #\u{2E397}; + #\u{2E398}; + #\u{2E399}; + #\u{2E39A}; + #\u{2E39B}; + #\u{2E39C}; + #\u{2E39D}; + #\u{2E39E}; + #\u{2E39F}; + #\u{2E3A0}; + #\u{2E3A1}; + #\u{2E3A2}; + #\u{2E3A3}; + #\u{2E3A4}; + #\u{2E3A5}; + #\u{2E3A6}; + #\u{2E3A7}; + #\u{2E3A8}; + #\u{2E3A9}; + #\u{2E3AA}; + #\u{2E3AB}; + #\u{2E3AC}; + #\u{2E3AD}; + #\u{2E3AE}; + #\u{2E3AF}; + #\u{2E3B0}; + #\u{2E3B1}; + #\u{2E3B2}; + #\u{2E3B3}; + #\u{2E3B4}; + #\u{2E3B5}; + #\u{2E3B6}; + #\u{2E3B7}; + #\u{2E3B8}; + #\u{2E3B9}; + #\u{2E3BA}; + #\u{2E3BB}; + #\u{2E3BC}; + #\u{2E3BD}; + #\u{2E3BE}; + #\u{2E3BF}; + #\u{2E3C0}; + #\u{2E3C1}; + #\u{2E3C2}; + #\u{2E3C3}; + #\u{2E3C4}; + #\u{2E3C5}; + #\u{2E3C6}; + #\u{2E3C7}; + #\u{2E3C8}; + #\u{2E3C9}; + #\u{2E3CA}; + #\u{2E3CB}; + #\u{2E3CC}; + #\u{2E3CD}; + #\u{2E3CE}; + #\u{2E3CF}; + #\u{2E3D0}; + #\u{2E3D1}; + #\u{2E3D2}; + #\u{2E3D3}; + #\u{2E3D4}; + #\u{2E3D5}; + #\u{2E3D6}; + #\u{2E3D7}; + #\u{2E3D8}; + #\u{2E3D9}; + #\u{2E3DA}; + #\u{2E3DB}; + #\u{2E3DC}; + #\u{2E3DD}; + #\u{2E3DE}; + #\u{2E3DF}; + #\u{2E3E0}; + #\u{2E3E1}; + #\u{2E3E2}; + #\u{2E3E3}; + #\u{2E3E4}; + #\u{2E3E5}; + #\u{2E3E6}; + #\u{2E3E7}; + #\u{2E3E8}; + #\u{2E3E9}; + #\u{2E3EA}; + #\u{2E3EB}; + #\u{2E3EC}; + #\u{2E3ED}; + #\u{2E3EE}; + #\u{2E3EF}; + #\u{2E3F0}; + #\u{2E3F1}; + #\u{2E3F2}; + #\u{2E3F3}; + #\u{2E3F4}; + #\u{2E3F5}; + #\u{2E3F6}; + #\u{2E3F7}; + #\u{2E3F8}; + #\u{2E3F9}; + #\u{2E3FA}; + #\u{2E3FB}; + #\u{2E3FC}; + #\u{2E3FD}; + #\u{2E3FE}; + #\u{2E3FF}; + #\u{2E400}; + #\u{2E401}; + #\u{2E402}; + #\u{2E403}; + #\u{2E404}; + #\u{2E405}; + #\u{2E406}; + #\u{2E407}; + #\u{2E408}; + #\u{2E409}; + #\u{2E40A}; + #\u{2E40B}; + #\u{2E40C}; + #\u{2E40D}; + #\u{2E40E}; + #\u{2E40F}; + #\u{2E410}; + #\u{2E411}; + #\u{2E412}; + #\u{2E413}; + #\u{2E414}; + #\u{2E415}; + #\u{2E416}; + #\u{2E417}; + #\u{2E418}; + #\u{2E419}; + #\u{2E41A}; + #\u{2E41B}; + #\u{2E41C}; + #\u{2E41D}; + #\u{2E41E}; + #\u{2E41F}; + #\u{2E420}; + #\u{2E421}; + #\u{2E422}; + #\u{2E423}; + #\u{2E424}; + #\u{2E425}; + #\u{2E426}; + #\u{2E427}; + #\u{2E428}; + #\u{2E429}; + #\u{2E42A}; + #\u{2E42B}; + #\u{2E42C}; + #\u{2E42D}; + #\u{2E42E}; + #\u{2E42F}; + #\u{2E430}; + #\u{2E431}; + #\u{2E432}; + #\u{2E433}; + #\u{2E434}; + #\u{2E435}; + #\u{2E436}; + #\u{2E437}; + #\u{2E438}; + #\u{2E439}; + #\u{2E43A}; + #\u{2E43B}; + #\u{2E43C}; + #\u{2E43D}; + #\u{2E43E}; + #\u{2E43F}; + #\u{2E440}; + #\u{2E441}; + #\u{2E442}; + #\u{2E443}; + #\u{2E444}; + #\u{2E445}; + #\u{2E446}; + #\u{2E447}; + #\u{2E448}; + #\u{2E449}; + #\u{2E44A}; + #\u{2E44B}; + #\u{2E44C}; + #\u{2E44D}; + #\u{2E44E}; + #\u{2E44F}; + #\u{2E450}; + #\u{2E451}; + #\u{2E452}; + #\u{2E453}; + #\u{2E454}; + #\u{2E455}; + #\u{2E456}; + #\u{2E457}; + #\u{2E458}; + #\u{2E459}; + #\u{2E45A}; + #\u{2E45B}; + #\u{2E45C}; + #\u{2E45D}; + #\u{2E45E}; + #\u{2E45F}; + #\u{2E460}; + #\u{2E461}; + #\u{2E462}; + #\u{2E463}; + #\u{2E464}; + #\u{2E465}; + #\u{2E466}; + #\u{2E467}; + #\u{2E468}; + #\u{2E469}; + #\u{2E46A}; + #\u{2E46B}; + #\u{2E46C}; + #\u{2E46D}; + #\u{2E46E}; + #\u{2E46F}; + #\u{2E470}; + #\u{2E471}; + #\u{2E472}; + #\u{2E473}; + #\u{2E474}; + #\u{2E475}; + #\u{2E476}; + #\u{2E477}; + #\u{2E478}; + #\u{2E479}; + #\u{2E47A}; + #\u{2E47B}; + #\u{2E47C}; + #\u{2E47D}; + #\u{2E47E}; + #\u{2E47F}; + #\u{2E480}; + #\u{2E481}; + #\u{2E482}; + #\u{2E483}; + #\u{2E484}; + #\u{2E485}; + #\u{2E486}; + #\u{2E487}; + #\u{2E488}; + #\u{2E489}; + #\u{2E48A}; + #\u{2E48B}; + #\u{2E48C}; + #\u{2E48D}; + #\u{2E48E}; + #\u{2E48F}; + #\u{2E490}; + #\u{2E491}; + #\u{2E492}; + #\u{2E493}; + #\u{2E494}; + #\u{2E495}; + #\u{2E496}; + #\u{2E497}; + #\u{2E498}; + #\u{2E499}; + #\u{2E49A}; + #\u{2E49B}; + #\u{2E49C}; + #\u{2E49D}; + #\u{2E49E}; + #\u{2E49F}; + #\u{2E4A0}; + #\u{2E4A1}; + #\u{2E4A2}; + #\u{2E4A3}; + #\u{2E4A4}; + #\u{2E4A5}; + #\u{2E4A6}; + #\u{2E4A7}; + #\u{2E4A8}; + #\u{2E4A9}; + #\u{2E4AA}; + #\u{2E4AB}; + #\u{2E4AC}; + #\u{2E4AD}; + #\u{2E4AE}; + #\u{2E4AF}; + #\u{2E4B0}; + #\u{2E4B1}; + #\u{2E4B2}; + #\u{2E4B3}; + #\u{2E4B4}; + #\u{2E4B5}; + #\u{2E4B6}; + #\u{2E4B7}; + #\u{2E4B8}; + #\u{2E4B9}; + #\u{2E4BA}; + #\u{2E4BB}; + #\u{2E4BC}; + #\u{2E4BD}; + #\u{2E4BE}; + #\u{2E4BF}; + #\u{2E4C0}; + #\u{2E4C1}; + #\u{2E4C2}; + #\u{2E4C3}; + #\u{2E4C4}; + #\u{2E4C5}; + #\u{2E4C6}; + #\u{2E4C7}; + #\u{2E4C8}; + #\u{2E4C9}; + #\u{2E4CA}; + #\u{2E4CB}; + #\u{2E4CC}; + #\u{2E4CD}; + #\u{2E4CE}; + #\u{2E4CF}; + #\u{2E4D0}; + #\u{2E4D1}; + #\u{2E4D2}; + #\u{2E4D3}; + #\u{2E4D4}; + #\u{2E4D5}; + #\u{2E4D6}; + #\u{2E4D7}; + #\u{2E4D8}; + #\u{2E4D9}; + #\u{2E4DA}; + #\u{2E4DB}; + #\u{2E4DC}; + #\u{2E4DD}; + #\u{2E4DE}; + #\u{2E4DF}; + #\u{2E4E0}; + #\u{2E4E1}; + #\u{2E4E2}; + #\u{2E4E3}; + #\u{2E4E4}; + #\u{2E4E5}; + #\u{2E4E6}; + #\u{2E4E7}; + #\u{2E4E8}; + #\u{2E4E9}; + #\u{2E4EA}; + #\u{2E4EB}; + #\u{2E4EC}; + #\u{2E4ED}; + #\u{2E4EE}; + #\u{2E4EF}; + #\u{2E4F0}; + #\u{2E4F1}; + #\u{2E4F2}; + #\u{2E4F3}; + #\u{2E4F4}; + #\u{2E4F5}; + #\u{2E4F6}; + #\u{2E4F7}; + #\u{2E4F8}; + #\u{2E4F9}; + #\u{2E4FA}; + #\u{2E4FB}; + #\u{2E4FC}; + #\u{2E4FD}; + #\u{2E4FE}; + #\u{2E4FF}; + #\u{2E500}; + #\u{2E501}; + #\u{2E502}; + #\u{2E503}; + #\u{2E504}; + #\u{2E505}; + #\u{2E506}; + #\u{2E507}; + #\u{2E508}; + #\u{2E509}; + #\u{2E50A}; + #\u{2E50B}; + #\u{2E50C}; + #\u{2E50D}; + #\u{2E50E}; + #\u{2E50F}; + #\u{2E510}; + #\u{2E511}; + #\u{2E512}; + #\u{2E513}; + #\u{2E514}; + #\u{2E515}; + #\u{2E516}; + #\u{2E517}; + #\u{2E518}; + #\u{2E519}; + #\u{2E51A}; + #\u{2E51B}; + #\u{2E51C}; + #\u{2E51D}; + #\u{2E51E}; + #\u{2E51F}; + #\u{2E520}; + #\u{2E521}; + #\u{2E522}; + #\u{2E523}; + #\u{2E524}; + #\u{2E525}; + #\u{2E526}; + #\u{2E527}; + #\u{2E528}; + #\u{2E529}; + #\u{2E52A}; + #\u{2E52B}; + #\u{2E52C}; + #\u{2E52D}; + #\u{2E52E}; + #\u{2E52F}; + #\u{2E530}; + #\u{2E531}; + #\u{2E532}; + #\u{2E533}; + #\u{2E534}; + #\u{2E535}; + #\u{2E536}; + #\u{2E537}; + #\u{2E538}; + #\u{2E539}; + #\u{2E53A}; + #\u{2E53B}; + #\u{2E53C}; + #\u{2E53D}; + #\u{2E53E}; + #\u{2E53F}; + #\u{2E540}; + #\u{2E541}; + #\u{2E542}; + #\u{2E543}; + #\u{2E544}; + #\u{2E545}; + #\u{2E546}; + #\u{2E547}; + #\u{2E548}; + #\u{2E549}; + #\u{2E54A}; + #\u{2E54B}; + #\u{2E54C}; + #\u{2E54D}; + #\u{2E54E}; + #\u{2E54F}; + #\u{2E550}; + #\u{2E551}; + #\u{2E552}; + #\u{2E553}; + #\u{2E554}; + #\u{2E555}; + #\u{2E556}; + #\u{2E557}; + #\u{2E558}; + #\u{2E559}; + #\u{2E55A}; + #\u{2E55B}; + #\u{2E55C}; + #\u{2E55D}; + #\u{2E55E}; + #\u{2E55F}; + #\u{2E560}; + #\u{2E561}; + #\u{2E562}; + #\u{2E563}; + #\u{2E564}; + #\u{2E565}; + #\u{2E566}; + #\u{2E567}; + #\u{2E568}; + #\u{2E569}; + #\u{2E56A}; + #\u{2E56B}; + #\u{2E56C}; + #\u{2E56D}; + #\u{2E56E}; + #\u{2E56F}; + #\u{2E570}; + #\u{2E571}; + #\u{2E572}; + #\u{2E573}; + #\u{2E574}; + #\u{2E575}; + #\u{2E576}; + #\u{2E577}; + #\u{2E578}; + #\u{2E579}; + #\u{2E57A}; + #\u{2E57B}; + #\u{2E57C}; + #\u{2E57D}; + #\u{2E57E}; + #\u{2E57F}; + #\u{2E580}; + #\u{2E581}; + #\u{2E582}; + #\u{2E583}; + #\u{2E584}; + #\u{2E585}; + #\u{2E586}; + #\u{2E587}; + #\u{2E588}; + #\u{2E589}; + #\u{2E58A}; + #\u{2E58B}; + #\u{2E58C}; + #\u{2E58D}; + #\u{2E58E}; + #\u{2E58F}; + #\u{2E590}; + #\u{2E591}; + #\u{2E592}; + #\u{2E593}; + #\u{2E594}; + #\u{2E595}; + #\u{2E596}; + #\u{2E597}; + #\u{2E598}; + #\u{2E599}; + #\u{2E59A}; + #\u{2E59B}; + #\u{2E59C}; + #\u{2E59D}; + #\u{2E59E}; + #\u{2E59F}; + #\u{2E5A0}; + #\u{2E5A1}; + #\u{2E5A2}; + #\u{2E5A3}; + #\u{2E5A4}; + #\u{2E5A5}; + #\u{2E5A6}; + #\u{2E5A7}; + #\u{2E5A8}; + #\u{2E5A9}; + #\u{2E5AA}; + #\u{2E5AB}; + #\u{2E5AC}; + #\u{2E5AD}; + #\u{2E5AE}; + #\u{2E5AF}; + #\u{2E5B0}; + #\u{2E5B1}; + #\u{2E5B2}; + #\u{2E5B3}; + #\u{2E5B4}; + #\u{2E5B5}; + #\u{2E5B6}; + #\u{2E5B7}; + #\u{2E5B8}; + #\u{2E5B9}; + #\u{2E5BA}; + #\u{2E5BB}; + #\u{2E5BC}; + #\u{2E5BD}; + #\u{2E5BE}; + #\u{2E5BF}; + #\u{2E5C0}; + #\u{2E5C1}; + #\u{2E5C2}; + #\u{2E5C3}; + #\u{2E5C4}; + #\u{2E5C5}; + #\u{2E5C6}; + #\u{2E5C7}; + #\u{2E5C8}; + #\u{2E5C9}; + #\u{2E5CA}; + #\u{2E5CB}; + #\u{2E5CC}; + #\u{2E5CD}; + #\u{2E5CE}; + #\u{2E5CF}; + #\u{2E5D0}; + #\u{2E5D1}; + #\u{2E5D2}; + #\u{2E5D3}; + #\u{2E5D4}; + #\u{2E5D5}; + #\u{2E5D6}; + #\u{2E5D7}; + #\u{2E5D8}; + #\u{2E5D9}; + #\u{2E5DA}; + #\u{2E5DB}; + #\u{2E5DC}; + #\u{2E5DD}; + #\u{2E5DE}; + #\u{2E5DF}; + #\u{2E5E0}; + #\u{2E5E1}; + #\u{2E5E2}; + #\u{2E5E3}; + #\u{2E5E4}; + #\u{2E5E5}; + #\u{2E5E6}; + #\u{2E5E7}; + #\u{2E5E8}; + #\u{2E5E9}; + #\u{2E5EA}; + #\u{2E5EB}; + #\u{2E5EC}; + #\u{2E5ED}; + #\u{2E5EE}; + #\u{2E5EF}; + #\u{2E5F0}; + #\u{2E5F1}; + #\u{2E5F2}; + #\u{2E5F3}; + #\u{2E5F4}; + #\u{2E5F5}; + #\u{2E5F6}; + #\u{2E5F7}; + #\u{2E5F8}; + #\u{2E5F9}; + #\u{2E5FA}; + #\u{2E5FB}; + #\u{2E5FC}; + #\u{2E5FD}; + #\u{2E5FE}; + #\u{2E5FF}; + #\u{2E600}; + #\u{2E601}; + #\u{2E602}; + #\u{2E603}; + #\u{2E604}; + #\u{2E605}; + #\u{2E606}; + #\u{2E607}; + #\u{2E608}; + #\u{2E609}; + #\u{2E60A}; + #\u{2E60B}; + #\u{2E60C}; + #\u{2E60D}; + #\u{2E60E}; + #\u{2E60F}; + #\u{2E610}; + #\u{2E611}; + #\u{2E612}; + #\u{2E613}; + #\u{2E614}; + #\u{2E615}; + #\u{2E616}; + #\u{2E617}; + #\u{2E618}; + #\u{2E619}; + #\u{2E61A}; + #\u{2E61B}; + #\u{2E61C}; + #\u{2E61D}; + #\u{2E61E}; + #\u{2E61F}; + #\u{2E620}; + #\u{2E621}; + #\u{2E622}; + #\u{2E623}; + #\u{2E624}; + #\u{2E625}; + #\u{2E626}; + #\u{2E627}; + #\u{2E628}; + #\u{2E629}; + #\u{2E62A}; + #\u{2E62B}; + #\u{2E62C}; + #\u{2E62D}; + #\u{2E62E}; + #\u{2E62F}; + #\u{2E630}; + #\u{2E631}; + #\u{2E632}; + #\u{2E633}; + #\u{2E634}; + #\u{2E635}; + #\u{2E636}; + #\u{2E637}; + #\u{2E638}; + #\u{2E639}; + #\u{2E63A}; + #\u{2E63B}; + #\u{2E63C}; + #\u{2E63D}; + #\u{2E63E}; + #\u{2E63F}; + #\u{2E640}; + #\u{2E641}; + #\u{2E642}; + #\u{2E643}; + #\u{2E644}; + #\u{2E645}; + #\u{2E646}; + #\u{2E647}; + #\u{2E648}; + #\u{2E649}; + #\u{2E64A}; + #\u{2E64B}; + #\u{2E64C}; + #\u{2E64D}; + #\u{2E64E}; + #\u{2E64F}; + #\u{2E650}; + #\u{2E651}; + #\u{2E652}; + #\u{2E653}; + #\u{2E654}; + #\u{2E655}; + #\u{2E656}; + #\u{2E657}; + #\u{2E658}; + #\u{2E659}; + #\u{2E65A}; + #\u{2E65B}; + #\u{2E65C}; + #\u{2E65D}; + #\u{2E65E}; + #\u{2E65F}; + #\u{2E660}; + #\u{2E661}; + #\u{2E662}; + #\u{2E663}; + #\u{2E664}; + #\u{2E665}; + #\u{2E666}; + #\u{2E667}; + #\u{2E668}; + #\u{2E669}; + #\u{2E66A}; + #\u{2E66B}; + #\u{2E66C}; + #\u{2E66D}; + #\u{2E66E}; + #\u{2E66F}; + #\u{2E670}; + #\u{2E671}; + #\u{2E672}; + #\u{2E673}; + #\u{2E674}; + #\u{2E675}; + #\u{2E676}; + #\u{2E677}; + #\u{2E678}; + #\u{2E679}; + #\u{2E67A}; + #\u{2E67B}; + #\u{2E67C}; + #\u{2E67D}; + #\u{2E67E}; + #\u{2E67F}; + #\u{2E680}; + #\u{2E681}; + #\u{2E682}; + #\u{2E683}; + #\u{2E684}; + #\u{2E685}; + #\u{2E686}; + #\u{2E687}; + #\u{2E688}; + #\u{2E689}; + #\u{2E68A}; + #\u{2E68B}; + #\u{2E68C}; + #\u{2E68D}; + #\u{2E68E}; + #\u{2E68F}; + #\u{2E690}; + #\u{2E691}; + #\u{2E692}; + #\u{2E693}; + #\u{2E694}; + #\u{2E695}; + #\u{2E696}; + #\u{2E697}; + #\u{2E698}; + #\u{2E699}; + #\u{2E69A}; + #\u{2E69B}; + #\u{2E69C}; + #\u{2E69D}; + #\u{2E69E}; + #\u{2E69F}; + #\u{2E6A0}; + #\u{2E6A1}; + #\u{2E6A2}; + #\u{2E6A3}; + #\u{2E6A4}; + #\u{2E6A5}; + #\u{2E6A6}; + #\u{2E6A7}; + #\u{2E6A8}; + #\u{2E6A9}; + #\u{2E6AA}; + #\u{2E6AB}; + #\u{2E6AC}; + #\u{2E6AD}; + #\u{2E6AE}; + #\u{2E6AF}; + #\u{2E6B0}; + #\u{2E6B1}; + #\u{2E6B2}; + #\u{2E6B3}; + #\u{2E6B4}; + #\u{2E6B5}; + #\u{2E6B6}; + #\u{2E6B7}; + #\u{2E6B8}; + #\u{2E6B9}; + #\u{2E6BA}; + #\u{2E6BB}; + #\u{2E6BC}; + #\u{2E6BD}; + #\u{2E6BE}; + #\u{2E6BF}; + #\u{2E6C0}; + #\u{2E6C1}; + #\u{2E6C2}; + #\u{2E6C3}; + #\u{2E6C4}; + #\u{2E6C5}; + #\u{2E6C6}; + #\u{2E6C7}; + #\u{2E6C8}; + #\u{2E6C9}; + #\u{2E6CA}; + #\u{2E6CB}; + #\u{2E6CC}; + #\u{2E6CD}; + #\u{2E6CE}; + #\u{2E6CF}; + #\u{2E6D0}; + #\u{2E6D1}; + #\u{2E6D2}; + #\u{2E6D3}; + #\u{2E6D4}; + #\u{2E6D5}; + #\u{2E6D6}; + #\u{2E6D7}; + #\u{2E6D8}; + #\u{2E6D9}; + #\u{2E6DA}; + #\u{2E6DB}; + #\u{2E6DC}; + #\u{2E6DD}; + #\u{2E6DE}; + #\u{2E6DF}; + #\u{2E6E0}; + #\u{2E6E1}; + #\u{2E6E2}; + #\u{2E6E3}; + #\u{2E6E4}; + #\u{2E6E5}; + #\u{2E6E6}; + #\u{2E6E7}; + #\u{2E6E8}; + #\u{2E6E9}; + #\u{2E6EA}; + #\u{2E6EB}; + #\u{2E6EC}; + #\u{2E6ED}; + #\u{2E6EE}; + #\u{2E6EF}; + #\u{2E6F0}; + #\u{2E6F1}; + #\u{2E6F2}; + #\u{2E6F3}; + #\u{2E6F4}; + #\u{2E6F5}; + #\u{2E6F6}; + #\u{2E6F7}; + #\u{2E6F8}; + #\u{2E6F9}; + #\u{2E6FA}; + #\u{2E6FB}; + #\u{2E6FC}; + #\u{2E6FD}; + #\u{2E6FE}; + #\u{2E6FF}; + #\u{2E700}; + #\u{2E701}; + #\u{2E702}; + #\u{2E703}; + #\u{2E704}; + #\u{2E705}; + #\u{2E706}; + #\u{2E707}; + #\u{2E708}; + #\u{2E709}; + #\u{2E70A}; + #\u{2E70B}; + #\u{2E70C}; + #\u{2E70D}; + #\u{2E70E}; + #\u{2E70F}; + #\u{2E710}; + #\u{2E711}; + #\u{2E712}; + #\u{2E713}; + #\u{2E714}; + #\u{2E715}; + #\u{2E716}; + #\u{2E717}; + #\u{2E718}; + #\u{2E719}; + #\u{2E71A}; + #\u{2E71B}; + #\u{2E71C}; + #\u{2E71D}; + #\u{2E71E}; + #\u{2E71F}; + #\u{2E720}; + #\u{2E721}; + #\u{2E722}; + #\u{2E723}; + #\u{2E724}; + #\u{2E725}; + #\u{2E726}; + #\u{2E727}; + #\u{2E728}; + #\u{2E729}; + #\u{2E72A}; + #\u{2E72B}; + #\u{2E72C}; + #\u{2E72D}; + #\u{2E72E}; + #\u{2E72F}; + #\u{2E730}; + #\u{2E731}; + #\u{2E732}; + #\u{2E733}; + #\u{2E734}; + #\u{2E735}; + #\u{2E736}; + #\u{2E737}; + #\u{2E738}; + #\u{2E739}; + #\u{2E73A}; + #\u{2E73B}; + #\u{2E73C}; + #\u{2E73D}; + #\u{2E73E}; + #\u{2E73F}; + #\u{2E740}; + #\u{2E741}; + #\u{2E742}; + #\u{2E743}; + #\u{2E744}; + #\u{2E745}; + #\u{2E746}; + #\u{2E747}; + #\u{2E748}; + #\u{2E749}; + #\u{2E74A}; + #\u{2E74B}; + #\u{2E74C}; + #\u{2E74D}; + #\u{2E74E}; + #\u{2E74F}; + #\u{2E750}; + #\u{2E751}; + #\u{2E752}; + #\u{2E753}; + #\u{2E754}; + #\u{2E755}; + #\u{2E756}; + #\u{2E757}; + #\u{2E758}; + #\u{2E759}; + #\u{2E75A}; + #\u{2E75B}; + #\u{2E75C}; + #\u{2E75D}; + #\u{2E75E}; + #\u{2E75F}; + #\u{2E760}; + #\u{2E761}; + #\u{2E762}; + #\u{2E763}; + #\u{2E764}; + #\u{2E765}; + #\u{2E766}; + #\u{2E767}; + #\u{2E768}; + #\u{2E769}; + #\u{2E76A}; + #\u{2E76B}; + #\u{2E76C}; + #\u{2E76D}; + #\u{2E76E}; + #\u{2E76F}; + #\u{2E770}; + #\u{2E771}; + #\u{2E772}; + #\u{2E773}; + #\u{2E774}; + #\u{2E775}; + #\u{2E776}; + #\u{2E777}; + #\u{2E778}; + #\u{2E779}; + #\u{2E77A}; + #\u{2E77B}; + #\u{2E77C}; + #\u{2E77D}; + #\u{2E77E}; + #\u{2E77F}; + #\u{2E780}; + #\u{2E781}; + #\u{2E782}; + #\u{2E783}; + #\u{2E784}; + #\u{2E785}; + #\u{2E786}; + #\u{2E787}; + #\u{2E788}; + #\u{2E789}; + #\u{2E78A}; + #\u{2E78B}; + #\u{2E78C}; + #\u{2E78D}; + #\u{2E78E}; + #\u{2E78F}; + #\u{2E790}; + #\u{2E791}; + #\u{2E792}; + #\u{2E793}; + #\u{2E794}; + #\u{2E795}; + #\u{2E796}; + #\u{2E797}; + #\u{2E798}; + #\u{2E799}; + #\u{2E79A}; + #\u{2E79B}; + #\u{2E79C}; + #\u{2E79D}; + #\u{2E79E}; + #\u{2E79F}; + #\u{2E7A0}; + #\u{2E7A1}; + #\u{2E7A2}; + #\u{2E7A3}; + #\u{2E7A4}; + #\u{2E7A5}; + #\u{2E7A6}; + #\u{2E7A7}; + #\u{2E7A8}; + #\u{2E7A9}; + #\u{2E7AA}; + #\u{2E7AB}; + #\u{2E7AC}; + #\u{2E7AD}; + #\u{2E7AE}; + #\u{2E7AF}; + #\u{2E7B0}; + #\u{2E7B1}; + #\u{2E7B2}; + #\u{2E7B3}; + #\u{2E7B4}; + #\u{2E7B5}; + #\u{2E7B6}; + #\u{2E7B7}; + #\u{2E7B8}; + #\u{2E7B9}; + #\u{2E7BA}; + #\u{2E7BB}; + #\u{2E7BC}; + #\u{2E7BD}; + #\u{2E7BE}; + #\u{2E7BF}; + #\u{2E7C0}; + #\u{2E7C1}; + #\u{2E7C2}; + #\u{2E7C3}; + #\u{2E7C4}; + #\u{2E7C5}; + #\u{2E7C6}; + #\u{2E7C7}; + #\u{2E7C8}; + #\u{2E7C9}; + #\u{2E7CA}; + #\u{2E7CB}; + #\u{2E7CC}; + #\u{2E7CD}; + #\u{2E7CE}; + #\u{2E7CF}; + #\u{2E7D0}; + #\u{2E7D1}; + #\u{2E7D2}; + #\u{2E7D3}; + #\u{2E7D4}; + #\u{2E7D5}; + #\u{2E7D6}; + #\u{2E7D7}; + #\u{2E7D8}; + #\u{2E7D9}; + #\u{2E7DA}; + #\u{2E7DB}; + #\u{2E7DC}; + #\u{2E7DD}; + #\u{2E7DE}; + #\u{2E7DF}; + #\u{2E7E0}; + #\u{2E7E1}; + #\u{2E7E2}; + #\u{2E7E3}; + #\u{2E7E4}; + #\u{2E7E5}; + #\u{2E7E6}; + #\u{2E7E7}; + #\u{2E7E8}; + #\u{2E7E9}; + #\u{2E7EA}; + #\u{2E7EB}; + #\u{2E7EC}; + #\u{2E7ED}; + #\u{2E7EE}; + #\u{2E7EF}; + #\u{2E7F0}; + #\u{2E7F1}; + #\u{2E7F2}; + #\u{2E7F3}; + #\u{2E7F4}; + #\u{2E7F5}; + #\u{2E7F6}; + #\u{2E7F7}; + #\u{2E7F8}; + #\u{2E7F9}; + #\u{2E7FA}; + #\u{2E7FB}; + #\u{2E7FC}; + #\u{2E7FD}; + #\u{2E7FE}; + #\u{2E7FF}; + #\u{2E800}; + #\u{2E801}; + #\u{2E802}; + #\u{2E803}; + #\u{2E804}; + #\u{2E805}; + #\u{2E806}; + #\u{2E807}; + #\u{2E808}; + #\u{2E809}; + #\u{2E80A}; + #\u{2E80B}; + #\u{2E80C}; + #\u{2E80D}; + #\u{2E80E}; + #\u{2E80F}; + #\u{2E810}; + #\u{2E811}; + #\u{2E812}; + #\u{2E813}; + #\u{2E814}; + #\u{2E815}; + #\u{2E816}; + #\u{2E817}; + #\u{2E818}; + #\u{2E819}; + #\u{2E81A}; + #\u{2E81B}; + #\u{2E81C}; + #\u{2E81D}; + #\u{2E81E}; + #\u{2E81F}; + #\u{2E820}; + #\u{2E821}; + #\u{2E822}; + #\u{2E823}; + #\u{2E824}; + #\u{2E825}; + #\u{2E826}; + #\u{2E827}; + #\u{2E828}; + #\u{2E829}; + #\u{2E82A}; + #\u{2E82B}; + #\u{2E82C}; + #\u{2E82D}; + #\u{2E82E}; + #\u{2E82F}; + #\u{2E830}; + #\u{2E831}; + #\u{2E832}; + #\u{2E833}; + #\u{2E834}; + #\u{2E835}; + #\u{2E836}; + #\u{2E837}; + #\u{2E838}; + #\u{2E839}; + #\u{2E83A}; + #\u{2E83B}; + #\u{2E83C}; + #\u{2E83D}; + #\u{2E83E}; + #\u{2E83F}; + #\u{2E840}; + #\u{2E841}; + #\u{2E842}; + #\u{2E843}; + #\u{2E844}; + #\u{2E845}; + #\u{2E846}; + #\u{2E847}; + #\u{2E848}; + #\u{2E849}; + #\u{2E84A}; + #\u{2E84B}; + #\u{2E84C}; + #\u{2E84D}; + #\u{2E84E}; + #\u{2E84F}; + #\u{2E850}; + #\u{2E851}; + #\u{2E852}; + #\u{2E853}; + #\u{2E854}; + #\u{2E855}; + #\u{2E856}; + #\u{2E857}; + #\u{2E858}; + #\u{2E859}; + #\u{2E85A}; + #\u{2E85B}; + #\u{2E85C}; + #\u{2E85D}; + #\u{2E85E}; + #\u{2E85F}; + #\u{2E860}; + #\u{2E861}; + #\u{2E862}; + #\u{2E863}; + #\u{2E864}; + #\u{2E865}; + #\u{2E866}; + #\u{2E867}; + #\u{2E868}; + #\u{2E869}; + #\u{2E86A}; + #\u{2E86B}; + #\u{2E86C}; + #\u{2E86D}; + #\u{2E86E}; + #\u{2E86F}; + #\u{2E870}; + #\u{2E871}; + #\u{2E872}; + #\u{2E873}; + #\u{2E874}; + #\u{2E875}; + #\u{2E876}; + #\u{2E877}; + #\u{2E878}; + #\u{2E879}; + #\u{2E87A}; + #\u{2E87B}; + #\u{2E87C}; + #\u{2E87D}; + #\u{2E87E}; + #\u{2E87F}; + #\u{2E880}; + #\u{2E881}; + #\u{2E882}; + #\u{2E883}; + #\u{2E884}; + #\u{2E885}; + #\u{2E886}; + #\u{2E887}; + #\u{2E888}; + #\u{2E889}; + #\u{2E88A}; + #\u{2E88B}; + #\u{2E88C}; + #\u{2E88D}; + #\u{2E88E}; + #\u{2E88F}; + #\u{2E890}; + #\u{2E891}; + #\u{2E892}; + #\u{2E893}; + #\u{2E894}; + #\u{2E895}; + #\u{2E896}; + #\u{2E897}; + #\u{2E898}; + #\u{2E899}; + #\u{2E89A}; + #\u{2E89B}; + #\u{2E89C}; + #\u{2E89D}; + #\u{2E89E}; + #\u{2E89F}; + #\u{2E8A0}; + #\u{2E8A1}; + #\u{2E8A2}; + #\u{2E8A3}; + #\u{2E8A4}; + #\u{2E8A5}; + #\u{2E8A6}; + #\u{2E8A7}; + #\u{2E8A8}; + #\u{2E8A9}; + #\u{2E8AA}; + #\u{2E8AB}; + #\u{2E8AC}; + #\u{2E8AD}; + #\u{2E8AE}; + #\u{2E8AF}; + #\u{2E8B0}; + #\u{2E8B1}; + #\u{2E8B2}; + #\u{2E8B3}; + #\u{2E8B4}; + #\u{2E8B5}; + #\u{2E8B6}; + #\u{2E8B7}; + #\u{2E8B8}; + #\u{2E8B9}; + #\u{2E8BA}; + #\u{2E8BB}; + #\u{2E8BC}; + #\u{2E8BD}; + #\u{2E8BE}; + #\u{2E8BF}; + #\u{2E8C0}; + #\u{2E8C1}; + #\u{2E8C2}; + #\u{2E8C3}; + #\u{2E8C4}; + #\u{2E8C5}; + #\u{2E8C6}; + #\u{2E8C7}; + #\u{2E8C8}; + #\u{2E8C9}; + #\u{2E8CA}; + #\u{2E8CB}; + #\u{2E8CC}; + #\u{2E8CD}; + #\u{2E8CE}; + #\u{2E8CF}; + #\u{2E8D0}; + #\u{2E8D1}; + #\u{2E8D2}; + #\u{2E8D3}; + #\u{2E8D4}; + #\u{2E8D5}; + #\u{2E8D6}; + #\u{2E8D7}; + #\u{2E8D8}; + #\u{2E8D9}; + #\u{2E8DA}; + #\u{2E8DB}; + #\u{2E8DC}; + #\u{2E8DD}; + #\u{2E8DE}; + #\u{2E8DF}; + #\u{2E8E0}; + #\u{2E8E1}; + #\u{2E8E2}; + #\u{2E8E3}; + #\u{2E8E4}; + #\u{2E8E5}; + #\u{2E8E6}; + #\u{2E8E7}; + #\u{2E8E8}; + #\u{2E8E9}; + #\u{2E8EA}; + #\u{2E8EB}; + #\u{2E8EC}; + #\u{2E8ED}; + #\u{2E8EE}; + #\u{2E8EF}; + #\u{2E8F0}; + #\u{2E8F1}; + #\u{2E8F2}; + #\u{2E8F3}; + #\u{2E8F4}; + #\u{2E8F5}; + #\u{2E8F6}; + #\u{2E8F7}; + #\u{2E8F8}; + #\u{2E8F9}; + #\u{2E8FA}; + #\u{2E8FB}; + #\u{2E8FC}; + #\u{2E8FD}; + #\u{2E8FE}; + #\u{2E8FF}; + #\u{2E900}; + #\u{2E901}; + #\u{2E902}; + #\u{2E903}; + #\u{2E904}; + #\u{2E905}; + #\u{2E906}; + #\u{2E907}; + #\u{2E908}; + #\u{2E909}; + #\u{2E90A}; + #\u{2E90B}; + #\u{2E90C}; + #\u{2E90D}; + #\u{2E90E}; + #\u{2E90F}; + #\u{2E910}; + #\u{2E911}; + #\u{2E912}; + #\u{2E913}; + #\u{2E914}; + #\u{2E915}; + #\u{2E916}; + #\u{2E917}; + #\u{2E918}; + #\u{2E919}; + #\u{2E91A}; + #\u{2E91B}; + #\u{2E91C}; + #\u{2E91D}; + #\u{2E91E}; + #\u{2E91F}; + #\u{2E920}; + #\u{2E921}; + #\u{2E922}; + #\u{2E923}; + #\u{2E924}; + #\u{2E925}; + #\u{2E926}; + #\u{2E927}; + #\u{2E928}; + #\u{2E929}; + #\u{2E92A}; + #\u{2E92B}; + #\u{2E92C}; + #\u{2E92D}; + #\u{2E92E}; + #\u{2E92F}; + #\u{2E930}; + #\u{2E931}; + #\u{2E932}; + #\u{2E933}; + #\u{2E934}; + #\u{2E935}; + #\u{2E936}; + #\u{2E937}; + #\u{2E938}; + #\u{2E939}; + #\u{2E93A}; + #\u{2E93B}; + #\u{2E93C}; + #\u{2E93D}; + #\u{2E93E}; + #\u{2E93F}; + #\u{2E940}; + #\u{2E941}; + #\u{2E942}; + #\u{2E943}; + #\u{2E944}; + #\u{2E945}; + #\u{2E946}; + #\u{2E947}; + #\u{2E948}; + #\u{2E949}; + #\u{2E94A}; + #\u{2E94B}; + #\u{2E94C}; + #\u{2E94D}; + #\u{2E94E}; + #\u{2E94F}; + #\u{2E950}; + #\u{2E951}; + #\u{2E952}; + #\u{2E953}; + #\u{2E954}; + #\u{2E955}; + #\u{2E956}; + #\u{2E957}; + #\u{2E958}; + #\u{2E959}; + #\u{2E95A}; + #\u{2E95B}; + #\u{2E95C}; + #\u{2E95D}; + #\u{2E95E}; + #\u{2E95F}; + #\u{2E960}; + #\u{2E961}; + #\u{2E962}; + #\u{2E963}; + #\u{2E964}; + #\u{2E965}; + #\u{2E966}; + #\u{2E967}; + #\u{2E968}; + #\u{2E969}; + #\u{2E96A}; + #\u{2E96B}; + #\u{2E96C}; + #\u{2E96D}; + #\u{2E96E}; + #\u{2E96F}; + #\u{2E970}; + #\u{2E971}; + #\u{2E972}; + #\u{2E973}; + #\u{2E974}; + #\u{2E975}; + #\u{2E976}; + #\u{2E977}; + #\u{2E978}; + #\u{2E979}; + #\u{2E97A}; + #\u{2E97B}; + #\u{2E97C}; + #\u{2E97D}; + #\u{2E97E}; + #\u{2E97F}; + #\u{2E980}; + #\u{2E981}; + #\u{2E982}; + #\u{2E983}; + #\u{2E984}; + #\u{2E985}; + #\u{2E986}; + #\u{2E987}; + #\u{2E988}; + #\u{2E989}; + #\u{2E98A}; + #\u{2E98B}; + #\u{2E98C}; + #\u{2E98D}; + #\u{2E98E}; + #\u{2E98F}; + #\u{2E990}; + #\u{2E991}; + #\u{2E992}; + #\u{2E993}; + #\u{2E994}; + #\u{2E995}; + #\u{2E996}; + #\u{2E997}; + #\u{2E998}; + #\u{2E999}; + #\u{2E99A}; + #\u{2E99B}; + #\u{2E99C}; + #\u{2E99D}; + #\u{2E99E}; + #\u{2E99F}; + #\u{2E9A0}; + #\u{2E9A1}; + #\u{2E9A2}; + #\u{2E9A3}; + #\u{2E9A4}; + #\u{2E9A5}; + #\u{2E9A6}; + #\u{2E9A7}; + #\u{2E9A8}; + #\u{2E9A9}; + #\u{2E9AA}; + #\u{2E9AB}; + #\u{2E9AC}; + #\u{2E9AD}; + #\u{2E9AE}; + #\u{2E9AF}; + #\u{2E9B0}; + #\u{2E9B1}; + #\u{2E9B2}; + #\u{2E9B3}; + #\u{2E9B4}; + #\u{2E9B5}; + #\u{2E9B6}; + #\u{2E9B7}; + #\u{2E9B8}; + #\u{2E9B9}; + #\u{2E9BA}; + #\u{2E9BB}; + #\u{2E9BC}; + #\u{2E9BD}; + #\u{2E9BE}; + #\u{2E9BF}; + #\u{2E9C0}; + #\u{2E9C1}; + #\u{2E9C2}; + #\u{2E9C3}; + #\u{2E9C4}; + #\u{2E9C5}; + #\u{2E9C6}; + #\u{2E9C7}; + #\u{2E9C8}; + #\u{2E9C9}; + #\u{2E9CA}; + #\u{2E9CB}; + #\u{2E9CC}; + #\u{2E9CD}; + #\u{2E9CE}; + #\u{2E9CF}; + #\u{2E9D0}; + #\u{2E9D1}; + #\u{2E9D2}; + #\u{2E9D3}; + #\u{2E9D4}; + #\u{2E9D5}; + #\u{2E9D6}; + #\u{2E9D7}; + #\u{2E9D8}; + #\u{2E9D9}; + #\u{2E9DA}; + #\u{2E9DB}; + #\u{2E9DC}; + #\u{2E9DD}; + #\u{2E9DE}; + #\u{2E9DF}; + #\u{2E9E0}; + #\u{2E9E1}; + #\u{2E9E2}; + #\u{2E9E3}; + #\u{2E9E4}; + #\u{2E9E5}; + #\u{2E9E6}; + #\u{2E9E7}; + #\u{2E9E8}; + #\u{2E9E9}; + #\u{2E9EA}; + #\u{2E9EB}; + #\u{2E9EC}; + #\u{2E9ED}; + #\u{2E9EE}; + #\u{2E9EF}; + #\u{2E9F0}; + #\u{2E9F1}; + #\u{2E9F2}; + #\u{2E9F3}; + #\u{2E9F4}; + #\u{2E9F5}; + #\u{2E9F6}; + #\u{2E9F7}; + #\u{2E9F8}; + #\u{2E9F9}; + #\u{2E9FA}; + #\u{2E9FB}; + #\u{2E9FC}; + #\u{2E9FD}; + #\u{2E9FE}; + #\u{2E9FF}; + #\u{2EA00}; + #\u{2EA01}; + #\u{2EA02}; + #\u{2EA03}; + #\u{2EA04}; + #\u{2EA05}; + #\u{2EA06}; + #\u{2EA07}; + #\u{2EA08}; + #\u{2EA09}; + #\u{2EA0A}; + #\u{2EA0B}; + #\u{2EA0C}; + #\u{2EA0D}; + #\u{2EA0E}; + #\u{2EA0F}; + #\u{2EA10}; + #\u{2EA11}; + #\u{2EA12}; + #\u{2EA13}; + #\u{2EA14}; + #\u{2EA15}; + #\u{2EA16}; + #\u{2EA17}; + #\u{2EA18}; + #\u{2EA19}; + #\u{2EA1A}; + #\u{2EA1B}; + #\u{2EA1C}; + #\u{2EA1D}; + #\u{2EA1E}; + #\u{2EA1F}; + #\u{2EA20}; + #\u{2EA21}; + #\u{2EA22}; + #\u{2EA23}; + #\u{2EA24}; + #\u{2EA25}; + #\u{2EA26}; + #\u{2EA27}; + #\u{2EA28}; + #\u{2EA29}; + #\u{2EA2A}; + #\u{2EA2B}; + #\u{2EA2C}; + #\u{2EA2D}; + #\u{2EA2E}; + #\u{2EA2F}; + #\u{2EA30}; + #\u{2EA31}; + #\u{2EA32}; + #\u{2EA33}; + #\u{2EA34}; + #\u{2EA35}; + #\u{2EA36}; + #\u{2EA37}; + #\u{2EA38}; + #\u{2EA39}; + #\u{2EA3A}; + #\u{2EA3B}; + #\u{2EA3C}; + #\u{2EA3D}; + #\u{2EA3E}; + #\u{2EA3F}; + #\u{2EA40}; + #\u{2EA41}; + #\u{2EA42}; + #\u{2EA43}; + #\u{2EA44}; + #\u{2EA45}; + #\u{2EA46}; + #\u{2EA47}; + #\u{2EA48}; + #\u{2EA49}; + #\u{2EA4A}; + #\u{2EA4B}; + #\u{2EA4C}; + #\u{2EA4D}; + #\u{2EA4E}; + #\u{2EA4F}; + #\u{2EA50}; + #\u{2EA51}; + #\u{2EA52}; + #\u{2EA53}; + #\u{2EA54}; + #\u{2EA55}; + #\u{2EA56}; + #\u{2EA57}; + #\u{2EA58}; + #\u{2EA59}; + #\u{2EA5A}; + #\u{2EA5B}; + #\u{2EA5C}; + #\u{2EA5D}; + #\u{2EA5E}; + #\u{2EA5F}; + #\u{2EA60}; + #\u{2EA61}; + #\u{2EA62}; + #\u{2EA63}; + #\u{2EA64}; + #\u{2EA65}; + #\u{2EA66}; + #\u{2EA67}; + #\u{2EA68}; + #\u{2EA69}; + #\u{2EA6A}; + #\u{2EA6B}; + #\u{2EA6C}; + #\u{2EA6D}; + #\u{2EA6E}; + #\u{2EA6F}; + #\u{2EA70}; + #\u{2EA71}; + #\u{2EA72}; + #\u{2EA73}; + #\u{2EA74}; + #\u{2EA75}; + #\u{2EA76}; + #\u{2EA77}; + #\u{2EA78}; + #\u{2EA79}; + #\u{2EA7A}; + #\u{2EA7B}; + #\u{2EA7C}; + #\u{2EA7D}; + #\u{2EA7E}; + #\u{2EA7F}; + #\u{2EA80}; + #\u{2EA81}; + #\u{2EA82}; + #\u{2EA83}; + #\u{2EA84}; + #\u{2EA85}; + #\u{2EA86}; + #\u{2EA87}; + #\u{2EA88}; + #\u{2EA89}; + #\u{2EA8A}; + #\u{2EA8B}; + #\u{2EA8C}; + #\u{2EA8D}; + #\u{2EA8E}; + #\u{2EA8F}; + #\u{2EA90}; + #\u{2EA91}; + #\u{2EA92}; + #\u{2EA93}; + #\u{2EA94}; + #\u{2EA95}; + #\u{2EA96}; + #\u{2EA97}; + #\u{2EA98}; + #\u{2EA99}; + #\u{2EA9A}; + #\u{2EA9B}; + #\u{2EA9C}; + #\u{2EA9D}; + #\u{2EA9E}; + #\u{2EA9F}; + #\u{2EAA0}; + #\u{2EAA1}; + #\u{2EAA2}; + #\u{2EAA3}; + #\u{2EAA4}; + #\u{2EAA5}; + #\u{2EAA6}; + #\u{2EAA7}; + #\u{2EAA8}; + #\u{2EAA9}; + #\u{2EAAA}; + #\u{2EAAB}; + #\u{2EAAC}; + #\u{2EAAD}; + #\u{2EAAE}; + #\u{2EAAF}; + #\u{2EAB0}; + #\u{2EAB1}; + #\u{2EAB2}; + #\u{2EAB3}; + #\u{2EAB4}; + #\u{2EAB5}; + #\u{2EAB6}; + #\u{2EAB7}; + #\u{2EAB8}; + #\u{2EAB9}; + #\u{2EABA}; + #\u{2EABB}; + #\u{2EABC}; + #\u{2EABD}; + #\u{2EABE}; + #\u{2EABF}; + #\u{2EAC0}; + #\u{2EAC1}; + #\u{2EAC2}; + #\u{2EAC3}; + #\u{2EAC4}; + #\u{2EAC5}; + #\u{2EAC6}; + #\u{2EAC7}; + #\u{2EAC8}; + #\u{2EAC9}; + #\u{2EACA}; + #\u{2EACB}; + #\u{2EACC}; + #\u{2EACD}; + #\u{2EACE}; + #\u{2EACF}; + #\u{2EAD0}; + #\u{2EAD1}; + #\u{2EAD2}; + #\u{2EAD3}; + #\u{2EAD4}; + #\u{2EAD5}; + #\u{2EAD6}; + #\u{2EAD7}; + #\u{2EAD8}; + #\u{2EAD9}; + #\u{2EADA}; + #\u{2EADB}; + #\u{2EADC}; + #\u{2EADD}; + #\u{2EADE}; + #\u{2EADF}; + #\u{2EAE0}; + #\u{2EAE1}; + #\u{2EAE2}; + #\u{2EAE3}; + #\u{2EAE4}; + #\u{2EAE5}; + #\u{2EAE6}; + #\u{2EAE7}; + #\u{2EAE8}; + #\u{2EAE9}; + #\u{2EAEA}; + #\u{2EAEB}; + #\u{2EAEC}; + #\u{2EAED}; + #\u{2EAEE}; + #\u{2EAEF}; + #\u{2EAF0}; + #\u{2EAF1}; + #\u{2EAF2}; + #\u{2EAF3}; + #\u{2EAF4}; + #\u{2EAF5}; + #\u{2EAF6}; + #\u{2EAF7}; + #\u{2EAF8}; + #\u{2EAF9}; + #\u{2EAFA}; + #\u{2EAFB}; + #\u{2EAFC}; + #\u{2EAFD}; + #\u{2EAFE}; + #\u{2EAFF}; + #\u{2EB00}; + #\u{2EB01}; + #\u{2EB02}; + #\u{2EB03}; + #\u{2EB04}; + #\u{2EB05}; + #\u{2EB06}; + #\u{2EB07}; + #\u{2EB08}; + #\u{2EB09}; + #\u{2EB0A}; + #\u{2EB0B}; + #\u{2EB0C}; + #\u{2EB0D}; + #\u{2EB0E}; + #\u{2EB0F}; + #\u{2EB10}; + #\u{2EB11}; + #\u{2EB12}; + #\u{2EB13}; + #\u{2EB14}; + #\u{2EB15}; + #\u{2EB16}; + #\u{2EB17}; + #\u{2EB18}; + #\u{2EB19}; + #\u{2EB1A}; + #\u{2EB1B}; + #\u{2EB1C}; + #\u{2EB1D}; + #\u{2EB1E}; + #\u{2EB1F}; + #\u{2EB20}; + #\u{2EB21}; + #\u{2EB22}; + #\u{2EB23}; + #\u{2EB24}; + #\u{2EB25}; + #\u{2EB26}; + #\u{2EB27}; + #\u{2EB28}; + #\u{2EB29}; + #\u{2EB2A}; + #\u{2EB2B}; + #\u{2EB2C}; + #\u{2EB2D}; + #\u{2EB2E}; + #\u{2EB2F}; + #\u{2EB30}; + #\u{2EB31}; + #\u{2EB32}; + #\u{2EB33}; + #\u{2EB34}; + #\u{2EB35}; + #\u{2EB36}; + #\u{2EB37}; + #\u{2EB38}; + #\u{2EB39}; + #\u{2EB3A}; + #\u{2EB3B}; + #\u{2EB3C}; + #\u{2EB3D}; + #\u{2EB3E}; + #\u{2EB3F}; + #\u{2EB40}; + #\u{2EB41}; + #\u{2EB42}; + #\u{2EB43}; + #\u{2EB44}; + #\u{2EB45}; + #\u{2EB46}; + #\u{2EB47}; + #\u{2EB48}; + #\u{2EB49}; + #\u{2EB4A}; + #\u{2EB4B}; + #\u{2EB4C}; + #\u{2EB4D}; + #\u{2EB4E}; + #\u{2EB4F}; + #\u{2EB50}; + #\u{2EB51}; + #\u{2EB52}; + #\u{2EB53}; + #\u{2EB54}; + #\u{2EB55}; + #\u{2EB56}; + #\u{2EB57}; + #\u{2EB58}; + #\u{2EB59}; + #\u{2EB5A}; + #\u{2EB5B}; + #\u{2EB5C}; + #\u{2EB5D}; + #\u{2EB5E}; + #\u{2EB5F}; + #\u{2EB60}; + #\u{2EB61}; + #\u{2EB62}; + #\u{2EB63}; + #\u{2EB64}; + #\u{2EB65}; + #\u{2EB66}; + #\u{2EB67}; + #\u{2EB68}; + #\u{2EB69}; + #\u{2EB6A}; + #\u{2EB6B}; + #\u{2EB6C}; + #\u{2EB6D}; + #\u{2EB6E}; + #\u{2EB6F}; + #\u{2EB70}; + #\u{2EB71}; + #\u{2EB72}; + #\u{2EB73}; + #\u{2EB74}; + #\u{2EB75}; + #\u{2EB76}; + #\u{2EB77}; + #\u{2EB78}; + #\u{2EB79}; + #\u{2EB7A}; + #\u{2EB7B}; + #\u{2EB7C}; + #\u{2EB7D}; + #\u{2EB7E}; + #\u{2EB7F}; + #\u{2EB80}; + #\u{2EB81}; + #\u{2EB82}; + #\u{2EB83}; + #\u{2EB84}; + #\u{2EB85}; + #\u{2EB86}; + #\u{2EB87}; + #\u{2EB88}; + #\u{2EB89}; + #\u{2EB8A}; + #\u{2EB8B}; + #\u{2EB8C}; + #\u{2EB8D}; + #\u{2EB8E}; + #\u{2EB8F}; + #\u{2EB90}; + #\u{2EB91}; + #\u{2EB92}; + #\u{2EB93}; + #\u{2EB94}; + #\u{2EB95}; + #\u{2EB96}; + #\u{2EB97}; + #\u{2EB98}; + #\u{2EB99}; + #\u{2EB9A}; + #\u{2EB9B}; + #\u{2EB9C}; + #\u{2EB9D}; + #\u{2EB9E}; + #\u{2EB9F}; + #\u{2EBA0}; + #\u{2EBA1}; + #\u{2EBA2}; + #\u{2EBA3}; + #\u{2EBA4}; + #\u{2EBA5}; + #\u{2EBA6}; + #\u{2EBA7}; + #\u{2EBA8}; + #\u{2EBA9}; + #\u{2EBAA}; + #\u{2EBAB}; + #\u{2EBAC}; + #\u{2EBAD}; + #\u{2EBAE}; + #\u{2EBAF}; + #\u{2EBB0}; + #\u{2EBB1}; + #\u{2EBB2}; + #\u{2EBB3}; + #\u{2EBB4}; + #\u{2EBB5}; + #\u{2EBB6}; + #\u{2EBB7}; + #\u{2EBB8}; + #\u{2EBB9}; + #\u{2EBBA}; + #\u{2EBBB}; + #\u{2EBBC}; + #\u{2EBBD}; + #\u{2EBBE}; + #\u{2EBBF}; + #\u{2EBC0}; + #\u{2EBC1}; + #\u{2EBC2}; + #\u{2EBC3}; + #\u{2EBC4}; + #\u{2EBC5}; + #\u{2EBC6}; + #\u{2EBC7}; + #\u{2EBC8}; + #\u{2EBC9}; + #\u{2EBCA}; + #\u{2EBCB}; + #\u{2EBCC}; + #\u{2EBCD}; + #\u{2EBCE}; + #\u{2EBCF}; + #\u{2EBD0}; + #\u{2EBD1}; + #\u{2EBD2}; + #\u{2EBD3}; + #\u{2EBD4}; + #\u{2EBD5}; + #\u{2EBD6}; + #\u{2EBD7}; + #\u{2EBD8}; + #\u{2EBD9}; + #\u{2EBDA}; + #\u{2EBDB}; + #\u{2EBDC}; + #\u{2EBDD}; + #\u{2EBDE}; + #\u{2EBDF}; + #\u{2EBE0}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0-class.js new file mode 100644 index 000000000..3d6479140 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0-class.js @@ -0,0 +1,8343 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v10.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #ࡠ; + #ࡡ; + #ࡢ; + #ࡣ; + #ࡤ; + #ࡥ; + #ࡦ; + #ࡧ; + #ࡨ; + #ࡩ; + #ࡪ; + #ৼ; + #ㄮ; + #鿖; + #鿗; + #鿘; + #鿙; + #鿚; + #鿛; + #鿜; + #鿝; + #鿞; + #鿟; + #鿠; + #鿡; + #鿢; + #鿣; + #鿤; + #鿥; + #鿦; + #鿧; + #鿨; + #鿩; + #鿪; + #𐌭; + #𐌮; + #𐌯; + #𑨀; + #𑨋; + #𑨌; + #𑨍; + #𑨎; + #𑨏; + #𑨐; + #𑨑; + #𑨒; + #𑨓; + #𑨔; + #𑨕; + #𑨖; + #𑨗; + #𑨘; + #𑨙; + #𑨚; + #𑨛; + #𑨜; + #𑨝; + #𑨞; + #𑨟; + #𑨠; + #𑨡; + #𑨢; + #𑨣; + #𑨤; + #𑨥; + #𑨦; + #𑨧; + #𑨨; + #𑨩; + #𑨪; + #𑨫; + #𑨬; + #𑨭; + #𑨮; + #𑨯; + #𑨰; + #𑨱; + #𑨲; + #𑨺; + #𑩐; + #𑩜; + #𑩝; + #𑩞; + #𑩟; + #𑩠; + #𑩡; + #𑩢; + #𑩣; + #𑩤; + #𑩥; + #𑩦; + #𑩧; + #𑩨; + #𑩩; + #𑩪; + #𑩫; + #𑩬; + #𑩭; + #𑩮; + #𑩯; + #𑩰; + #𑩱; + #𑩲; + #𑩳; + #𑩴; + #𑩵; + #𑩶; + #𑩷; + #𑩸; + #𑩹; + #𑩺; + #𑩻; + #𑩼; + #𑩽; + #𑩾; + #𑩿; + #𑪀; + #𑪁; + #𑪂; + #𑪃; + #𑪆; + #𑪇; + #𑪈; + #𑪉; + #𑴀; + #𑴁; + #𑴂; + #𑴃; + #𑴄; + #𑴅; + #𑴆; + #𑴈; + #𑴉; + #𑴋; + #𑴌; + #𑴍; + #𑴎; + #𑴏; + #𑴐; + #𑴑; + #𑴒; + #𑴓; + #𑴔; + #𑴕; + #𑴖; + #𑴗; + #𑴘; + #𑴙; + #𑴚; + #𑴛; + #𑴜; + #𑴝; + #𑴞; + #𑴟; + #𑴠; + #𑴡; + #𑴢; + #𑴣; + #𑴤; + #𑴥; + #𑴦; + #𑴧; + #𑴨; + #𑴩; + #𑴪; + #𑴫; + #𑴬; + #𑴭; + #𑴮; + #𑴯; + #𑴰; + #𑵆; + #𖿡; + #𛀂; + #𛀃; + #𛀄; + #𛀅; + #𛀆; + #𛀇; + #𛀈; + #𛀉; + #𛀊; + #𛀋; + #𛀌; + #𛀍; + #𛀎; + #𛀏; + #𛀐; + #𛀑; + #𛀒; + #𛀓; + #𛀔; + #𛀕; + #𛀖; + #𛀗; + #𛀘; + #𛀙; + #𛀚; + #𛀛; + #𛀜; + #𛀝; + #𛀞; + #𛀟; + #𛀠; + #𛀡; + #𛀢; + #𛀣; + #𛀤; + #𛀥; + #𛀦; + #𛀧; + #𛀨; + #𛀩; + #𛀪; + #𛀫; + #𛀬; + #𛀭; + #𛀮; + #𛀯; + #𛀰; + #𛀱; + #𛀲; + #𛀳; + #𛀴; + #𛀵; + #𛀶; + #𛀷; + #𛀸; + #𛀹; + #𛀺; + #𛀻; + #𛀼; + #𛀽; + #𛀾; + #𛀿; + #𛁀; + #𛁁; + #𛁂; + #𛁃; + #𛁄; + #𛁅; + #𛁆; + #𛁇; + #𛁈; + #𛁉; + #𛁊; + #𛁋; + #𛁌; + #𛁍; + #𛁎; + #𛁏; + #𛁐; + #𛁑; + #𛁒; + #𛁓; + #𛁔; + #𛁕; + #𛁖; + #𛁗; + #𛁘; + #𛁙; + #𛁚; + #𛁛; + #𛁜; + #𛁝; + #𛁞; + #𛁟; + #𛁠; + #𛁡; + #𛁢; + #𛁣; + #𛁤; + #𛁥; + #𛁦; + #𛁧; + #𛁨; + #𛁩; + #𛁪; + #𛁫; + #𛁬; + #𛁭; + #𛁮; + #𛁯; + #𛁰; + #𛁱; + #𛁲; + #𛁳; + #𛁴; + #𛁵; + #𛁶; + #𛁷; + #𛁸; + #𛁹; + #𛁺; + #𛁻; + #𛁼; + #𛁽; + #𛁾; + #𛁿; + #𛂀; + #𛂁; + #𛂂; + #𛂃; + #𛂄; + #𛂅; + #𛂆; + #𛂇; + #𛂈; + #𛂉; + #𛂊; + #𛂋; + #𛂌; + #𛂍; + #𛂎; + #𛂏; + #𛂐; + #𛂑; + #𛂒; + #𛂓; + #𛂔; + #𛂕; + #𛂖; + #𛂗; + #𛂘; + #𛂙; + #𛂚; + #𛂛; + #𛂜; + #𛂝; + #𛂞; + #𛂟; + #𛂠; + #𛂡; + #𛂢; + #𛂣; + #𛂤; + #𛂥; + #𛂦; + #𛂧; + #𛂨; + #𛂩; + #𛂪; + #𛂫; + #𛂬; + #𛂭; + #𛂮; + #𛂯; + #𛂰; + #𛂱; + #𛂲; + #𛂳; + #𛂴; + #𛂵; + #𛂶; + #𛂷; + #𛂸; + #𛂹; + #𛂺; + #𛂻; + #𛂼; + #𛂽; + #𛂾; + #𛂿; + #𛃀; + #𛃁; + #𛃂; + #𛃃; + #𛃄; + #𛃅; + #𛃆; + #𛃇; + #𛃈; + #𛃉; + #𛃊; + #𛃋; + #𛃌; + #𛃍; + #𛃎; + #𛃏; + #𛃐; + #𛃑; + #𛃒; + #𛃓; + #𛃔; + #𛃕; + #𛃖; + #𛃗; + #𛃘; + #𛃙; + #𛃚; + #𛃛; + #𛃜; + #𛃝; + #𛃞; + #𛃟; + #𛃠; + #𛃡; + #𛃢; + #𛃣; + #𛃤; + #𛃥; + #𛃦; + #𛃧; + #𛃨; + #𛃩; + #𛃪; + #𛃫; + #𛃬; + #𛃭; + #𛃮; + #𛃯; + #𛃰; + #𛃱; + #𛃲; + #𛃳; + #𛃴; + #𛃵; + #𛃶; + #𛃷; + #𛃸; + #𛃹; + #𛃺; + #𛃻; + #𛃼; + #𛃽; + #𛃾; + #𛃿; + #𛄀; + #𛄁; + #𛄂; + #𛄃; + #𛄄; + #𛄅; + #𛄆; + #𛄇; + #𛄈; + #𛄉; + #𛄊; + #𛄋; + #𛄌; + #𛄍; + #𛄎; + #𛄏; + #𛄐; + #𛄑; + #𛄒; + #𛄓; + #𛄔; + #𛄕; + #𛄖; + #𛄗; + #𛄘; + #𛄙; + #𛄚; + #𛄛; + #𛄜; + #𛄝; + #𛄞; + #𛅰; + #𛅱; + #𛅲; + #𛅳; + #𛅴; + #𛅵; + #𛅶; + #𛅷; + #𛅸; + #𛅹; + #𛅺; + #𛅻; + #𛅼; + #𛅽; + #𛅾; + #𛅿; + #𛆀; + #𛆁; + #𛆂; + #𛆃; + #𛆄; + #𛆅; + #𛆆; + #𛆇; + #𛆈; + #𛆉; + #𛆊; + #𛆋; + #𛆌; + #𛆍; + #𛆎; + #𛆏; + #𛆐; + #𛆑; + #𛆒; + #𛆓; + #𛆔; + #𛆕; + #𛆖; + #𛆗; + #𛆘; + #𛆙; + #𛆚; + #𛆛; + #𛆜; + #𛆝; + #𛆞; + #𛆟; + #𛆠; + #𛆡; + #𛆢; + #𛆣; + #𛆤; + #𛆥; + #𛆦; + #𛆧; + #𛆨; + #𛆩; + #𛆪; + #𛆫; + #𛆬; + #𛆭; + #𛆮; + #𛆯; + #𛆰; + #𛆱; + #𛆲; + #𛆳; + #𛆴; + #𛆵; + #𛆶; + #𛆷; + #𛆸; + #𛆹; + #𛆺; + #𛆻; + #𛆼; + #𛆽; + #𛆾; + #𛆿; + #𛇀; + #𛇁; + #𛇂; + #𛇃; + #𛇄; + #𛇅; + #𛇆; + #𛇇; + #𛇈; + #𛇉; + #𛇊; + #𛇋; + #𛇌; + #𛇍; + #𛇎; + #𛇏; + #𛇐; + #𛇑; + #𛇒; + #𛇓; + #𛇔; + #𛇕; + #𛇖; + #𛇗; + #𛇘; + #𛇙; + #𛇚; + #𛇛; + #𛇜; + #𛇝; + #𛇞; + #𛇟; + #𛇠; + #𛇡; + #𛇢; + #𛇣; + #𛇤; + #𛇥; + #𛇦; + #𛇧; + #𛇨; + #𛇩; + #𛇪; + #𛇫; + #𛇬; + #𛇭; + #𛇮; + #𛇯; + #𛇰; + #𛇱; + #𛇲; + #𛇳; + #𛇴; + #𛇵; + #𛇶; + #𛇷; + #𛇸; + #𛇹; + #𛇺; + #𛇻; + #𛇼; + #𛇽; + #𛇾; + #𛇿; + #𛈀; + #𛈁; + #𛈂; + #𛈃; + #𛈄; + #𛈅; + #𛈆; + #𛈇; + #𛈈; + #𛈉; + #𛈊; + #𛈋; + #𛈌; + #𛈍; + #𛈎; + #𛈏; + #𛈐; + #𛈑; + #𛈒; + #𛈓; + #𛈔; + #𛈕; + #𛈖; + #𛈗; + #𛈘; + #𛈙; + #𛈚; + #𛈛; + #𛈜; + #𛈝; + #𛈞; + #𛈟; + #𛈠; + #𛈡; + #𛈢; + #𛈣; + #𛈤; + #𛈥; + #𛈦; + #𛈧; + #𛈨; + #𛈩; + #𛈪; + #𛈫; + #𛈬; + #𛈭; + #𛈮; + #𛈯; + #𛈰; + #𛈱; + #𛈲; + #𛈳; + #𛈴; + #𛈵; + #𛈶; + #𛈷; + #𛈸; + #𛈹; + #𛈺; + #𛈻; + #𛈼; + #𛈽; + #𛈾; + #𛈿; + #𛉀; + #𛉁; + #𛉂; + #𛉃; + #𛉄; + #𛉅; + #𛉆; + #𛉇; + #𛉈; + #𛉉; + #𛉊; + #𛉋; + #𛉌; + #𛉍; + #𛉎; + #𛉏; + #𛉐; + #𛉑; + #𛉒; + #𛉓; + #𛉔; + #𛉕; + #𛉖; + #𛉗; + #𛉘; + #𛉙; + #𛉚; + #𛉛; + #𛉜; + #𛉝; + #𛉞; + #𛉟; + #𛉠; + #𛉡; + #𛉢; + #𛉣; + #𛉤; + #𛉥; + #𛉦; + #𛉧; + #𛉨; + #𛉩; + #𛉪; + #𛉫; + #𛉬; + #𛉭; + #𛉮; + #𛉯; + #𛉰; + #𛉱; + #𛉲; + #𛉳; + #𛉴; + #𛉵; + #𛉶; + #𛉷; + #𛉸; + #𛉹; + #𛉺; + #𛉻; + #𛉼; + #𛉽; + #𛉾; + #𛉿; + #𛊀; + #𛊁; + #𛊂; + #𛊃; + #𛊄; + #𛊅; + #𛊆; + #𛊇; + #𛊈; + #𛊉; + #𛊊; + #𛊋; + #𛊌; + #𛊍; + #𛊎; + #𛊏; + #𛊐; + #𛊑; + #𛊒; + #𛊓; + #𛊔; + #𛊕; + #𛊖; + #𛊗; + #𛊘; + #𛊙; + #𛊚; + #𛊛; + #𛊜; + #𛊝; + #𛊞; + #𛊟; + #𛊠; + #𛊡; + #𛊢; + #𛊣; + #𛊤; + #𛊥; + #𛊦; + #𛊧; + #𛊨; + #𛊩; + #𛊪; + #𛊫; + #𛊬; + #𛊭; + #𛊮; + #𛊯; + #𛊰; + #𛊱; + #𛊲; + #𛊳; + #𛊴; + #𛊵; + #𛊶; + #𛊷; + #𛊸; + #𛊹; + #𛊺; + #𛊻; + #𛊼; + #𛊽; + #𛊾; + #𛊿; + #𛋀; + #𛋁; + #𛋂; + #𛋃; + #𛋄; + #𛋅; + #𛋆; + #𛋇; + #𛋈; + #𛋉; + #𛋊; + #𛋋; + #𛋌; + #𛋍; + #𛋎; + #𛋏; + #𛋐; + #𛋑; + #𛋒; + #𛋓; + #𛋔; + #𛋕; + #𛋖; + #𛋗; + #𛋘; + #𛋙; + #𛋚; + #𛋛; + #𛋜; + #𛋝; + #𛋞; + #𛋟; + #𛋠; + #𛋡; + #𛋢; + #𛋣; + #𛋤; + #𛋥; + #𛋦; + #𛋧; + #𛋨; + #𛋩; + #𛋪; + #𛋫; + #𛋬; + #𛋭; + #𛋮; + #𛋯; + #𛋰; + #𛋱; + #𛋲; + #𛋳; + #𛋴; + #𛋵; + #𛋶; + #𛋷; + #𛋸; + #𛋹; + #𛋺; + #𛋻; + #𬺰; + #𬺱; + #𬺲; + #𬺳; + #𬺴; + #𬺵; + #𬺶; + #𬺷; + #𬺸; + #𬺹; + #𬺺; + #𬺻; + #𬺼; + #𬺽; + #𬺾; + #𬺿; + #𬻀; + #𬻁; + #𬻂; + #𬻃; + #𬻄; + #𬻅; + #𬻆; + #𬻇; + #𬻈; + #𬻉; + #𬻊; + #𬻋; + #𬻌; + #𬻍; + #𬻎; + #𬻏; + #𬻐; + #𬻑; + #𬻒; + #𬻓; + #𬻔; + #𬻕; + #𬻖; + #𬻗; + #𬻘; + #𬻙; + #𬻚; + #𬻛; + #𬻜; + #𬻝; + #𬻞; + #𬻟; + #𬻠; + #𬻡; + #𬻢; + #𬻣; + #𬻤; + #𬻥; + #𬻦; + #𬻧; + #𬻨; + #𬻩; + #𬻪; + #𬻫; + #𬻬; + #𬻭; + #𬻮; + #𬻯; + #𬻰; + #𬻱; + #𬻲; + #𬻳; + #𬻴; + #𬻵; + #𬻶; + #𬻷; + #𬻸; + #𬻹; + #𬻺; + #𬻻; + #𬻼; + #𬻽; + #𬻾; + #𬻿; + #𬼀; + #𬼁; + #𬼂; + #𬼃; + #𬼄; + #𬼅; + #𬼆; + #𬼇; + #𬼈; + #𬼉; + #𬼊; + #𬼋; + #𬼌; + #𬼍; + #𬼎; + #𬼏; + #𬼐; + #𬼑; + #𬼒; + #𬼓; + #𬼔; + #𬼕; + #𬼖; + #𬼗; + #𬼘; + #𬼙; + #𬼚; + #𬼛; + #𬼜; + #𬼝; + #𬼞; + #𬼟; + #𬼠; + #𬼡; + #𬼢; + #𬼣; + #𬼤; + #𬼥; + #𬼦; + #𬼧; + #𬼨; + #𬼩; + #𬼪; + #𬼫; + #𬼬; + #𬼭; + #𬼮; + #𬼯; + #𬼰; + #𬼱; + #𬼲; + #𬼳; + #𬼴; + #𬼵; + #𬼶; + #𬼷; + #𬼸; + #𬼹; + #𬼺; + #𬼻; + #𬼼; + #𬼽; + #𬼾; + #𬼿; + #𬽀; + #𬽁; + #𬽂; + #𬽃; + #𬽄; + #𬽅; + #𬽆; + #𬽇; + #𬽈; + #𬽉; + #𬽊; + #𬽋; + #𬽌; + #𬽍; + #𬽎; + #𬽏; + #𬽐; + #𬽑; + #𬽒; + #𬽓; + #𬽔; + #𬽕; + #𬽖; + #𬽗; + #𬽘; + #𬽙; + #𬽚; + #𬽛; + #𬽜; + #𬽝; + #𬽞; + #𬽟; + #𬽠; + #𬽡; + #𬽢; + #𬽣; + #𬽤; + #𬽥; + #𬽦; + #𬽧; + #𬽨; + #𬽩; + #𬽪; + #𬽫; + #𬽬; + #𬽭; + #𬽮; + #𬽯; + #𬽰; + #𬽱; + #𬽲; + #𬽳; + #𬽴; + #𬽵; + #𬽶; + #𬽷; + #𬽸; + #𬽹; + #𬽺; + #𬽻; + #𬽼; + #𬽽; + #𬽾; + #𬽿; + #𬾀; + #𬾁; + #𬾂; + #𬾃; + #𬾄; + #𬾅; + #𬾆; + #𬾇; + #𬾈; + #𬾉; + #𬾊; + #𬾋; + #𬾌; + #𬾍; + #𬾎; + #𬾏; + #𬾐; + #𬾑; + #𬾒; + #𬾓; + #𬾔; + #𬾕; + #𬾖; + #𬾗; + #𬾘; + #𬾙; + #𬾚; + #𬾛; + #𬾜; + #𬾝; + #𬾞; + #𬾟; + #𬾠; + #𬾡; + #𬾢; + #𬾣; + #𬾤; + #𬾥; + #𬾦; + #𬾧; + #𬾨; + #𬾩; + #𬾪; + #𬾫; + #𬾬; + #𬾭; + #𬾮; + #𬾯; + #𬾰; + #𬾱; + #𬾲; + #𬾳; + #𬾴; + #𬾵; + #𬾶; + #𬾷; + #𬾸; + #𬾹; + #𬾺; + #𬾻; + #𬾼; + #𬾽; + #𬾾; + #𬾿; + #𬿀; + #𬿁; + #𬿂; + #𬿃; + #𬿄; + #𬿅; + #𬿆; + #𬿇; + #𬿈; + #𬿉; + #𬿊; + #𬿋; + #𬿌; + #𬿍; + #𬿎; + #𬿏; + #𬿐; + #𬿑; + #𬿒; + #𬿓; + #𬿔; + #𬿕; + #𬿖; + #𬿗; + #𬿘; + #𬿙; + #𬿚; + #𬿛; + #𬿜; + #𬿝; + #𬿞; + #𬿟; + #𬿠; + #𬿡; + #𬿢; + #𬿣; + #𬿤; + #𬿥; + #𬿦; + #𬿧; + #𬿨; + #𬿩; + #𬿪; + #𬿫; + #𬿬; + #𬿭; + #𬿮; + #𬿯; + #𬿰; + #𬿱; + #𬿲; + #𬿳; + #𬿴; + #𬿵; + #𬿶; + #𬿷; + #𬿸; + #𬿹; + #𬿺; + #𬿻; + #𬿼; + #𬿽; + #𬿾; + #𬿿; + #𭀀; + #𭀁; + #𭀂; + #𭀃; + #𭀄; + #𭀅; + #𭀆; + #𭀇; + #𭀈; + #𭀉; + #𭀊; + #𭀋; + #𭀌; + #𭀍; + #𭀎; + #𭀏; + #𭀐; + #𭀑; + #𭀒; + #𭀓; + #𭀔; + #𭀕; + #𭀖; + #𭀗; + #𭀘; + #𭀙; + #𭀚; + #𭀛; + #𭀜; + #𭀝; + #𭀞; + #𭀟; + #𭀠; + #𭀡; + #𭀢; + #𭀣; + #𭀤; + #𭀥; + #𭀦; + #𭀧; + #𭀨; + #𭀩; + #𭀪; + #𭀫; + #𭀬; + #𭀭; + #𭀮; + #𭀯; + #𭀰; + #𭀱; + #𭀲; + #𭀳; + #𭀴; + #𭀵; + #𭀶; + #𭀷; + #𭀸; + #𭀹; + #𭀺; + #𭀻; + #𭀼; + #𭀽; + #𭀾; + #𭀿; + #𭁀; + #𭁁; + #𭁂; + #𭁃; + #𭁄; + #𭁅; + #𭁆; + #𭁇; + #𭁈; + #𭁉; + #𭁊; + #𭁋; + #𭁌; + #𭁍; + #𭁎; + #𭁏; + #𭁐; + #𭁑; + #𭁒; + #𭁓; + #𭁔; + #𭁕; + #𭁖; + #𭁗; + #𭁘; + #𭁙; + #𭁚; + #𭁛; + #𭁜; + #𭁝; + #𭁞; + #𭁟; + #𭁠; + #𭁡; + #𭁢; + #𭁣; + #𭁤; + #𭁥; + #𭁦; + #𭁧; + #𭁨; + #𭁩; + #𭁪; + #𭁫; + #𭁬; + #𭁭; + #𭁮; + #𭁯; + #𭁰; + #𭁱; + #𭁲; + #𭁳; + #𭁴; + #𭁵; + #𭁶; + #𭁷; + #𭁸; + #𭁹; + #𭁺; + #𭁻; + #𭁼; + #𭁽; + #𭁾; + #𭁿; + #𭂀; + #𭂁; + #𭂂; + #𭂃; + #𭂄; + #𭂅; + #𭂆; + #𭂇; + #𭂈; + #𭂉; + #𭂊; + #𭂋; + #𭂌; + #𭂍; + #𭂎; + #𭂏; + #𭂐; + #𭂑; + #𭂒; + #𭂓; + #𭂔; + #𭂕; + #𭂖; + #𭂗; + #𭂘; + #𭂙; + #𭂚; + #𭂛; + #𭂜; + #𭂝; + #𭂞; + #𭂟; + #𭂠; + #𭂡; + #𭂢; + #𭂣; + #𭂤; + #𭂥; + #𭂦; + #𭂧; + #𭂨; + #𭂩; + #𭂪; + #𭂫; + #𭂬; + #𭂭; + #𭂮; + #𭂯; + #𭂰; + #𭂱; + #𭂲; + #𭂳; + #𭂴; + #𭂵; + #𭂶; + #𭂷; + #𭂸; + #𭂹; + #𭂺; + #𭂻; + #𭂼; + #𭂽; + #𭂾; + #𭂿; + #𭃀; + #𭃁; + #𭃂; + #𭃃; + #𭃄; + #𭃅; + #𭃆; + #𭃇; + #𭃈; + #𭃉; + #𭃊; + #𭃋; + #𭃌; + #𭃍; + #𭃎; + #𭃏; + #𭃐; + #𭃑; + #𭃒; + #𭃓; + #𭃔; + #𭃕; + #𭃖; + #𭃗; + #𭃘; + #𭃙; + #𭃚; + #𭃛; + #𭃜; + #𭃝; + #𭃞; + #𭃟; + #𭃠; + #𭃡; + #𭃢; + #𭃣; + #𭃤; + #𭃥; + #𭃦; + #𭃧; + #𭃨; + #𭃩; + #𭃪; + #𭃫; + #𭃬; + #𭃭; + #𭃮; + #𭃯; + #𭃰; + #𭃱; + #𭃲; + #𭃳; + #𭃴; + #𭃵; + #𭃶; + #𭃷; + #𭃸; + #𭃹; + #𭃺; + #𭃻; + #𭃼; + #𭃽; + #𭃾; + #𭃿; + #𭄀; + #𭄁; + #𭄂; + #𭄃; + #𭄄; + #𭄅; + #𭄆; + #𭄇; + #𭄈; + #𭄉; + #𭄊; + #𭄋; + #𭄌; + #𭄍; + #𭄎; + #𭄏; + #𭄐; + #𭄑; + #𭄒; + #𭄓; + #𭄔; + #𭄕; + #𭄖; + #𭄗; + #𭄘; + #𭄙; + #𭄚; + #𭄛; + #𭄜; + #𭄝; + #𭄞; + #𭄟; + #𭄠; + #𭄡; + #𭄢; + #𭄣; + #𭄤; + #𭄥; + #𭄦; + #𭄧; + #𭄨; + #𭄩; + #𭄪; + #𭄫; + #𭄬; + #𭄭; + #𭄮; + #𭄯; + #𭄰; + #𭄱; + #𭄲; + #𭄳; + #𭄴; + #𭄵; + #𭄶; + #𭄷; + #𭄸; + #𭄹; + #𭄺; + #𭄻; + #𭄼; + #𭄽; + #𭄾; + #𭄿; + #𭅀; + #𭅁; + #𭅂; + #𭅃; + #𭅄; + #𭅅; + #𭅆; + #𭅇; + #𭅈; + #𭅉; + #𭅊; + #𭅋; + #𭅌; + #𭅍; + #𭅎; + #𭅏; + #𭅐; + #𭅑; + #𭅒; + #𭅓; + #𭅔; + #𭅕; + #𭅖; + #𭅗; + #𭅘; + #𭅙; + #𭅚; + #𭅛; + #𭅜; + #𭅝; + #𭅞; + #𭅟; + #𭅠; + #𭅡; + #𭅢; + #𭅣; + #𭅤; + #𭅥; + #𭅦; + #𭅧; + #𭅨; + #𭅩; + #𭅪; + #𭅫; + #𭅬; + #𭅭; + #𭅮; + #𭅯; + #𭅰; + #𭅱; + #𭅲; + #𭅳; + #𭅴; + #𭅵; + #𭅶; + #𭅷; + #𭅸; + #𭅹; + #𭅺; + #𭅻; + #𭅼; + #𭅽; + #𭅾; + #𭅿; + #𭆀; + #𭆁; + #𭆂; + #𭆃; + #𭆄; + #𭆅; + #𭆆; + #𭆇; + #𭆈; + #𭆉; + #𭆊; + #𭆋; + #𭆌; + #𭆍; + #𭆎; + #𭆏; + #𭆐; + #𭆑; + #𭆒; + #𭆓; + #𭆔; + #𭆕; + #𭆖; + #𭆗; + #𭆘; + #𭆙; + #𭆚; + #𭆛; + #𭆜; + #𭆝; + #𭆞; + #𭆟; + #𭆠; + #𭆡; + #𭆢; + #𭆣; + #𭆤; + #𭆥; + #𭆦; + #𭆧; + #𭆨; + #𭆩; + #𭆪; + #𭆫; + #𭆬; + #𭆭; + #𭆮; + #𭆯; + #𭆰; + #𭆱; + #𭆲; + #𭆳; + #𭆴; + #𭆵; + #𭆶; + #𭆷; + #𭆸; + #𭆹; + #𭆺; + #𭆻; + #𭆼; + #𭆽; + #𭆾; + #𭆿; + #𭇀; + #𭇁; + #𭇂; + #𭇃; + #𭇄; + #𭇅; + #𭇆; + #𭇇; + #𭇈; + #𭇉; + #𭇊; + #𭇋; + #𭇌; + #𭇍; + #𭇎; + #𭇏; + #𭇐; + #𭇑; + #𭇒; + #𭇓; + #𭇔; + #𭇕; + #𭇖; + #𭇗; + #𭇘; + #𭇙; + #𭇚; + #𭇛; + #𭇜; + #𭇝; + #𭇞; + #𭇟; + #𭇠; + #𭇡; + #𭇢; + #𭇣; + #𭇤; + #𭇥; + #𭇦; + #𭇧; + #𭇨; + #𭇩; + #𭇪; + #𭇫; + #𭇬; + #𭇭; + #𭇮; + #𭇯; + #𭇰; + #𭇱; + #𭇲; + #𭇳; + #𭇴; + #𭇵; + #𭇶; + #𭇷; + #𭇸; + #𭇹; + #𭇺; + #𭇻; + #𭇼; + #𭇽; + #𭇾; + #𭇿; + #𭈀; + #𭈁; + #𭈂; + #𭈃; + #𭈄; + #𭈅; + #𭈆; + #𭈇; + #𭈈; + #𭈉; + #𭈊; + #𭈋; + #𭈌; + #𭈍; + #𭈎; + #𭈏; + #𭈐; + #𭈑; + #𭈒; + #𭈓; + #𭈔; + #𭈕; + #𭈖; + #𭈗; + #𭈘; + #𭈙; + #𭈚; + #𭈛; + #𭈜; + #𭈝; + #𭈞; + #𭈟; + #𭈠; + #𭈡; + #𭈢; + #𭈣; + #𭈤; + #𭈥; + #𭈦; + #𭈧; + #𭈨; + #𭈩; + #𭈪; + #𭈫; + #𭈬; + #𭈭; + #𭈮; + #𭈯; + #𭈰; + #𭈱; + #𭈲; + #𭈳; + #𭈴; + #𭈵; + #𭈶; + #𭈷; + #𭈸; + #𭈹; + #𭈺; + #𭈻; + #𭈼; + #𭈽; + #𭈾; + #𭈿; + #𭉀; + #𭉁; + #𭉂; + #𭉃; + #𭉄; + #𭉅; + #𭉆; + #𭉇; + #𭉈; + #𭉉; + #𭉊; + #𭉋; + #𭉌; + #𭉍; + #𭉎; + #𭉏; + #𭉐; + #𭉑; + #𭉒; + #𭉓; + #𭉔; + #𭉕; + #𭉖; + #𭉗; + #𭉘; + #𭉙; + #𭉚; + #𭉛; + #𭉜; + #𭉝; + #𭉞; + #𭉟; + #𭉠; + #𭉡; + #𭉢; + #𭉣; + #𭉤; + #𭉥; + #𭉦; + #𭉧; + #𭉨; + #𭉩; + #𭉪; + #𭉫; + #𭉬; + #𭉭; + #𭉮; + #𭉯; + #𭉰; + #𭉱; + #𭉲; + #𭉳; + #𭉴; + #𭉵; + #𭉶; + #𭉷; + #𭉸; + #𭉹; + #𭉺; + #𭉻; + #𭉼; + #𭉽; + #𭉾; + #𭉿; + #𭊀; + #𭊁; + #𭊂; + #𭊃; + #𭊄; + #𭊅; + #𭊆; + #𭊇; + #𭊈; + #𭊉; + #𭊊; + #𭊋; + #𭊌; + #𭊍; + #𭊎; + #𭊏; + #𭊐; + #𭊑; + #𭊒; + #𭊓; + #𭊔; + #𭊕; + #𭊖; + #𭊗; + #𭊘; + #𭊙; + #𭊚; + #𭊛; + #𭊜; + #𭊝; + #𭊞; + #𭊟; + #𭊠; + #𭊡; + #𭊢; + #𭊣; + #𭊤; + #𭊥; + #𭊦; + #𭊧; + #𭊨; + #𭊩; + #𭊪; + #𭊫; + #𭊬; + #𭊭; + #𭊮; + #𭊯; + #𭊰; + #𭊱; + #𭊲; + #𭊳; + #𭊴; + #𭊵; + #𭊶; + #𭊷; + #𭊸; + #𭊹; + #𭊺; + #𭊻; + #𭊼; + #𭊽; + #𭊾; + #𭊿; + #𭋀; + #𭋁; + #𭋂; + #𭋃; + #𭋄; + #𭋅; + #𭋆; + #𭋇; + #𭋈; + #𭋉; + #𭋊; + #𭋋; + #𭋌; + #𭋍; + #𭋎; + #𭋏; + #𭋐; + #𭋑; + #𭋒; + #𭋓; + #𭋔; + #𭋕; + #𭋖; + #𭋗; + #𭋘; + #𭋙; + #𭋚; + #𭋛; + #𭋜; + #𭋝; + #𭋞; + #𭋟; + #𭋠; + #𭋡; + #𭋢; + #𭋣; + #𭋤; + #𭋥; + #𭋦; + #𭋧; + #𭋨; + #𭋩; + #𭋪; + #𭋫; + #𭋬; + #𭋭; + #𭋮; + #𭋯; + #𭋰; + #𭋱; + #𭋲; + #𭋳; + #𭋴; + #𭋵; + #𭋶; + #𭋷; + #𭋸; + #𭋹; + #𭋺; + #𭋻; + #𭋼; + #𭋽; + #𭋾; + #𭋿; + #𭌀; + #𭌁; + #𭌂; + #𭌃; + #𭌄; + #𭌅; + #𭌆; + #𭌇; + #𭌈; + #𭌉; + #𭌊; + #𭌋; + #𭌌; + #𭌍; + #𭌎; + #𭌏; + #𭌐; + #𭌑; + #𭌒; + #𭌓; + #𭌔; + #𭌕; + #𭌖; + #𭌗; + #𭌘; + #𭌙; + #𭌚; + #𭌛; + #𭌜; + #𭌝; + #𭌞; + #𭌟; + #𭌠; + #𭌡; + #𭌢; + #𭌣; + #𭌤; + #𭌥; + #𭌦; + #𭌧; + #𭌨; + #𭌩; + #𭌪; + #𭌫; + #𭌬; + #𭌭; + #𭌮; + #𭌯; + #𭌰; + #𭌱; + #𭌲; + #𭌳; + #𭌴; + #𭌵; + #𭌶; + #𭌷; + #𭌸; + #𭌹; + #𭌺; + #𭌻; + #𭌼; + #𭌽; + #𭌾; + #𭌿; + #𭍀; + #𭍁; + #𭍂; + #𭍃; + #𭍄; + #𭍅; + #𭍆; + #𭍇; + #𭍈; + #𭍉; + #𭍊; + #𭍋; + #𭍌; + #𭍍; + #𭍎; + #𭍏; + #𭍐; + #𭍑; + #𭍒; + #𭍓; + #𭍔; + #𭍕; + #𭍖; + #𭍗; + #𭍘; + #𭍙; + #𭍚; + #𭍛; + #𭍜; + #𭍝; + #𭍞; + #𭍟; + #𭍠; + #𭍡; + #𭍢; + #𭍣; + #𭍤; + #𭍥; + #𭍦; + #𭍧; + #𭍨; + #𭍩; + #𭍪; + #𭍫; + #𭍬; + #𭍭; + #𭍮; + #𭍯; + #𭍰; + #𭍱; + #𭍲; + #𭍳; + #𭍴; + #𭍵; + #𭍶; + #𭍷; + #𭍸; + #𭍹; + #𭍺; + #𭍻; + #𭍼; + #𭍽; + #𭍾; + #𭍿; + #𭎀; + #𭎁; + #𭎂; + #𭎃; + #𭎄; + #𭎅; + #𭎆; + #𭎇; + #𭎈; + #𭎉; + #𭎊; + #𭎋; + #𭎌; + #𭎍; + #𭎎; + #𭎏; + #𭎐; + #𭎑; + #𭎒; + #𭎓; + #𭎔; + #𭎕; + #𭎖; + #𭎗; + #𭎘; + #𭎙; + #𭎚; + #𭎛; + #𭎜; + #𭎝; + #𭎞; + #𭎟; + #𭎠; + #𭎡; + #𭎢; + #𭎣; + #𭎤; + #𭎥; + #𭎦; + #𭎧; + #𭎨; + #𭎩; + #𭎪; + #𭎫; + #𭎬; + #𭎭; + #𭎮; + #𭎯; + #𭎰; + #𭎱; + #𭎲; + #𭎳; + #𭎴; + #𭎵; + #𭎶; + #𭎷; + #𭎸; + #𭎹; + #𭎺; + #𭎻; + #𭎼; + #𭎽; + #𭎾; + #𭎿; + #𭏀; + #𭏁; + #𭏂; + #𭏃; + #𭏄; + #𭏅; + #𭏆; + #𭏇; + #𭏈; + #𭏉; + #𭏊; + #𭏋; + #𭏌; + #𭏍; + #𭏎; + #𭏏; + #𭏐; + #𭏑; + #𭏒; + #𭏓; + #𭏔; + #𭏕; + #𭏖; + #𭏗; + #𭏘; + #𭏙; + #𭏚; + #𭏛; + #𭏜; + #𭏝; + #𭏞; + #𭏟; + #𭏠; + #𭏡; + #𭏢; + #𭏣; + #𭏤; + #𭏥; + #𭏦; + #𭏧; + #𭏨; + #𭏩; + #𭏪; + #𭏫; + #𭏬; + #𭏭; + #𭏮; + #𭏯; + #𭏰; + #𭏱; + #𭏲; + #𭏳; + #𭏴; + #𭏵; + #𭏶; + #𭏷; + #𭏸; + #𭏹; + #𭏺; + #𭏻; + #𭏼; + #𭏽; + #𭏾; + #𭏿; + #𭐀; + #𭐁; + #𭐂; + #𭐃; + #𭐄; + #𭐅; + #𭐆; + #𭐇; + #𭐈; + #𭐉; + #𭐊; + #𭐋; + #𭐌; + #𭐍; + #𭐎; + #𭐏; + #𭐐; + #𭐑; + #𭐒; + #𭐓; + #𭐔; + #𭐕; + #𭐖; + #𭐗; + #𭐘; + #𭐙; + #𭐚; + #𭐛; + #𭐜; + #𭐝; + #𭐞; + #𭐟; + #𭐠; + #𭐡; + #𭐢; + #𭐣; + #𭐤; + #𭐥; + #𭐦; + #𭐧; + #𭐨; + #𭐩; + #𭐪; + #𭐫; + #𭐬; + #𭐭; + #𭐮; + #𭐯; + #𭐰; + #𭐱; + #𭐲; + #𭐳; + #𭐴; + #𭐵; + #𭐶; + #𭐷; + #𭐸; + #𭐹; + #𭐺; + #𭐻; + #𭐼; + #𭐽; + #𭐾; + #𭐿; + #𭑀; + #𭑁; + #𭑂; + #𭑃; + #𭑄; + #𭑅; + #𭑆; + #𭑇; + #𭑈; + #𭑉; + #𭑊; + #𭑋; + #𭑌; + #𭑍; + #𭑎; + #𭑏; + #𭑐; + #𭑑; + #𭑒; + #𭑓; + #𭑔; + #𭑕; + #𭑖; + #𭑗; + #𭑘; + #𭑙; + #𭑚; + #𭑛; + #𭑜; + #𭑝; + #𭑞; + #𭑟; + #𭑠; + #𭑡; + #𭑢; + #𭑣; + #𭑤; + #𭑥; + #𭑦; + #𭑧; + #𭑨; + #𭑩; + #𭑪; + #𭑫; + #𭑬; + #𭑭; + #𭑮; + #𭑯; + #𭑰; + #𭑱; + #𭑲; + #𭑳; + #𭑴; + #𭑵; + #𭑶; + #𭑷; + #𭑸; + #𭑹; + #𭑺; + #𭑻; + #𭑼; + #𭑽; + #𭑾; + #𭑿; + #𭒀; + #𭒁; + #𭒂; + #𭒃; + #𭒄; + #𭒅; + #𭒆; + #𭒇; + #𭒈; + #𭒉; + #𭒊; + #𭒋; + #𭒌; + #𭒍; + #𭒎; + #𭒏; + #𭒐; + #𭒑; + #𭒒; + #𭒓; + #𭒔; + #𭒕; + #𭒖; + #𭒗; + #𭒘; + #𭒙; + #𭒚; + #𭒛; + #𭒜; + #𭒝; + #𭒞; + #𭒟; + #𭒠; + #𭒡; + #𭒢; + #𭒣; + #𭒤; + #𭒥; + #𭒦; + #𭒧; + #𭒨; + #𭒩; + #𭒪; + #𭒫; + #𭒬; + #𭒭; + #𭒮; + #𭒯; + #𭒰; + #𭒱; + #𭒲; + #𭒳; + #𭒴; + #𭒵; + #𭒶; + #𭒷; + #𭒸; + #𭒹; + #𭒺; + #𭒻; + #𭒼; + #𭒽; + #𭒾; + #𭒿; + #𭓀; + #𭓁; + #𭓂; + #𭓃; + #𭓄; + #𭓅; + #𭓆; + #𭓇; + #𭓈; + #𭓉; + #𭓊; + #𭓋; + #𭓌; + #𭓍; + #𭓎; + #𭓏; + #𭓐; + #𭓑; + #𭓒; + #𭓓; + #𭓔; + #𭓕; + #𭓖; + #𭓗; + #𭓘; + #𭓙; + #𭓚; + #𭓛; + #𭓜; + #𭓝; + #𭓞; + #𭓟; + #𭓠; + #𭓡; + #𭓢; + #𭓣; + #𭓤; + #𭓥; + #𭓦; + #𭓧; + #𭓨; + #𭓩; + #𭓪; + #𭓫; + #𭓬; + #𭓭; + #𭓮; + #𭓯; + #𭓰; + #𭓱; + #𭓲; + #𭓳; + #𭓴; + #𭓵; + #𭓶; + #𭓷; + #𭓸; + #𭓹; + #𭓺; + #𭓻; + #𭓼; + #𭓽; + #𭓾; + #𭓿; + #𭔀; + #𭔁; + #𭔂; + #𭔃; + #𭔄; + #𭔅; + #𭔆; + #𭔇; + #𭔈; + #𭔉; + #𭔊; + #𭔋; + #𭔌; + #𭔍; + #𭔎; + #𭔏; + #𭔐; + #𭔑; + #𭔒; + #𭔓; + #𭔔; + #𭔕; + #𭔖; + #𭔗; + #𭔘; + #𭔙; + #𭔚; + #𭔛; + #𭔜; + #𭔝; + #𭔞; + #𭔟; + #𭔠; + #𭔡; + #𭔢; + #𭔣; + #𭔤; + #𭔥; + #𭔦; + #𭔧; + #𭔨; + #𭔩; + #𭔪; + #𭔫; + #𭔬; + #𭔭; + #𭔮; + #𭔯; + #𭔰; + #𭔱; + #𭔲; + #𭔳; + #𭔴; + #𭔵; + #𭔶; + #𭔷; + #𭔸; + #𭔹; + #𭔺; + #𭔻; + #𭔼; + #𭔽; + #𭔾; + #𭔿; + #𭕀; + #𭕁; + #𭕂; + #𭕃; + #𭕄; + #𭕅; + #𭕆; + #𭕇; + #𭕈; + #𭕉; + #𭕊; + #𭕋; + #𭕌; + #𭕍; + #𭕎; + #𭕏; + #𭕐; + #𭕑; + #𭕒; + #𭕓; + #𭕔; + #𭕕; + #𭕖; + #𭕗; + #𭕘; + #𭕙; + #𭕚; + #𭕛; + #𭕜; + #𭕝; + #𭕞; + #𭕟; + #𭕠; + #𭕡; + #𭕢; + #𭕣; + #𭕤; + #𭕥; + #𭕦; + #𭕧; + #𭕨; + #𭕩; + #𭕪; + #𭕫; + #𭕬; + #𭕭; + #𭕮; + #𭕯; + #𭕰; + #𭕱; + #𭕲; + #𭕳; + #𭕴; + #𭕵; + #𭕶; + #𭕷; + #𭕸; + #𭕹; + #𭕺; + #𭕻; + #𭕼; + #𭕽; + #𭕾; + #𭕿; + #𭖀; + #𭖁; + #𭖂; + #𭖃; + #𭖄; + #𭖅; + #𭖆; + #𭖇; + #𭖈; + #𭖉; + #𭖊; + #𭖋; + #𭖌; + #𭖍; + #𭖎; + #𭖏; + #𭖐; + #𭖑; + #𭖒; + #𭖓; + #𭖔; + #𭖕; + #𭖖; + #𭖗; + #𭖘; + #𭖙; + #𭖚; + #𭖛; + #𭖜; + #𭖝; + #𭖞; + #𭖟; + #𭖠; + #𭖡; + #𭖢; + #𭖣; + #𭖤; + #𭖥; + #𭖦; + #𭖧; + #𭖨; + #𭖩; + #𭖪; + #𭖫; + #𭖬; + #𭖭; + #𭖮; + #𭖯; + #𭖰; + #𭖱; + #𭖲; + #𭖳; + #𭖴; + #𭖵; + #𭖶; + #𭖷; + #𭖸; + #𭖹; + #𭖺; + #𭖻; + #𭖼; + #𭖽; + #𭖾; + #𭖿; + #𭗀; + #𭗁; + #𭗂; + #𭗃; + #𭗄; + #𭗅; + #𭗆; + #𭗇; + #𭗈; + #𭗉; + #𭗊; + #𭗋; + #𭗌; + #𭗍; + #𭗎; + #𭗏; + #𭗐; + #𭗑; + #𭗒; + #𭗓; + #𭗔; + #𭗕; + #𭗖; + #𭗗; + #𭗘; + #𭗙; + #𭗚; + #𭗛; + #𭗜; + #𭗝; + #𭗞; + #𭗟; + #𭗠; + #𭗡; + #𭗢; + #𭗣; + #𭗤; + #𭗥; + #𭗦; + #𭗧; + #𭗨; + #𭗩; + #𭗪; + #𭗫; + #𭗬; + #𭗭; + #𭗮; + #𭗯; + #𭗰; + #𭗱; + #𭗲; + #𭗳; + #𭗴; + #𭗵; + #𭗶; + #𭗷; + #𭗸; + #𭗹; + #𭗺; + #𭗻; + #𭗼; + #𭗽; + #𭗾; + #𭗿; + #𭘀; + #𭘁; + #𭘂; + #𭘃; + #𭘄; + #𭘅; + #𭘆; + #𭘇; + #𭘈; + #𭘉; + #𭘊; + #𭘋; + #𭘌; + #𭘍; + #𭘎; + #𭘏; + #𭘐; + #𭘑; + #𭘒; + #𭘓; + #𭘔; + #𭘕; + #𭘖; + #𭘗; + #𭘘; + #𭘙; + #𭘚; + #𭘛; + #𭘜; + #𭘝; + #𭘞; + #𭘟; + #𭘠; + #𭘡; + #𭘢; + #𭘣; + #𭘤; + #𭘥; + #𭘦; + #𭘧; + #𭘨; + #𭘩; + #𭘪; + #𭘫; + #𭘬; + #𭘭; + #𭘮; + #𭘯; + #𭘰; + #𭘱; + #𭘲; + #𭘳; + #𭘴; + #𭘵; + #𭘶; + #𭘷; + #𭘸; + #𭘹; + #𭘺; + #𭘻; + #𭘼; + #𭘽; + #𭘾; + #𭘿; + #𭙀; + #𭙁; + #𭙂; + #𭙃; + #𭙄; + #𭙅; + #𭙆; + #𭙇; + #𭙈; + #𭙉; + #𭙊; + #𭙋; + #𭙌; + #𭙍; + #𭙎; + #𭙏; + #𭙐; + #𭙑; + #𭙒; + #𭙓; + #𭙔; + #𭙕; + #𭙖; + #𭙗; + #𭙘; + #𭙙; + #𭙚; + #𭙛; + #𭙜; + #𭙝; + #𭙞; + #𭙟; + #𭙠; + #𭙡; + #𭙢; + #𭙣; + #𭙤; + #𭙥; + #𭙦; + #𭙧; + #𭙨; + #𭙩; + #𭙪; + #𭙫; + #𭙬; + #𭙭; + #𭙮; + #𭙯; + #𭙰; + #𭙱; + #𭙲; + #𭙳; + #𭙴; + #𭙵; + #𭙶; + #𭙷; + #𭙸; + #𭙹; + #𭙺; + #𭙻; + #𭙼; + #𭙽; + #𭙾; + #𭙿; + #𭚀; + #𭚁; + #𭚂; + #𭚃; + #𭚄; + #𭚅; + #𭚆; + #𭚇; + #𭚈; + #𭚉; + #𭚊; + #𭚋; + #𭚌; + #𭚍; + #𭚎; + #𭚏; + #𭚐; + #𭚑; + #𭚒; + #𭚓; + #𭚔; + #𭚕; + #𭚖; + #𭚗; + #𭚘; + #𭚙; + #𭚚; + #𭚛; + #𭚜; + #𭚝; + #𭚞; + #𭚟; + #𭚠; + #𭚡; + #𭚢; + #𭚣; + #𭚤; + #𭚥; + #𭚦; + #𭚧; + #𭚨; + #𭚩; + #𭚪; + #𭚫; + #𭚬; + #𭚭; + #𭚮; + #𭚯; + #𭚰; + #𭚱; + #𭚲; + #𭚳; + #𭚴; + #𭚵; + #𭚶; + #𭚷; + #𭚸; + #𭚹; + #𭚺; + #𭚻; + #𭚼; + #𭚽; + #𭚾; + #𭚿; + #𭛀; + #𭛁; + #𭛂; + #𭛃; + #𭛄; + #𭛅; + #𭛆; + #𭛇; + #𭛈; + #𭛉; + #𭛊; + #𭛋; + #𭛌; + #𭛍; + #𭛎; + #𭛏; + #𭛐; + #𭛑; + #𭛒; + #𭛓; + #𭛔; + #𭛕; + #𭛖; + #𭛗; + #𭛘; + #𭛙; + #𭛚; + #𭛛; + #𭛜; + #𭛝; + #𭛞; + #𭛟; + #𭛠; + #𭛡; + #𭛢; + #𭛣; + #𭛤; + #𭛥; + #𭛦; + #𭛧; + #𭛨; + #𭛩; + #𭛪; + #𭛫; + #𭛬; + #𭛭; + #𭛮; + #𭛯; + #𭛰; + #𭛱; + #𭛲; + #𭛳; + #𭛴; + #𭛵; + #𭛶; + #𭛷; + #𭛸; + #𭛹; + #𭛺; + #𭛻; + #𭛼; + #𭛽; + #𭛾; + #𭛿; + #𭜀; + #𭜁; + #𭜂; + #𭜃; + #𭜄; + #𭜅; + #𭜆; + #𭜇; + #𭜈; + #𭜉; + #𭜊; + #𭜋; + #𭜌; + #𭜍; + #𭜎; + #𭜏; + #𭜐; + #𭜑; + #𭜒; + #𭜓; + #𭜔; + #𭜕; + #𭜖; + #𭜗; + #𭜘; + #𭜙; + #𭜚; + #𭜛; + #𭜜; + #𭜝; + #𭜞; + #𭜟; + #𭜠; + #𭜡; + #𭜢; + #𭜣; + #𭜤; + #𭜥; + #𭜦; + #𭜧; + #𭜨; + #𭜩; + #𭜪; + #𭜫; + #𭜬; + #𭜭; + #𭜮; + #𭜯; + #𭜰; + #𭜱; + #𭜲; + #𭜳; + #𭜴; + #𭜵; + #𭜶; + #𭜷; + #𭜸; + #𭜹; + #𭜺; + #𭜻; + #𭜼; + #𭜽; + #𭜾; + #𭜿; + #𭝀; + #𭝁; + #𭝂; + #𭝃; + #𭝄; + #𭝅; + #𭝆; + #𭝇; + #𭝈; + #𭝉; + #𭝊; + #𭝋; + #𭝌; + #𭝍; + #𭝎; + #𭝏; + #𭝐; + #𭝑; + #𭝒; + #𭝓; + #𭝔; + #𭝕; + #𭝖; + #𭝗; + #𭝘; + #𭝙; + #𭝚; + #𭝛; + #𭝜; + #𭝝; + #𭝞; + #𭝟; + #𭝠; + #𭝡; + #𭝢; + #𭝣; + #𭝤; + #𭝥; + #𭝦; + #𭝧; + #𭝨; + #𭝩; + #𭝪; + #𭝫; + #𭝬; + #𭝭; + #𭝮; + #𭝯; + #𭝰; + #𭝱; + #𭝲; + #𭝳; + #𭝴; + #𭝵; + #𭝶; + #𭝷; + #𭝸; + #𭝹; + #𭝺; + #𭝻; + #𭝼; + #𭝽; + #𭝾; + #𭝿; + #𭞀; + #𭞁; + #𭞂; + #𭞃; + #𭞄; + #𭞅; + #𭞆; + #𭞇; + #𭞈; + #𭞉; + #𭞊; + #𭞋; + #𭞌; + #𭞍; + #𭞎; + #𭞏; + #𭞐; + #𭞑; + #𭞒; + #𭞓; + #𭞔; + #𭞕; + #𭞖; + #𭞗; + #𭞘; + #𭞙; + #𭞚; + #𭞛; + #𭞜; + #𭞝; + #𭞞; + #𭞟; + #𭞠; + #𭞡; + #𭞢; + #𭞣; + #𭞤; + #𭞥; + #𭞦; + #𭞧; + #𭞨; + #𭞩; + #𭞪; + #𭞫; + #𭞬; + #𭞭; + #𭞮; + #𭞯; + #𭞰; + #𭞱; + #𭞲; + #𭞳; + #𭞴; + #𭞵; + #𭞶; + #𭞷; + #𭞸; + #𭞹; + #𭞺; + #𭞻; + #𭞼; + #𭞽; + #𭞾; + #𭞿; + #𭟀; + #𭟁; + #𭟂; + #𭟃; + #𭟄; + #𭟅; + #𭟆; + #𭟇; + #𭟈; + #𭟉; + #𭟊; + #𭟋; + #𭟌; + #𭟍; + #𭟎; + #𭟏; + #𭟐; + #𭟑; + #𭟒; + #𭟓; + #𭟔; + #𭟕; + #𭟖; + #𭟗; + #𭟘; + #𭟙; + #𭟚; + #𭟛; + #𭟜; + #𭟝; + #𭟞; + #𭟟; + #𭟠; + #𭟡; + #𭟢; + #𭟣; + #𭟤; + #𭟥; + #𭟦; + #𭟧; + #𭟨; + #𭟩; + #𭟪; + #𭟫; + #𭟬; + #𭟭; + #𭟮; + #𭟯; + #𭟰; + #𭟱; + #𭟲; + #𭟳; + #𭟴; + #𭟵; + #𭟶; + #𭟷; + #𭟸; + #𭟹; + #𭟺; + #𭟻; + #𭟼; + #𭟽; + #𭟾; + #𭟿; + #𭠀; + #𭠁; + #𭠂; + #𭠃; + #𭠄; + #𭠅; + #𭠆; + #𭠇; + #𭠈; + #𭠉; + #𭠊; + #𭠋; + #𭠌; + #𭠍; + #𭠎; + #𭠏; + #𭠐; + #𭠑; + #𭠒; + #𭠓; + #𭠔; + #𭠕; + #𭠖; + #𭠗; + #𭠘; + #𭠙; + #𭠚; + #𭠛; + #𭠜; + #𭠝; + #𭠞; + #𭠟; + #𭠠; + #𭠡; + #𭠢; + #𭠣; + #𭠤; + #𭠥; + #𭠦; + #𭠧; + #𭠨; + #𭠩; + #𭠪; + #𭠫; + #𭠬; + #𭠭; + #𭠮; + #𭠯; + #𭠰; + #𭠱; + #𭠲; + #𭠳; + #𭠴; + #𭠵; + #𭠶; + #𭠷; + #𭠸; + #𭠹; + #𭠺; + #𭠻; + #𭠼; + #𭠽; + #𭠾; + #𭠿; + #𭡀; + #𭡁; + #𭡂; + #𭡃; + #𭡄; + #𭡅; + #𭡆; + #𭡇; + #𭡈; + #𭡉; + #𭡊; + #𭡋; + #𭡌; + #𭡍; + #𭡎; + #𭡏; + #𭡐; + #𭡑; + #𭡒; + #𭡓; + #𭡔; + #𭡕; + #𭡖; + #𭡗; + #𭡘; + #𭡙; + #𭡚; + #𭡛; + #𭡜; + #𭡝; + #𭡞; + #𭡟; + #𭡠; + #𭡡; + #𭡢; + #𭡣; + #𭡤; + #𭡥; + #𭡦; + #𭡧; + #𭡨; + #𭡩; + #𭡪; + #𭡫; + #𭡬; + #𭡭; + #𭡮; + #𭡯; + #𭡰; + #𭡱; + #𭡲; + #𭡳; + #𭡴; + #𭡵; + #𭡶; + #𭡷; + #𭡸; + #𭡹; + #𭡺; + #𭡻; + #𭡼; + #𭡽; + #𭡾; + #𭡿; + #𭢀; + #𭢁; + #𭢂; + #𭢃; + #𭢄; + #𭢅; + #𭢆; + #𭢇; + #𭢈; + #𭢉; + #𭢊; + #𭢋; + #𭢌; + #𭢍; + #𭢎; + #𭢏; + #𭢐; + #𭢑; + #𭢒; + #𭢓; + #𭢔; + #𭢕; + #𭢖; + #𭢗; + #𭢘; + #𭢙; + #𭢚; + #𭢛; + #𭢜; + #𭢝; + #𭢞; + #𭢟; + #𭢠; + #𭢡; + #𭢢; + #𭢣; + #𭢤; + #𭢥; + #𭢦; + #𭢧; + #𭢨; + #𭢩; + #𭢪; + #𭢫; + #𭢬; + #𭢭; + #𭢮; + #𭢯; + #𭢰; + #𭢱; + #𭢲; + #𭢳; + #𭢴; + #𭢵; + #𭢶; + #𭢷; + #𭢸; + #𭢹; + #𭢺; + #𭢻; + #𭢼; + #𭢽; + #𭢾; + #𭢿; + #𭣀; + #𭣁; + #𭣂; + #𭣃; + #𭣄; + #𭣅; + #𭣆; + #𭣇; + #𭣈; + #𭣉; + #𭣊; + #𭣋; + #𭣌; + #𭣍; + #𭣎; + #𭣏; + #𭣐; + #𭣑; + #𭣒; + #𭣓; + #𭣔; + #𭣕; + #𭣖; + #𭣗; + #𭣘; + #𭣙; + #𭣚; + #𭣛; + #𭣜; + #𭣝; + #𭣞; + #𭣟; + #𭣠; + #𭣡; + #𭣢; + #𭣣; + #𭣤; + #𭣥; + #𭣦; + #𭣧; + #𭣨; + #𭣩; + #𭣪; + #𭣫; + #𭣬; + #𭣭; + #𭣮; + #𭣯; + #𭣰; + #𭣱; + #𭣲; + #𭣳; + #𭣴; + #𭣵; + #𭣶; + #𭣷; + #𭣸; + #𭣹; + #𭣺; + #𭣻; + #𭣼; + #𭣽; + #𭣾; + #𭣿; + #𭤀; + #𭤁; + #𭤂; + #𭤃; + #𭤄; + #𭤅; + #𭤆; + #𭤇; + #𭤈; + #𭤉; + #𭤊; + #𭤋; + #𭤌; + #𭤍; + #𭤎; + #𭤏; + #𭤐; + #𭤑; + #𭤒; + #𭤓; + #𭤔; + #𭤕; + #𭤖; + #𭤗; + #𭤘; + #𭤙; + #𭤚; + #𭤛; + #𭤜; + #𭤝; + #𭤞; + #𭤟; + #𭤠; + #𭤡; + #𭤢; + #𭤣; + #𭤤; + #𭤥; + #𭤦; + #𭤧; + #𭤨; + #𭤩; + #𭤪; + #𭤫; + #𭤬; + #𭤭; + #𭤮; + #𭤯; + #𭤰; + #𭤱; + #𭤲; + #𭤳; + #𭤴; + #𭤵; + #𭤶; + #𭤷; + #𭤸; + #𭤹; + #𭤺; + #𭤻; + #𭤼; + #𭤽; + #𭤾; + #𭤿; + #𭥀; + #𭥁; + #𭥂; + #𭥃; + #𭥄; + #𭥅; + #𭥆; + #𭥇; + #𭥈; + #𭥉; + #𭥊; + #𭥋; + #𭥌; + #𭥍; + #𭥎; + #𭥏; + #𭥐; + #𭥑; + #𭥒; + #𭥓; + #𭥔; + #𭥕; + #𭥖; + #𭥗; + #𭥘; + #𭥙; + #𭥚; + #𭥛; + #𭥜; + #𭥝; + #𭥞; + #𭥟; + #𭥠; + #𭥡; + #𭥢; + #𭥣; + #𭥤; + #𭥥; + #𭥦; + #𭥧; + #𭥨; + #𭥩; + #𭥪; + #𭥫; + #𭥬; + #𭥭; + #𭥮; + #𭥯; + #𭥰; + #𭥱; + #𭥲; + #𭥳; + #𭥴; + #𭥵; + #𭥶; + #𭥷; + #𭥸; + #𭥹; + #𭥺; + #𭥻; + #𭥼; + #𭥽; + #𭥾; + #𭥿; + #𭦀; + #𭦁; + #𭦂; + #𭦃; + #𭦄; + #𭦅; + #𭦆; + #𭦇; + #𭦈; + #𭦉; + #𭦊; + #𭦋; + #𭦌; + #𭦍; + #𭦎; + #𭦏; + #𭦐; + #𭦑; + #𭦒; + #𭦓; + #𭦔; + #𭦕; + #𭦖; + #𭦗; + #𭦘; + #𭦙; + #𭦚; + #𭦛; + #𭦜; + #𭦝; + #𭦞; + #𭦟; + #𭦠; + #𭦡; + #𭦢; + #𭦣; + #𭦤; + #𭦥; + #𭦦; + #𭦧; + #𭦨; + #𭦩; + #𭦪; + #𭦫; + #𭦬; + #𭦭; + #𭦮; + #𭦯; + #𭦰; + #𭦱; + #𭦲; + #𭦳; + #𭦴; + #𭦵; + #𭦶; + #𭦷; + #𭦸; + #𭦹; + #𭦺; + #𭦻; + #𭦼; + #𭦽; + #𭦾; + #𭦿; + #𭧀; + #𭧁; + #𭧂; + #𭧃; + #𭧄; + #𭧅; + #𭧆; + #𭧇; + #𭧈; + #𭧉; + #𭧊; + #𭧋; + #𭧌; + #𭧍; + #𭧎; + #𭧏; + #𭧐; + #𭧑; + #𭧒; + #𭧓; + #𭧔; + #𭧕; + #𭧖; + #𭧗; + #𭧘; + #𭧙; + #𭧚; + #𭧛; + #𭧜; + #𭧝; + #𭧞; + #𭧟; + #𭧠; + #𭧡; + #𭧢; + #𭧣; + #𭧤; + #𭧥; + #𭧦; + #𭧧; + #𭧨; + #𭧩; + #𭧪; + #𭧫; + #𭧬; + #𭧭; + #𭧮; + #𭧯; + #𭧰; + #𭧱; + #𭧲; + #𭧳; + #𭧴; + #𭧵; + #𭧶; + #𭧷; + #𭧸; + #𭧹; + #𭧺; + #𭧻; + #𭧼; + #𭧽; + #𭧾; + #𭧿; + #𭨀; + #𭨁; + #𭨂; + #𭨃; + #𭨄; + #𭨅; + #𭨆; + #𭨇; + #𭨈; + #𭨉; + #𭨊; + #𭨋; + #𭨌; + #𭨍; + #𭨎; + #𭨏; + #𭨐; + #𭨑; + #𭨒; + #𭨓; + #𭨔; + #𭨕; + #𭨖; + #𭨗; + #𭨘; + #𭨙; + #𭨚; + #𭨛; + #𭨜; + #𭨝; + #𭨞; + #𭨟; + #𭨠; + #𭨡; + #𭨢; + #𭨣; + #𭨤; + #𭨥; + #𭨦; + #𭨧; + #𭨨; + #𭨩; + #𭨪; + #𭨫; + #𭨬; + #𭨭; + #𭨮; + #𭨯; + #𭨰; + #𭨱; + #𭨲; + #𭨳; + #𭨴; + #𭨵; + #𭨶; + #𭨷; + #𭨸; + #𭨹; + #𭨺; + #𭨻; + #𭨼; + #𭨽; + #𭨾; + #𭨿; + #𭩀; + #𭩁; + #𭩂; + #𭩃; + #𭩄; + #𭩅; + #𭩆; + #𭩇; + #𭩈; + #𭩉; + #𭩊; + #𭩋; + #𭩌; + #𭩍; + #𭩎; + #𭩏; + #𭩐; + #𭩑; + #𭩒; + #𭩓; + #𭩔; + #𭩕; + #𭩖; + #𭩗; + #𭩘; + #𭩙; + #𭩚; + #𭩛; + #𭩜; + #𭩝; + #𭩞; + #𭩟; + #𭩠; + #𭩡; + #𭩢; + #𭩣; + #𭩤; + #𭩥; + #𭩦; + #𭩧; + #𭩨; + #𭩩; + #𭩪; + #𭩫; + #𭩬; + #𭩭; + #𭩮; + #𭩯; + #𭩰; + #𭩱; + #𭩲; + #𭩳; + #𭩴; + #𭩵; + #𭩶; + #𭩷; + #𭩸; + #𭩹; + #𭩺; + #𭩻; + #𭩼; + #𭩽; + #𭩾; + #𭩿; + #𭪀; + #𭪁; + #𭪂; + #𭪃; + #𭪄; + #𭪅; + #𭪆; + #𭪇; + #𭪈; + #𭪉; + #𭪊; + #𭪋; + #𭪌; + #𭪍; + #𭪎; + #𭪏; + #𭪐; + #𭪑; + #𭪒; + #𭪓; + #𭪔; + #𭪕; + #𭪖; + #𭪗; + #𭪘; + #𭪙; + #𭪚; + #𭪛; + #𭪜; + #𭪝; + #𭪞; + #𭪟; + #𭪠; + #𭪡; + #𭪢; + #𭪣; + #𭪤; + #𭪥; + #𭪦; + #𭪧; + #𭪨; + #𭪩; + #𭪪; + #𭪫; + #𭪬; + #𭪭; + #𭪮; + #𭪯; + #𭪰; + #𭪱; + #𭪲; + #𭪳; + #𭪴; + #𭪵; + #𭪶; + #𭪷; + #𭪸; + #𭪹; + #𭪺; + #𭪻; + #𭪼; + #𭪽; + #𭪾; + #𭪿; + #𭫀; + #𭫁; + #𭫂; + #𭫃; + #𭫄; + #𭫅; + #𭫆; + #𭫇; + #𭫈; + #𭫉; + #𭫊; + #𭫋; + #𭫌; + #𭫍; + #𭫎; + #𭫏; + #𭫐; + #𭫑; + #𭫒; + #𭫓; + #𭫔; + #𭫕; + #𭫖; + #𭫗; + #𭫘; + #𭫙; + #𭫚; + #𭫛; + #𭫜; + #𭫝; + #𭫞; + #𭫟; + #𭫠; + #𭫡; + #𭫢; + #𭫣; + #𭫤; + #𭫥; + #𭫦; + #𭫧; + #𭫨; + #𭫩; + #𭫪; + #𭫫; + #𭫬; + #𭫭; + #𭫮; + #𭫯; + #𭫰; + #𭫱; + #𭫲; + #𭫳; + #𭫴; + #𭫵; + #𭫶; + #𭫷; + #𭫸; + #𭫹; + #𭫺; + #𭫻; + #𭫼; + #𭫽; + #𭫾; + #𭫿; + #𭬀; + #𭬁; + #𭬂; + #𭬃; + #𭬄; + #𭬅; + #𭬆; + #𭬇; + #𭬈; + #𭬉; + #𭬊; + #𭬋; + #𭬌; + #𭬍; + #𭬎; + #𭬏; + #𭬐; + #𭬑; + #𭬒; + #𭬓; + #𭬔; + #𭬕; + #𭬖; + #𭬗; + #𭬘; + #𭬙; + #𭬚; + #𭬛; + #𭬜; + #𭬝; + #𭬞; + #𭬟; + #𭬠; + #𭬡; + #𭬢; + #𭬣; + #𭬤; + #𭬥; + #𭬦; + #𭬧; + #𭬨; + #𭬩; + #𭬪; + #𭬫; + #𭬬; + #𭬭; + #𭬮; + #𭬯; + #𭬰; + #𭬱; + #𭬲; + #𭬳; + #𭬴; + #𭬵; + #𭬶; + #𭬷; + #𭬸; + #𭬹; + #𭬺; + #𭬻; + #𭬼; + #𭬽; + #𭬾; + #𭬿; + #𭭀; + #𭭁; + #𭭂; + #𭭃; + #𭭄; + #𭭅; + #𭭆; + #𭭇; + #𭭈; + #𭭉; + #𭭊; + #𭭋; + #𭭌; + #𭭍; + #𭭎; + #𭭏; + #𭭐; + #𭭑; + #𭭒; + #𭭓; + #𭭔; + #𭭕; + #𭭖; + #𭭗; + #𭭘; + #𭭙; + #𭭚; + #𭭛; + #𭭜; + #𭭝; + #𭭞; + #𭭟; + #𭭠; + #𭭡; + #𭭢; + #𭭣; + #𭭤; + #𭭥; + #𭭦; + #𭭧; + #𭭨; + #𭭩; + #𭭪; + #𭭫; + #𭭬; + #𭭭; + #𭭮; + #𭭯; + #𭭰; + #𭭱; + #𭭲; + #𭭳; + #𭭴; + #𭭵; + #𭭶; + #𭭷; + #𭭸; + #𭭹; + #𭭺; + #𭭻; + #𭭼; + #𭭽; + #𭭾; + #𭭿; + #𭮀; + #𭮁; + #𭮂; + #𭮃; + #𭮄; + #𭮅; + #𭮆; + #𭮇; + #𭮈; + #𭮉; + #𭮊; + #𭮋; + #𭮌; + #𭮍; + #𭮎; + #𭮏; + #𭮐; + #𭮑; + #𭮒; + #𭮓; + #𭮔; + #𭮕; + #𭮖; + #𭮗; + #𭮘; + #𭮙; + #𭮚; + #𭮛; + #𭮜; + #𭮝; + #𭮞; + #𭮟; + #𭮠; + #𭮡; + #𭮢; + #𭮣; + #𭮤; + #𭮥; + #𭮦; + #𭮧; + #𭮨; + #𭮩; + #𭮪; + #𭮫; + #𭮬; + #𭮭; + #𭮮; + #𭮯; + #𭮰; + #𭮱; + #𭮲; + #𭮳; + #𭮴; + #𭮵; + #𭮶; + #𭮷; + #𭮸; + #𭮹; + #𭮺; + #𭮻; + #𭮼; + #𭮽; + #𭮾; + #𭮿; + #𭯀; + #𭯁; + #𭯂; + #𭯃; + #𭯄; + #𭯅; + #𭯆; + #𭯇; + #𭯈; + #𭯉; + #𭯊; + #𭯋; + #𭯌; + #𭯍; + #𭯎; + #𭯏; + #𭯐; + #𭯑; + #𭯒; + #𭯓; + #𭯔; + #𭯕; + #𭯖; + #𭯗; + #𭯘; + #𭯙; + #𭯚; + #𭯛; + #𭯜; + #𭯝; + #𭯞; + #𭯟; + #𭯠; + #𭯡; + #𭯢; + #𭯣; + #𭯤; + #𭯥; + #𭯦; + #𭯧; + #𭯨; + #𭯩; + #𭯪; + #𭯫; + #𭯬; + #𭯭; + #𭯮; + #𭯯; + #𭯰; + #𭯱; + #𭯲; + #𭯳; + #𭯴; + #𭯵; + #𭯶; + #𭯷; + #𭯸; + #𭯹; + #𭯺; + #𭯻; + #𭯼; + #𭯽; + #𭯾; + #𭯿; + #𭰀; + #𭰁; + #𭰂; + #𭰃; + #𭰄; + #𭰅; + #𭰆; + #𭰇; + #𭰈; + #𭰉; + #𭰊; + #𭰋; + #𭰌; + #𭰍; + #𭰎; + #𭰏; + #𭰐; + #𭰑; + #𭰒; + #𭰓; + #𭰔; + #𭰕; + #𭰖; + #𭰗; + #𭰘; + #𭰙; + #𭰚; + #𭰛; + #𭰜; + #𭰝; + #𭰞; + #𭰟; + #𭰠; + #𭰡; + #𭰢; + #𭰣; + #𭰤; + #𭰥; + #𭰦; + #𭰧; + #𭰨; + #𭰩; + #𭰪; + #𭰫; + #𭰬; + #𭰭; + #𭰮; + #𭰯; + #𭰰; + #𭰱; + #𭰲; + #𭰳; + #𭰴; + #𭰵; + #𭰶; + #𭰷; + #𭰸; + #𭰹; + #𭰺; + #𭰻; + #𭰼; + #𭰽; + #𭰾; + #𭰿; + #𭱀; + #𭱁; + #𭱂; + #𭱃; + #𭱄; + #𭱅; + #𭱆; + #𭱇; + #𭱈; + #𭱉; + #𭱊; + #𭱋; + #𭱌; + #𭱍; + #𭱎; + #𭱏; + #𭱐; + #𭱑; + #𭱒; + #𭱓; + #𭱔; + #𭱕; + #𭱖; + #𭱗; + #𭱘; + #𭱙; + #𭱚; + #𭱛; + #𭱜; + #𭱝; + #𭱞; + #𭱟; + #𭱠; + #𭱡; + #𭱢; + #𭱣; + #𭱤; + #𭱥; + #𭱦; + #𭱧; + #𭱨; + #𭱩; + #𭱪; + #𭱫; + #𭱬; + #𭱭; + #𭱮; + #𭱯; + #𭱰; + #𭱱; + #𭱲; + #𭱳; + #𭱴; + #𭱵; + #𭱶; + #𭱷; + #𭱸; + #𭱹; + #𭱺; + #𭱻; + #𭱼; + #𭱽; + #𭱾; + #𭱿; + #𭲀; + #𭲁; + #𭲂; + #𭲃; + #𭲄; + #𭲅; + #𭲆; + #𭲇; + #𭲈; + #𭲉; + #𭲊; + #𭲋; + #𭲌; + #𭲍; + #𭲎; + #𭲏; + #𭲐; + #𭲑; + #𭲒; + #𭲓; + #𭲔; + #𭲕; + #𭲖; + #𭲗; + #𭲘; + #𭲙; + #𭲚; + #𭲛; + #𭲜; + #𭲝; + #𭲞; + #𭲟; + #𭲠; + #𭲡; + #𭲢; + #𭲣; + #𭲤; + #𭲥; + #𭲦; + #𭲧; + #𭲨; + #𭲩; + #𭲪; + #𭲫; + #𭲬; + #𭲭; + #𭲮; + #𭲯; + #𭲰; + #𭲱; + #𭲲; + #𭲳; + #𭲴; + #𭲵; + #𭲶; + #𭲷; + #𭲸; + #𭲹; + #𭲺; + #𭲻; + #𭲼; + #𭲽; + #𭲾; + #𭲿; + #𭳀; + #𭳁; + #𭳂; + #𭳃; + #𭳄; + #𭳅; + #𭳆; + #𭳇; + #𭳈; + #𭳉; + #𭳊; + #𭳋; + #𭳌; + #𭳍; + #𭳎; + #𭳏; + #𭳐; + #𭳑; + #𭳒; + #𭳓; + #𭳔; + #𭳕; + #𭳖; + #𭳗; + #𭳘; + #𭳙; + #𭳚; + #𭳛; + #𭳜; + #𭳝; + #𭳞; + #𭳟; + #𭳠; + #𭳡; + #𭳢; + #𭳣; + #𭳤; + #𭳥; + #𭳦; + #𭳧; + #𭳨; + #𭳩; + #𭳪; + #𭳫; + #𭳬; + #𭳭; + #𭳮; + #𭳯; + #𭳰; + #𭳱; + #𭳲; + #𭳳; + #𭳴; + #𭳵; + #𭳶; + #𭳷; + #𭳸; + #𭳹; + #𭳺; + #𭳻; + #𭳼; + #𭳽; + #𭳾; + #𭳿; + #𭴀; + #𭴁; + #𭴂; + #𭴃; + #𭴄; + #𭴅; + #𭴆; + #𭴇; + #𭴈; + #𭴉; + #𭴊; + #𭴋; + #𭴌; + #𭴍; + #𭴎; + #𭴏; + #𭴐; + #𭴑; + #𭴒; + #𭴓; + #𭴔; + #𭴕; + #𭴖; + #𭴗; + #𭴘; + #𭴙; + #𭴚; + #𭴛; + #𭴜; + #𭴝; + #𭴞; + #𭴟; + #𭴠; + #𭴡; + #𭴢; + #𭴣; + #𭴤; + #𭴥; + #𭴦; + #𭴧; + #𭴨; + #𭴩; + #𭴪; + #𭴫; + #𭴬; + #𭴭; + #𭴮; + #𭴯; + #𭴰; + #𭴱; + #𭴲; + #𭴳; + #𭴴; + #𭴵; + #𭴶; + #𭴷; + #𭴸; + #𭴹; + #𭴺; + #𭴻; + #𭴼; + #𭴽; + #𭴾; + #𭴿; + #𭵀; + #𭵁; + #𭵂; + #𭵃; + #𭵄; + #𭵅; + #𭵆; + #𭵇; + #𭵈; + #𭵉; + #𭵊; + #𭵋; + #𭵌; + #𭵍; + #𭵎; + #𭵏; + #𭵐; + #𭵑; + #𭵒; + #𭵓; + #𭵔; + #𭵕; + #𭵖; + #𭵗; + #𭵘; + #𭵙; + #𭵚; + #𭵛; + #𭵜; + #𭵝; + #𭵞; + #𭵟; + #𭵠; + #𭵡; + #𭵢; + #𭵣; + #𭵤; + #𭵥; + #𭵦; + #𭵧; + #𭵨; + #𭵩; + #𭵪; + #𭵫; + #𭵬; + #𭵭; + #𭵮; + #𭵯; + #𭵰; + #𭵱; + #𭵲; + #𭵳; + #𭵴; + #𭵵; + #𭵶; + #𭵷; + #𭵸; + #𭵹; + #𭵺; + #𭵻; + #𭵼; + #𭵽; + #𭵾; + #𭵿; + #𭶀; + #𭶁; + #𭶂; + #𭶃; + #𭶄; + #𭶅; + #𭶆; + #𭶇; + #𭶈; + #𭶉; + #𭶊; + #𭶋; + #𭶌; + #𭶍; + #𭶎; + #𭶏; + #𭶐; + #𭶑; + #𭶒; + #𭶓; + #𭶔; + #𭶕; + #𭶖; + #𭶗; + #𭶘; + #𭶙; + #𭶚; + #𭶛; + #𭶜; + #𭶝; + #𭶞; + #𭶟; + #𭶠; + #𭶡; + #𭶢; + #𭶣; + #𭶤; + #𭶥; + #𭶦; + #𭶧; + #𭶨; + #𭶩; + #𭶪; + #𭶫; + #𭶬; + #𭶭; + #𭶮; + #𭶯; + #𭶰; + #𭶱; + #𭶲; + #𭶳; + #𭶴; + #𭶵; + #𭶶; + #𭶷; + #𭶸; + #𭶹; + #𭶺; + #𭶻; + #𭶼; + #𭶽; + #𭶾; + #𭶿; + #𭷀; + #𭷁; + #𭷂; + #𭷃; + #𭷄; + #𭷅; + #𭷆; + #𭷇; + #𭷈; + #𭷉; + #𭷊; + #𭷋; + #𭷌; + #𭷍; + #𭷎; + #𭷏; + #𭷐; + #𭷑; + #𭷒; + #𭷓; + #𭷔; + #𭷕; + #𭷖; + #𭷗; + #𭷘; + #𭷙; + #𭷚; + #𭷛; + #𭷜; + #𭷝; + #𭷞; + #𭷟; + #𭷠; + #𭷡; + #𭷢; + #𭷣; + #𭷤; + #𭷥; + #𭷦; + #𭷧; + #𭷨; + #𭷩; + #𭷪; + #𭷫; + #𭷬; + #𭷭; + #𭷮; + #𭷯; + #𭷰; + #𭷱; + #𭷲; + #𭷳; + #𭷴; + #𭷵; + #𭷶; + #𭷷; + #𭷸; + #𭷹; + #𭷺; + #𭷻; + #𭷼; + #𭷽; + #𭷾; + #𭷿; + #𭸀; + #𭸁; + #𭸂; + #𭸃; + #𭸄; + #𭸅; + #𭸆; + #𭸇; + #𭸈; + #𭸉; + #𭸊; + #𭸋; + #𭸌; + #𭸍; + #𭸎; + #𭸏; + #𭸐; + #𭸑; + #𭸒; + #𭸓; + #𭸔; + #𭸕; + #𭸖; + #𭸗; + #𭸘; + #𭸙; + #𭸚; + #𭸛; + #𭸜; + #𭸝; + #𭸞; + #𭸟; + #𭸠; + #𭸡; + #𭸢; + #𭸣; + #𭸤; + #𭸥; + #𭸦; + #𭸧; + #𭸨; + #𭸩; + #𭸪; + #𭸫; + #𭸬; + #𭸭; + #𭸮; + #𭸯; + #𭸰; + #𭸱; + #𭸲; + #𭸳; + #𭸴; + #𭸵; + #𭸶; + #𭸷; + #𭸸; + #𭸹; + #𭸺; + #𭸻; + #𭸼; + #𭸽; + #𭸾; + #𭸿; + #𭹀; + #𭹁; + #𭹂; + #𭹃; + #𭹄; + #𭹅; + #𭹆; + #𭹇; + #𭹈; + #𭹉; + #𭹊; + #𭹋; + #𭹌; + #𭹍; + #𭹎; + #𭹏; + #𭹐; + #𭹑; + #𭹒; + #𭹓; + #𭹔; + #𭹕; + #𭹖; + #𭹗; + #𭹘; + #𭹙; + #𭹚; + #𭹛; + #𭹜; + #𭹝; + #𭹞; + #𭹟; + #𭹠; + #𭹡; + #𭹢; + #𭹣; + #𭹤; + #𭹥; + #𭹦; + #𭹧; + #𭹨; + #𭹩; + #𭹪; + #𭹫; + #𭹬; + #𭹭; + #𭹮; + #𭹯; + #𭹰; + #𭹱; + #𭹲; + #𭹳; + #𭹴; + #𭹵; + #𭹶; + #𭹷; + #𭹸; + #𭹹; + #𭹺; + #𭹻; + #𭹼; + #𭹽; + #𭹾; + #𭹿; + #𭺀; + #𭺁; + #𭺂; + #𭺃; + #𭺄; + #𭺅; + #𭺆; + #𭺇; + #𭺈; + #𭺉; + #𭺊; + #𭺋; + #𭺌; + #𭺍; + #𭺎; + #𭺏; + #𭺐; + #𭺑; + #𭺒; + #𭺓; + #𭺔; + #𭺕; + #𭺖; + #𭺗; + #𭺘; + #𭺙; + #𭺚; + #𭺛; + #𭺜; + #𭺝; + #𭺞; + #𭺟; + #𭺠; + #𭺡; + #𭺢; + #𭺣; + #𭺤; + #𭺥; + #𭺦; + #𭺧; + #𭺨; + #𭺩; + #𭺪; + #𭺫; + #𭺬; + #𭺭; + #𭺮; + #𭺯; + #𭺰; + #𭺱; + #𭺲; + #𭺳; + #𭺴; + #𭺵; + #𭺶; + #𭺷; + #𭺸; + #𭺹; + #𭺺; + #𭺻; + #𭺼; + #𭺽; + #𭺾; + #𭺿; + #𭻀; + #𭻁; + #𭻂; + #𭻃; + #𭻄; + #𭻅; + #𭻆; + #𭻇; + #𭻈; + #𭻉; + #𭻊; + #𭻋; + #𭻌; + #𭻍; + #𭻎; + #𭻏; + #𭻐; + #𭻑; + #𭻒; + #𭻓; + #𭻔; + #𭻕; + #𭻖; + #𭻗; + #𭻘; + #𭻙; + #𭻚; + #𭻛; + #𭻜; + #𭻝; + #𭻞; + #𭻟; + #𭻠; + #𭻡; + #𭻢; + #𭻣; + #𭻤; + #𭻥; + #𭻦; + #𭻧; + #𭻨; + #𭻩; + #𭻪; + #𭻫; + #𭻬; + #𭻭; + #𭻮; + #𭻯; + #𭻰; + #𭻱; + #𭻲; + #𭻳; + #𭻴; + #𭻵; + #𭻶; + #𭻷; + #𭻸; + #𭻹; + #𭻺; + #𭻻; + #𭻼; + #𭻽; + #𭻾; + #𭻿; + #𭼀; + #𭼁; + #𭼂; + #𭼃; + #𭼄; + #𭼅; + #𭼆; + #𭼇; + #𭼈; + #𭼉; + #𭼊; + #𭼋; + #𭼌; + #𭼍; + #𭼎; + #𭼏; + #𭼐; + #𭼑; + #𭼒; + #𭼓; + #𭼔; + #𭼕; + #𭼖; + #𭼗; + #𭼘; + #𭼙; + #𭼚; + #𭼛; + #𭼜; + #𭼝; + #𭼞; + #𭼟; + #𭼠; + #𭼡; + #𭼢; + #𭼣; + #𭼤; + #𭼥; + #𭼦; + #𭼧; + #𭼨; + #𭼩; + #𭼪; + #𭼫; + #𭼬; + #𭼭; + #𭼮; + #𭼯; + #𭼰; + #𭼱; + #𭼲; + #𭼳; + #𭼴; + #𭼵; + #𭼶; + #𭼷; + #𭼸; + #𭼹; + #𭼺; + #𭼻; + #𭼼; + #𭼽; + #𭼾; + #𭼿; + #𭽀; + #𭽁; + #𭽂; + #𭽃; + #𭽄; + #𭽅; + #𭽆; + #𭽇; + #𭽈; + #𭽉; + #𭽊; + #𭽋; + #𭽌; + #𭽍; + #𭽎; + #𭽏; + #𭽐; + #𭽑; + #𭽒; + #𭽓; + #𭽔; + #𭽕; + #𭽖; + #𭽗; + #𭽘; + #𭽙; + #𭽚; + #𭽛; + #𭽜; + #𭽝; + #𭽞; + #𭽟; + #𭽠; + #𭽡; + #𭽢; + #𭽣; + #𭽤; + #𭽥; + #𭽦; + #𭽧; + #𭽨; + #𭽩; + #𭽪; + #𭽫; + #𭽬; + #𭽭; + #𭽮; + #𭽯; + #𭽰; + #𭽱; + #𭽲; + #𭽳; + #𭽴; + #𭽵; + #𭽶; + #𭽷; + #𭽸; + #𭽹; + #𭽺; + #𭽻; + #𭽼; + #𭽽; + #𭽾; + #𭽿; + #𭾀; + #𭾁; + #𭾂; + #𭾃; + #𭾄; + #𭾅; + #𭾆; + #𭾇; + #𭾈; + #𭾉; + #𭾊; + #𭾋; + #𭾌; + #𭾍; + #𭾎; + #𭾏; + #𭾐; + #𭾑; + #𭾒; + #𭾓; + #𭾔; + #𭾕; + #𭾖; + #𭾗; + #𭾘; + #𭾙; + #𭾚; + #𭾛; + #𭾜; + #𭾝; + #𭾞; + #𭾟; + #𭾠; + #𭾡; + #𭾢; + #𭾣; + #𭾤; + #𭾥; + #𭾦; + #𭾧; + #𭾨; + #𭾩; + #𭾪; + #𭾫; + #𭾬; + #𭾭; + #𭾮; + #𭾯; + #𭾰; + #𭾱; + #𭾲; + #𭾳; + #𭾴; + #𭾵; + #𭾶; + #𭾷; + #𭾸; + #𭾹; + #𭾺; + #𭾻; + #𭾼; + #𭾽; + #𭾾; + #𭾿; + #𭿀; + #𭿁; + #𭿂; + #𭿃; + #𭿄; + #𭿅; + #𭿆; + #𭿇; + #𭿈; + #𭿉; + #𭿊; + #𭿋; + #𭿌; + #𭿍; + #𭿎; + #𭿏; + #𭿐; + #𭿑; + #𭿒; + #𭿓; + #𭿔; + #𭿕; + #𭿖; + #𭿗; + #𭿘; + #𭿙; + #𭿚; + #𭿛; + #𭿜; + #𭿝; + #𭿞; + #𭿟; + #𭿠; + #𭿡; + #𭿢; + #𭿣; + #𭿤; + #𭿥; + #𭿦; + #𭿧; + #𭿨; + #𭿩; + #𭿪; + #𭿫; + #𭿬; + #𭿭; + #𭿮; + #𭿯; + #𭿰; + #𭿱; + #𭿲; + #𭿳; + #𭿴; + #𭿵; + #𭿶; + #𭿷; + #𭿸; + #𭿹; + #𭿺; + #𭿻; + #𭿼; + #𭿽; + #𭿾; + #𭿿; + #𮀀; + #𮀁; + #𮀂; + #𮀃; + #𮀄; + #𮀅; + #𮀆; + #𮀇; + #𮀈; + #𮀉; + #𮀊; + #𮀋; + #𮀌; + #𮀍; + #𮀎; + #𮀏; + #𮀐; + #𮀑; + #𮀒; + #𮀓; + #𮀔; + #𮀕; + #𮀖; + #𮀗; + #𮀘; + #𮀙; + #𮀚; + #𮀛; + #𮀜; + #𮀝; + #𮀞; + #𮀟; + #𮀠; + #𮀡; + #𮀢; + #𮀣; + #𮀤; + #𮀥; + #𮀦; + #𮀧; + #𮀨; + #𮀩; + #𮀪; + #𮀫; + #𮀬; + #𮀭; + #𮀮; + #𮀯; + #𮀰; + #𮀱; + #𮀲; + #𮀳; + #𮀴; + #𮀵; + #𮀶; + #𮀷; + #𮀸; + #𮀹; + #𮀺; + #𮀻; + #𮀼; + #𮀽; + #𮀾; + #𮀿; + #𮁀; + #𮁁; + #𮁂; + #𮁃; + #𮁄; + #𮁅; + #𮁆; + #𮁇; + #𮁈; + #𮁉; + #𮁊; + #𮁋; + #𮁌; + #𮁍; + #𮁎; + #𮁏; + #𮁐; + #𮁑; + #𮁒; + #𮁓; + #𮁔; + #𮁕; + #𮁖; + #𮁗; + #𮁘; + #𮁙; + #𮁚; + #𮁛; + #𮁜; + #𮁝; + #𮁞; + #𮁟; + #𮁠; + #𮁡; + #𮁢; + #𮁣; + #𮁤; + #𮁥; + #𮁦; + #𮁧; + #𮁨; + #𮁩; + #𮁪; + #𮁫; + #𮁬; + #𮁭; + #𮁮; + #𮁯; + #𮁰; + #𮁱; + #𮁲; + #𮁳; + #𮁴; + #𮁵; + #𮁶; + #𮁷; + #𮁸; + #𮁹; + #𮁺; + #𮁻; + #𮁼; + #𮁽; + #𮁾; + #𮁿; + #𮂀; + #𮂁; + #𮂂; + #𮂃; + #𮂄; + #𮂅; + #𮂆; + #𮂇; + #𮂈; + #𮂉; + #𮂊; + #𮂋; + #𮂌; + #𮂍; + #𮂎; + #𮂏; + #𮂐; + #𮂑; + #𮂒; + #𮂓; + #𮂔; + #𮂕; + #𮂖; + #𮂗; + #𮂘; + #𮂙; + #𮂚; + #𮂛; + #𮂜; + #𮂝; + #𮂞; + #𮂟; + #𮂠; + #𮂡; + #𮂢; + #𮂣; + #𮂤; + #𮂥; + #𮂦; + #𮂧; + #𮂨; + #𮂩; + #𮂪; + #𮂫; + #𮂬; + #𮂭; + #𮂮; + #𮂯; + #𮂰; + #𮂱; + #𮂲; + #𮂳; + #𮂴; + #𮂵; + #𮂶; + #𮂷; + #𮂸; + #𮂹; + #𮂺; + #𮂻; + #𮂼; + #𮂽; + #𮂾; + #𮂿; + #𮃀; + #𮃁; + #𮃂; + #𮃃; + #𮃄; + #𮃅; + #𮃆; + #𮃇; + #𮃈; + #𮃉; + #𮃊; + #𮃋; + #𮃌; + #𮃍; + #𮃎; + #𮃏; + #𮃐; + #𮃑; + #𮃒; + #𮃓; + #𮃔; + #𮃕; + #𮃖; + #𮃗; + #𮃘; + #𮃙; + #𮃚; + #𮃛; + #𮃜; + #𮃝; + #𮃞; + #𮃟; + #𮃠; + #𮃡; + #𮃢; + #𮃣; + #𮃤; + #𮃥; + #𮃦; + #𮃧; + #𮃨; + #𮃩; + #𮃪; + #𮃫; + #𮃬; + #𮃭; + #𮃮; + #𮃯; + #𮃰; + #𮃱; + #𮃲; + #𮃳; + #𮃴; + #𮃵; + #𮃶; + #𮃷; + #𮃸; + #𮃹; + #𮃺; + #𮃻; + #𮃼; + #𮃽; + #𮃾; + #𮃿; + #𮄀; + #𮄁; + #𮄂; + #𮄃; + #𮄄; + #𮄅; + #𮄆; + #𮄇; + #𮄈; + #𮄉; + #𮄊; + #𮄋; + #𮄌; + #𮄍; + #𮄎; + #𮄏; + #𮄐; + #𮄑; + #𮄒; + #𮄓; + #𮄔; + #𮄕; + #𮄖; + #𮄗; + #𮄘; + #𮄙; + #𮄚; + #𮄛; + #𮄜; + #𮄝; + #𮄞; + #𮄟; + #𮄠; + #𮄡; + #𮄢; + #𮄣; + #𮄤; + #𮄥; + #𮄦; + #𮄧; + #𮄨; + #𮄩; + #𮄪; + #𮄫; + #𮄬; + #𮄭; + #𮄮; + #𮄯; + #𮄰; + #𮄱; + #𮄲; + #𮄳; + #𮄴; + #𮄵; + #𮄶; + #𮄷; + #𮄸; + #𮄹; + #𮄺; + #𮄻; + #𮄼; + #𮄽; + #𮄾; + #𮄿; + #𮅀; + #𮅁; + #𮅂; + #𮅃; + #𮅄; + #𮅅; + #𮅆; + #𮅇; + #𮅈; + #𮅉; + #𮅊; + #𮅋; + #𮅌; + #𮅍; + #𮅎; + #𮅏; + #𮅐; + #𮅑; + #𮅒; + #𮅓; + #𮅔; + #𮅕; + #𮅖; + #𮅗; + #𮅘; + #𮅙; + #𮅚; + #𮅛; + #𮅜; + #𮅝; + #𮅞; + #𮅟; + #𮅠; + #𮅡; + #𮅢; + #𮅣; + #𮅤; + #𮅥; + #𮅦; + #𮅧; + #𮅨; + #𮅩; + #𮅪; + #𮅫; + #𮅬; + #𮅭; + #𮅮; + #𮅯; + #𮅰; + #𮅱; + #𮅲; + #𮅳; + #𮅴; + #𮅵; + #𮅶; + #𮅷; + #𮅸; + #𮅹; + #𮅺; + #𮅻; + #𮅼; + #𮅽; + #𮅾; + #𮅿; + #𮆀; + #𮆁; + #𮆂; + #𮆃; + #𮆄; + #𮆅; + #𮆆; + #𮆇; + #𮆈; + #𮆉; + #𮆊; + #𮆋; + #𮆌; + #𮆍; + #𮆎; + #𮆏; + #𮆐; + #𮆑; + #𮆒; + #𮆓; + #𮆔; + #𮆕; + #𮆖; + #𮆗; + #𮆘; + #𮆙; + #𮆚; + #𮆛; + #𮆜; + #𮆝; + #𮆞; + #𮆟; + #𮆠; + #𮆡; + #𮆢; + #𮆣; + #𮆤; + #𮆥; + #𮆦; + #𮆧; + #𮆨; + #𮆩; + #𮆪; + #𮆫; + #𮆬; + #𮆭; + #𮆮; + #𮆯; + #𮆰; + #𮆱; + #𮆲; + #𮆳; + #𮆴; + #𮆵; + #𮆶; + #𮆷; + #𮆸; + #𮆹; + #𮆺; + #𮆻; + #𮆼; + #𮆽; + #𮆾; + #𮆿; + #𮇀; + #𮇁; + #𮇂; + #𮇃; + #𮇄; + #𮇅; + #𮇆; + #𮇇; + #𮇈; + #𮇉; + #𮇊; + #𮇋; + #𮇌; + #𮇍; + #𮇎; + #𮇏; + #𮇐; + #𮇑; + #𮇒; + #𮇓; + #𮇔; + #𮇕; + #𮇖; + #𮇗; + #𮇘; + #𮇙; + #𮇚; + #𮇛; + #𮇜; + #𮇝; + #𮇞; + #𮇟; + #𮇠; + #𮇡; + #𮇢; + #𮇣; + #𮇤; + #𮇥; + #𮇦; + #𮇧; + #𮇨; + #𮇩; + #𮇪; + #𮇫; + #𮇬; + #𮇭; + #𮇮; + #𮇯; + #𮇰; + #𮇱; + #𮇲; + #𮇳; + #𮇴; + #𮇵; + #𮇶; + #𮇷; + #𮇸; + #𮇹; + #𮇺; + #𮇻; + #𮇼; + #𮇽; + #𮇾; + #𮇿; + #𮈀; + #𮈁; + #𮈂; + #𮈃; + #𮈄; + #𮈅; + #𮈆; + #𮈇; + #𮈈; + #𮈉; + #𮈊; + #𮈋; + #𮈌; + #𮈍; + #𮈎; + #𮈏; + #𮈐; + #𮈑; + #𮈒; + #𮈓; + #𮈔; + #𮈕; + #𮈖; + #𮈗; + #𮈘; + #𮈙; + #𮈚; + #𮈛; + #𮈜; + #𮈝; + #𮈞; + #𮈟; + #𮈠; + #𮈡; + #𮈢; + #𮈣; + #𮈤; + #𮈥; + #𮈦; + #𮈧; + #𮈨; + #𮈩; + #𮈪; + #𮈫; + #𮈬; + #𮈭; + #𮈮; + #𮈯; + #𮈰; + #𮈱; + #𮈲; + #𮈳; + #𮈴; + #𮈵; + #𮈶; + #𮈷; + #𮈸; + #𮈹; + #𮈺; + #𮈻; + #𮈼; + #𮈽; + #𮈾; + #𮈿; + #𮉀; + #𮉁; + #𮉂; + #𮉃; + #𮉄; + #𮉅; + #𮉆; + #𮉇; + #𮉈; + #𮉉; + #𮉊; + #𮉋; + #𮉌; + #𮉍; + #𮉎; + #𮉏; + #𮉐; + #𮉑; + #𮉒; + #𮉓; + #𮉔; + #𮉕; + #𮉖; + #𮉗; + #𮉘; + #𮉙; + #𮉚; + #𮉛; + #𮉜; + #𮉝; + #𮉞; + #𮉟; + #𮉠; + #𮉡; + #𮉢; + #𮉣; + #𮉤; + #𮉥; + #𮉦; + #𮉧; + #𮉨; + #𮉩; + #𮉪; + #𮉫; + #𮉬; + #𮉭; + #𮉮; + #𮉯; + #𮉰; + #𮉱; + #𮉲; + #𮉳; + #𮉴; + #𮉵; + #𮉶; + #𮉷; + #𮉸; + #𮉹; + #𮉺; + #𮉻; + #𮉼; + #𮉽; + #𮉾; + #𮉿; + #𮊀; + #𮊁; + #𮊂; + #𮊃; + #𮊄; + #𮊅; + #𮊆; + #𮊇; + #𮊈; + #𮊉; + #𮊊; + #𮊋; + #𮊌; + #𮊍; + #𮊎; + #𮊏; + #𮊐; + #𮊑; + #𮊒; + #𮊓; + #𮊔; + #𮊕; + #𮊖; + #𮊗; + #𮊘; + #𮊙; + #𮊚; + #𮊛; + #𮊜; + #𮊝; + #𮊞; + #𮊟; + #𮊠; + #𮊡; + #𮊢; + #𮊣; + #𮊤; + #𮊥; + #𮊦; + #𮊧; + #𮊨; + #𮊩; + #𮊪; + #𮊫; + #𮊬; + #𮊭; + #𮊮; + #𮊯; + #𮊰; + #𮊱; + #𮊲; + #𮊳; + #𮊴; + #𮊵; + #𮊶; + #𮊷; + #𮊸; + #𮊹; + #𮊺; + #𮊻; + #𮊼; + #𮊽; + #𮊾; + #𮊿; + #𮋀; + #𮋁; + #𮋂; + #𮋃; + #𮋄; + #𮋅; + #𮋆; + #𮋇; + #𮋈; + #𮋉; + #𮋊; + #𮋋; + #𮋌; + #𮋍; + #𮋎; + #𮋏; + #𮋐; + #𮋑; + #𮋒; + #𮋓; + #𮋔; + #𮋕; + #𮋖; + #𮋗; + #𮋘; + #𮋙; + #𮋚; + #𮋛; + #𮋜; + #𮋝; + #𮋞; + #𮋟; + #𮋠; + #𮋡; + #𮋢; + #𮋣; + #𮋤; + #𮋥; + #𮋦; + #𮋧; + #𮋨; + #𮋩; + #𮋪; + #𮋫; + #𮋬; + #𮋭; + #𮋮; + #𮋯; + #𮋰; + #𮋱; + #𮋲; + #𮋳; + #𮋴; + #𮋵; + #𮋶; + #𮋷; + #𮋸; + #𮋹; + #𮋺; + #𮋻; + #𮋼; + #𮋽; + #𮋾; + #𮋿; + #𮌀; + #𮌁; + #𮌂; + #𮌃; + #𮌄; + #𮌅; + #𮌆; + #𮌇; + #𮌈; + #𮌉; + #𮌊; + #𮌋; + #𮌌; + #𮌍; + #𮌎; + #𮌏; + #𮌐; + #𮌑; + #𮌒; + #𮌓; + #𮌔; + #𮌕; + #𮌖; + #𮌗; + #𮌘; + #𮌙; + #𮌚; + #𮌛; + #𮌜; + #𮌝; + #𮌞; + #𮌟; + #𮌠; + #𮌡; + #𮌢; + #𮌣; + #𮌤; + #𮌥; + #𮌦; + #𮌧; + #𮌨; + #𮌩; + #𮌪; + #𮌫; + #𮌬; + #𮌭; + #𮌮; + #𮌯; + #𮌰; + #𮌱; + #𮌲; + #𮌳; + #𮌴; + #𮌵; + #𮌶; + #𮌷; + #𮌸; + #𮌹; + #𮌺; + #𮌻; + #𮌼; + #𮌽; + #𮌾; + #𮌿; + #𮍀; + #𮍁; + #𮍂; + #𮍃; + #𮍄; + #𮍅; + #𮍆; + #𮍇; + #𮍈; + #𮍉; + #𮍊; + #𮍋; + #𮍌; + #𮍍; + #𮍎; + #𮍏; + #𮍐; + #𮍑; + #𮍒; + #𮍓; + #𮍔; + #𮍕; + #𮍖; + #𮍗; + #𮍘; + #𮍙; + #𮍚; + #𮍛; + #𮍜; + #𮍝; + #𮍞; + #𮍟; + #𮍠; + #𮍡; + #𮍢; + #𮍣; + #𮍤; + #𮍥; + #𮍦; + #𮍧; + #𮍨; + #𮍩; + #𮍪; + #𮍫; + #𮍬; + #𮍭; + #𮍮; + #𮍯; + #𮍰; + #𮍱; + #𮍲; + #𮍳; + #𮍴; + #𮍵; + #𮍶; + #𮍷; + #𮍸; + #𮍹; + #𮍺; + #𮍻; + #𮍼; + #𮍽; + #𮍾; + #𮍿; + #𮎀; + #𮎁; + #𮎂; + #𮎃; + #𮎄; + #𮎅; + #𮎆; + #𮎇; + #𮎈; + #𮎉; + #𮎊; + #𮎋; + #𮎌; + #𮎍; + #𮎎; + #𮎏; + #𮎐; + #𮎑; + #𮎒; + #𮎓; + #𮎔; + #𮎕; + #𮎖; + #𮎗; + #𮎘; + #𮎙; + #𮎚; + #𮎛; + #𮎜; + #𮎝; + #𮎞; + #𮎟; + #𮎠; + #𮎡; + #𮎢; + #𮎣; + #𮎤; + #𮎥; + #𮎦; + #𮎧; + #𮎨; + #𮎩; + #𮎪; + #𮎫; + #𮎬; + #𮎭; + #𮎮; + #𮎯; + #𮎰; + #𮎱; + #𮎲; + #𮎳; + #𮎴; + #𮎵; + #𮎶; + #𮎷; + #𮎸; + #𮎹; + #𮎺; + #𮎻; + #𮎼; + #𮎽; + #𮎾; + #𮎿; + #𮏀; + #𮏁; + #𮏂; + #𮏃; + #𮏄; + #𮏅; + #𮏆; + #𮏇; + #𮏈; + #𮏉; + #𮏊; + #𮏋; + #𮏌; + #𮏍; + #𮏎; + #𮏏; + #𮏐; + #𮏑; + #𮏒; + #𮏓; + #𮏔; + #𮏕; + #𮏖; + #𮏗; + #𮏘; + #𮏙; + #𮏚; + #𮏛; + #𮏜; + #𮏝; + #𮏞; + #𮏟; + #𮏠; + #𮏡; + #𮏢; + #𮏣; + #𮏤; + #𮏥; + #𮏦; + #𮏧; + #𮏨; + #𮏩; + #𮏪; + #𮏫; + #𮏬; + #𮏭; + #𮏮; + #𮏯; + #𮏰; + #𮏱; + #𮏲; + #𮏳; + #𮏴; + #𮏵; + #𮏶; + #𮏷; + #𮏸; + #𮏹; + #𮏺; + #𮏻; + #𮏼; + #𮏽; + #𮏾; + #𮏿; + #𮐀; + #𮐁; + #𮐂; + #𮐃; + #𮐄; + #𮐅; + #𮐆; + #𮐇; + #𮐈; + #𮐉; + #𮐊; + #𮐋; + #𮐌; + #𮐍; + #𮐎; + #𮐏; + #𮐐; + #𮐑; + #𮐒; + #𮐓; + #𮐔; + #𮐕; + #𮐖; + #𮐗; + #𮐘; + #𮐙; + #𮐚; + #𮐛; + #𮐜; + #𮐝; + #𮐞; + #𮐟; + #𮐠; + #𮐡; + #𮐢; + #𮐣; + #𮐤; + #𮐥; + #𮐦; + #𮐧; + #𮐨; + #𮐩; + #𮐪; + #𮐫; + #𮐬; + #𮐭; + #𮐮; + #𮐯; + #𮐰; + #𮐱; + #𮐲; + #𮐳; + #𮐴; + #𮐵; + #𮐶; + #𮐷; + #𮐸; + #𮐹; + #𮐺; + #𮐻; + #𮐼; + #𮐽; + #𮐾; + #𮐿; + #𮑀; + #𮑁; + #𮑂; + #𮑃; + #𮑄; + #𮑅; + #𮑆; + #𮑇; + #𮑈; + #𮑉; + #𮑊; + #𮑋; + #𮑌; + #𮑍; + #𮑎; + #𮑏; + #𮑐; + #𮑑; + #𮑒; + #𮑓; + #𮑔; + #𮑕; + #𮑖; + #𮑗; + #𮑘; + #𮑙; + #𮑚; + #𮑛; + #𮑜; + #𮑝; + #𮑞; + #𮑟; + #𮑠; + #𮑡; + #𮑢; + #𮑣; + #𮑤; + #𮑥; + #𮑦; + #𮑧; + #𮑨; + #𮑩; + #𮑪; + #𮑫; + #𮑬; + #𮑭; + #𮑮; + #𮑯; + #𮑰; + #𮑱; + #𮑲; + #𮑳; + #𮑴; + #𮑵; + #𮑶; + #𮑷; + #𮑸; + #𮑹; + #𮑺; + #𮑻; + #𮑼; + #𮑽; + #𮑾; + #𮑿; + #𮒀; + #𮒁; + #𮒂; + #𮒃; + #𮒄; + #𮒅; + #𮒆; + #𮒇; + #𮒈; + #𮒉; + #𮒊; + #𮒋; + #𮒌; + #𮒍; + #𮒎; + #𮒏; + #𮒐; + #𮒑; + #𮒒; + #𮒓; + #𮒔; + #𮒕; + #𮒖; + #𮒗; + #𮒘; + #𮒙; + #𮒚; + #𮒛; + #𮒜; + #𮒝; + #𮒞; + #𮒟; + #𮒠; + #𮒡; + #𮒢; + #𮒣; + #𮒤; + #𮒥; + #𮒦; + #𮒧; + #𮒨; + #𮒩; + #𮒪; + #𮒫; + #𮒬; + #𮒭; + #𮒮; + #𮒯; + #𮒰; + #𮒱; + #𮒲; + #𮒳; + #𮒴; + #𮒵; + #𮒶; + #𮒷; + #𮒸; + #𮒹; + #𮒺; + #𮒻; + #𮒼; + #𮒽; + #𮒾; + #𮒿; + #𮓀; + #𮓁; + #𮓂; + #𮓃; + #𮓄; + #𮓅; + #𮓆; + #𮓇; + #𮓈; + #𮓉; + #𮓊; + #𮓋; + #𮓌; + #𮓍; + #𮓎; + #𮓏; + #𮓐; + #𮓑; + #𮓒; + #𮓓; + #𮓔; + #𮓕; + #𮓖; + #𮓗; + #𮓘; + #𮓙; + #𮓚; + #𮓛; + #𮓜; + #𮓝; + #𮓞; + #𮓟; + #𮓠; + #𮓡; + #𮓢; + #𮓣; + #𮓤; + #𮓥; + #𮓦; + #𮓧; + #𮓨; + #𮓩; + #𮓪; + #𮓫; + #𮓬; + #𮓭; + #𮓮; + #𮓯; + #𮓰; + #𮓱; + #𮓲; + #𮓳; + #𮓴; + #𮓵; + #𮓶; + #𮓷; + #𮓸; + #𮓹; + #𮓺; + #𮓻; + #𮓼; + #𮓽; + #𮓾; + #𮓿; + #𮔀; + #𮔁; + #𮔂; + #𮔃; + #𮔄; + #𮔅; + #𮔆; + #𮔇; + #𮔈; + #𮔉; + #𮔊; + #𮔋; + #𮔌; + #𮔍; + #𮔎; + #𮔏; + #𮔐; + #𮔑; + #𮔒; + #𮔓; + #𮔔; + #𮔕; + #𮔖; + #𮔗; + #𮔘; + #𮔙; + #𮔚; + #𮔛; + #𮔜; + #𮔝; + #𮔞; + #𮔟; + #𮔠; + #𮔡; + #𮔢; + #𮔣; + #𮔤; + #𮔥; + #𮔦; + #𮔧; + #𮔨; + #𮔩; + #𮔪; + #𮔫; + #𮔬; + #𮔭; + #𮔮; + #𮔯; + #𮔰; + #𮔱; + #𮔲; + #𮔳; + #𮔴; + #𮔵; + #𮔶; + #𮔷; + #𮔸; + #𮔹; + #𮔺; + #𮔻; + #𮔼; + #𮔽; + #𮔾; + #𮔿; + #𮕀; + #𮕁; + #𮕂; + #𮕃; + #𮕄; + #𮕅; + #𮕆; + #𮕇; + #𮕈; + #𮕉; + #𮕊; + #𮕋; + #𮕌; + #𮕍; + #𮕎; + #𮕏; + #𮕐; + #𮕑; + #𮕒; + #𮕓; + #𮕔; + #𮕕; + #𮕖; + #𮕗; + #𮕘; + #𮕙; + #𮕚; + #𮕛; + #𮕜; + #𮕝; + #𮕞; + #𮕟; + #𮕠; + #𮕡; + #𮕢; + #𮕣; + #𮕤; + #𮕥; + #𮕦; + #𮕧; + #𮕨; + #𮕩; + #𮕪; + #𮕫; + #𮕬; + #𮕭; + #𮕮; + #𮕯; + #𮕰; + #𮕱; + #𮕲; + #𮕳; + #𮕴; + #𮕵; + #𮕶; + #𮕷; + #𮕸; + #𮕹; + #𮕺; + #𮕻; + #𮕼; + #𮕽; + #𮕾; + #𮕿; + #𮖀; + #𮖁; + #𮖂; + #𮖃; + #𮖄; + #𮖅; + #𮖆; + #𮖇; + #𮖈; + #𮖉; + #𮖊; + #𮖋; + #𮖌; + #𮖍; + #𮖎; + #𮖏; + #𮖐; + #𮖑; + #𮖒; + #𮖓; + #𮖔; + #𮖕; + #𮖖; + #𮖗; + #𮖘; + #𮖙; + #𮖚; + #𮖛; + #𮖜; + #𮖝; + #𮖞; + #𮖟; + #𮖠; + #𮖡; + #𮖢; + #𮖣; + #𮖤; + #𮖥; + #𮖦; + #𮖧; + #𮖨; + #𮖩; + #𮖪; + #𮖫; + #𮖬; + #𮖭; + #𮖮; + #𮖯; + #𮖰; + #𮖱; + #𮖲; + #𮖳; + #𮖴; + #𮖵; + #𮖶; + #𮖷; + #𮖸; + #𮖹; + #𮖺; + #𮖻; + #𮖼; + #𮖽; + #𮖾; + #𮖿; + #𮗀; + #𮗁; + #𮗂; + #𮗃; + #𮗄; + #𮗅; + #𮗆; + #𮗇; + #𮗈; + #𮗉; + #𮗊; + #𮗋; + #𮗌; + #𮗍; + #𮗎; + #𮗏; + #𮗐; + #𮗑; + #𮗒; + #𮗓; + #𮗔; + #𮗕; + #𮗖; + #𮗗; + #𮗘; + #𮗙; + #𮗚; + #𮗛; + #𮗜; + #𮗝; + #𮗞; + #𮗟; + #𮗠; + #𮗡; + #𮗢; + #𮗣; + #𮗤; + #𮗥; + #𮗦; + #𮗧; + #𮗨; + #𮗩; + #𮗪; + #𮗫; + #𮗬; + #𮗭; + #𮗮; + #𮗯; + #𮗰; + #𮗱; + #𮗲; + #𮗳; + #𮗴; + #𮗵; + #𮗶; + #𮗷; + #𮗸; + #𮗹; + #𮗺; + #𮗻; + #𮗼; + #𮗽; + #𮗾; + #𮗿; + #𮘀; + #𮘁; + #𮘂; + #𮘃; + #𮘄; + #𮘅; + #𮘆; + #𮘇; + #𮘈; + #𮘉; + #𮘊; + #𮘋; + #𮘌; + #𮘍; + #𮘎; + #𮘏; + #𮘐; + #𮘑; + #𮘒; + #𮘓; + #𮘔; + #𮘕; + #𮘖; + #𮘗; + #𮘘; + #𮘙; + #𮘚; + #𮘛; + #𮘜; + #𮘝; + #𮘞; + #𮘟; + #𮘠; + #𮘡; + #𮘢; + #𮘣; + #𮘤; + #𮘥; + #𮘦; + #𮘧; + #𮘨; + #𮘩; + #𮘪; + #𮘫; + #𮘬; + #𮘭; + #𮘮; + #𮘯; + #𮘰; + #𮘱; + #𮘲; + #𮘳; + #𮘴; + #𮘵; + #𮘶; + #𮘷; + #𮘸; + #𮘹; + #𮘺; + #𮘻; + #𮘼; + #𮘽; + #𮘾; + #𮘿; + #𮙀; + #𮙁; + #𮙂; + #𮙃; + #𮙄; + #𮙅; + #𮙆; + #𮙇; + #𮙈; + #𮙉; + #𮙊; + #𮙋; + #𮙌; + #𮙍; + #𮙎; + #𮙏; + #𮙐; + #𮙑; + #𮙒; + #𮙓; + #𮙔; + #𮙕; + #𮙖; + #𮙗; + #𮙘; + #𮙙; + #𮙚; + #𮙛; + #𮙜; + #𮙝; + #𮙞; + #𮙟; + #𮙠; + #𮙡; + #𮙢; + #𮙣; + #𮙤; + #𮙥; + #𮙦; + #𮙧; + #𮙨; + #𮙩; + #𮙪; + #𮙫; + #𮙬; + #𮙭; + #𮙮; + #𮙯; + #𮙰; + #𮙱; + #𮙲; + #𮙳; + #𮙴; + #𮙵; + #𮙶; + #𮙷; + #𮙸; + #𮙹; + #𮙺; + #𮙻; + #𮙼; + #𮙽; + #𮙾; + #𮙿; + #𮚀; + #𮚁; + #𮚂; + #𮚃; + #𮚄; + #𮚅; + #𮚆; + #𮚇; + #𮚈; + #𮚉; + #𮚊; + #𮚋; + #𮚌; + #𮚍; + #𮚎; + #𮚏; + #𮚐; + #𮚑; + #𮚒; + #𮚓; + #𮚔; + #𮚕; + #𮚖; + #𮚗; + #𮚘; + #𮚙; + #𮚚; + #𮚛; + #𮚜; + #𮚝; + #𮚞; + #𮚟; + #𮚠; + #𮚡; + #𮚢; + #𮚣; + #𮚤; + #𮚥; + #𮚦; + #𮚧; + #𮚨; + #𮚩; + #𮚪; + #𮚫; + #𮚬; + #𮚭; + #𮚮; + #𮚯; + #𮚰; + #𮚱; + #𮚲; + #𮚳; + #𮚴; + #𮚵; + #𮚶; + #𮚷; + #𮚸; + #𮚹; + #𮚺; + #𮚻; + #𮚼; + #𮚽; + #𮚾; + #𮚿; + #𮛀; + #𮛁; + #𮛂; + #𮛃; + #𮛄; + #𮛅; + #𮛆; + #𮛇; + #𮛈; + #𮛉; + #𮛊; + #𮛋; + #𮛌; + #𮛍; + #𮛎; + #𮛏; + #𮛐; + #𮛑; + #𮛒; + #𮛓; + #𮛔; + #𮛕; + #𮛖; + #𮛗; + #𮛘; + #𮛙; + #𮛚; + #𮛛; + #𮛜; + #𮛝; + #𮛞; + #𮛟; + #𮛠; + #𮛡; + #𮛢; + #𮛣; + #𮛤; + #𮛥; + #𮛦; + #𮛧; + #𮛨; + #𮛩; + #𮛪; + #𮛫; + #𮛬; + #𮛭; + #𮛮; + #𮛯; + #𮛰; + #𮛱; + #𮛲; + #𮛳; + #𮛴; + #𮛵; + #𮛶; + #𮛷; + #𮛸; + #𮛹; + #𮛺; + #𮛻; + #𮛼; + #𮛽; + #𮛾; + #𮛿; + #𮜀; + #𮜁; + #𮜂; + #𮜃; + #𮜄; + #𮜅; + #𮜆; + #𮜇; + #𮜈; + #𮜉; + #𮜊; + #𮜋; + #𮜌; + #𮜍; + #𮜎; + #𮜏; + #𮜐; + #𮜑; + #𮜒; + #𮜓; + #𮜔; + #𮜕; + #𮜖; + #𮜗; + #𮜘; + #𮜙; + #𮜚; + #𮜛; + #𮜜; + #𮜝; + #𮜞; + #𮜟; + #𮜠; + #𮜡; + #𮜢; + #𮜣; + #𮜤; + #𮜥; + #𮜦; + #𮜧; + #𮜨; + #𮜩; + #𮜪; + #𮜫; + #𮜬; + #𮜭; + #𮜮; + #𮜯; + #𮜰; + #𮜱; + #𮜲; + #𮜳; + #𮜴; + #𮜵; + #𮜶; + #𮜷; + #𮜸; + #𮜹; + #𮜺; + #𮜻; + #𮜼; + #𮜽; + #𮜾; + #𮜿; + #𮝀; + #𮝁; + #𮝂; + #𮝃; + #𮝄; + #𮝅; + #𮝆; + #𮝇; + #𮝈; + #𮝉; + #𮝊; + #𮝋; + #𮝌; + #𮝍; + #𮝎; + #𮝏; + #𮝐; + #𮝑; + #𮝒; + #𮝓; + #𮝔; + #𮝕; + #𮝖; + #𮝗; + #𮝘; + #𮝙; + #𮝚; + #𮝛; + #𮝜; + #𮝝; + #𮝞; + #𮝟; + #𮝠; + #𮝡; + #𮝢; + #𮝣; + #𮝤; + #𮝥; + #𮝦; + #𮝧; + #𮝨; + #𮝩; + #𮝪; + #𮝫; + #𮝬; + #𮝭; + #𮝮; + #𮝯; + #𮝰; + #𮝱; + #𮝲; + #𮝳; + #𮝴; + #𮝵; + #𮝶; + #𮝷; + #𮝸; + #𮝹; + #𮝺; + #𮝻; + #𮝼; + #𮝽; + #𮝾; + #𮝿; + #𮞀; + #𮞁; + #𮞂; + #𮞃; + #𮞄; + #𮞅; + #𮞆; + #𮞇; + #𮞈; + #𮞉; + #𮞊; + #𮞋; + #𮞌; + #𮞍; + #𮞎; + #𮞏; + #𮞐; + #𮞑; + #𮞒; + #𮞓; + #𮞔; + #𮞕; + #𮞖; + #𮞗; + #𮞘; + #𮞙; + #𮞚; + #𮞛; + #𮞜; + #𮞝; + #𮞞; + #𮞟; + #𮞠; + #𮞡; + #𮞢; + #𮞣; + #𮞤; + #𮞥; + #𮞦; + #𮞧; + #𮞨; + #𮞩; + #𮞪; + #𮞫; + #𮞬; + #𮞭; + #𮞮; + #𮞯; + #𮞰; + #𮞱; + #𮞲; + #𮞳; + #𮞴; + #𮞵; + #𮞶; + #𮞷; + #𮞸; + #𮞹; + #𮞺; + #𮞻; + #𮞼; + #𮞽; + #𮞾; + #𮞿; + #𮟀; + #𮟁; + #𮟂; + #𮟃; + #𮟄; + #𮟅; + #𮟆; + #𮟇; + #𮟈; + #𮟉; + #𮟊; + #𮟋; + #𮟌; + #𮟍; + #𮟎; + #𮟏; + #𮟐; + #𮟑; + #𮟒; + #𮟓; + #𮟔; + #𮟕; + #𮟖; + #𮟗; + #𮟘; + #𮟙; + #𮟚; + #𮟛; + #𮟜; + #𮟝; + #𮟞; + #𮟟; + #𮟠; + #𮟡; + #𮟢; + #𮟣; + #𮟤; + #𮟥; + #𮟦; + #𮟧; + #𮟨; + #𮟩; + #𮟪; + #𮟫; + #𮟬; + #𮟭; + #𮟮; + #𮟯; + #𮟰; + #𮟱; + #𮟲; + #𮟳; + #𮟴; + #𮟵; + #𮟶; + #𮟷; + #𮟸; + #𮟹; + #𮟺; + #𮟻; + #𮟼; + #𮟽; + #𮟾; + #𮟿; + #𮠀; + #𮠁; + #𮠂; + #𮠃; + #𮠄; + #𮠅; + #𮠆; + #𮠇; + #𮠈; + #𮠉; + #𮠊; + #𮠋; + #𮠌; + #𮠍; + #𮠎; + #𮠏; + #𮠐; + #𮠑; + #𮠒; + #𮠓; + #𮠔; + #𮠕; + #𮠖; + #𮠗; + #𮠘; + #𮠙; + #𮠚; + #𮠛; + #𮠜; + #𮠝; + #𮠞; + #𮠟; + #𮠠; + #𮠡; + #𮠢; + #𮠣; + #𮠤; + #𮠥; + #𮠦; + #𮠧; + #𮠨; + #𮠩; + #𮠪; + #𮠫; + #𮠬; + #𮠭; + #𮠮; + #𮠯; + #𮠰; + #𮠱; + #𮠲; + #𮠳; + #𮠴; + #𮠵; + #𮠶; + #𮠷; + #𮠸; + #𮠹; + #𮠺; + #𮠻; + #𮠼; + #𮠽; + #𮠾; + #𮠿; + #𮡀; + #𮡁; + #𮡂; + #𮡃; + #𮡄; + #𮡅; + #𮡆; + #𮡇; + #𮡈; + #𮡉; + #𮡊; + #𮡋; + #𮡌; + #𮡍; + #𮡎; + #𮡏; + #𮡐; + #𮡑; + #𮡒; + #𮡓; + #𮡔; + #𮡕; + #𮡖; + #𮡗; + #𮡘; + #𮡙; + #𮡚; + #𮡛; + #𮡜; + #𮡝; + #𮡞; + #𮡟; + #𮡠; + #𮡡; + #𮡢; + #𮡣; + #𮡤; + #𮡥; + #𮡦; + #𮡧; + #𮡨; + #𮡩; + #𮡪; + #𮡫; + #𮡬; + #𮡭; + #𮡮; + #𮡯; + #𮡰; + #𮡱; + #𮡲; + #𮡳; + #𮡴; + #𮡵; + #𮡶; + #𮡷; + #𮡸; + #𮡹; + #𮡺; + #𮡻; + #𮡼; + #𮡽; + #𮡾; + #𮡿; + #𮢀; + #𮢁; + #𮢂; + #𮢃; + #𮢄; + #𮢅; + #𮢆; + #𮢇; + #𮢈; + #𮢉; + #𮢊; + #𮢋; + #𮢌; + #𮢍; + #𮢎; + #𮢏; + #𮢐; + #𮢑; + #𮢒; + #𮢓; + #𮢔; + #𮢕; + #𮢖; + #𮢗; + #𮢘; + #𮢙; + #𮢚; + #𮢛; + #𮢜; + #𮢝; + #𮢞; + #𮢟; + #𮢠; + #𮢡; + #𮢢; + #𮢣; + #𮢤; + #𮢥; + #𮢦; + #𮢧; + #𮢨; + #𮢩; + #𮢪; + #𮢫; + #𮢬; + #𮢭; + #𮢮; + #𮢯; + #𮢰; + #𮢱; + #𮢲; + #𮢳; + #𮢴; + #𮢵; + #𮢶; + #𮢷; + #𮢸; + #𮢹; + #𮢺; + #𮢻; + #𮢼; + #𮢽; + #𮢾; + #𮢿; + #𮣀; + #𮣁; + #𮣂; + #𮣃; + #𮣄; + #𮣅; + #𮣆; + #𮣇; + #𮣈; + #𮣉; + #𮣊; + #𮣋; + #𮣌; + #𮣍; + #𮣎; + #𮣏; + #𮣐; + #𮣑; + #𮣒; + #𮣓; + #𮣔; + #𮣕; + #𮣖; + #𮣗; + #𮣘; + #𮣙; + #𮣚; + #𮣛; + #𮣜; + #𮣝; + #𮣞; + #𮣟; + #𮣠; + #𮣡; + #𮣢; + #𮣣; + #𮣤; + #𮣥; + #𮣦; + #𮣧; + #𮣨; + #𮣩; + #𮣪; + #𮣫; + #𮣬; + #𮣭; + #𮣮; + #𮣯; + #𮣰; + #𮣱; + #𮣲; + #𮣳; + #𮣴; + #𮣵; + #𮣶; + #𮣷; + #𮣸; + #𮣹; + #𮣺; + #𮣻; + #𮣼; + #𮣽; + #𮣾; + #𮣿; + #𮤀; + #𮤁; + #𮤂; + #𮤃; + #𮤄; + #𮤅; + #𮤆; + #𮤇; + #𮤈; + #𮤉; + #𮤊; + #𮤋; + #𮤌; + #𮤍; + #𮤎; + #𮤏; + #𮤐; + #𮤑; + #𮤒; + #𮤓; + #𮤔; + #𮤕; + #𮤖; + #𮤗; + #𮤘; + #𮤙; + #𮤚; + #𮤛; + #𮤜; + #𮤝; + #𮤞; + #𮤟; + #𮤠; + #𮤡; + #𮤢; + #𮤣; + #𮤤; + #𮤥; + #𮤦; + #𮤧; + #𮤨; + #𮤩; + #𮤪; + #𮤫; + #𮤬; + #𮤭; + #𮤮; + #𮤯; + #𮤰; + #𮤱; + #𮤲; + #𮤳; + #𮤴; + #𮤵; + #𮤶; + #𮤷; + #𮤸; + #𮤹; + #𮤺; + #𮤻; + #𮤼; + #𮤽; + #𮤾; + #𮤿; + #𮥀; + #𮥁; + #𮥂; + #𮥃; + #𮥄; + #𮥅; + #𮥆; + #𮥇; + #𮥈; + #𮥉; + #𮥊; + #𮥋; + #𮥌; + #𮥍; + #𮥎; + #𮥏; + #𮥐; + #𮥑; + #𮥒; + #𮥓; + #𮥔; + #𮥕; + #𮥖; + #𮥗; + #𮥘; + #𮥙; + #𮥚; + #𮥛; + #𮥜; + #𮥝; + #𮥞; + #𮥟; + #𮥠; + #𮥡; + #𮥢; + #𮥣; + #𮥤; + #𮥥; + #𮥦; + #𮥧; + #𮥨; + #𮥩; + #𮥪; + #𮥫; + #𮥬; + #𮥭; + #𮥮; + #𮥯; + #𮥰; + #𮥱; + #𮥲; + #𮥳; + #𮥴; + #𮥵; + #𮥶; + #𮥷; + #𮥸; + #𮥹; + #𮥺; + #𮥻; + #𮥼; + #𮥽; + #𮥾; + #𮥿; + #𮦀; + #𮦁; + #𮦂; + #𮦃; + #𮦄; + #𮦅; + #𮦆; + #𮦇; + #𮦈; + #𮦉; + #𮦊; + #𮦋; + #𮦌; + #𮦍; + #𮦎; + #𮦏; + #𮦐; + #𮦑; + #𮦒; + #𮦓; + #𮦔; + #𮦕; + #𮦖; + #𮦗; + #𮦘; + #𮦙; + #𮦚; + #𮦛; + #𮦜; + #𮦝; + #𮦞; + #𮦟; + #𮦠; + #𮦡; + #𮦢; + #𮦣; + #𮦤; + #𮦥; + #𮦦; + #𮦧; + #𮦨; + #𮦩; + #𮦪; + #𮦫; + #𮦬; + #𮦭; + #𮦮; + #𮦯; + #𮦰; + #𮦱; + #𮦲; + #𮦳; + #𮦴; + #𮦵; + #𮦶; + #𮦷; + #𮦸; + #𮦹; + #𮦺; + #𮦻; + #𮦼; + #𮦽; + #𮦾; + #𮦿; + #𮧀; + #𮧁; + #𮧂; + #𮧃; + #𮧄; + #𮧅; + #𮧆; + #𮧇; + #𮧈; + #𮧉; + #𮧊; + #𮧋; + #𮧌; + #𮧍; + #𮧎; + #𮧏; + #𮧐; + #𮧑; + #𮧒; + #𮧓; + #𮧔; + #𮧕; + #𮧖; + #𮧗; + #𮧘; + #𮧙; + #𮧚; + #𮧛; + #𮧜; + #𮧝; + #𮧞; + #𮧟; + #𮧠; + #𮧡; + #𮧢; + #𮧣; + #𮧤; + #𮧥; + #𮧦; + #𮧧; + #𮧨; + #𮧩; + #𮧪; + #𮧫; + #𮧬; + #𮧭; + #𮧮; + #𮧯; + #𮧰; + #𮧱; + #𮧲; + #𮧳; + #𮧴; + #𮧵; + #𮧶; + #𮧷; + #𮧸; + #𮧹; + #𮧺; + #𮧻; + #𮧼; + #𮧽; + #𮧾; + #𮧿; + #𮨀; + #𮨁; + #𮨂; + #𮨃; + #𮨄; + #𮨅; + #𮨆; + #𮨇; + #𮨈; + #𮨉; + #𮨊; + #𮨋; + #𮨌; + #𮨍; + #𮨎; + #𮨏; + #𮨐; + #𮨑; + #𮨒; + #𮨓; + #𮨔; + #𮨕; + #𮨖; + #𮨗; + #𮨘; + #𮨙; + #𮨚; + #𮨛; + #𮨜; + #𮨝; + #𮨞; + #𮨟; + #𮨠; + #𮨡; + #𮨢; + #𮨣; + #𮨤; + #𮨥; + #𮨦; + #𮨧; + #𮨨; + #𮨩; + #𮨪; + #𮨫; + #𮨬; + #𮨭; + #𮨮; + #𮨯; + #𮨰; + #𮨱; + #𮨲; + #𮨳; + #𮨴; + #𮨵; + #𮨶; + #𮨷; + #𮨸; + #𮨹; + #𮨺; + #𮨻; + #𮨼; + #𮨽; + #𮨾; + #𮨿; + #𮩀; + #𮩁; + #𮩂; + #𮩃; + #𮩄; + #𮩅; + #𮩆; + #𮩇; + #𮩈; + #𮩉; + #𮩊; + #𮩋; + #𮩌; + #𮩍; + #𮩎; + #𮩏; + #𮩐; + #𮩑; + #𮩒; + #𮩓; + #𮩔; + #𮩕; + #𮩖; + #𮩗; + #𮩘; + #𮩙; + #𮩚; + #𮩛; + #𮩜; + #𮩝; + #𮩞; + #𮩟; + #𮩠; + #𮩡; + #𮩢; + #𮩣; + #𮩤; + #𮩥; + #𮩦; + #𮩧; + #𮩨; + #𮩩; + #𮩪; + #𮩫; + #𮩬; + #𮩭; + #𮩮; + #𮩯; + #𮩰; + #𮩱; + #𮩲; + #𮩳; + #𮩴; + #𮩵; + #𮩶; + #𮩷; + #𮩸; + #𮩹; + #𮩺; + #𮩻; + #𮩼; + #𮩽; + #𮩾; + #𮩿; + #𮪀; + #𮪁; + #𮪂; + #𮪃; + #𮪄; + #𮪅; + #𮪆; + #𮪇; + #𮪈; + #𮪉; + #𮪊; + #𮪋; + #𮪌; + #𮪍; + #𮪎; + #𮪏; + #𮪐; + #𮪑; + #𮪒; + #𮪓; + #𮪔; + #𮪕; + #𮪖; + #𮪗; + #𮪘; + #𮪙; + #𮪚; + #𮪛; + #𮪜; + #𮪝; + #𮪞; + #𮪟; + #𮪠; + #𮪡; + #𮪢; + #𮪣; + #𮪤; + #𮪥; + #𮪦; + #𮪧; + #𮪨; + #𮪩; + #𮪪; + #𮪫; + #𮪬; + #𮪭; + #𮪮; + #𮪯; + #𮪰; + #𮪱; + #𮪲; + #𮪳; + #𮪴; + #𮪵; + #𮪶; + #𮪷; + #𮪸; + #𮪹; + #𮪺; + #𮪻; + #𮪼; + #𮪽; + #𮪾; + #𮪿; + #𮫀; + #𮫁; + #𮫂; + #𮫃; + #𮫄; + #𮫅; + #𮫆; + #𮫇; + #𮫈; + #𮫉; + #𮫊; + #𮫋; + #𮫌; + #𮫍; + #𮫎; + #𮫏; + #𮫐; + #𮫑; + #𮫒; + #𮫓; + #𮫔; + #𮫕; + #𮫖; + #𮫗; + #𮫘; + #𮫙; + #𮫚; + #𮫛; + #𮫜; + #𮫝; + #𮫞; + #𮫟; + #𮫠; + #𮫡; + #𮫢; + #𮫣; + #𮫤; + #𮫥; + #𮫦; + #𮫧; + #𮫨; + #𮫩; + #𮫪; + #𮫫; + #𮫬; + #𮫭; + #𮫮; + #𮫯; + #𮫰; + #𮫱; + #𮫲; + #𮫳; + #𮫴; + #𮫵; + #𮫶; + #𮫷; + #𮫸; + #𮫹; + #𮫺; + #𮫻; + #𮫼; + #𮫽; + #𮫾; + #𮫿; + #𮬀; + #𮬁; + #𮬂; + #𮬃; + #𮬄; + #𮬅; + #𮬆; + #𮬇; + #𮬈; + #𮬉; + #𮬊; + #𮬋; + #𮬌; + #𮬍; + #𮬎; + #𮬏; + #𮬐; + #𮬑; + #𮬒; + #𮬓; + #𮬔; + #𮬕; + #𮬖; + #𮬗; + #𮬘; + #𮬙; + #𮬚; + #𮬛; + #𮬜; + #𮬝; + #𮬞; + #𮬟; + #𮬠; + #𮬡; + #𮬢; + #𮬣; + #𮬤; + #𮬥; + #𮬦; + #𮬧; + #𮬨; + #𮬩; + #𮬪; + #𮬫; + #𮬬; + #𮬭; + #𮬮; + #𮬯; + #𮬰; + #𮬱; + #𮬲; + #𮬳; + #𮬴; + #𮬵; + #𮬶; + #𮬷; + #𮬸; + #𮬹; + #𮬺; + #𮬻; + #𮬼; + #𮬽; + #𮬾; + #𮬿; + #𮭀; + #𮭁; + #𮭂; + #𮭃; + #𮭄; + #𮭅; + #𮭆; + #𮭇; + #𮭈; + #𮭉; + #𮭊; + #𮭋; + #𮭌; + #𮭍; + #𮭎; + #𮭏; + #𮭐; + #𮭑; + #𮭒; + #𮭓; + #𮭔; + #𮭕; + #𮭖; + #𮭗; + #𮭘; + #𮭙; + #𮭚; + #𮭛; + #𮭜; + #𮭝; + #𮭞; + #𮭟; + #𮭠; + #𮭡; + #𮭢; + #𮭣; + #𮭤; + #𮭥; + #𮭦; + #𮭧; + #𮭨; + #𮭩; + #𮭪; + #𮭫; + #𮭬; + #𮭭; + #𮭮; + #𮭯; + #𮭰; + #𮭱; + #𮭲; + #𮭳; + #𮭴; + #𮭵; + #𮭶; + #𮭷; + #𮭸; + #𮭹; + #𮭺; + #𮭻; + #𮭼; + #𮭽; + #𮭾; + #𮭿; + #𮮀; + #𮮁; + #𮮂; + #𮮃; + #𮮄; + #𮮅; + #𮮆; + #𮮇; + #𮮈; + #𮮉; + #𮮊; + #𮮋; + #𮮌; + #𮮍; + #𮮎; + #𮮏; + #𮮐; + #𮮑; + #𮮒; + #𮮓; + #𮮔; + #𮮕; + #𮮖; + #𮮗; + #𮮘; + #𮮙; + #𮮚; + #𮮛; + #𮮜; + #𮮝; + #𮮞; + #𮮟; + #𮮠; + #𮮡; + #𮮢; + #𮮣; + #𮮤; + #𮮥; + #𮮦; + #𮮧; + #𮮨; + #𮮩; + #𮮪; + #𮮫; + #𮮬; + #𮮭; + #𮮮; + #𮮯; + #𮮰; + #𮮱; + #𮮲; + #𮮳; + #𮮴; + #𮮵; + #𮮶; + #𮮷; + #𮮸; + #𮮹; + #𮮺; + #𮮻; + #𮮼; + #𮮽; + #𮮾; + #𮮿; + #𮯀; + #𮯁; + #𮯂; + #𮯃; + #𮯄; + #𮯅; + #𮯆; + #𮯇; + #𮯈; + #𮯉; + #𮯊; + #𮯋; + #𮯌; + #𮯍; + #𮯎; + #𮯏; + #𮯐; + #𮯑; + #𮯒; + #𮯓; + #𮯔; + #𮯕; + #𮯖; + #𮯗; + #𮯘; + #𮯙; + #𮯚; + #𮯛; + #𮯜; + #𮯝; + #𮯞; + #𮯟; + #𮯠; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0-escaped.js new file mode 100644 index 000000000..18821930d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0-escaped.js @@ -0,0 +1,8342 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v10.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u0860; +var \u0861; +var \u0862; +var \u0863; +var \u0864; +var \u0865; +var \u0866; +var \u0867; +var \u0868; +var \u0869; +var \u086A; +var \u09FC; +var \u312E; +var \u9FD6; +var \u9FD7; +var \u9FD8; +var \u9FD9; +var \u9FDA; +var \u9FDB; +var \u9FDC; +var \u9FDD; +var \u9FDE; +var \u9FDF; +var \u9FE0; +var \u9FE1; +var \u9FE2; +var \u9FE3; +var \u9FE4; +var \u9FE5; +var \u9FE6; +var \u9FE7; +var \u9FE8; +var \u9FE9; +var \u9FEA; +var \u{1032D}; +var \u{1032E}; +var \u{1032F}; +var \u{11A00}; +var \u{11A0B}; +var \u{11A0C}; +var \u{11A0D}; +var \u{11A0E}; +var \u{11A0F}; +var \u{11A10}; +var \u{11A11}; +var \u{11A12}; +var \u{11A13}; +var \u{11A14}; +var \u{11A15}; +var \u{11A16}; +var \u{11A17}; +var \u{11A18}; +var \u{11A19}; +var \u{11A1A}; +var \u{11A1B}; +var \u{11A1C}; +var \u{11A1D}; +var \u{11A1E}; +var \u{11A1F}; +var \u{11A20}; +var \u{11A21}; +var \u{11A22}; +var \u{11A23}; +var \u{11A24}; +var \u{11A25}; +var \u{11A26}; +var \u{11A27}; +var \u{11A28}; +var \u{11A29}; +var \u{11A2A}; +var \u{11A2B}; +var \u{11A2C}; +var \u{11A2D}; +var \u{11A2E}; +var \u{11A2F}; +var \u{11A30}; +var \u{11A31}; +var \u{11A32}; +var \u{11A3A}; +var \u{11A50}; +var \u{11A5C}; +var \u{11A5D}; +var \u{11A5E}; +var \u{11A5F}; +var \u{11A60}; +var \u{11A61}; +var \u{11A62}; +var \u{11A63}; +var \u{11A64}; +var \u{11A65}; +var \u{11A66}; +var \u{11A67}; +var \u{11A68}; +var \u{11A69}; +var \u{11A6A}; +var \u{11A6B}; +var \u{11A6C}; +var \u{11A6D}; +var \u{11A6E}; +var \u{11A6F}; +var \u{11A70}; +var \u{11A71}; +var \u{11A72}; +var \u{11A73}; +var \u{11A74}; +var \u{11A75}; +var \u{11A76}; +var \u{11A77}; +var \u{11A78}; +var \u{11A79}; +var \u{11A7A}; +var \u{11A7B}; +var \u{11A7C}; +var \u{11A7D}; +var \u{11A7E}; +var \u{11A7F}; +var \u{11A80}; +var \u{11A81}; +var \u{11A82}; +var \u{11A83}; +var \u{11A86}; +var \u{11A87}; +var \u{11A88}; +var \u{11A89}; +var \u{11D00}; +var \u{11D01}; +var \u{11D02}; +var \u{11D03}; +var \u{11D04}; +var \u{11D05}; +var \u{11D06}; +var \u{11D08}; +var \u{11D09}; +var \u{11D0B}; +var \u{11D0C}; +var \u{11D0D}; +var \u{11D0E}; +var \u{11D0F}; +var \u{11D10}; +var \u{11D11}; +var \u{11D12}; +var \u{11D13}; +var \u{11D14}; +var \u{11D15}; +var \u{11D16}; +var \u{11D17}; +var \u{11D18}; +var \u{11D19}; +var \u{11D1A}; +var \u{11D1B}; +var \u{11D1C}; +var \u{11D1D}; +var \u{11D1E}; +var \u{11D1F}; +var \u{11D20}; +var \u{11D21}; +var \u{11D22}; +var \u{11D23}; +var \u{11D24}; +var \u{11D25}; +var \u{11D26}; +var \u{11D27}; +var \u{11D28}; +var \u{11D29}; +var \u{11D2A}; +var \u{11D2B}; +var \u{11D2C}; +var \u{11D2D}; +var \u{11D2E}; +var \u{11D2F}; +var \u{11D30}; +var \u{11D46}; +var \u{16FE1}; +var \u{1B002}; +var \u{1B003}; +var \u{1B004}; +var \u{1B005}; +var \u{1B006}; +var \u{1B007}; +var \u{1B008}; +var \u{1B009}; +var \u{1B00A}; +var \u{1B00B}; +var \u{1B00C}; +var \u{1B00D}; +var \u{1B00E}; +var \u{1B00F}; +var \u{1B010}; +var \u{1B011}; +var \u{1B012}; +var \u{1B013}; +var \u{1B014}; +var \u{1B015}; +var \u{1B016}; +var \u{1B017}; +var \u{1B018}; +var \u{1B019}; +var \u{1B01A}; +var \u{1B01B}; +var \u{1B01C}; +var \u{1B01D}; +var \u{1B01E}; +var \u{1B01F}; +var \u{1B020}; +var \u{1B021}; +var \u{1B022}; +var \u{1B023}; +var \u{1B024}; +var \u{1B025}; +var \u{1B026}; +var \u{1B027}; +var \u{1B028}; +var \u{1B029}; +var \u{1B02A}; +var \u{1B02B}; +var \u{1B02C}; +var \u{1B02D}; +var \u{1B02E}; +var \u{1B02F}; +var \u{1B030}; +var \u{1B031}; +var \u{1B032}; +var \u{1B033}; +var \u{1B034}; +var \u{1B035}; +var \u{1B036}; +var \u{1B037}; +var \u{1B038}; +var \u{1B039}; +var \u{1B03A}; +var \u{1B03B}; +var \u{1B03C}; +var \u{1B03D}; +var \u{1B03E}; +var \u{1B03F}; +var \u{1B040}; +var \u{1B041}; +var \u{1B042}; +var \u{1B043}; +var \u{1B044}; +var \u{1B045}; +var \u{1B046}; +var \u{1B047}; +var \u{1B048}; +var \u{1B049}; +var \u{1B04A}; +var \u{1B04B}; +var \u{1B04C}; +var \u{1B04D}; +var \u{1B04E}; +var \u{1B04F}; +var \u{1B050}; +var \u{1B051}; +var \u{1B052}; +var \u{1B053}; +var \u{1B054}; +var \u{1B055}; +var \u{1B056}; +var \u{1B057}; +var \u{1B058}; +var \u{1B059}; +var \u{1B05A}; +var \u{1B05B}; +var \u{1B05C}; +var \u{1B05D}; +var \u{1B05E}; +var \u{1B05F}; +var \u{1B060}; +var \u{1B061}; +var \u{1B062}; +var \u{1B063}; +var \u{1B064}; +var \u{1B065}; +var \u{1B066}; +var \u{1B067}; +var \u{1B068}; +var \u{1B069}; +var \u{1B06A}; +var \u{1B06B}; +var \u{1B06C}; +var \u{1B06D}; +var \u{1B06E}; +var \u{1B06F}; +var \u{1B070}; +var \u{1B071}; +var \u{1B072}; +var \u{1B073}; +var \u{1B074}; +var \u{1B075}; +var \u{1B076}; +var \u{1B077}; +var \u{1B078}; +var \u{1B079}; +var \u{1B07A}; +var \u{1B07B}; +var \u{1B07C}; +var \u{1B07D}; +var \u{1B07E}; +var \u{1B07F}; +var \u{1B080}; +var \u{1B081}; +var \u{1B082}; +var \u{1B083}; +var \u{1B084}; +var \u{1B085}; +var \u{1B086}; +var \u{1B087}; +var \u{1B088}; +var \u{1B089}; +var \u{1B08A}; +var \u{1B08B}; +var \u{1B08C}; +var \u{1B08D}; +var \u{1B08E}; +var \u{1B08F}; +var \u{1B090}; +var \u{1B091}; +var \u{1B092}; +var \u{1B093}; +var \u{1B094}; +var \u{1B095}; +var \u{1B096}; +var \u{1B097}; +var \u{1B098}; +var \u{1B099}; +var \u{1B09A}; +var \u{1B09B}; +var \u{1B09C}; +var \u{1B09D}; +var \u{1B09E}; +var \u{1B09F}; +var \u{1B0A0}; +var \u{1B0A1}; +var \u{1B0A2}; +var \u{1B0A3}; +var \u{1B0A4}; +var \u{1B0A5}; +var \u{1B0A6}; +var \u{1B0A7}; +var \u{1B0A8}; +var \u{1B0A9}; +var \u{1B0AA}; +var \u{1B0AB}; +var \u{1B0AC}; +var \u{1B0AD}; +var \u{1B0AE}; +var \u{1B0AF}; +var \u{1B0B0}; +var \u{1B0B1}; +var \u{1B0B2}; +var \u{1B0B3}; +var \u{1B0B4}; +var \u{1B0B5}; +var \u{1B0B6}; +var \u{1B0B7}; +var \u{1B0B8}; +var \u{1B0B9}; +var \u{1B0BA}; +var \u{1B0BB}; +var \u{1B0BC}; +var \u{1B0BD}; +var \u{1B0BE}; +var \u{1B0BF}; +var \u{1B0C0}; +var \u{1B0C1}; +var \u{1B0C2}; +var \u{1B0C3}; +var \u{1B0C4}; +var \u{1B0C5}; +var \u{1B0C6}; +var \u{1B0C7}; +var \u{1B0C8}; +var \u{1B0C9}; +var \u{1B0CA}; +var \u{1B0CB}; +var \u{1B0CC}; +var \u{1B0CD}; +var \u{1B0CE}; +var \u{1B0CF}; +var \u{1B0D0}; +var \u{1B0D1}; +var \u{1B0D2}; +var \u{1B0D3}; +var \u{1B0D4}; +var \u{1B0D5}; +var \u{1B0D6}; +var \u{1B0D7}; +var \u{1B0D8}; +var \u{1B0D9}; +var \u{1B0DA}; +var \u{1B0DB}; +var \u{1B0DC}; +var \u{1B0DD}; +var \u{1B0DE}; +var \u{1B0DF}; +var \u{1B0E0}; +var \u{1B0E1}; +var \u{1B0E2}; +var \u{1B0E3}; +var \u{1B0E4}; +var \u{1B0E5}; +var \u{1B0E6}; +var \u{1B0E7}; +var \u{1B0E8}; +var \u{1B0E9}; +var \u{1B0EA}; +var \u{1B0EB}; +var \u{1B0EC}; +var \u{1B0ED}; +var \u{1B0EE}; +var \u{1B0EF}; +var \u{1B0F0}; +var \u{1B0F1}; +var \u{1B0F2}; +var \u{1B0F3}; +var \u{1B0F4}; +var \u{1B0F5}; +var \u{1B0F6}; +var \u{1B0F7}; +var \u{1B0F8}; +var \u{1B0F9}; +var \u{1B0FA}; +var \u{1B0FB}; +var \u{1B0FC}; +var \u{1B0FD}; +var \u{1B0FE}; +var \u{1B0FF}; +var \u{1B100}; +var \u{1B101}; +var \u{1B102}; +var \u{1B103}; +var \u{1B104}; +var \u{1B105}; +var \u{1B106}; +var \u{1B107}; +var \u{1B108}; +var \u{1B109}; +var \u{1B10A}; +var \u{1B10B}; +var \u{1B10C}; +var \u{1B10D}; +var \u{1B10E}; +var \u{1B10F}; +var \u{1B110}; +var \u{1B111}; +var \u{1B112}; +var \u{1B113}; +var \u{1B114}; +var \u{1B115}; +var \u{1B116}; +var \u{1B117}; +var \u{1B118}; +var \u{1B119}; +var \u{1B11A}; +var \u{1B11B}; +var \u{1B11C}; +var \u{1B11D}; +var \u{1B11E}; +var \u{1B170}; +var \u{1B171}; +var \u{1B172}; +var \u{1B173}; +var \u{1B174}; +var \u{1B175}; +var \u{1B176}; +var \u{1B177}; +var \u{1B178}; +var \u{1B179}; +var \u{1B17A}; +var \u{1B17B}; +var \u{1B17C}; +var \u{1B17D}; +var \u{1B17E}; +var \u{1B17F}; +var \u{1B180}; +var \u{1B181}; +var \u{1B182}; +var \u{1B183}; +var \u{1B184}; +var \u{1B185}; +var \u{1B186}; +var \u{1B187}; +var \u{1B188}; +var \u{1B189}; +var \u{1B18A}; +var \u{1B18B}; +var \u{1B18C}; +var \u{1B18D}; +var \u{1B18E}; +var \u{1B18F}; +var \u{1B190}; +var \u{1B191}; +var \u{1B192}; +var \u{1B193}; +var \u{1B194}; +var \u{1B195}; +var \u{1B196}; +var \u{1B197}; +var \u{1B198}; +var \u{1B199}; +var \u{1B19A}; +var \u{1B19B}; +var \u{1B19C}; +var \u{1B19D}; +var \u{1B19E}; +var \u{1B19F}; +var \u{1B1A0}; +var \u{1B1A1}; +var \u{1B1A2}; +var \u{1B1A3}; +var \u{1B1A4}; +var \u{1B1A5}; +var \u{1B1A6}; +var \u{1B1A7}; +var \u{1B1A8}; +var \u{1B1A9}; +var \u{1B1AA}; +var \u{1B1AB}; +var \u{1B1AC}; +var \u{1B1AD}; +var \u{1B1AE}; +var \u{1B1AF}; +var \u{1B1B0}; +var \u{1B1B1}; +var \u{1B1B2}; +var \u{1B1B3}; +var \u{1B1B4}; +var \u{1B1B5}; +var \u{1B1B6}; +var \u{1B1B7}; +var \u{1B1B8}; +var \u{1B1B9}; +var \u{1B1BA}; +var \u{1B1BB}; +var \u{1B1BC}; +var \u{1B1BD}; +var \u{1B1BE}; +var \u{1B1BF}; +var \u{1B1C0}; +var \u{1B1C1}; +var \u{1B1C2}; +var \u{1B1C3}; +var \u{1B1C4}; +var \u{1B1C5}; +var \u{1B1C6}; +var \u{1B1C7}; +var \u{1B1C8}; +var \u{1B1C9}; +var \u{1B1CA}; +var \u{1B1CB}; +var \u{1B1CC}; +var \u{1B1CD}; +var \u{1B1CE}; +var \u{1B1CF}; +var \u{1B1D0}; +var \u{1B1D1}; +var \u{1B1D2}; +var \u{1B1D3}; +var \u{1B1D4}; +var \u{1B1D5}; +var \u{1B1D6}; +var \u{1B1D7}; +var \u{1B1D8}; +var \u{1B1D9}; +var \u{1B1DA}; +var \u{1B1DB}; +var \u{1B1DC}; +var \u{1B1DD}; +var \u{1B1DE}; +var \u{1B1DF}; +var \u{1B1E0}; +var \u{1B1E1}; +var \u{1B1E2}; +var \u{1B1E3}; +var \u{1B1E4}; +var \u{1B1E5}; +var \u{1B1E6}; +var \u{1B1E7}; +var \u{1B1E8}; +var \u{1B1E9}; +var \u{1B1EA}; +var \u{1B1EB}; +var \u{1B1EC}; +var \u{1B1ED}; +var \u{1B1EE}; +var \u{1B1EF}; +var \u{1B1F0}; +var \u{1B1F1}; +var \u{1B1F2}; +var \u{1B1F3}; +var \u{1B1F4}; +var \u{1B1F5}; +var \u{1B1F6}; +var \u{1B1F7}; +var \u{1B1F8}; +var \u{1B1F9}; +var \u{1B1FA}; +var \u{1B1FB}; +var \u{1B1FC}; +var \u{1B1FD}; +var \u{1B1FE}; +var \u{1B1FF}; +var \u{1B200}; +var \u{1B201}; +var \u{1B202}; +var \u{1B203}; +var \u{1B204}; +var \u{1B205}; +var \u{1B206}; +var \u{1B207}; +var \u{1B208}; +var \u{1B209}; +var \u{1B20A}; +var \u{1B20B}; +var \u{1B20C}; +var \u{1B20D}; +var \u{1B20E}; +var \u{1B20F}; +var \u{1B210}; +var \u{1B211}; +var \u{1B212}; +var \u{1B213}; +var \u{1B214}; +var \u{1B215}; +var \u{1B216}; +var \u{1B217}; +var \u{1B218}; +var \u{1B219}; +var \u{1B21A}; +var \u{1B21B}; +var \u{1B21C}; +var \u{1B21D}; +var \u{1B21E}; +var \u{1B21F}; +var \u{1B220}; +var \u{1B221}; +var \u{1B222}; +var \u{1B223}; +var \u{1B224}; +var \u{1B225}; +var \u{1B226}; +var \u{1B227}; +var \u{1B228}; +var \u{1B229}; +var \u{1B22A}; +var \u{1B22B}; +var \u{1B22C}; +var \u{1B22D}; +var \u{1B22E}; +var \u{1B22F}; +var \u{1B230}; +var \u{1B231}; +var \u{1B232}; +var \u{1B233}; +var \u{1B234}; +var \u{1B235}; +var \u{1B236}; +var \u{1B237}; +var \u{1B238}; +var \u{1B239}; +var \u{1B23A}; +var \u{1B23B}; +var \u{1B23C}; +var \u{1B23D}; +var \u{1B23E}; +var \u{1B23F}; +var \u{1B240}; +var \u{1B241}; +var \u{1B242}; +var \u{1B243}; +var \u{1B244}; +var \u{1B245}; +var \u{1B246}; +var \u{1B247}; +var \u{1B248}; +var \u{1B249}; +var \u{1B24A}; +var \u{1B24B}; +var \u{1B24C}; +var \u{1B24D}; +var \u{1B24E}; +var \u{1B24F}; +var \u{1B250}; +var \u{1B251}; +var \u{1B252}; +var \u{1B253}; +var \u{1B254}; +var \u{1B255}; +var \u{1B256}; +var \u{1B257}; +var \u{1B258}; +var \u{1B259}; +var \u{1B25A}; +var \u{1B25B}; +var \u{1B25C}; +var \u{1B25D}; +var \u{1B25E}; +var \u{1B25F}; +var \u{1B260}; +var \u{1B261}; +var \u{1B262}; +var \u{1B263}; +var \u{1B264}; +var \u{1B265}; +var \u{1B266}; +var \u{1B267}; +var \u{1B268}; +var \u{1B269}; +var \u{1B26A}; +var \u{1B26B}; +var \u{1B26C}; +var \u{1B26D}; +var \u{1B26E}; +var \u{1B26F}; +var \u{1B270}; +var \u{1B271}; +var \u{1B272}; +var \u{1B273}; +var \u{1B274}; +var \u{1B275}; +var \u{1B276}; +var \u{1B277}; +var \u{1B278}; +var \u{1B279}; +var \u{1B27A}; +var \u{1B27B}; +var \u{1B27C}; +var \u{1B27D}; +var \u{1B27E}; +var \u{1B27F}; +var \u{1B280}; +var \u{1B281}; +var \u{1B282}; +var \u{1B283}; +var \u{1B284}; +var \u{1B285}; +var \u{1B286}; +var \u{1B287}; +var \u{1B288}; +var \u{1B289}; +var \u{1B28A}; +var \u{1B28B}; +var \u{1B28C}; +var \u{1B28D}; +var \u{1B28E}; +var \u{1B28F}; +var \u{1B290}; +var \u{1B291}; +var \u{1B292}; +var \u{1B293}; +var \u{1B294}; +var \u{1B295}; +var \u{1B296}; +var \u{1B297}; +var \u{1B298}; +var \u{1B299}; +var \u{1B29A}; +var \u{1B29B}; +var \u{1B29C}; +var \u{1B29D}; +var \u{1B29E}; +var \u{1B29F}; +var \u{1B2A0}; +var \u{1B2A1}; +var \u{1B2A2}; +var \u{1B2A3}; +var \u{1B2A4}; +var \u{1B2A5}; +var \u{1B2A6}; +var \u{1B2A7}; +var \u{1B2A8}; +var \u{1B2A9}; +var \u{1B2AA}; +var \u{1B2AB}; +var \u{1B2AC}; +var \u{1B2AD}; +var \u{1B2AE}; +var \u{1B2AF}; +var \u{1B2B0}; +var \u{1B2B1}; +var \u{1B2B2}; +var \u{1B2B3}; +var \u{1B2B4}; +var \u{1B2B5}; +var \u{1B2B6}; +var \u{1B2B7}; +var \u{1B2B8}; +var \u{1B2B9}; +var \u{1B2BA}; +var \u{1B2BB}; +var \u{1B2BC}; +var \u{1B2BD}; +var \u{1B2BE}; +var \u{1B2BF}; +var \u{1B2C0}; +var \u{1B2C1}; +var \u{1B2C2}; +var \u{1B2C3}; +var \u{1B2C4}; +var \u{1B2C5}; +var \u{1B2C6}; +var \u{1B2C7}; +var \u{1B2C8}; +var \u{1B2C9}; +var \u{1B2CA}; +var \u{1B2CB}; +var \u{1B2CC}; +var \u{1B2CD}; +var \u{1B2CE}; +var \u{1B2CF}; +var \u{1B2D0}; +var \u{1B2D1}; +var \u{1B2D2}; +var \u{1B2D3}; +var \u{1B2D4}; +var \u{1B2D5}; +var \u{1B2D6}; +var \u{1B2D7}; +var \u{1B2D8}; +var \u{1B2D9}; +var \u{1B2DA}; +var \u{1B2DB}; +var \u{1B2DC}; +var \u{1B2DD}; +var \u{1B2DE}; +var \u{1B2DF}; +var \u{1B2E0}; +var \u{1B2E1}; +var \u{1B2E2}; +var \u{1B2E3}; +var \u{1B2E4}; +var \u{1B2E5}; +var \u{1B2E6}; +var \u{1B2E7}; +var \u{1B2E8}; +var \u{1B2E9}; +var \u{1B2EA}; +var \u{1B2EB}; +var \u{1B2EC}; +var \u{1B2ED}; +var \u{1B2EE}; +var \u{1B2EF}; +var \u{1B2F0}; +var \u{1B2F1}; +var \u{1B2F2}; +var \u{1B2F3}; +var \u{1B2F4}; +var \u{1B2F5}; +var \u{1B2F6}; +var \u{1B2F7}; +var \u{1B2F8}; +var \u{1B2F9}; +var \u{1B2FA}; +var \u{1B2FB}; +var \u{2CEB0}; +var \u{2CEB1}; +var \u{2CEB2}; +var \u{2CEB3}; +var \u{2CEB4}; +var \u{2CEB5}; +var \u{2CEB6}; +var \u{2CEB7}; +var \u{2CEB8}; +var \u{2CEB9}; +var \u{2CEBA}; +var \u{2CEBB}; +var \u{2CEBC}; +var \u{2CEBD}; +var \u{2CEBE}; +var \u{2CEBF}; +var \u{2CEC0}; +var \u{2CEC1}; +var \u{2CEC2}; +var \u{2CEC3}; +var \u{2CEC4}; +var \u{2CEC5}; +var \u{2CEC6}; +var \u{2CEC7}; +var \u{2CEC8}; +var \u{2CEC9}; +var \u{2CECA}; +var \u{2CECB}; +var \u{2CECC}; +var \u{2CECD}; +var \u{2CECE}; +var \u{2CECF}; +var \u{2CED0}; +var \u{2CED1}; +var \u{2CED2}; +var \u{2CED3}; +var \u{2CED4}; +var \u{2CED5}; +var \u{2CED6}; +var \u{2CED7}; +var \u{2CED8}; +var \u{2CED9}; +var \u{2CEDA}; +var \u{2CEDB}; +var \u{2CEDC}; +var \u{2CEDD}; +var \u{2CEDE}; +var \u{2CEDF}; +var \u{2CEE0}; +var \u{2CEE1}; +var \u{2CEE2}; +var \u{2CEE3}; +var \u{2CEE4}; +var \u{2CEE5}; +var \u{2CEE6}; +var \u{2CEE7}; +var \u{2CEE8}; +var \u{2CEE9}; +var \u{2CEEA}; +var \u{2CEEB}; +var \u{2CEEC}; +var \u{2CEED}; +var \u{2CEEE}; +var \u{2CEEF}; +var \u{2CEF0}; +var \u{2CEF1}; +var \u{2CEF2}; +var \u{2CEF3}; +var \u{2CEF4}; +var \u{2CEF5}; +var \u{2CEF6}; +var \u{2CEF7}; +var \u{2CEF8}; +var \u{2CEF9}; +var \u{2CEFA}; +var \u{2CEFB}; +var \u{2CEFC}; +var \u{2CEFD}; +var \u{2CEFE}; +var \u{2CEFF}; +var \u{2CF00}; +var \u{2CF01}; +var \u{2CF02}; +var \u{2CF03}; +var \u{2CF04}; +var \u{2CF05}; +var \u{2CF06}; +var \u{2CF07}; +var \u{2CF08}; +var \u{2CF09}; +var \u{2CF0A}; +var \u{2CF0B}; +var \u{2CF0C}; +var \u{2CF0D}; +var \u{2CF0E}; +var \u{2CF0F}; +var \u{2CF10}; +var \u{2CF11}; +var \u{2CF12}; +var \u{2CF13}; +var \u{2CF14}; +var \u{2CF15}; +var \u{2CF16}; +var \u{2CF17}; +var \u{2CF18}; +var \u{2CF19}; +var \u{2CF1A}; +var \u{2CF1B}; +var \u{2CF1C}; +var \u{2CF1D}; +var \u{2CF1E}; +var \u{2CF1F}; +var \u{2CF20}; +var \u{2CF21}; +var \u{2CF22}; +var \u{2CF23}; +var \u{2CF24}; +var \u{2CF25}; +var \u{2CF26}; +var \u{2CF27}; +var \u{2CF28}; +var \u{2CF29}; +var \u{2CF2A}; +var \u{2CF2B}; +var \u{2CF2C}; +var \u{2CF2D}; +var \u{2CF2E}; +var \u{2CF2F}; +var \u{2CF30}; +var \u{2CF31}; +var \u{2CF32}; +var \u{2CF33}; +var \u{2CF34}; +var \u{2CF35}; +var \u{2CF36}; +var \u{2CF37}; +var \u{2CF38}; +var \u{2CF39}; +var \u{2CF3A}; +var \u{2CF3B}; +var \u{2CF3C}; +var \u{2CF3D}; +var \u{2CF3E}; +var \u{2CF3F}; +var \u{2CF40}; +var \u{2CF41}; +var \u{2CF42}; +var \u{2CF43}; +var \u{2CF44}; +var \u{2CF45}; +var \u{2CF46}; +var \u{2CF47}; +var \u{2CF48}; +var \u{2CF49}; +var \u{2CF4A}; +var \u{2CF4B}; +var \u{2CF4C}; +var \u{2CF4D}; +var \u{2CF4E}; +var \u{2CF4F}; +var \u{2CF50}; +var \u{2CF51}; +var \u{2CF52}; +var \u{2CF53}; +var \u{2CF54}; +var \u{2CF55}; +var \u{2CF56}; +var \u{2CF57}; +var \u{2CF58}; +var \u{2CF59}; +var \u{2CF5A}; +var \u{2CF5B}; +var \u{2CF5C}; +var \u{2CF5D}; +var \u{2CF5E}; +var \u{2CF5F}; +var \u{2CF60}; +var \u{2CF61}; +var \u{2CF62}; +var \u{2CF63}; +var \u{2CF64}; +var \u{2CF65}; +var \u{2CF66}; +var \u{2CF67}; +var \u{2CF68}; +var \u{2CF69}; +var \u{2CF6A}; +var \u{2CF6B}; +var \u{2CF6C}; +var \u{2CF6D}; +var \u{2CF6E}; +var \u{2CF6F}; +var \u{2CF70}; +var \u{2CF71}; +var \u{2CF72}; +var \u{2CF73}; +var \u{2CF74}; +var \u{2CF75}; +var \u{2CF76}; +var \u{2CF77}; +var \u{2CF78}; +var \u{2CF79}; +var \u{2CF7A}; +var \u{2CF7B}; +var \u{2CF7C}; +var \u{2CF7D}; +var \u{2CF7E}; +var \u{2CF7F}; +var \u{2CF80}; +var \u{2CF81}; +var \u{2CF82}; +var \u{2CF83}; +var \u{2CF84}; +var \u{2CF85}; +var \u{2CF86}; +var \u{2CF87}; +var \u{2CF88}; +var \u{2CF89}; +var \u{2CF8A}; +var \u{2CF8B}; +var \u{2CF8C}; +var \u{2CF8D}; +var \u{2CF8E}; +var \u{2CF8F}; +var \u{2CF90}; +var \u{2CF91}; +var \u{2CF92}; +var \u{2CF93}; +var \u{2CF94}; +var \u{2CF95}; +var \u{2CF96}; +var \u{2CF97}; +var \u{2CF98}; +var \u{2CF99}; +var \u{2CF9A}; +var \u{2CF9B}; +var \u{2CF9C}; +var \u{2CF9D}; +var \u{2CF9E}; +var \u{2CF9F}; +var \u{2CFA0}; +var \u{2CFA1}; +var \u{2CFA2}; +var \u{2CFA3}; +var \u{2CFA4}; +var \u{2CFA5}; +var \u{2CFA6}; +var \u{2CFA7}; +var \u{2CFA8}; +var \u{2CFA9}; +var \u{2CFAA}; +var \u{2CFAB}; +var \u{2CFAC}; +var \u{2CFAD}; +var \u{2CFAE}; +var \u{2CFAF}; +var \u{2CFB0}; +var \u{2CFB1}; +var \u{2CFB2}; +var \u{2CFB3}; +var \u{2CFB4}; +var \u{2CFB5}; +var \u{2CFB6}; +var \u{2CFB7}; +var \u{2CFB8}; +var \u{2CFB9}; +var \u{2CFBA}; +var \u{2CFBB}; +var \u{2CFBC}; +var \u{2CFBD}; +var \u{2CFBE}; +var \u{2CFBF}; +var \u{2CFC0}; +var \u{2CFC1}; +var \u{2CFC2}; +var \u{2CFC3}; +var \u{2CFC4}; +var \u{2CFC5}; +var \u{2CFC6}; +var \u{2CFC7}; +var \u{2CFC8}; +var \u{2CFC9}; +var \u{2CFCA}; +var \u{2CFCB}; +var \u{2CFCC}; +var \u{2CFCD}; +var \u{2CFCE}; +var \u{2CFCF}; +var \u{2CFD0}; +var \u{2CFD1}; +var \u{2CFD2}; +var \u{2CFD3}; +var \u{2CFD4}; +var \u{2CFD5}; +var \u{2CFD6}; +var \u{2CFD7}; +var \u{2CFD8}; +var \u{2CFD9}; +var \u{2CFDA}; +var \u{2CFDB}; +var \u{2CFDC}; +var \u{2CFDD}; +var \u{2CFDE}; +var \u{2CFDF}; +var \u{2CFE0}; +var \u{2CFE1}; +var \u{2CFE2}; +var \u{2CFE3}; +var \u{2CFE4}; +var \u{2CFE5}; +var \u{2CFE6}; +var \u{2CFE7}; +var \u{2CFE8}; +var \u{2CFE9}; +var \u{2CFEA}; +var \u{2CFEB}; +var \u{2CFEC}; +var \u{2CFED}; +var \u{2CFEE}; +var \u{2CFEF}; +var \u{2CFF0}; +var \u{2CFF1}; +var \u{2CFF2}; +var \u{2CFF3}; +var \u{2CFF4}; +var \u{2CFF5}; +var \u{2CFF6}; +var \u{2CFF7}; +var \u{2CFF8}; +var \u{2CFF9}; +var \u{2CFFA}; +var \u{2CFFB}; +var \u{2CFFC}; +var \u{2CFFD}; +var \u{2CFFE}; +var \u{2CFFF}; +var \u{2D000}; +var \u{2D001}; +var \u{2D002}; +var \u{2D003}; +var \u{2D004}; +var \u{2D005}; +var \u{2D006}; +var \u{2D007}; +var \u{2D008}; +var \u{2D009}; +var \u{2D00A}; +var \u{2D00B}; +var \u{2D00C}; +var \u{2D00D}; +var \u{2D00E}; +var \u{2D00F}; +var \u{2D010}; +var \u{2D011}; +var \u{2D012}; +var \u{2D013}; +var \u{2D014}; +var \u{2D015}; +var \u{2D016}; +var \u{2D017}; +var \u{2D018}; +var \u{2D019}; +var \u{2D01A}; +var \u{2D01B}; +var \u{2D01C}; +var \u{2D01D}; +var \u{2D01E}; +var \u{2D01F}; +var \u{2D020}; +var \u{2D021}; +var \u{2D022}; +var \u{2D023}; +var \u{2D024}; +var \u{2D025}; +var \u{2D026}; +var \u{2D027}; +var \u{2D028}; +var \u{2D029}; +var \u{2D02A}; +var \u{2D02B}; +var \u{2D02C}; +var \u{2D02D}; +var \u{2D02E}; +var \u{2D02F}; +var \u{2D030}; +var \u{2D031}; +var \u{2D032}; +var \u{2D033}; +var \u{2D034}; +var \u{2D035}; +var \u{2D036}; +var \u{2D037}; +var \u{2D038}; +var \u{2D039}; +var \u{2D03A}; +var \u{2D03B}; +var \u{2D03C}; +var \u{2D03D}; +var \u{2D03E}; +var \u{2D03F}; +var \u{2D040}; +var \u{2D041}; +var \u{2D042}; +var \u{2D043}; +var \u{2D044}; +var \u{2D045}; +var \u{2D046}; +var \u{2D047}; +var \u{2D048}; +var \u{2D049}; +var \u{2D04A}; +var \u{2D04B}; +var \u{2D04C}; +var \u{2D04D}; +var \u{2D04E}; +var \u{2D04F}; +var \u{2D050}; +var \u{2D051}; +var \u{2D052}; +var \u{2D053}; +var \u{2D054}; +var \u{2D055}; +var \u{2D056}; +var \u{2D057}; +var \u{2D058}; +var \u{2D059}; +var \u{2D05A}; +var \u{2D05B}; +var \u{2D05C}; +var \u{2D05D}; +var \u{2D05E}; +var \u{2D05F}; +var \u{2D060}; +var \u{2D061}; +var \u{2D062}; +var \u{2D063}; +var \u{2D064}; +var \u{2D065}; +var \u{2D066}; +var \u{2D067}; +var \u{2D068}; +var \u{2D069}; +var \u{2D06A}; +var \u{2D06B}; +var \u{2D06C}; +var \u{2D06D}; +var \u{2D06E}; +var \u{2D06F}; +var \u{2D070}; +var \u{2D071}; +var \u{2D072}; +var \u{2D073}; +var \u{2D074}; +var \u{2D075}; +var \u{2D076}; +var \u{2D077}; +var \u{2D078}; +var \u{2D079}; +var \u{2D07A}; +var \u{2D07B}; +var \u{2D07C}; +var \u{2D07D}; +var \u{2D07E}; +var \u{2D07F}; +var \u{2D080}; +var \u{2D081}; +var \u{2D082}; +var \u{2D083}; +var \u{2D084}; +var \u{2D085}; +var \u{2D086}; +var \u{2D087}; +var \u{2D088}; +var \u{2D089}; +var \u{2D08A}; +var \u{2D08B}; +var \u{2D08C}; +var \u{2D08D}; +var \u{2D08E}; +var \u{2D08F}; +var \u{2D090}; +var \u{2D091}; +var \u{2D092}; +var \u{2D093}; +var \u{2D094}; +var \u{2D095}; +var \u{2D096}; +var \u{2D097}; +var \u{2D098}; +var \u{2D099}; +var \u{2D09A}; +var \u{2D09B}; +var \u{2D09C}; +var \u{2D09D}; +var \u{2D09E}; +var \u{2D09F}; +var \u{2D0A0}; +var \u{2D0A1}; +var \u{2D0A2}; +var \u{2D0A3}; +var \u{2D0A4}; +var \u{2D0A5}; +var \u{2D0A6}; +var \u{2D0A7}; +var \u{2D0A8}; +var \u{2D0A9}; +var \u{2D0AA}; +var \u{2D0AB}; +var \u{2D0AC}; +var \u{2D0AD}; +var \u{2D0AE}; +var \u{2D0AF}; +var \u{2D0B0}; +var \u{2D0B1}; +var \u{2D0B2}; +var \u{2D0B3}; +var \u{2D0B4}; +var \u{2D0B5}; +var \u{2D0B6}; +var \u{2D0B7}; +var \u{2D0B8}; +var \u{2D0B9}; +var \u{2D0BA}; +var \u{2D0BB}; +var \u{2D0BC}; +var \u{2D0BD}; +var \u{2D0BE}; +var \u{2D0BF}; +var \u{2D0C0}; +var \u{2D0C1}; +var \u{2D0C2}; +var \u{2D0C3}; +var \u{2D0C4}; +var \u{2D0C5}; +var \u{2D0C6}; +var \u{2D0C7}; +var \u{2D0C8}; +var \u{2D0C9}; +var \u{2D0CA}; +var \u{2D0CB}; +var \u{2D0CC}; +var \u{2D0CD}; +var \u{2D0CE}; +var \u{2D0CF}; +var \u{2D0D0}; +var \u{2D0D1}; +var \u{2D0D2}; +var \u{2D0D3}; +var \u{2D0D4}; +var \u{2D0D5}; +var \u{2D0D6}; +var \u{2D0D7}; +var \u{2D0D8}; +var \u{2D0D9}; +var \u{2D0DA}; +var \u{2D0DB}; +var \u{2D0DC}; +var \u{2D0DD}; +var \u{2D0DE}; +var \u{2D0DF}; +var \u{2D0E0}; +var \u{2D0E1}; +var \u{2D0E2}; +var \u{2D0E3}; +var \u{2D0E4}; +var \u{2D0E5}; +var \u{2D0E6}; +var \u{2D0E7}; +var \u{2D0E8}; +var \u{2D0E9}; +var \u{2D0EA}; +var \u{2D0EB}; +var \u{2D0EC}; +var \u{2D0ED}; +var \u{2D0EE}; +var \u{2D0EF}; +var \u{2D0F0}; +var \u{2D0F1}; +var \u{2D0F2}; +var \u{2D0F3}; +var \u{2D0F4}; +var \u{2D0F5}; +var \u{2D0F6}; +var \u{2D0F7}; +var \u{2D0F8}; +var \u{2D0F9}; +var \u{2D0FA}; +var \u{2D0FB}; +var \u{2D0FC}; +var \u{2D0FD}; +var \u{2D0FE}; +var \u{2D0FF}; +var \u{2D100}; +var \u{2D101}; +var \u{2D102}; +var \u{2D103}; +var \u{2D104}; +var \u{2D105}; +var \u{2D106}; +var \u{2D107}; +var \u{2D108}; +var \u{2D109}; +var \u{2D10A}; +var \u{2D10B}; +var \u{2D10C}; +var \u{2D10D}; +var \u{2D10E}; +var \u{2D10F}; +var \u{2D110}; +var \u{2D111}; +var \u{2D112}; +var \u{2D113}; +var \u{2D114}; +var \u{2D115}; +var \u{2D116}; +var \u{2D117}; +var \u{2D118}; +var \u{2D119}; +var \u{2D11A}; +var \u{2D11B}; +var \u{2D11C}; +var \u{2D11D}; +var \u{2D11E}; +var \u{2D11F}; +var \u{2D120}; +var \u{2D121}; +var \u{2D122}; +var \u{2D123}; +var \u{2D124}; +var \u{2D125}; +var \u{2D126}; +var \u{2D127}; +var \u{2D128}; +var \u{2D129}; +var \u{2D12A}; +var \u{2D12B}; +var \u{2D12C}; +var \u{2D12D}; +var \u{2D12E}; +var \u{2D12F}; +var \u{2D130}; +var \u{2D131}; +var \u{2D132}; +var \u{2D133}; +var \u{2D134}; +var \u{2D135}; +var \u{2D136}; +var \u{2D137}; +var \u{2D138}; +var \u{2D139}; +var \u{2D13A}; +var \u{2D13B}; +var \u{2D13C}; +var \u{2D13D}; +var \u{2D13E}; +var \u{2D13F}; +var \u{2D140}; +var \u{2D141}; +var \u{2D142}; +var \u{2D143}; +var \u{2D144}; +var \u{2D145}; +var \u{2D146}; +var \u{2D147}; +var \u{2D148}; +var \u{2D149}; +var \u{2D14A}; +var \u{2D14B}; +var \u{2D14C}; +var \u{2D14D}; +var \u{2D14E}; +var \u{2D14F}; +var \u{2D150}; +var \u{2D151}; +var \u{2D152}; +var \u{2D153}; +var \u{2D154}; +var \u{2D155}; +var \u{2D156}; +var \u{2D157}; +var \u{2D158}; +var \u{2D159}; +var \u{2D15A}; +var \u{2D15B}; +var \u{2D15C}; +var \u{2D15D}; +var \u{2D15E}; +var \u{2D15F}; +var \u{2D160}; +var \u{2D161}; +var \u{2D162}; +var \u{2D163}; +var \u{2D164}; +var \u{2D165}; +var \u{2D166}; +var \u{2D167}; +var \u{2D168}; +var \u{2D169}; +var \u{2D16A}; +var \u{2D16B}; +var \u{2D16C}; +var \u{2D16D}; +var \u{2D16E}; +var \u{2D16F}; +var \u{2D170}; +var \u{2D171}; +var \u{2D172}; +var \u{2D173}; +var \u{2D174}; +var \u{2D175}; +var \u{2D176}; +var \u{2D177}; +var \u{2D178}; +var \u{2D179}; +var \u{2D17A}; +var \u{2D17B}; +var \u{2D17C}; +var \u{2D17D}; +var \u{2D17E}; +var \u{2D17F}; +var \u{2D180}; +var \u{2D181}; +var \u{2D182}; +var \u{2D183}; +var \u{2D184}; +var \u{2D185}; +var \u{2D186}; +var \u{2D187}; +var \u{2D188}; +var \u{2D189}; +var \u{2D18A}; +var \u{2D18B}; +var \u{2D18C}; +var \u{2D18D}; +var \u{2D18E}; +var \u{2D18F}; +var \u{2D190}; +var \u{2D191}; +var \u{2D192}; +var \u{2D193}; +var \u{2D194}; +var \u{2D195}; +var \u{2D196}; +var \u{2D197}; +var \u{2D198}; +var \u{2D199}; +var \u{2D19A}; +var \u{2D19B}; +var \u{2D19C}; +var \u{2D19D}; +var \u{2D19E}; +var \u{2D19F}; +var \u{2D1A0}; +var \u{2D1A1}; +var \u{2D1A2}; +var \u{2D1A3}; +var \u{2D1A4}; +var \u{2D1A5}; +var \u{2D1A6}; +var \u{2D1A7}; +var \u{2D1A8}; +var \u{2D1A9}; +var \u{2D1AA}; +var \u{2D1AB}; +var \u{2D1AC}; +var \u{2D1AD}; +var \u{2D1AE}; +var \u{2D1AF}; +var \u{2D1B0}; +var \u{2D1B1}; +var \u{2D1B2}; +var \u{2D1B3}; +var \u{2D1B4}; +var \u{2D1B5}; +var \u{2D1B6}; +var \u{2D1B7}; +var \u{2D1B8}; +var \u{2D1B9}; +var \u{2D1BA}; +var \u{2D1BB}; +var \u{2D1BC}; +var \u{2D1BD}; +var \u{2D1BE}; +var \u{2D1BF}; +var \u{2D1C0}; +var \u{2D1C1}; +var \u{2D1C2}; +var \u{2D1C3}; +var \u{2D1C4}; +var \u{2D1C5}; +var \u{2D1C6}; +var \u{2D1C7}; +var \u{2D1C8}; +var \u{2D1C9}; +var \u{2D1CA}; +var \u{2D1CB}; +var \u{2D1CC}; +var \u{2D1CD}; +var \u{2D1CE}; +var \u{2D1CF}; +var \u{2D1D0}; +var \u{2D1D1}; +var \u{2D1D2}; +var \u{2D1D3}; +var \u{2D1D4}; +var \u{2D1D5}; +var \u{2D1D6}; +var \u{2D1D7}; +var \u{2D1D8}; +var \u{2D1D9}; +var \u{2D1DA}; +var \u{2D1DB}; +var \u{2D1DC}; +var \u{2D1DD}; +var \u{2D1DE}; +var \u{2D1DF}; +var \u{2D1E0}; +var \u{2D1E1}; +var \u{2D1E2}; +var \u{2D1E3}; +var \u{2D1E4}; +var \u{2D1E5}; +var \u{2D1E6}; +var \u{2D1E7}; +var \u{2D1E8}; +var \u{2D1E9}; +var \u{2D1EA}; +var \u{2D1EB}; +var \u{2D1EC}; +var \u{2D1ED}; +var \u{2D1EE}; +var \u{2D1EF}; +var \u{2D1F0}; +var \u{2D1F1}; +var \u{2D1F2}; +var \u{2D1F3}; +var \u{2D1F4}; +var \u{2D1F5}; +var \u{2D1F6}; +var \u{2D1F7}; +var \u{2D1F8}; +var \u{2D1F9}; +var \u{2D1FA}; +var \u{2D1FB}; +var \u{2D1FC}; +var \u{2D1FD}; +var \u{2D1FE}; +var \u{2D1FF}; +var \u{2D200}; +var \u{2D201}; +var \u{2D202}; +var \u{2D203}; +var \u{2D204}; +var \u{2D205}; +var \u{2D206}; +var \u{2D207}; +var \u{2D208}; +var \u{2D209}; +var \u{2D20A}; +var \u{2D20B}; +var \u{2D20C}; +var \u{2D20D}; +var \u{2D20E}; +var \u{2D20F}; +var \u{2D210}; +var \u{2D211}; +var \u{2D212}; +var \u{2D213}; +var \u{2D214}; +var \u{2D215}; +var \u{2D216}; +var \u{2D217}; +var \u{2D218}; +var \u{2D219}; +var \u{2D21A}; +var \u{2D21B}; +var \u{2D21C}; +var \u{2D21D}; +var \u{2D21E}; +var \u{2D21F}; +var \u{2D220}; +var \u{2D221}; +var \u{2D222}; +var \u{2D223}; +var \u{2D224}; +var \u{2D225}; +var \u{2D226}; +var \u{2D227}; +var \u{2D228}; +var \u{2D229}; +var \u{2D22A}; +var \u{2D22B}; +var \u{2D22C}; +var \u{2D22D}; +var \u{2D22E}; +var \u{2D22F}; +var \u{2D230}; +var \u{2D231}; +var \u{2D232}; +var \u{2D233}; +var \u{2D234}; +var \u{2D235}; +var \u{2D236}; +var \u{2D237}; +var \u{2D238}; +var \u{2D239}; +var \u{2D23A}; +var \u{2D23B}; +var \u{2D23C}; +var \u{2D23D}; +var \u{2D23E}; +var \u{2D23F}; +var \u{2D240}; +var \u{2D241}; +var \u{2D242}; +var \u{2D243}; +var \u{2D244}; +var \u{2D245}; +var \u{2D246}; +var \u{2D247}; +var \u{2D248}; +var \u{2D249}; +var \u{2D24A}; +var \u{2D24B}; +var \u{2D24C}; +var \u{2D24D}; +var \u{2D24E}; +var \u{2D24F}; +var \u{2D250}; +var \u{2D251}; +var \u{2D252}; +var \u{2D253}; +var \u{2D254}; +var \u{2D255}; +var \u{2D256}; +var \u{2D257}; +var \u{2D258}; +var \u{2D259}; +var \u{2D25A}; +var \u{2D25B}; +var \u{2D25C}; +var \u{2D25D}; +var \u{2D25E}; +var \u{2D25F}; +var \u{2D260}; +var \u{2D261}; +var \u{2D262}; +var \u{2D263}; +var \u{2D264}; +var \u{2D265}; +var \u{2D266}; +var \u{2D267}; +var \u{2D268}; +var \u{2D269}; +var \u{2D26A}; +var \u{2D26B}; +var \u{2D26C}; +var \u{2D26D}; +var \u{2D26E}; +var \u{2D26F}; +var \u{2D270}; +var \u{2D271}; +var \u{2D272}; +var \u{2D273}; +var \u{2D274}; +var \u{2D275}; +var \u{2D276}; +var \u{2D277}; +var \u{2D278}; +var \u{2D279}; +var \u{2D27A}; +var \u{2D27B}; +var \u{2D27C}; +var \u{2D27D}; +var \u{2D27E}; +var \u{2D27F}; +var \u{2D280}; +var \u{2D281}; +var \u{2D282}; +var \u{2D283}; +var \u{2D284}; +var \u{2D285}; +var \u{2D286}; +var \u{2D287}; +var \u{2D288}; +var \u{2D289}; +var \u{2D28A}; +var \u{2D28B}; +var \u{2D28C}; +var \u{2D28D}; +var \u{2D28E}; +var \u{2D28F}; +var \u{2D290}; +var \u{2D291}; +var \u{2D292}; +var \u{2D293}; +var \u{2D294}; +var \u{2D295}; +var \u{2D296}; +var \u{2D297}; +var \u{2D298}; +var \u{2D299}; +var \u{2D29A}; +var \u{2D29B}; +var \u{2D29C}; +var \u{2D29D}; +var \u{2D29E}; +var \u{2D29F}; +var \u{2D2A0}; +var \u{2D2A1}; +var \u{2D2A2}; +var \u{2D2A3}; +var \u{2D2A4}; +var \u{2D2A5}; +var \u{2D2A6}; +var \u{2D2A7}; +var \u{2D2A8}; +var \u{2D2A9}; +var \u{2D2AA}; +var \u{2D2AB}; +var \u{2D2AC}; +var \u{2D2AD}; +var \u{2D2AE}; +var \u{2D2AF}; +var \u{2D2B0}; +var \u{2D2B1}; +var \u{2D2B2}; +var \u{2D2B3}; +var \u{2D2B4}; +var \u{2D2B5}; +var \u{2D2B6}; +var \u{2D2B7}; +var \u{2D2B8}; +var \u{2D2B9}; +var \u{2D2BA}; +var \u{2D2BB}; +var \u{2D2BC}; +var \u{2D2BD}; +var \u{2D2BE}; +var \u{2D2BF}; +var \u{2D2C0}; +var \u{2D2C1}; +var \u{2D2C2}; +var \u{2D2C3}; +var \u{2D2C4}; +var \u{2D2C5}; +var \u{2D2C6}; +var \u{2D2C7}; +var \u{2D2C8}; +var \u{2D2C9}; +var \u{2D2CA}; +var \u{2D2CB}; +var \u{2D2CC}; +var \u{2D2CD}; +var \u{2D2CE}; +var \u{2D2CF}; +var \u{2D2D0}; +var \u{2D2D1}; +var \u{2D2D2}; +var \u{2D2D3}; +var \u{2D2D4}; +var \u{2D2D5}; +var \u{2D2D6}; +var \u{2D2D7}; +var \u{2D2D8}; +var \u{2D2D9}; +var \u{2D2DA}; +var \u{2D2DB}; +var \u{2D2DC}; +var \u{2D2DD}; +var \u{2D2DE}; +var \u{2D2DF}; +var \u{2D2E0}; +var \u{2D2E1}; +var \u{2D2E2}; +var \u{2D2E3}; +var \u{2D2E4}; +var \u{2D2E5}; +var \u{2D2E6}; +var \u{2D2E7}; +var \u{2D2E8}; +var \u{2D2E9}; +var \u{2D2EA}; +var \u{2D2EB}; +var \u{2D2EC}; +var \u{2D2ED}; +var \u{2D2EE}; +var \u{2D2EF}; +var \u{2D2F0}; +var \u{2D2F1}; +var \u{2D2F2}; +var \u{2D2F3}; +var \u{2D2F4}; +var \u{2D2F5}; +var \u{2D2F6}; +var \u{2D2F7}; +var \u{2D2F8}; +var \u{2D2F9}; +var \u{2D2FA}; +var \u{2D2FB}; +var \u{2D2FC}; +var \u{2D2FD}; +var \u{2D2FE}; +var \u{2D2FF}; +var \u{2D300}; +var \u{2D301}; +var \u{2D302}; +var \u{2D303}; +var \u{2D304}; +var \u{2D305}; +var \u{2D306}; +var \u{2D307}; +var \u{2D308}; +var \u{2D309}; +var \u{2D30A}; +var \u{2D30B}; +var \u{2D30C}; +var \u{2D30D}; +var \u{2D30E}; +var \u{2D30F}; +var \u{2D310}; +var \u{2D311}; +var \u{2D312}; +var \u{2D313}; +var \u{2D314}; +var \u{2D315}; +var \u{2D316}; +var \u{2D317}; +var \u{2D318}; +var \u{2D319}; +var \u{2D31A}; +var \u{2D31B}; +var \u{2D31C}; +var \u{2D31D}; +var \u{2D31E}; +var \u{2D31F}; +var \u{2D320}; +var \u{2D321}; +var \u{2D322}; +var \u{2D323}; +var \u{2D324}; +var \u{2D325}; +var \u{2D326}; +var \u{2D327}; +var \u{2D328}; +var \u{2D329}; +var \u{2D32A}; +var \u{2D32B}; +var \u{2D32C}; +var \u{2D32D}; +var \u{2D32E}; +var \u{2D32F}; +var \u{2D330}; +var \u{2D331}; +var \u{2D332}; +var \u{2D333}; +var \u{2D334}; +var \u{2D335}; +var \u{2D336}; +var \u{2D337}; +var \u{2D338}; +var \u{2D339}; +var \u{2D33A}; +var \u{2D33B}; +var \u{2D33C}; +var \u{2D33D}; +var \u{2D33E}; +var \u{2D33F}; +var \u{2D340}; +var \u{2D341}; +var \u{2D342}; +var \u{2D343}; +var \u{2D344}; +var \u{2D345}; +var \u{2D346}; +var \u{2D347}; +var \u{2D348}; +var \u{2D349}; +var \u{2D34A}; +var \u{2D34B}; +var \u{2D34C}; +var \u{2D34D}; +var \u{2D34E}; +var \u{2D34F}; +var \u{2D350}; +var \u{2D351}; +var \u{2D352}; +var \u{2D353}; +var \u{2D354}; +var \u{2D355}; +var \u{2D356}; +var \u{2D357}; +var \u{2D358}; +var \u{2D359}; +var \u{2D35A}; +var \u{2D35B}; +var \u{2D35C}; +var \u{2D35D}; +var \u{2D35E}; +var \u{2D35F}; +var \u{2D360}; +var \u{2D361}; +var \u{2D362}; +var \u{2D363}; +var \u{2D364}; +var \u{2D365}; +var \u{2D366}; +var \u{2D367}; +var \u{2D368}; +var \u{2D369}; +var \u{2D36A}; +var \u{2D36B}; +var \u{2D36C}; +var \u{2D36D}; +var \u{2D36E}; +var \u{2D36F}; +var \u{2D370}; +var \u{2D371}; +var \u{2D372}; +var \u{2D373}; +var \u{2D374}; +var \u{2D375}; +var \u{2D376}; +var \u{2D377}; +var \u{2D378}; +var \u{2D379}; +var \u{2D37A}; +var \u{2D37B}; +var \u{2D37C}; +var \u{2D37D}; +var \u{2D37E}; +var \u{2D37F}; +var \u{2D380}; +var \u{2D381}; +var \u{2D382}; +var \u{2D383}; +var \u{2D384}; +var \u{2D385}; +var \u{2D386}; +var \u{2D387}; +var \u{2D388}; +var \u{2D389}; +var \u{2D38A}; +var \u{2D38B}; +var \u{2D38C}; +var \u{2D38D}; +var \u{2D38E}; +var \u{2D38F}; +var \u{2D390}; +var \u{2D391}; +var \u{2D392}; +var \u{2D393}; +var \u{2D394}; +var \u{2D395}; +var \u{2D396}; +var \u{2D397}; +var \u{2D398}; +var \u{2D399}; +var \u{2D39A}; +var \u{2D39B}; +var \u{2D39C}; +var \u{2D39D}; +var \u{2D39E}; +var \u{2D39F}; +var \u{2D3A0}; +var \u{2D3A1}; +var \u{2D3A2}; +var \u{2D3A3}; +var \u{2D3A4}; +var \u{2D3A5}; +var \u{2D3A6}; +var \u{2D3A7}; +var \u{2D3A8}; +var \u{2D3A9}; +var \u{2D3AA}; +var \u{2D3AB}; +var \u{2D3AC}; +var \u{2D3AD}; +var \u{2D3AE}; +var \u{2D3AF}; +var \u{2D3B0}; +var \u{2D3B1}; +var \u{2D3B2}; +var \u{2D3B3}; +var \u{2D3B4}; +var \u{2D3B5}; +var \u{2D3B6}; +var \u{2D3B7}; +var \u{2D3B8}; +var \u{2D3B9}; +var \u{2D3BA}; +var \u{2D3BB}; +var \u{2D3BC}; +var \u{2D3BD}; +var \u{2D3BE}; +var \u{2D3BF}; +var \u{2D3C0}; +var \u{2D3C1}; +var \u{2D3C2}; +var \u{2D3C3}; +var \u{2D3C4}; +var \u{2D3C5}; +var \u{2D3C6}; +var \u{2D3C7}; +var \u{2D3C8}; +var \u{2D3C9}; +var \u{2D3CA}; +var \u{2D3CB}; +var \u{2D3CC}; +var \u{2D3CD}; +var \u{2D3CE}; +var \u{2D3CF}; +var \u{2D3D0}; +var \u{2D3D1}; +var \u{2D3D2}; +var \u{2D3D3}; +var \u{2D3D4}; +var \u{2D3D5}; +var \u{2D3D6}; +var \u{2D3D7}; +var \u{2D3D8}; +var \u{2D3D9}; +var \u{2D3DA}; +var \u{2D3DB}; +var \u{2D3DC}; +var \u{2D3DD}; +var \u{2D3DE}; +var \u{2D3DF}; +var \u{2D3E0}; +var \u{2D3E1}; +var \u{2D3E2}; +var \u{2D3E3}; +var \u{2D3E4}; +var \u{2D3E5}; +var \u{2D3E6}; +var \u{2D3E7}; +var \u{2D3E8}; +var \u{2D3E9}; +var \u{2D3EA}; +var \u{2D3EB}; +var \u{2D3EC}; +var \u{2D3ED}; +var \u{2D3EE}; +var \u{2D3EF}; +var \u{2D3F0}; +var \u{2D3F1}; +var \u{2D3F2}; +var \u{2D3F3}; +var \u{2D3F4}; +var \u{2D3F5}; +var \u{2D3F6}; +var \u{2D3F7}; +var \u{2D3F8}; +var \u{2D3F9}; +var \u{2D3FA}; +var \u{2D3FB}; +var \u{2D3FC}; +var \u{2D3FD}; +var \u{2D3FE}; +var \u{2D3FF}; +var \u{2D400}; +var \u{2D401}; +var \u{2D402}; +var \u{2D403}; +var \u{2D404}; +var \u{2D405}; +var \u{2D406}; +var \u{2D407}; +var \u{2D408}; +var \u{2D409}; +var \u{2D40A}; +var \u{2D40B}; +var \u{2D40C}; +var \u{2D40D}; +var \u{2D40E}; +var \u{2D40F}; +var \u{2D410}; +var \u{2D411}; +var \u{2D412}; +var \u{2D413}; +var \u{2D414}; +var \u{2D415}; +var \u{2D416}; +var \u{2D417}; +var \u{2D418}; +var \u{2D419}; +var \u{2D41A}; +var \u{2D41B}; +var \u{2D41C}; +var \u{2D41D}; +var \u{2D41E}; +var \u{2D41F}; +var \u{2D420}; +var \u{2D421}; +var \u{2D422}; +var \u{2D423}; +var \u{2D424}; +var \u{2D425}; +var \u{2D426}; +var \u{2D427}; +var \u{2D428}; +var \u{2D429}; +var \u{2D42A}; +var \u{2D42B}; +var \u{2D42C}; +var \u{2D42D}; +var \u{2D42E}; +var \u{2D42F}; +var \u{2D430}; +var \u{2D431}; +var \u{2D432}; +var \u{2D433}; +var \u{2D434}; +var \u{2D435}; +var \u{2D436}; +var \u{2D437}; +var \u{2D438}; +var \u{2D439}; +var \u{2D43A}; +var \u{2D43B}; +var \u{2D43C}; +var \u{2D43D}; +var \u{2D43E}; +var \u{2D43F}; +var \u{2D440}; +var \u{2D441}; +var \u{2D442}; +var \u{2D443}; +var \u{2D444}; +var \u{2D445}; +var \u{2D446}; +var \u{2D447}; +var \u{2D448}; +var \u{2D449}; +var \u{2D44A}; +var \u{2D44B}; +var \u{2D44C}; +var \u{2D44D}; +var \u{2D44E}; +var \u{2D44F}; +var \u{2D450}; +var \u{2D451}; +var \u{2D452}; +var \u{2D453}; +var \u{2D454}; +var \u{2D455}; +var \u{2D456}; +var \u{2D457}; +var \u{2D458}; +var \u{2D459}; +var \u{2D45A}; +var \u{2D45B}; +var \u{2D45C}; +var \u{2D45D}; +var \u{2D45E}; +var \u{2D45F}; +var \u{2D460}; +var \u{2D461}; +var \u{2D462}; +var \u{2D463}; +var \u{2D464}; +var \u{2D465}; +var \u{2D466}; +var \u{2D467}; +var \u{2D468}; +var \u{2D469}; +var \u{2D46A}; +var \u{2D46B}; +var \u{2D46C}; +var \u{2D46D}; +var \u{2D46E}; +var \u{2D46F}; +var \u{2D470}; +var \u{2D471}; +var \u{2D472}; +var \u{2D473}; +var \u{2D474}; +var \u{2D475}; +var \u{2D476}; +var \u{2D477}; +var \u{2D478}; +var \u{2D479}; +var \u{2D47A}; +var \u{2D47B}; +var \u{2D47C}; +var \u{2D47D}; +var \u{2D47E}; +var \u{2D47F}; +var \u{2D480}; +var \u{2D481}; +var \u{2D482}; +var \u{2D483}; +var \u{2D484}; +var \u{2D485}; +var \u{2D486}; +var \u{2D487}; +var \u{2D488}; +var \u{2D489}; +var \u{2D48A}; +var \u{2D48B}; +var \u{2D48C}; +var \u{2D48D}; +var \u{2D48E}; +var \u{2D48F}; +var \u{2D490}; +var \u{2D491}; +var \u{2D492}; +var \u{2D493}; +var \u{2D494}; +var \u{2D495}; +var \u{2D496}; +var \u{2D497}; +var \u{2D498}; +var \u{2D499}; +var \u{2D49A}; +var \u{2D49B}; +var \u{2D49C}; +var \u{2D49D}; +var \u{2D49E}; +var \u{2D49F}; +var \u{2D4A0}; +var \u{2D4A1}; +var \u{2D4A2}; +var \u{2D4A3}; +var \u{2D4A4}; +var \u{2D4A5}; +var \u{2D4A6}; +var \u{2D4A7}; +var \u{2D4A8}; +var \u{2D4A9}; +var \u{2D4AA}; +var \u{2D4AB}; +var \u{2D4AC}; +var \u{2D4AD}; +var \u{2D4AE}; +var \u{2D4AF}; +var \u{2D4B0}; +var \u{2D4B1}; +var \u{2D4B2}; +var \u{2D4B3}; +var \u{2D4B4}; +var \u{2D4B5}; +var \u{2D4B6}; +var \u{2D4B7}; +var \u{2D4B8}; +var \u{2D4B9}; +var \u{2D4BA}; +var \u{2D4BB}; +var \u{2D4BC}; +var \u{2D4BD}; +var \u{2D4BE}; +var \u{2D4BF}; +var \u{2D4C0}; +var \u{2D4C1}; +var \u{2D4C2}; +var \u{2D4C3}; +var \u{2D4C4}; +var \u{2D4C5}; +var \u{2D4C6}; +var \u{2D4C7}; +var \u{2D4C8}; +var \u{2D4C9}; +var \u{2D4CA}; +var \u{2D4CB}; +var \u{2D4CC}; +var \u{2D4CD}; +var \u{2D4CE}; +var \u{2D4CF}; +var \u{2D4D0}; +var \u{2D4D1}; +var \u{2D4D2}; +var \u{2D4D3}; +var \u{2D4D4}; +var \u{2D4D5}; +var \u{2D4D6}; +var \u{2D4D7}; +var \u{2D4D8}; +var \u{2D4D9}; +var \u{2D4DA}; +var \u{2D4DB}; +var \u{2D4DC}; +var \u{2D4DD}; +var \u{2D4DE}; +var \u{2D4DF}; +var \u{2D4E0}; +var \u{2D4E1}; +var \u{2D4E2}; +var \u{2D4E3}; +var \u{2D4E4}; +var \u{2D4E5}; +var \u{2D4E6}; +var \u{2D4E7}; +var \u{2D4E8}; +var \u{2D4E9}; +var \u{2D4EA}; +var \u{2D4EB}; +var \u{2D4EC}; +var \u{2D4ED}; +var \u{2D4EE}; +var \u{2D4EF}; +var \u{2D4F0}; +var \u{2D4F1}; +var \u{2D4F2}; +var \u{2D4F3}; +var \u{2D4F4}; +var \u{2D4F5}; +var \u{2D4F6}; +var \u{2D4F7}; +var \u{2D4F8}; +var \u{2D4F9}; +var \u{2D4FA}; +var \u{2D4FB}; +var \u{2D4FC}; +var \u{2D4FD}; +var \u{2D4FE}; +var \u{2D4FF}; +var \u{2D500}; +var \u{2D501}; +var \u{2D502}; +var \u{2D503}; +var \u{2D504}; +var \u{2D505}; +var \u{2D506}; +var \u{2D507}; +var \u{2D508}; +var \u{2D509}; +var \u{2D50A}; +var \u{2D50B}; +var \u{2D50C}; +var \u{2D50D}; +var \u{2D50E}; +var \u{2D50F}; +var \u{2D510}; +var \u{2D511}; +var \u{2D512}; +var \u{2D513}; +var \u{2D514}; +var \u{2D515}; +var \u{2D516}; +var \u{2D517}; +var \u{2D518}; +var \u{2D519}; +var \u{2D51A}; +var \u{2D51B}; +var \u{2D51C}; +var \u{2D51D}; +var \u{2D51E}; +var \u{2D51F}; +var \u{2D520}; +var \u{2D521}; +var \u{2D522}; +var \u{2D523}; +var \u{2D524}; +var \u{2D525}; +var \u{2D526}; +var \u{2D527}; +var \u{2D528}; +var \u{2D529}; +var \u{2D52A}; +var \u{2D52B}; +var \u{2D52C}; +var \u{2D52D}; +var \u{2D52E}; +var \u{2D52F}; +var \u{2D530}; +var \u{2D531}; +var \u{2D532}; +var \u{2D533}; +var \u{2D534}; +var \u{2D535}; +var \u{2D536}; +var \u{2D537}; +var \u{2D538}; +var \u{2D539}; +var \u{2D53A}; +var \u{2D53B}; +var \u{2D53C}; +var \u{2D53D}; +var \u{2D53E}; +var \u{2D53F}; +var \u{2D540}; +var \u{2D541}; +var \u{2D542}; +var \u{2D543}; +var \u{2D544}; +var \u{2D545}; +var \u{2D546}; +var \u{2D547}; +var \u{2D548}; +var \u{2D549}; +var \u{2D54A}; +var \u{2D54B}; +var \u{2D54C}; +var \u{2D54D}; +var \u{2D54E}; +var \u{2D54F}; +var \u{2D550}; +var \u{2D551}; +var \u{2D552}; +var \u{2D553}; +var \u{2D554}; +var \u{2D555}; +var \u{2D556}; +var \u{2D557}; +var \u{2D558}; +var \u{2D559}; +var \u{2D55A}; +var \u{2D55B}; +var \u{2D55C}; +var \u{2D55D}; +var \u{2D55E}; +var \u{2D55F}; +var \u{2D560}; +var \u{2D561}; +var \u{2D562}; +var \u{2D563}; +var \u{2D564}; +var \u{2D565}; +var \u{2D566}; +var \u{2D567}; +var \u{2D568}; +var \u{2D569}; +var \u{2D56A}; +var \u{2D56B}; +var \u{2D56C}; +var \u{2D56D}; +var \u{2D56E}; +var \u{2D56F}; +var \u{2D570}; +var \u{2D571}; +var \u{2D572}; +var \u{2D573}; +var \u{2D574}; +var \u{2D575}; +var \u{2D576}; +var \u{2D577}; +var \u{2D578}; +var \u{2D579}; +var \u{2D57A}; +var \u{2D57B}; +var \u{2D57C}; +var \u{2D57D}; +var \u{2D57E}; +var \u{2D57F}; +var \u{2D580}; +var \u{2D581}; +var \u{2D582}; +var \u{2D583}; +var \u{2D584}; +var \u{2D585}; +var \u{2D586}; +var \u{2D587}; +var \u{2D588}; +var \u{2D589}; +var \u{2D58A}; +var \u{2D58B}; +var \u{2D58C}; +var \u{2D58D}; +var \u{2D58E}; +var \u{2D58F}; +var \u{2D590}; +var \u{2D591}; +var \u{2D592}; +var \u{2D593}; +var \u{2D594}; +var \u{2D595}; +var \u{2D596}; +var \u{2D597}; +var \u{2D598}; +var \u{2D599}; +var \u{2D59A}; +var \u{2D59B}; +var \u{2D59C}; +var \u{2D59D}; +var \u{2D59E}; +var \u{2D59F}; +var \u{2D5A0}; +var \u{2D5A1}; +var \u{2D5A2}; +var \u{2D5A3}; +var \u{2D5A4}; +var \u{2D5A5}; +var \u{2D5A6}; +var \u{2D5A7}; +var \u{2D5A8}; +var \u{2D5A9}; +var \u{2D5AA}; +var \u{2D5AB}; +var \u{2D5AC}; +var \u{2D5AD}; +var \u{2D5AE}; +var \u{2D5AF}; +var \u{2D5B0}; +var \u{2D5B1}; +var \u{2D5B2}; +var \u{2D5B3}; +var \u{2D5B4}; +var \u{2D5B5}; +var \u{2D5B6}; +var \u{2D5B7}; +var \u{2D5B8}; +var \u{2D5B9}; +var \u{2D5BA}; +var \u{2D5BB}; +var \u{2D5BC}; +var \u{2D5BD}; +var \u{2D5BE}; +var \u{2D5BF}; +var \u{2D5C0}; +var \u{2D5C1}; +var \u{2D5C2}; +var \u{2D5C3}; +var \u{2D5C4}; +var \u{2D5C5}; +var \u{2D5C6}; +var \u{2D5C7}; +var \u{2D5C8}; +var \u{2D5C9}; +var \u{2D5CA}; +var \u{2D5CB}; +var \u{2D5CC}; +var \u{2D5CD}; +var \u{2D5CE}; +var \u{2D5CF}; +var \u{2D5D0}; +var \u{2D5D1}; +var \u{2D5D2}; +var \u{2D5D3}; +var \u{2D5D4}; +var \u{2D5D5}; +var \u{2D5D6}; +var \u{2D5D7}; +var \u{2D5D8}; +var \u{2D5D9}; +var \u{2D5DA}; +var \u{2D5DB}; +var \u{2D5DC}; +var \u{2D5DD}; +var \u{2D5DE}; +var \u{2D5DF}; +var \u{2D5E0}; +var \u{2D5E1}; +var \u{2D5E2}; +var \u{2D5E3}; +var \u{2D5E4}; +var \u{2D5E5}; +var \u{2D5E6}; +var \u{2D5E7}; +var \u{2D5E8}; +var \u{2D5E9}; +var \u{2D5EA}; +var \u{2D5EB}; +var \u{2D5EC}; +var \u{2D5ED}; +var \u{2D5EE}; +var \u{2D5EF}; +var \u{2D5F0}; +var \u{2D5F1}; +var \u{2D5F2}; +var \u{2D5F3}; +var \u{2D5F4}; +var \u{2D5F5}; +var \u{2D5F6}; +var \u{2D5F7}; +var \u{2D5F8}; +var \u{2D5F9}; +var \u{2D5FA}; +var \u{2D5FB}; +var \u{2D5FC}; +var \u{2D5FD}; +var \u{2D5FE}; +var \u{2D5FF}; +var \u{2D600}; +var \u{2D601}; +var \u{2D602}; +var \u{2D603}; +var \u{2D604}; +var \u{2D605}; +var \u{2D606}; +var \u{2D607}; +var \u{2D608}; +var \u{2D609}; +var \u{2D60A}; +var \u{2D60B}; +var \u{2D60C}; +var \u{2D60D}; +var \u{2D60E}; +var \u{2D60F}; +var \u{2D610}; +var \u{2D611}; +var \u{2D612}; +var \u{2D613}; +var \u{2D614}; +var \u{2D615}; +var \u{2D616}; +var \u{2D617}; +var \u{2D618}; +var \u{2D619}; +var \u{2D61A}; +var \u{2D61B}; +var \u{2D61C}; +var \u{2D61D}; +var \u{2D61E}; +var \u{2D61F}; +var \u{2D620}; +var \u{2D621}; +var \u{2D622}; +var \u{2D623}; +var \u{2D624}; +var \u{2D625}; +var \u{2D626}; +var \u{2D627}; +var \u{2D628}; +var \u{2D629}; +var \u{2D62A}; +var \u{2D62B}; +var \u{2D62C}; +var \u{2D62D}; +var \u{2D62E}; +var \u{2D62F}; +var \u{2D630}; +var \u{2D631}; +var \u{2D632}; +var \u{2D633}; +var \u{2D634}; +var \u{2D635}; +var \u{2D636}; +var \u{2D637}; +var \u{2D638}; +var \u{2D639}; +var \u{2D63A}; +var \u{2D63B}; +var \u{2D63C}; +var \u{2D63D}; +var \u{2D63E}; +var \u{2D63F}; +var \u{2D640}; +var \u{2D641}; +var \u{2D642}; +var \u{2D643}; +var \u{2D644}; +var \u{2D645}; +var \u{2D646}; +var \u{2D647}; +var \u{2D648}; +var \u{2D649}; +var \u{2D64A}; +var \u{2D64B}; +var \u{2D64C}; +var \u{2D64D}; +var \u{2D64E}; +var \u{2D64F}; +var \u{2D650}; +var \u{2D651}; +var \u{2D652}; +var \u{2D653}; +var \u{2D654}; +var \u{2D655}; +var \u{2D656}; +var \u{2D657}; +var \u{2D658}; +var \u{2D659}; +var \u{2D65A}; +var \u{2D65B}; +var \u{2D65C}; +var \u{2D65D}; +var \u{2D65E}; +var \u{2D65F}; +var \u{2D660}; +var \u{2D661}; +var \u{2D662}; +var \u{2D663}; +var \u{2D664}; +var \u{2D665}; +var \u{2D666}; +var \u{2D667}; +var \u{2D668}; +var \u{2D669}; +var \u{2D66A}; +var \u{2D66B}; +var \u{2D66C}; +var \u{2D66D}; +var \u{2D66E}; +var \u{2D66F}; +var \u{2D670}; +var \u{2D671}; +var \u{2D672}; +var \u{2D673}; +var \u{2D674}; +var \u{2D675}; +var \u{2D676}; +var \u{2D677}; +var \u{2D678}; +var \u{2D679}; +var \u{2D67A}; +var \u{2D67B}; +var \u{2D67C}; +var \u{2D67D}; +var \u{2D67E}; +var \u{2D67F}; +var \u{2D680}; +var \u{2D681}; +var \u{2D682}; +var \u{2D683}; +var \u{2D684}; +var \u{2D685}; +var \u{2D686}; +var \u{2D687}; +var \u{2D688}; +var \u{2D689}; +var \u{2D68A}; +var \u{2D68B}; +var \u{2D68C}; +var \u{2D68D}; +var \u{2D68E}; +var \u{2D68F}; +var \u{2D690}; +var \u{2D691}; +var \u{2D692}; +var \u{2D693}; +var \u{2D694}; +var \u{2D695}; +var \u{2D696}; +var \u{2D697}; +var \u{2D698}; +var \u{2D699}; +var \u{2D69A}; +var \u{2D69B}; +var \u{2D69C}; +var \u{2D69D}; +var \u{2D69E}; +var \u{2D69F}; +var \u{2D6A0}; +var \u{2D6A1}; +var \u{2D6A2}; +var \u{2D6A3}; +var \u{2D6A4}; +var \u{2D6A5}; +var \u{2D6A6}; +var \u{2D6A7}; +var \u{2D6A8}; +var \u{2D6A9}; +var \u{2D6AA}; +var \u{2D6AB}; +var \u{2D6AC}; +var \u{2D6AD}; +var \u{2D6AE}; +var \u{2D6AF}; +var \u{2D6B0}; +var \u{2D6B1}; +var \u{2D6B2}; +var \u{2D6B3}; +var \u{2D6B4}; +var \u{2D6B5}; +var \u{2D6B6}; +var \u{2D6B7}; +var \u{2D6B8}; +var \u{2D6B9}; +var \u{2D6BA}; +var \u{2D6BB}; +var \u{2D6BC}; +var \u{2D6BD}; +var \u{2D6BE}; +var \u{2D6BF}; +var \u{2D6C0}; +var \u{2D6C1}; +var \u{2D6C2}; +var \u{2D6C3}; +var \u{2D6C4}; +var \u{2D6C5}; +var \u{2D6C6}; +var \u{2D6C7}; +var \u{2D6C8}; +var \u{2D6C9}; +var \u{2D6CA}; +var \u{2D6CB}; +var \u{2D6CC}; +var \u{2D6CD}; +var \u{2D6CE}; +var \u{2D6CF}; +var \u{2D6D0}; +var \u{2D6D1}; +var \u{2D6D2}; +var \u{2D6D3}; +var \u{2D6D4}; +var \u{2D6D5}; +var \u{2D6D6}; +var \u{2D6D7}; +var \u{2D6D8}; +var \u{2D6D9}; +var \u{2D6DA}; +var \u{2D6DB}; +var \u{2D6DC}; +var \u{2D6DD}; +var \u{2D6DE}; +var \u{2D6DF}; +var \u{2D6E0}; +var \u{2D6E1}; +var \u{2D6E2}; +var \u{2D6E3}; +var \u{2D6E4}; +var \u{2D6E5}; +var \u{2D6E6}; +var \u{2D6E7}; +var \u{2D6E8}; +var \u{2D6E9}; +var \u{2D6EA}; +var \u{2D6EB}; +var \u{2D6EC}; +var \u{2D6ED}; +var \u{2D6EE}; +var \u{2D6EF}; +var \u{2D6F0}; +var \u{2D6F1}; +var \u{2D6F2}; +var \u{2D6F3}; +var \u{2D6F4}; +var \u{2D6F5}; +var \u{2D6F6}; +var \u{2D6F7}; +var \u{2D6F8}; +var \u{2D6F9}; +var \u{2D6FA}; +var \u{2D6FB}; +var \u{2D6FC}; +var \u{2D6FD}; +var \u{2D6FE}; +var \u{2D6FF}; +var \u{2D700}; +var \u{2D701}; +var \u{2D702}; +var \u{2D703}; +var \u{2D704}; +var \u{2D705}; +var \u{2D706}; +var \u{2D707}; +var \u{2D708}; +var \u{2D709}; +var \u{2D70A}; +var \u{2D70B}; +var \u{2D70C}; +var \u{2D70D}; +var \u{2D70E}; +var \u{2D70F}; +var \u{2D710}; +var \u{2D711}; +var \u{2D712}; +var \u{2D713}; +var \u{2D714}; +var \u{2D715}; +var \u{2D716}; +var \u{2D717}; +var \u{2D718}; +var \u{2D719}; +var \u{2D71A}; +var \u{2D71B}; +var \u{2D71C}; +var \u{2D71D}; +var \u{2D71E}; +var \u{2D71F}; +var \u{2D720}; +var \u{2D721}; +var \u{2D722}; +var \u{2D723}; +var \u{2D724}; +var \u{2D725}; +var \u{2D726}; +var \u{2D727}; +var \u{2D728}; +var \u{2D729}; +var \u{2D72A}; +var \u{2D72B}; +var \u{2D72C}; +var \u{2D72D}; +var \u{2D72E}; +var \u{2D72F}; +var \u{2D730}; +var \u{2D731}; +var \u{2D732}; +var \u{2D733}; +var \u{2D734}; +var \u{2D735}; +var \u{2D736}; +var \u{2D737}; +var \u{2D738}; +var \u{2D739}; +var \u{2D73A}; +var \u{2D73B}; +var \u{2D73C}; +var \u{2D73D}; +var \u{2D73E}; +var \u{2D73F}; +var \u{2D740}; +var \u{2D741}; +var \u{2D742}; +var \u{2D743}; +var \u{2D744}; +var \u{2D745}; +var \u{2D746}; +var \u{2D747}; +var \u{2D748}; +var \u{2D749}; +var \u{2D74A}; +var \u{2D74B}; +var \u{2D74C}; +var \u{2D74D}; +var \u{2D74E}; +var \u{2D74F}; +var \u{2D750}; +var \u{2D751}; +var \u{2D752}; +var \u{2D753}; +var \u{2D754}; +var \u{2D755}; +var \u{2D756}; +var \u{2D757}; +var \u{2D758}; +var \u{2D759}; +var \u{2D75A}; +var \u{2D75B}; +var \u{2D75C}; +var \u{2D75D}; +var \u{2D75E}; +var \u{2D75F}; +var \u{2D760}; +var \u{2D761}; +var \u{2D762}; +var \u{2D763}; +var \u{2D764}; +var \u{2D765}; +var \u{2D766}; +var \u{2D767}; +var \u{2D768}; +var \u{2D769}; +var \u{2D76A}; +var \u{2D76B}; +var \u{2D76C}; +var \u{2D76D}; +var \u{2D76E}; +var \u{2D76F}; +var \u{2D770}; +var \u{2D771}; +var \u{2D772}; +var \u{2D773}; +var \u{2D774}; +var \u{2D775}; +var \u{2D776}; +var \u{2D777}; +var \u{2D778}; +var \u{2D779}; +var \u{2D77A}; +var \u{2D77B}; +var \u{2D77C}; +var \u{2D77D}; +var \u{2D77E}; +var \u{2D77F}; +var \u{2D780}; +var \u{2D781}; +var \u{2D782}; +var \u{2D783}; +var \u{2D784}; +var \u{2D785}; +var \u{2D786}; +var \u{2D787}; +var \u{2D788}; +var \u{2D789}; +var \u{2D78A}; +var \u{2D78B}; +var \u{2D78C}; +var \u{2D78D}; +var \u{2D78E}; +var \u{2D78F}; +var \u{2D790}; +var \u{2D791}; +var \u{2D792}; +var \u{2D793}; +var \u{2D794}; +var \u{2D795}; +var \u{2D796}; +var \u{2D797}; +var \u{2D798}; +var \u{2D799}; +var \u{2D79A}; +var \u{2D79B}; +var \u{2D79C}; +var \u{2D79D}; +var \u{2D79E}; +var \u{2D79F}; +var \u{2D7A0}; +var \u{2D7A1}; +var \u{2D7A2}; +var \u{2D7A3}; +var \u{2D7A4}; +var \u{2D7A5}; +var \u{2D7A6}; +var \u{2D7A7}; +var \u{2D7A8}; +var \u{2D7A9}; +var \u{2D7AA}; +var \u{2D7AB}; +var \u{2D7AC}; +var \u{2D7AD}; +var \u{2D7AE}; +var \u{2D7AF}; +var \u{2D7B0}; +var \u{2D7B1}; +var \u{2D7B2}; +var \u{2D7B3}; +var \u{2D7B4}; +var \u{2D7B5}; +var \u{2D7B6}; +var \u{2D7B7}; +var \u{2D7B8}; +var \u{2D7B9}; +var \u{2D7BA}; +var \u{2D7BB}; +var \u{2D7BC}; +var \u{2D7BD}; +var \u{2D7BE}; +var \u{2D7BF}; +var \u{2D7C0}; +var \u{2D7C1}; +var \u{2D7C2}; +var \u{2D7C3}; +var \u{2D7C4}; +var \u{2D7C5}; +var \u{2D7C6}; +var \u{2D7C7}; +var \u{2D7C8}; +var \u{2D7C9}; +var \u{2D7CA}; +var \u{2D7CB}; +var \u{2D7CC}; +var \u{2D7CD}; +var \u{2D7CE}; +var \u{2D7CF}; +var \u{2D7D0}; +var \u{2D7D1}; +var \u{2D7D2}; +var \u{2D7D3}; +var \u{2D7D4}; +var \u{2D7D5}; +var \u{2D7D6}; +var \u{2D7D7}; +var \u{2D7D8}; +var \u{2D7D9}; +var \u{2D7DA}; +var \u{2D7DB}; +var \u{2D7DC}; +var \u{2D7DD}; +var \u{2D7DE}; +var \u{2D7DF}; +var \u{2D7E0}; +var \u{2D7E1}; +var \u{2D7E2}; +var \u{2D7E3}; +var \u{2D7E4}; +var \u{2D7E5}; +var \u{2D7E6}; +var \u{2D7E7}; +var \u{2D7E8}; +var \u{2D7E9}; +var \u{2D7EA}; +var \u{2D7EB}; +var \u{2D7EC}; +var \u{2D7ED}; +var \u{2D7EE}; +var \u{2D7EF}; +var \u{2D7F0}; +var \u{2D7F1}; +var \u{2D7F2}; +var \u{2D7F3}; +var \u{2D7F4}; +var \u{2D7F5}; +var \u{2D7F6}; +var \u{2D7F7}; +var \u{2D7F8}; +var \u{2D7F9}; +var \u{2D7FA}; +var \u{2D7FB}; +var \u{2D7FC}; +var \u{2D7FD}; +var \u{2D7FE}; +var \u{2D7FF}; +var \u{2D800}; +var \u{2D801}; +var \u{2D802}; +var \u{2D803}; +var \u{2D804}; +var \u{2D805}; +var \u{2D806}; +var \u{2D807}; +var \u{2D808}; +var \u{2D809}; +var \u{2D80A}; +var \u{2D80B}; +var \u{2D80C}; +var \u{2D80D}; +var \u{2D80E}; +var \u{2D80F}; +var \u{2D810}; +var \u{2D811}; +var \u{2D812}; +var \u{2D813}; +var \u{2D814}; +var \u{2D815}; +var \u{2D816}; +var \u{2D817}; +var \u{2D818}; +var \u{2D819}; +var \u{2D81A}; +var \u{2D81B}; +var \u{2D81C}; +var \u{2D81D}; +var \u{2D81E}; +var \u{2D81F}; +var \u{2D820}; +var \u{2D821}; +var \u{2D822}; +var \u{2D823}; +var \u{2D824}; +var \u{2D825}; +var \u{2D826}; +var \u{2D827}; +var \u{2D828}; +var \u{2D829}; +var \u{2D82A}; +var \u{2D82B}; +var \u{2D82C}; +var \u{2D82D}; +var \u{2D82E}; +var \u{2D82F}; +var \u{2D830}; +var \u{2D831}; +var \u{2D832}; +var \u{2D833}; +var \u{2D834}; +var \u{2D835}; +var \u{2D836}; +var \u{2D837}; +var \u{2D838}; +var \u{2D839}; +var \u{2D83A}; +var \u{2D83B}; +var \u{2D83C}; +var \u{2D83D}; +var \u{2D83E}; +var \u{2D83F}; +var \u{2D840}; +var \u{2D841}; +var \u{2D842}; +var \u{2D843}; +var \u{2D844}; +var \u{2D845}; +var \u{2D846}; +var \u{2D847}; +var \u{2D848}; +var \u{2D849}; +var \u{2D84A}; +var \u{2D84B}; +var \u{2D84C}; +var \u{2D84D}; +var \u{2D84E}; +var \u{2D84F}; +var \u{2D850}; +var \u{2D851}; +var \u{2D852}; +var \u{2D853}; +var \u{2D854}; +var \u{2D855}; +var \u{2D856}; +var \u{2D857}; +var \u{2D858}; +var \u{2D859}; +var \u{2D85A}; +var \u{2D85B}; +var \u{2D85C}; +var \u{2D85D}; +var \u{2D85E}; +var \u{2D85F}; +var \u{2D860}; +var \u{2D861}; +var \u{2D862}; +var \u{2D863}; +var \u{2D864}; +var \u{2D865}; +var \u{2D866}; +var \u{2D867}; +var \u{2D868}; +var \u{2D869}; +var \u{2D86A}; +var \u{2D86B}; +var \u{2D86C}; +var \u{2D86D}; +var \u{2D86E}; +var \u{2D86F}; +var \u{2D870}; +var \u{2D871}; +var \u{2D872}; +var \u{2D873}; +var \u{2D874}; +var \u{2D875}; +var \u{2D876}; +var \u{2D877}; +var \u{2D878}; +var \u{2D879}; +var \u{2D87A}; +var \u{2D87B}; +var \u{2D87C}; +var \u{2D87D}; +var \u{2D87E}; +var \u{2D87F}; +var \u{2D880}; +var \u{2D881}; +var \u{2D882}; +var \u{2D883}; +var \u{2D884}; +var \u{2D885}; +var \u{2D886}; +var \u{2D887}; +var \u{2D888}; +var \u{2D889}; +var \u{2D88A}; +var \u{2D88B}; +var \u{2D88C}; +var \u{2D88D}; +var \u{2D88E}; +var \u{2D88F}; +var \u{2D890}; +var \u{2D891}; +var \u{2D892}; +var \u{2D893}; +var \u{2D894}; +var \u{2D895}; +var \u{2D896}; +var \u{2D897}; +var \u{2D898}; +var \u{2D899}; +var \u{2D89A}; +var \u{2D89B}; +var \u{2D89C}; +var \u{2D89D}; +var \u{2D89E}; +var \u{2D89F}; +var \u{2D8A0}; +var \u{2D8A1}; +var \u{2D8A2}; +var \u{2D8A3}; +var \u{2D8A4}; +var \u{2D8A5}; +var \u{2D8A6}; +var \u{2D8A7}; +var \u{2D8A8}; +var \u{2D8A9}; +var \u{2D8AA}; +var \u{2D8AB}; +var \u{2D8AC}; +var \u{2D8AD}; +var \u{2D8AE}; +var \u{2D8AF}; +var \u{2D8B0}; +var \u{2D8B1}; +var \u{2D8B2}; +var \u{2D8B3}; +var \u{2D8B4}; +var \u{2D8B5}; +var \u{2D8B6}; +var \u{2D8B7}; +var \u{2D8B8}; +var \u{2D8B9}; +var \u{2D8BA}; +var \u{2D8BB}; +var \u{2D8BC}; +var \u{2D8BD}; +var \u{2D8BE}; +var \u{2D8BF}; +var \u{2D8C0}; +var \u{2D8C1}; +var \u{2D8C2}; +var \u{2D8C3}; +var \u{2D8C4}; +var \u{2D8C5}; +var \u{2D8C6}; +var \u{2D8C7}; +var \u{2D8C8}; +var \u{2D8C9}; +var \u{2D8CA}; +var \u{2D8CB}; +var \u{2D8CC}; +var \u{2D8CD}; +var \u{2D8CE}; +var \u{2D8CF}; +var \u{2D8D0}; +var \u{2D8D1}; +var \u{2D8D2}; +var \u{2D8D3}; +var \u{2D8D4}; +var \u{2D8D5}; +var \u{2D8D6}; +var \u{2D8D7}; +var \u{2D8D8}; +var \u{2D8D9}; +var \u{2D8DA}; +var \u{2D8DB}; +var \u{2D8DC}; +var \u{2D8DD}; +var \u{2D8DE}; +var \u{2D8DF}; +var \u{2D8E0}; +var \u{2D8E1}; +var \u{2D8E2}; +var \u{2D8E3}; +var \u{2D8E4}; +var \u{2D8E5}; +var \u{2D8E6}; +var \u{2D8E7}; +var \u{2D8E8}; +var \u{2D8E9}; +var \u{2D8EA}; +var \u{2D8EB}; +var \u{2D8EC}; +var \u{2D8ED}; +var \u{2D8EE}; +var \u{2D8EF}; +var \u{2D8F0}; +var \u{2D8F1}; +var \u{2D8F2}; +var \u{2D8F3}; +var \u{2D8F4}; +var \u{2D8F5}; +var \u{2D8F6}; +var \u{2D8F7}; +var \u{2D8F8}; +var \u{2D8F9}; +var \u{2D8FA}; +var \u{2D8FB}; +var \u{2D8FC}; +var \u{2D8FD}; +var \u{2D8FE}; +var \u{2D8FF}; +var \u{2D900}; +var \u{2D901}; +var \u{2D902}; +var \u{2D903}; +var \u{2D904}; +var \u{2D905}; +var \u{2D906}; +var \u{2D907}; +var \u{2D908}; +var \u{2D909}; +var \u{2D90A}; +var \u{2D90B}; +var \u{2D90C}; +var \u{2D90D}; +var \u{2D90E}; +var \u{2D90F}; +var \u{2D910}; +var \u{2D911}; +var \u{2D912}; +var \u{2D913}; +var \u{2D914}; +var \u{2D915}; +var \u{2D916}; +var \u{2D917}; +var \u{2D918}; +var \u{2D919}; +var \u{2D91A}; +var \u{2D91B}; +var \u{2D91C}; +var \u{2D91D}; +var \u{2D91E}; +var \u{2D91F}; +var \u{2D920}; +var \u{2D921}; +var \u{2D922}; +var \u{2D923}; +var \u{2D924}; +var \u{2D925}; +var \u{2D926}; +var \u{2D927}; +var \u{2D928}; +var \u{2D929}; +var \u{2D92A}; +var \u{2D92B}; +var \u{2D92C}; +var \u{2D92D}; +var \u{2D92E}; +var \u{2D92F}; +var \u{2D930}; +var \u{2D931}; +var \u{2D932}; +var \u{2D933}; +var \u{2D934}; +var \u{2D935}; +var \u{2D936}; +var \u{2D937}; +var \u{2D938}; +var \u{2D939}; +var \u{2D93A}; +var \u{2D93B}; +var \u{2D93C}; +var \u{2D93D}; +var \u{2D93E}; +var \u{2D93F}; +var \u{2D940}; +var \u{2D941}; +var \u{2D942}; +var \u{2D943}; +var \u{2D944}; +var \u{2D945}; +var \u{2D946}; +var \u{2D947}; +var \u{2D948}; +var \u{2D949}; +var \u{2D94A}; +var \u{2D94B}; +var \u{2D94C}; +var \u{2D94D}; +var \u{2D94E}; +var \u{2D94F}; +var \u{2D950}; +var \u{2D951}; +var \u{2D952}; +var \u{2D953}; +var \u{2D954}; +var \u{2D955}; +var \u{2D956}; +var \u{2D957}; +var \u{2D958}; +var \u{2D959}; +var \u{2D95A}; +var \u{2D95B}; +var \u{2D95C}; +var \u{2D95D}; +var \u{2D95E}; +var \u{2D95F}; +var \u{2D960}; +var \u{2D961}; +var \u{2D962}; +var \u{2D963}; +var \u{2D964}; +var \u{2D965}; +var \u{2D966}; +var \u{2D967}; +var \u{2D968}; +var \u{2D969}; +var \u{2D96A}; +var \u{2D96B}; +var \u{2D96C}; +var \u{2D96D}; +var \u{2D96E}; +var \u{2D96F}; +var \u{2D970}; +var \u{2D971}; +var \u{2D972}; +var \u{2D973}; +var \u{2D974}; +var \u{2D975}; +var \u{2D976}; +var \u{2D977}; +var \u{2D978}; +var \u{2D979}; +var \u{2D97A}; +var \u{2D97B}; +var \u{2D97C}; +var \u{2D97D}; +var \u{2D97E}; +var \u{2D97F}; +var \u{2D980}; +var \u{2D981}; +var \u{2D982}; +var \u{2D983}; +var \u{2D984}; +var \u{2D985}; +var \u{2D986}; +var \u{2D987}; +var \u{2D988}; +var \u{2D989}; +var \u{2D98A}; +var \u{2D98B}; +var \u{2D98C}; +var \u{2D98D}; +var \u{2D98E}; +var \u{2D98F}; +var \u{2D990}; +var \u{2D991}; +var \u{2D992}; +var \u{2D993}; +var \u{2D994}; +var \u{2D995}; +var \u{2D996}; +var \u{2D997}; +var \u{2D998}; +var \u{2D999}; +var \u{2D99A}; +var \u{2D99B}; +var \u{2D99C}; +var \u{2D99D}; +var \u{2D99E}; +var \u{2D99F}; +var \u{2D9A0}; +var \u{2D9A1}; +var \u{2D9A2}; +var \u{2D9A3}; +var \u{2D9A4}; +var \u{2D9A5}; +var \u{2D9A6}; +var \u{2D9A7}; +var \u{2D9A8}; +var \u{2D9A9}; +var \u{2D9AA}; +var \u{2D9AB}; +var \u{2D9AC}; +var \u{2D9AD}; +var \u{2D9AE}; +var \u{2D9AF}; +var \u{2D9B0}; +var \u{2D9B1}; +var \u{2D9B2}; +var \u{2D9B3}; +var \u{2D9B4}; +var \u{2D9B5}; +var \u{2D9B6}; +var \u{2D9B7}; +var \u{2D9B8}; +var \u{2D9B9}; +var \u{2D9BA}; +var \u{2D9BB}; +var \u{2D9BC}; +var \u{2D9BD}; +var \u{2D9BE}; +var \u{2D9BF}; +var \u{2D9C0}; +var \u{2D9C1}; +var \u{2D9C2}; +var \u{2D9C3}; +var \u{2D9C4}; +var \u{2D9C5}; +var \u{2D9C6}; +var \u{2D9C7}; +var \u{2D9C8}; +var \u{2D9C9}; +var \u{2D9CA}; +var \u{2D9CB}; +var \u{2D9CC}; +var \u{2D9CD}; +var \u{2D9CE}; +var \u{2D9CF}; +var \u{2D9D0}; +var \u{2D9D1}; +var \u{2D9D2}; +var \u{2D9D3}; +var \u{2D9D4}; +var \u{2D9D5}; +var \u{2D9D6}; +var \u{2D9D7}; +var \u{2D9D8}; +var \u{2D9D9}; +var \u{2D9DA}; +var \u{2D9DB}; +var \u{2D9DC}; +var \u{2D9DD}; +var \u{2D9DE}; +var \u{2D9DF}; +var \u{2D9E0}; +var \u{2D9E1}; +var \u{2D9E2}; +var \u{2D9E3}; +var \u{2D9E4}; +var \u{2D9E5}; +var \u{2D9E6}; +var \u{2D9E7}; +var \u{2D9E8}; +var \u{2D9E9}; +var \u{2D9EA}; +var \u{2D9EB}; +var \u{2D9EC}; +var \u{2D9ED}; +var \u{2D9EE}; +var \u{2D9EF}; +var \u{2D9F0}; +var \u{2D9F1}; +var \u{2D9F2}; +var \u{2D9F3}; +var \u{2D9F4}; +var \u{2D9F5}; +var \u{2D9F6}; +var \u{2D9F7}; +var \u{2D9F8}; +var \u{2D9F9}; +var \u{2D9FA}; +var \u{2D9FB}; +var \u{2D9FC}; +var \u{2D9FD}; +var \u{2D9FE}; +var \u{2D9FF}; +var \u{2DA00}; +var \u{2DA01}; +var \u{2DA02}; +var \u{2DA03}; +var \u{2DA04}; +var \u{2DA05}; +var \u{2DA06}; +var \u{2DA07}; +var \u{2DA08}; +var \u{2DA09}; +var \u{2DA0A}; +var \u{2DA0B}; +var \u{2DA0C}; +var \u{2DA0D}; +var \u{2DA0E}; +var \u{2DA0F}; +var \u{2DA10}; +var \u{2DA11}; +var \u{2DA12}; +var \u{2DA13}; +var \u{2DA14}; +var \u{2DA15}; +var \u{2DA16}; +var \u{2DA17}; +var \u{2DA18}; +var \u{2DA19}; +var \u{2DA1A}; +var \u{2DA1B}; +var \u{2DA1C}; +var \u{2DA1D}; +var \u{2DA1E}; +var \u{2DA1F}; +var \u{2DA20}; +var \u{2DA21}; +var \u{2DA22}; +var \u{2DA23}; +var \u{2DA24}; +var \u{2DA25}; +var \u{2DA26}; +var \u{2DA27}; +var \u{2DA28}; +var \u{2DA29}; +var \u{2DA2A}; +var \u{2DA2B}; +var \u{2DA2C}; +var \u{2DA2D}; +var \u{2DA2E}; +var \u{2DA2F}; +var \u{2DA30}; +var \u{2DA31}; +var \u{2DA32}; +var \u{2DA33}; +var \u{2DA34}; +var \u{2DA35}; +var \u{2DA36}; +var \u{2DA37}; +var \u{2DA38}; +var \u{2DA39}; +var \u{2DA3A}; +var \u{2DA3B}; +var \u{2DA3C}; +var \u{2DA3D}; +var \u{2DA3E}; +var \u{2DA3F}; +var \u{2DA40}; +var \u{2DA41}; +var \u{2DA42}; +var \u{2DA43}; +var \u{2DA44}; +var \u{2DA45}; +var \u{2DA46}; +var \u{2DA47}; +var \u{2DA48}; +var \u{2DA49}; +var \u{2DA4A}; +var \u{2DA4B}; +var \u{2DA4C}; +var \u{2DA4D}; +var \u{2DA4E}; +var \u{2DA4F}; +var \u{2DA50}; +var \u{2DA51}; +var \u{2DA52}; +var \u{2DA53}; +var \u{2DA54}; +var \u{2DA55}; +var \u{2DA56}; +var \u{2DA57}; +var \u{2DA58}; +var \u{2DA59}; +var \u{2DA5A}; +var \u{2DA5B}; +var \u{2DA5C}; +var \u{2DA5D}; +var \u{2DA5E}; +var \u{2DA5F}; +var \u{2DA60}; +var \u{2DA61}; +var \u{2DA62}; +var \u{2DA63}; +var \u{2DA64}; +var \u{2DA65}; +var \u{2DA66}; +var \u{2DA67}; +var \u{2DA68}; +var \u{2DA69}; +var \u{2DA6A}; +var \u{2DA6B}; +var \u{2DA6C}; +var \u{2DA6D}; +var \u{2DA6E}; +var \u{2DA6F}; +var \u{2DA70}; +var \u{2DA71}; +var \u{2DA72}; +var \u{2DA73}; +var \u{2DA74}; +var \u{2DA75}; +var \u{2DA76}; +var \u{2DA77}; +var \u{2DA78}; +var \u{2DA79}; +var \u{2DA7A}; +var \u{2DA7B}; +var \u{2DA7C}; +var \u{2DA7D}; +var \u{2DA7E}; +var \u{2DA7F}; +var \u{2DA80}; +var \u{2DA81}; +var \u{2DA82}; +var \u{2DA83}; +var \u{2DA84}; +var \u{2DA85}; +var \u{2DA86}; +var \u{2DA87}; +var \u{2DA88}; +var \u{2DA89}; +var \u{2DA8A}; +var \u{2DA8B}; +var \u{2DA8C}; +var \u{2DA8D}; +var \u{2DA8E}; +var \u{2DA8F}; +var \u{2DA90}; +var \u{2DA91}; +var \u{2DA92}; +var \u{2DA93}; +var \u{2DA94}; +var \u{2DA95}; +var \u{2DA96}; +var \u{2DA97}; +var \u{2DA98}; +var \u{2DA99}; +var \u{2DA9A}; +var \u{2DA9B}; +var \u{2DA9C}; +var \u{2DA9D}; +var \u{2DA9E}; +var \u{2DA9F}; +var \u{2DAA0}; +var \u{2DAA1}; +var \u{2DAA2}; +var \u{2DAA3}; +var \u{2DAA4}; +var \u{2DAA5}; +var \u{2DAA6}; +var \u{2DAA7}; +var \u{2DAA8}; +var \u{2DAA9}; +var \u{2DAAA}; +var \u{2DAAB}; +var \u{2DAAC}; +var \u{2DAAD}; +var \u{2DAAE}; +var \u{2DAAF}; +var \u{2DAB0}; +var \u{2DAB1}; +var \u{2DAB2}; +var \u{2DAB3}; +var \u{2DAB4}; +var \u{2DAB5}; +var \u{2DAB6}; +var \u{2DAB7}; +var \u{2DAB8}; +var \u{2DAB9}; +var \u{2DABA}; +var \u{2DABB}; +var \u{2DABC}; +var \u{2DABD}; +var \u{2DABE}; +var \u{2DABF}; +var \u{2DAC0}; +var \u{2DAC1}; +var \u{2DAC2}; +var \u{2DAC3}; +var \u{2DAC4}; +var \u{2DAC5}; +var \u{2DAC6}; +var \u{2DAC7}; +var \u{2DAC8}; +var \u{2DAC9}; +var \u{2DACA}; +var \u{2DACB}; +var \u{2DACC}; +var \u{2DACD}; +var \u{2DACE}; +var \u{2DACF}; +var \u{2DAD0}; +var \u{2DAD1}; +var \u{2DAD2}; +var \u{2DAD3}; +var \u{2DAD4}; +var \u{2DAD5}; +var \u{2DAD6}; +var \u{2DAD7}; +var \u{2DAD8}; +var \u{2DAD9}; +var \u{2DADA}; +var \u{2DADB}; +var \u{2DADC}; +var \u{2DADD}; +var \u{2DADE}; +var \u{2DADF}; +var \u{2DAE0}; +var \u{2DAE1}; +var \u{2DAE2}; +var \u{2DAE3}; +var \u{2DAE4}; +var \u{2DAE5}; +var \u{2DAE6}; +var \u{2DAE7}; +var \u{2DAE8}; +var \u{2DAE9}; +var \u{2DAEA}; +var \u{2DAEB}; +var \u{2DAEC}; +var \u{2DAED}; +var \u{2DAEE}; +var \u{2DAEF}; +var \u{2DAF0}; +var \u{2DAF1}; +var \u{2DAF2}; +var \u{2DAF3}; +var \u{2DAF4}; +var \u{2DAF5}; +var \u{2DAF6}; +var \u{2DAF7}; +var \u{2DAF8}; +var \u{2DAF9}; +var \u{2DAFA}; +var \u{2DAFB}; +var \u{2DAFC}; +var \u{2DAFD}; +var \u{2DAFE}; +var \u{2DAFF}; +var \u{2DB00}; +var \u{2DB01}; +var \u{2DB02}; +var \u{2DB03}; +var \u{2DB04}; +var \u{2DB05}; +var \u{2DB06}; +var \u{2DB07}; +var \u{2DB08}; +var \u{2DB09}; +var \u{2DB0A}; +var \u{2DB0B}; +var \u{2DB0C}; +var \u{2DB0D}; +var \u{2DB0E}; +var \u{2DB0F}; +var \u{2DB10}; +var \u{2DB11}; +var \u{2DB12}; +var \u{2DB13}; +var \u{2DB14}; +var \u{2DB15}; +var \u{2DB16}; +var \u{2DB17}; +var \u{2DB18}; +var \u{2DB19}; +var \u{2DB1A}; +var \u{2DB1B}; +var \u{2DB1C}; +var \u{2DB1D}; +var \u{2DB1E}; +var \u{2DB1F}; +var \u{2DB20}; +var \u{2DB21}; +var \u{2DB22}; +var \u{2DB23}; +var \u{2DB24}; +var \u{2DB25}; +var \u{2DB26}; +var \u{2DB27}; +var \u{2DB28}; +var \u{2DB29}; +var \u{2DB2A}; +var \u{2DB2B}; +var \u{2DB2C}; +var \u{2DB2D}; +var \u{2DB2E}; +var \u{2DB2F}; +var \u{2DB30}; +var \u{2DB31}; +var \u{2DB32}; +var \u{2DB33}; +var \u{2DB34}; +var \u{2DB35}; +var \u{2DB36}; +var \u{2DB37}; +var \u{2DB38}; +var \u{2DB39}; +var \u{2DB3A}; +var \u{2DB3B}; +var \u{2DB3C}; +var \u{2DB3D}; +var \u{2DB3E}; +var \u{2DB3F}; +var \u{2DB40}; +var \u{2DB41}; +var \u{2DB42}; +var \u{2DB43}; +var \u{2DB44}; +var \u{2DB45}; +var \u{2DB46}; +var \u{2DB47}; +var \u{2DB48}; +var \u{2DB49}; +var \u{2DB4A}; +var \u{2DB4B}; +var \u{2DB4C}; +var \u{2DB4D}; +var \u{2DB4E}; +var \u{2DB4F}; +var \u{2DB50}; +var \u{2DB51}; +var \u{2DB52}; +var \u{2DB53}; +var \u{2DB54}; +var \u{2DB55}; +var \u{2DB56}; +var \u{2DB57}; +var \u{2DB58}; +var \u{2DB59}; +var \u{2DB5A}; +var \u{2DB5B}; +var \u{2DB5C}; +var \u{2DB5D}; +var \u{2DB5E}; +var \u{2DB5F}; +var \u{2DB60}; +var \u{2DB61}; +var \u{2DB62}; +var \u{2DB63}; +var \u{2DB64}; +var \u{2DB65}; +var \u{2DB66}; +var \u{2DB67}; +var \u{2DB68}; +var \u{2DB69}; +var \u{2DB6A}; +var \u{2DB6B}; +var \u{2DB6C}; +var \u{2DB6D}; +var \u{2DB6E}; +var \u{2DB6F}; +var \u{2DB70}; +var \u{2DB71}; +var \u{2DB72}; +var \u{2DB73}; +var \u{2DB74}; +var \u{2DB75}; +var \u{2DB76}; +var \u{2DB77}; +var \u{2DB78}; +var \u{2DB79}; +var \u{2DB7A}; +var \u{2DB7B}; +var \u{2DB7C}; +var \u{2DB7D}; +var \u{2DB7E}; +var \u{2DB7F}; +var \u{2DB80}; +var \u{2DB81}; +var \u{2DB82}; +var \u{2DB83}; +var \u{2DB84}; +var \u{2DB85}; +var \u{2DB86}; +var \u{2DB87}; +var \u{2DB88}; +var \u{2DB89}; +var \u{2DB8A}; +var \u{2DB8B}; +var \u{2DB8C}; +var \u{2DB8D}; +var \u{2DB8E}; +var \u{2DB8F}; +var \u{2DB90}; +var \u{2DB91}; +var \u{2DB92}; +var \u{2DB93}; +var \u{2DB94}; +var \u{2DB95}; +var \u{2DB96}; +var \u{2DB97}; +var \u{2DB98}; +var \u{2DB99}; +var \u{2DB9A}; +var \u{2DB9B}; +var \u{2DB9C}; +var \u{2DB9D}; +var \u{2DB9E}; +var \u{2DB9F}; +var \u{2DBA0}; +var \u{2DBA1}; +var \u{2DBA2}; +var \u{2DBA3}; +var \u{2DBA4}; +var \u{2DBA5}; +var \u{2DBA6}; +var \u{2DBA7}; +var \u{2DBA8}; +var \u{2DBA9}; +var \u{2DBAA}; +var \u{2DBAB}; +var \u{2DBAC}; +var \u{2DBAD}; +var \u{2DBAE}; +var \u{2DBAF}; +var \u{2DBB0}; +var \u{2DBB1}; +var \u{2DBB2}; +var \u{2DBB3}; +var \u{2DBB4}; +var \u{2DBB5}; +var \u{2DBB6}; +var \u{2DBB7}; +var \u{2DBB8}; +var \u{2DBB9}; +var \u{2DBBA}; +var \u{2DBBB}; +var \u{2DBBC}; +var \u{2DBBD}; +var \u{2DBBE}; +var \u{2DBBF}; +var \u{2DBC0}; +var \u{2DBC1}; +var \u{2DBC2}; +var \u{2DBC3}; +var \u{2DBC4}; +var \u{2DBC5}; +var \u{2DBC6}; +var \u{2DBC7}; +var \u{2DBC8}; +var \u{2DBC9}; +var \u{2DBCA}; +var \u{2DBCB}; +var \u{2DBCC}; +var \u{2DBCD}; +var \u{2DBCE}; +var \u{2DBCF}; +var \u{2DBD0}; +var \u{2DBD1}; +var \u{2DBD2}; +var \u{2DBD3}; +var \u{2DBD4}; +var \u{2DBD5}; +var \u{2DBD6}; +var \u{2DBD7}; +var \u{2DBD8}; +var \u{2DBD9}; +var \u{2DBDA}; +var \u{2DBDB}; +var \u{2DBDC}; +var \u{2DBDD}; +var \u{2DBDE}; +var \u{2DBDF}; +var \u{2DBE0}; +var \u{2DBE1}; +var \u{2DBE2}; +var \u{2DBE3}; +var \u{2DBE4}; +var \u{2DBE5}; +var \u{2DBE6}; +var \u{2DBE7}; +var \u{2DBE8}; +var \u{2DBE9}; +var \u{2DBEA}; +var \u{2DBEB}; +var \u{2DBEC}; +var \u{2DBED}; +var \u{2DBEE}; +var \u{2DBEF}; +var \u{2DBF0}; +var \u{2DBF1}; +var \u{2DBF2}; +var \u{2DBF3}; +var \u{2DBF4}; +var \u{2DBF5}; +var \u{2DBF6}; +var \u{2DBF7}; +var \u{2DBF8}; +var \u{2DBF9}; +var \u{2DBFA}; +var \u{2DBFB}; +var \u{2DBFC}; +var \u{2DBFD}; +var \u{2DBFE}; +var \u{2DBFF}; +var \u{2DC00}; +var \u{2DC01}; +var \u{2DC02}; +var \u{2DC03}; +var \u{2DC04}; +var \u{2DC05}; +var \u{2DC06}; +var \u{2DC07}; +var \u{2DC08}; +var \u{2DC09}; +var \u{2DC0A}; +var \u{2DC0B}; +var \u{2DC0C}; +var \u{2DC0D}; +var \u{2DC0E}; +var \u{2DC0F}; +var \u{2DC10}; +var \u{2DC11}; +var \u{2DC12}; +var \u{2DC13}; +var \u{2DC14}; +var \u{2DC15}; +var \u{2DC16}; +var \u{2DC17}; +var \u{2DC18}; +var \u{2DC19}; +var \u{2DC1A}; +var \u{2DC1B}; +var \u{2DC1C}; +var \u{2DC1D}; +var \u{2DC1E}; +var \u{2DC1F}; +var \u{2DC20}; +var \u{2DC21}; +var \u{2DC22}; +var \u{2DC23}; +var \u{2DC24}; +var \u{2DC25}; +var \u{2DC26}; +var \u{2DC27}; +var \u{2DC28}; +var \u{2DC29}; +var \u{2DC2A}; +var \u{2DC2B}; +var \u{2DC2C}; +var \u{2DC2D}; +var \u{2DC2E}; +var \u{2DC2F}; +var \u{2DC30}; +var \u{2DC31}; +var \u{2DC32}; +var \u{2DC33}; +var \u{2DC34}; +var \u{2DC35}; +var \u{2DC36}; +var \u{2DC37}; +var \u{2DC38}; +var \u{2DC39}; +var \u{2DC3A}; +var \u{2DC3B}; +var \u{2DC3C}; +var \u{2DC3D}; +var \u{2DC3E}; +var \u{2DC3F}; +var \u{2DC40}; +var \u{2DC41}; +var \u{2DC42}; +var \u{2DC43}; +var \u{2DC44}; +var \u{2DC45}; +var \u{2DC46}; +var \u{2DC47}; +var \u{2DC48}; +var \u{2DC49}; +var \u{2DC4A}; +var \u{2DC4B}; +var \u{2DC4C}; +var \u{2DC4D}; +var \u{2DC4E}; +var \u{2DC4F}; +var \u{2DC50}; +var \u{2DC51}; +var \u{2DC52}; +var \u{2DC53}; +var \u{2DC54}; +var \u{2DC55}; +var \u{2DC56}; +var \u{2DC57}; +var \u{2DC58}; +var \u{2DC59}; +var \u{2DC5A}; +var \u{2DC5B}; +var \u{2DC5C}; +var \u{2DC5D}; +var \u{2DC5E}; +var \u{2DC5F}; +var \u{2DC60}; +var \u{2DC61}; +var \u{2DC62}; +var \u{2DC63}; +var \u{2DC64}; +var \u{2DC65}; +var \u{2DC66}; +var \u{2DC67}; +var \u{2DC68}; +var \u{2DC69}; +var \u{2DC6A}; +var \u{2DC6B}; +var \u{2DC6C}; +var \u{2DC6D}; +var \u{2DC6E}; +var \u{2DC6F}; +var \u{2DC70}; +var \u{2DC71}; +var \u{2DC72}; +var \u{2DC73}; +var \u{2DC74}; +var \u{2DC75}; +var \u{2DC76}; +var \u{2DC77}; +var \u{2DC78}; +var \u{2DC79}; +var \u{2DC7A}; +var \u{2DC7B}; +var \u{2DC7C}; +var \u{2DC7D}; +var \u{2DC7E}; +var \u{2DC7F}; +var \u{2DC80}; +var \u{2DC81}; +var \u{2DC82}; +var \u{2DC83}; +var \u{2DC84}; +var \u{2DC85}; +var \u{2DC86}; +var \u{2DC87}; +var \u{2DC88}; +var \u{2DC89}; +var \u{2DC8A}; +var \u{2DC8B}; +var \u{2DC8C}; +var \u{2DC8D}; +var \u{2DC8E}; +var \u{2DC8F}; +var \u{2DC90}; +var \u{2DC91}; +var \u{2DC92}; +var \u{2DC93}; +var \u{2DC94}; +var \u{2DC95}; +var \u{2DC96}; +var \u{2DC97}; +var \u{2DC98}; +var \u{2DC99}; +var \u{2DC9A}; +var \u{2DC9B}; +var \u{2DC9C}; +var \u{2DC9D}; +var \u{2DC9E}; +var \u{2DC9F}; +var \u{2DCA0}; +var \u{2DCA1}; +var \u{2DCA2}; +var \u{2DCA3}; +var \u{2DCA4}; +var \u{2DCA5}; +var \u{2DCA6}; +var \u{2DCA7}; +var \u{2DCA8}; +var \u{2DCA9}; +var \u{2DCAA}; +var \u{2DCAB}; +var \u{2DCAC}; +var \u{2DCAD}; +var \u{2DCAE}; +var \u{2DCAF}; +var \u{2DCB0}; +var \u{2DCB1}; +var \u{2DCB2}; +var \u{2DCB3}; +var \u{2DCB4}; +var \u{2DCB5}; +var \u{2DCB6}; +var \u{2DCB7}; +var \u{2DCB8}; +var \u{2DCB9}; +var \u{2DCBA}; +var \u{2DCBB}; +var \u{2DCBC}; +var \u{2DCBD}; +var \u{2DCBE}; +var \u{2DCBF}; +var \u{2DCC0}; +var \u{2DCC1}; +var \u{2DCC2}; +var \u{2DCC3}; +var \u{2DCC4}; +var \u{2DCC5}; +var \u{2DCC6}; +var \u{2DCC7}; +var \u{2DCC8}; +var \u{2DCC9}; +var \u{2DCCA}; +var \u{2DCCB}; +var \u{2DCCC}; +var \u{2DCCD}; +var \u{2DCCE}; +var \u{2DCCF}; +var \u{2DCD0}; +var \u{2DCD1}; +var \u{2DCD2}; +var \u{2DCD3}; +var \u{2DCD4}; +var \u{2DCD5}; +var \u{2DCD6}; +var \u{2DCD7}; +var \u{2DCD8}; +var \u{2DCD9}; +var \u{2DCDA}; +var \u{2DCDB}; +var \u{2DCDC}; +var \u{2DCDD}; +var \u{2DCDE}; +var \u{2DCDF}; +var \u{2DCE0}; +var \u{2DCE1}; +var \u{2DCE2}; +var \u{2DCE3}; +var \u{2DCE4}; +var \u{2DCE5}; +var \u{2DCE6}; +var \u{2DCE7}; +var \u{2DCE8}; +var \u{2DCE9}; +var \u{2DCEA}; +var \u{2DCEB}; +var \u{2DCEC}; +var \u{2DCED}; +var \u{2DCEE}; +var \u{2DCEF}; +var \u{2DCF0}; +var \u{2DCF1}; +var \u{2DCF2}; +var \u{2DCF3}; +var \u{2DCF4}; +var \u{2DCF5}; +var \u{2DCF6}; +var \u{2DCF7}; +var \u{2DCF8}; +var \u{2DCF9}; +var \u{2DCFA}; +var \u{2DCFB}; +var \u{2DCFC}; +var \u{2DCFD}; +var \u{2DCFE}; +var \u{2DCFF}; +var \u{2DD00}; +var \u{2DD01}; +var \u{2DD02}; +var \u{2DD03}; +var \u{2DD04}; +var \u{2DD05}; +var \u{2DD06}; +var \u{2DD07}; +var \u{2DD08}; +var \u{2DD09}; +var \u{2DD0A}; +var \u{2DD0B}; +var \u{2DD0C}; +var \u{2DD0D}; +var \u{2DD0E}; +var \u{2DD0F}; +var \u{2DD10}; +var \u{2DD11}; +var \u{2DD12}; +var \u{2DD13}; +var \u{2DD14}; +var \u{2DD15}; +var \u{2DD16}; +var \u{2DD17}; +var \u{2DD18}; +var \u{2DD19}; +var \u{2DD1A}; +var \u{2DD1B}; +var \u{2DD1C}; +var \u{2DD1D}; +var \u{2DD1E}; +var \u{2DD1F}; +var \u{2DD20}; +var \u{2DD21}; +var \u{2DD22}; +var \u{2DD23}; +var \u{2DD24}; +var \u{2DD25}; +var \u{2DD26}; +var \u{2DD27}; +var \u{2DD28}; +var \u{2DD29}; +var \u{2DD2A}; +var \u{2DD2B}; +var \u{2DD2C}; +var \u{2DD2D}; +var \u{2DD2E}; +var \u{2DD2F}; +var \u{2DD30}; +var \u{2DD31}; +var \u{2DD32}; +var \u{2DD33}; +var \u{2DD34}; +var \u{2DD35}; +var \u{2DD36}; +var \u{2DD37}; +var \u{2DD38}; +var \u{2DD39}; +var \u{2DD3A}; +var \u{2DD3B}; +var \u{2DD3C}; +var \u{2DD3D}; +var \u{2DD3E}; +var \u{2DD3F}; +var \u{2DD40}; +var \u{2DD41}; +var \u{2DD42}; +var \u{2DD43}; +var \u{2DD44}; +var \u{2DD45}; +var \u{2DD46}; +var \u{2DD47}; +var \u{2DD48}; +var \u{2DD49}; +var \u{2DD4A}; +var \u{2DD4B}; +var \u{2DD4C}; +var \u{2DD4D}; +var \u{2DD4E}; +var \u{2DD4F}; +var \u{2DD50}; +var \u{2DD51}; +var \u{2DD52}; +var \u{2DD53}; +var \u{2DD54}; +var \u{2DD55}; +var \u{2DD56}; +var \u{2DD57}; +var \u{2DD58}; +var \u{2DD59}; +var \u{2DD5A}; +var \u{2DD5B}; +var \u{2DD5C}; +var \u{2DD5D}; +var \u{2DD5E}; +var \u{2DD5F}; +var \u{2DD60}; +var \u{2DD61}; +var \u{2DD62}; +var \u{2DD63}; +var \u{2DD64}; +var \u{2DD65}; +var \u{2DD66}; +var \u{2DD67}; +var \u{2DD68}; +var \u{2DD69}; +var \u{2DD6A}; +var \u{2DD6B}; +var \u{2DD6C}; +var \u{2DD6D}; +var \u{2DD6E}; +var \u{2DD6F}; +var \u{2DD70}; +var \u{2DD71}; +var \u{2DD72}; +var \u{2DD73}; +var \u{2DD74}; +var \u{2DD75}; +var \u{2DD76}; +var \u{2DD77}; +var \u{2DD78}; +var \u{2DD79}; +var \u{2DD7A}; +var \u{2DD7B}; +var \u{2DD7C}; +var \u{2DD7D}; +var \u{2DD7E}; +var \u{2DD7F}; +var \u{2DD80}; +var \u{2DD81}; +var \u{2DD82}; +var \u{2DD83}; +var \u{2DD84}; +var \u{2DD85}; +var \u{2DD86}; +var \u{2DD87}; +var \u{2DD88}; +var \u{2DD89}; +var \u{2DD8A}; +var \u{2DD8B}; +var \u{2DD8C}; +var \u{2DD8D}; +var \u{2DD8E}; +var \u{2DD8F}; +var \u{2DD90}; +var \u{2DD91}; +var \u{2DD92}; +var \u{2DD93}; +var \u{2DD94}; +var \u{2DD95}; +var \u{2DD96}; +var \u{2DD97}; +var \u{2DD98}; +var \u{2DD99}; +var \u{2DD9A}; +var \u{2DD9B}; +var \u{2DD9C}; +var \u{2DD9D}; +var \u{2DD9E}; +var \u{2DD9F}; +var \u{2DDA0}; +var \u{2DDA1}; +var \u{2DDA2}; +var \u{2DDA3}; +var \u{2DDA4}; +var \u{2DDA5}; +var \u{2DDA6}; +var \u{2DDA7}; +var \u{2DDA8}; +var \u{2DDA9}; +var \u{2DDAA}; +var \u{2DDAB}; +var \u{2DDAC}; +var \u{2DDAD}; +var \u{2DDAE}; +var \u{2DDAF}; +var \u{2DDB0}; +var \u{2DDB1}; +var \u{2DDB2}; +var \u{2DDB3}; +var \u{2DDB4}; +var \u{2DDB5}; +var \u{2DDB6}; +var \u{2DDB7}; +var \u{2DDB8}; +var \u{2DDB9}; +var \u{2DDBA}; +var \u{2DDBB}; +var \u{2DDBC}; +var \u{2DDBD}; +var \u{2DDBE}; +var \u{2DDBF}; +var \u{2DDC0}; +var \u{2DDC1}; +var \u{2DDC2}; +var \u{2DDC3}; +var \u{2DDC4}; +var \u{2DDC5}; +var \u{2DDC6}; +var \u{2DDC7}; +var \u{2DDC8}; +var \u{2DDC9}; +var \u{2DDCA}; +var \u{2DDCB}; +var \u{2DDCC}; +var \u{2DDCD}; +var \u{2DDCE}; +var \u{2DDCF}; +var \u{2DDD0}; +var \u{2DDD1}; +var \u{2DDD2}; +var \u{2DDD3}; +var \u{2DDD4}; +var \u{2DDD5}; +var \u{2DDD6}; +var \u{2DDD7}; +var \u{2DDD8}; +var \u{2DDD9}; +var \u{2DDDA}; +var \u{2DDDB}; +var \u{2DDDC}; +var \u{2DDDD}; +var \u{2DDDE}; +var \u{2DDDF}; +var \u{2DDE0}; +var \u{2DDE1}; +var \u{2DDE2}; +var \u{2DDE3}; +var \u{2DDE4}; +var \u{2DDE5}; +var \u{2DDE6}; +var \u{2DDE7}; +var \u{2DDE8}; +var \u{2DDE9}; +var \u{2DDEA}; +var \u{2DDEB}; +var \u{2DDEC}; +var \u{2DDED}; +var \u{2DDEE}; +var \u{2DDEF}; +var \u{2DDF0}; +var \u{2DDF1}; +var \u{2DDF2}; +var \u{2DDF3}; +var \u{2DDF4}; +var \u{2DDF5}; +var \u{2DDF6}; +var \u{2DDF7}; +var \u{2DDF8}; +var \u{2DDF9}; +var \u{2DDFA}; +var \u{2DDFB}; +var \u{2DDFC}; +var \u{2DDFD}; +var \u{2DDFE}; +var \u{2DDFF}; +var \u{2DE00}; +var \u{2DE01}; +var \u{2DE02}; +var \u{2DE03}; +var \u{2DE04}; +var \u{2DE05}; +var \u{2DE06}; +var \u{2DE07}; +var \u{2DE08}; +var \u{2DE09}; +var \u{2DE0A}; +var \u{2DE0B}; +var \u{2DE0C}; +var \u{2DE0D}; +var \u{2DE0E}; +var \u{2DE0F}; +var \u{2DE10}; +var \u{2DE11}; +var \u{2DE12}; +var \u{2DE13}; +var \u{2DE14}; +var \u{2DE15}; +var \u{2DE16}; +var \u{2DE17}; +var \u{2DE18}; +var \u{2DE19}; +var \u{2DE1A}; +var \u{2DE1B}; +var \u{2DE1C}; +var \u{2DE1D}; +var \u{2DE1E}; +var \u{2DE1F}; +var \u{2DE20}; +var \u{2DE21}; +var \u{2DE22}; +var \u{2DE23}; +var \u{2DE24}; +var \u{2DE25}; +var \u{2DE26}; +var \u{2DE27}; +var \u{2DE28}; +var \u{2DE29}; +var \u{2DE2A}; +var \u{2DE2B}; +var \u{2DE2C}; +var \u{2DE2D}; +var \u{2DE2E}; +var \u{2DE2F}; +var \u{2DE30}; +var \u{2DE31}; +var \u{2DE32}; +var \u{2DE33}; +var \u{2DE34}; +var \u{2DE35}; +var \u{2DE36}; +var \u{2DE37}; +var \u{2DE38}; +var \u{2DE39}; +var \u{2DE3A}; +var \u{2DE3B}; +var \u{2DE3C}; +var \u{2DE3D}; +var \u{2DE3E}; +var \u{2DE3F}; +var \u{2DE40}; +var \u{2DE41}; +var \u{2DE42}; +var \u{2DE43}; +var \u{2DE44}; +var \u{2DE45}; +var \u{2DE46}; +var \u{2DE47}; +var \u{2DE48}; +var \u{2DE49}; +var \u{2DE4A}; +var \u{2DE4B}; +var \u{2DE4C}; +var \u{2DE4D}; +var \u{2DE4E}; +var \u{2DE4F}; +var \u{2DE50}; +var \u{2DE51}; +var \u{2DE52}; +var \u{2DE53}; +var \u{2DE54}; +var \u{2DE55}; +var \u{2DE56}; +var \u{2DE57}; +var \u{2DE58}; +var \u{2DE59}; +var \u{2DE5A}; +var \u{2DE5B}; +var \u{2DE5C}; +var \u{2DE5D}; +var \u{2DE5E}; +var \u{2DE5F}; +var \u{2DE60}; +var \u{2DE61}; +var \u{2DE62}; +var \u{2DE63}; +var \u{2DE64}; +var \u{2DE65}; +var \u{2DE66}; +var \u{2DE67}; +var \u{2DE68}; +var \u{2DE69}; +var \u{2DE6A}; +var \u{2DE6B}; +var \u{2DE6C}; +var \u{2DE6D}; +var \u{2DE6E}; +var \u{2DE6F}; +var \u{2DE70}; +var \u{2DE71}; +var \u{2DE72}; +var \u{2DE73}; +var \u{2DE74}; +var \u{2DE75}; +var \u{2DE76}; +var \u{2DE77}; +var \u{2DE78}; +var \u{2DE79}; +var \u{2DE7A}; +var \u{2DE7B}; +var \u{2DE7C}; +var \u{2DE7D}; +var \u{2DE7E}; +var \u{2DE7F}; +var \u{2DE80}; +var \u{2DE81}; +var \u{2DE82}; +var \u{2DE83}; +var \u{2DE84}; +var \u{2DE85}; +var \u{2DE86}; +var \u{2DE87}; +var \u{2DE88}; +var \u{2DE89}; +var \u{2DE8A}; +var \u{2DE8B}; +var \u{2DE8C}; +var \u{2DE8D}; +var \u{2DE8E}; +var \u{2DE8F}; +var \u{2DE90}; +var \u{2DE91}; +var \u{2DE92}; +var \u{2DE93}; +var \u{2DE94}; +var \u{2DE95}; +var \u{2DE96}; +var \u{2DE97}; +var \u{2DE98}; +var \u{2DE99}; +var \u{2DE9A}; +var \u{2DE9B}; +var \u{2DE9C}; +var \u{2DE9D}; +var \u{2DE9E}; +var \u{2DE9F}; +var \u{2DEA0}; +var \u{2DEA1}; +var \u{2DEA2}; +var \u{2DEA3}; +var \u{2DEA4}; +var \u{2DEA5}; +var \u{2DEA6}; +var \u{2DEA7}; +var \u{2DEA8}; +var \u{2DEA9}; +var \u{2DEAA}; +var \u{2DEAB}; +var \u{2DEAC}; +var \u{2DEAD}; +var \u{2DEAE}; +var \u{2DEAF}; +var \u{2DEB0}; +var \u{2DEB1}; +var \u{2DEB2}; +var \u{2DEB3}; +var \u{2DEB4}; +var \u{2DEB5}; +var \u{2DEB6}; +var \u{2DEB7}; +var \u{2DEB8}; +var \u{2DEB9}; +var \u{2DEBA}; +var \u{2DEBB}; +var \u{2DEBC}; +var \u{2DEBD}; +var \u{2DEBE}; +var \u{2DEBF}; +var \u{2DEC0}; +var \u{2DEC1}; +var \u{2DEC2}; +var \u{2DEC3}; +var \u{2DEC4}; +var \u{2DEC5}; +var \u{2DEC6}; +var \u{2DEC7}; +var \u{2DEC8}; +var \u{2DEC9}; +var \u{2DECA}; +var \u{2DECB}; +var \u{2DECC}; +var \u{2DECD}; +var \u{2DECE}; +var \u{2DECF}; +var \u{2DED0}; +var \u{2DED1}; +var \u{2DED2}; +var \u{2DED3}; +var \u{2DED4}; +var \u{2DED5}; +var \u{2DED6}; +var \u{2DED7}; +var \u{2DED8}; +var \u{2DED9}; +var \u{2DEDA}; +var \u{2DEDB}; +var \u{2DEDC}; +var \u{2DEDD}; +var \u{2DEDE}; +var \u{2DEDF}; +var \u{2DEE0}; +var \u{2DEE1}; +var \u{2DEE2}; +var \u{2DEE3}; +var \u{2DEE4}; +var \u{2DEE5}; +var \u{2DEE6}; +var \u{2DEE7}; +var \u{2DEE8}; +var \u{2DEE9}; +var \u{2DEEA}; +var \u{2DEEB}; +var \u{2DEEC}; +var \u{2DEED}; +var \u{2DEEE}; +var \u{2DEEF}; +var \u{2DEF0}; +var \u{2DEF1}; +var \u{2DEF2}; +var \u{2DEF3}; +var \u{2DEF4}; +var \u{2DEF5}; +var \u{2DEF6}; +var \u{2DEF7}; +var \u{2DEF8}; +var \u{2DEF9}; +var \u{2DEFA}; +var \u{2DEFB}; +var \u{2DEFC}; +var \u{2DEFD}; +var \u{2DEFE}; +var \u{2DEFF}; +var \u{2DF00}; +var \u{2DF01}; +var \u{2DF02}; +var \u{2DF03}; +var \u{2DF04}; +var \u{2DF05}; +var \u{2DF06}; +var \u{2DF07}; +var \u{2DF08}; +var \u{2DF09}; +var \u{2DF0A}; +var \u{2DF0B}; +var \u{2DF0C}; +var \u{2DF0D}; +var \u{2DF0E}; +var \u{2DF0F}; +var \u{2DF10}; +var \u{2DF11}; +var \u{2DF12}; +var \u{2DF13}; +var \u{2DF14}; +var \u{2DF15}; +var \u{2DF16}; +var \u{2DF17}; +var \u{2DF18}; +var \u{2DF19}; +var \u{2DF1A}; +var \u{2DF1B}; +var \u{2DF1C}; +var \u{2DF1D}; +var \u{2DF1E}; +var \u{2DF1F}; +var \u{2DF20}; +var \u{2DF21}; +var \u{2DF22}; +var \u{2DF23}; +var \u{2DF24}; +var \u{2DF25}; +var \u{2DF26}; +var \u{2DF27}; +var \u{2DF28}; +var \u{2DF29}; +var \u{2DF2A}; +var \u{2DF2B}; +var \u{2DF2C}; +var \u{2DF2D}; +var \u{2DF2E}; +var \u{2DF2F}; +var \u{2DF30}; +var \u{2DF31}; +var \u{2DF32}; +var \u{2DF33}; +var \u{2DF34}; +var \u{2DF35}; +var \u{2DF36}; +var \u{2DF37}; +var \u{2DF38}; +var \u{2DF39}; +var \u{2DF3A}; +var \u{2DF3B}; +var \u{2DF3C}; +var \u{2DF3D}; +var \u{2DF3E}; +var \u{2DF3F}; +var \u{2DF40}; +var \u{2DF41}; +var \u{2DF42}; +var \u{2DF43}; +var \u{2DF44}; +var \u{2DF45}; +var \u{2DF46}; +var \u{2DF47}; +var \u{2DF48}; +var \u{2DF49}; +var \u{2DF4A}; +var \u{2DF4B}; +var \u{2DF4C}; +var \u{2DF4D}; +var \u{2DF4E}; +var \u{2DF4F}; +var \u{2DF50}; +var \u{2DF51}; +var \u{2DF52}; +var \u{2DF53}; +var \u{2DF54}; +var \u{2DF55}; +var \u{2DF56}; +var \u{2DF57}; +var \u{2DF58}; +var \u{2DF59}; +var \u{2DF5A}; +var \u{2DF5B}; +var \u{2DF5C}; +var \u{2DF5D}; +var \u{2DF5E}; +var \u{2DF5F}; +var \u{2DF60}; +var \u{2DF61}; +var \u{2DF62}; +var \u{2DF63}; +var \u{2DF64}; +var \u{2DF65}; +var \u{2DF66}; +var \u{2DF67}; +var \u{2DF68}; +var \u{2DF69}; +var \u{2DF6A}; +var \u{2DF6B}; +var \u{2DF6C}; +var \u{2DF6D}; +var \u{2DF6E}; +var \u{2DF6F}; +var \u{2DF70}; +var \u{2DF71}; +var \u{2DF72}; +var \u{2DF73}; +var \u{2DF74}; +var \u{2DF75}; +var \u{2DF76}; +var \u{2DF77}; +var \u{2DF78}; +var \u{2DF79}; +var \u{2DF7A}; +var \u{2DF7B}; +var \u{2DF7C}; +var \u{2DF7D}; +var \u{2DF7E}; +var \u{2DF7F}; +var \u{2DF80}; +var \u{2DF81}; +var \u{2DF82}; +var \u{2DF83}; +var \u{2DF84}; +var \u{2DF85}; +var \u{2DF86}; +var \u{2DF87}; +var \u{2DF88}; +var \u{2DF89}; +var \u{2DF8A}; +var \u{2DF8B}; +var \u{2DF8C}; +var \u{2DF8D}; +var \u{2DF8E}; +var \u{2DF8F}; +var \u{2DF90}; +var \u{2DF91}; +var \u{2DF92}; +var \u{2DF93}; +var \u{2DF94}; +var \u{2DF95}; +var \u{2DF96}; +var \u{2DF97}; +var \u{2DF98}; +var \u{2DF99}; +var \u{2DF9A}; +var \u{2DF9B}; +var \u{2DF9C}; +var \u{2DF9D}; +var \u{2DF9E}; +var \u{2DF9F}; +var \u{2DFA0}; +var \u{2DFA1}; +var \u{2DFA2}; +var \u{2DFA3}; +var \u{2DFA4}; +var \u{2DFA5}; +var \u{2DFA6}; +var \u{2DFA7}; +var \u{2DFA8}; +var \u{2DFA9}; +var \u{2DFAA}; +var \u{2DFAB}; +var \u{2DFAC}; +var \u{2DFAD}; +var \u{2DFAE}; +var \u{2DFAF}; +var \u{2DFB0}; +var \u{2DFB1}; +var \u{2DFB2}; +var \u{2DFB3}; +var \u{2DFB4}; +var \u{2DFB5}; +var \u{2DFB6}; +var \u{2DFB7}; +var \u{2DFB8}; +var \u{2DFB9}; +var \u{2DFBA}; +var \u{2DFBB}; +var \u{2DFBC}; +var \u{2DFBD}; +var \u{2DFBE}; +var \u{2DFBF}; +var \u{2DFC0}; +var \u{2DFC1}; +var \u{2DFC2}; +var \u{2DFC3}; +var \u{2DFC4}; +var \u{2DFC5}; +var \u{2DFC6}; +var \u{2DFC7}; +var \u{2DFC8}; +var \u{2DFC9}; +var \u{2DFCA}; +var \u{2DFCB}; +var \u{2DFCC}; +var \u{2DFCD}; +var \u{2DFCE}; +var \u{2DFCF}; +var \u{2DFD0}; +var \u{2DFD1}; +var \u{2DFD2}; +var \u{2DFD3}; +var \u{2DFD4}; +var \u{2DFD5}; +var \u{2DFD6}; +var \u{2DFD7}; +var \u{2DFD8}; +var \u{2DFD9}; +var \u{2DFDA}; +var \u{2DFDB}; +var \u{2DFDC}; +var \u{2DFDD}; +var \u{2DFDE}; +var \u{2DFDF}; +var \u{2DFE0}; +var \u{2DFE1}; +var \u{2DFE2}; +var \u{2DFE3}; +var \u{2DFE4}; +var \u{2DFE5}; +var \u{2DFE6}; +var \u{2DFE7}; +var \u{2DFE8}; +var \u{2DFE9}; +var \u{2DFEA}; +var \u{2DFEB}; +var \u{2DFEC}; +var \u{2DFED}; +var \u{2DFEE}; +var \u{2DFEF}; +var \u{2DFF0}; +var \u{2DFF1}; +var \u{2DFF2}; +var \u{2DFF3}; +var \u{2DFF4}; +var \u{2DFF5}; +var \u{2DFF6}; +var \u{2DFF7}; +var \u{2DFF8}; +var \u{2DFF9}; +var \u{2DFFA}; +var \u{2DFFB}; +var \u{2DFFC}; +var \u{2DFFD}; +var \u{2DFFE}; +var \u{2DFFF}; +var \u{2E000}; +var \u{2E001}; +var \u{2E002}; +var \u{2E003}; +var \u{2E004}; +var \u{2E005}; +var \u{2E006}; +var \u{2E007}; +var \u{2E008}; +var \u{2E009}; +var \u{2E00A}; +var \u{2E00B}; +var \u{2E00C}; +var \u{2E00D}; +var \u{2E00E}; +var \u{2E00F}; +var \u{2E010}; +var \u{2E011}; +var \u{2E012}; +var \u{2E013}; +var \u{2E014}; +var \u{2E015}; +var \u{2E016}; +var \u{2E017}; +var \u{2E018}; +var \u{2E019}; +var \u{2E01A}; +var \u{2E01B}; +var \u{2E01C}; +var \u{2E01D}; +var \u{2E01E}; +var \u{2E01F}; +var \u{2E020}; +var \u{2E021}; +var \u{2E022}; +var \u{2E023}; +var \u{2E024}; +var \u{2E025}; +var \u{2E026}; +var \u{2E027}; +var \u{2E028}; +var \u{2E029}; +var \u{2E02A}; +var \u{2E02B}; +var \u{2E02C}; +var \u{2E02D}; +var \u{2E02E}; +var \u{2E02F}; +var \u{2E030}; +var \u{2E031}; +var \u{2E032}; +var \u{2E033}; +var \u{2E034}; +var \u{2E035}; +var \u{2E036}; +var \u{2E037}; +var \u{2E038}; +var \u{2E039}; +var \u{2E03A}; +var \u{2E03B}; +var \u{2E03C}; +var \u{2E03D}; +var \u{2E03E}; +var \u{2E03F}; +var \u{2E040}; +var \u{2E041}; +var \u{2E042}; +var \u{2E043}; +var \u{2E044}; +var \u{2E045}; +var \u{2E046}; +var \u{2E047}; +var \u{2E048}; +var \u{2E049}; +var \u{2E04A}; +var \u{2E04B}; +var \u{2E04C}; +var \u{2E04D}; +var \u{2E04E}; +var \u{2E04F}; +var \u{2E050}; +var \u{2E051}; +var \u{2E052}; +var \u{2E053}; +var \u{2E054}; +var \u{2E055}; +var \u{2E056}; +var \u{2E057}; +var \u{2E058}; +var \u{2E059}; +var \u{2E05A}; +var \u{2E05B}; +var \u{2E05C}; +var \u{2E05D}; +var \u{2E05E}; +var \u{2E05F}; +var \u{2E060}; +var \u{2E061}; +var \u{2E062}; +var \u{2E063}; +var \u{2E064}; +var \u{2E065}; +var \u{2E066}; +var \u{2E067}; +var \u{2E068}; +var \u{2E069}; +var \u{2E06A}; +var \u{2E06B}; +var \u{2E06C}; +var \u{2E06D}; +var \u{2E06E}; +var \u{2E06F}; +var \u{2E070}; +var \u{2E071}; +var \u{2E072}; +var \u{2E073}; +var \u{2E074}; +var \u{2E075}; +var \u{2E076}; +var \u{2E077}; +var \u{2E078}; +var \u{2E079}; +var \u{2E07A}; +var \u{2E07B}; +var \u{2E07C}; +var \u{2E07D}; +var \u{2E07E}; +var \u{2E07F}; +var \u{2E080}; +var \u{2E081}; +var \u{2E082}; +var \u{2E083}; +var \u{2E084}; +var \u{2E085}; +var \u{2E086}; +var \u{2E087}; +var \u{2E088}; +var \u{2E089}; +var \u{2E08A}; +var \u{2E08B}; +var \u{2E08C}; +var \u{2E08D}; +var \u{2E08E}; +var \u{2E08F}; +var \u{2E090}; +var \u{2E091}; +var \u{2E092}; +var \u{2E093}; +var \u{2E094}; +var \u{2E095}; +var \u{2E096}; +var \u{2E097}; +var \u{2E098}; +var \u{2E099}; +var \u{2E09A}; +var \u{2E09B}; +var \u{2E09C}; +var \u{2E09D}; +var \u{2E09E}; +var \u{2E09F}; +var \u{2E0A0}; +var \u{2E0A1}; +var \u{2E0A2}; +var \u{2E0A3}; +var \u{2E0A4}; +var \u{2E0A5}; +var \u{2E0A6}; +var \u{2E0A7}; +var \u{2E0A8}; +var \u{2E0A9}; +var \u{2E0AA}; +var \u{2E0AB}; +var \u{2E0AC}; +var \u{2E0AD}; +var \u{2E0AE}; +var \u{2E0AF}; +var \u{2E0B0}; +var \u{2E0B1}; +var \u{2E0B2}; +var \u{2E0B3}; +var \u{2E0B4}; +var \u{2E0B5}; +var \u{2E0B6}; +var \u{2E0B7}; +var \u{2E0B8}; +var \u{2E0B9}; +var \u{2E0BA}; +var \u{2E0BB}; +var \u{2E0BC}; +var \u{2E0BD}; +var \u{2E0BE}; +var \u{2E0BF}; +var \u{2E0C0}; +var \u{2E0C1}; +var \u{2E0C2}; +var \u{2E0C3}; +var \u{2E0C4}; +var \u{2E0C5}; +var \u{2E0C6}; +var \u{2E0C7}; +var \u{2E0C8}; +var \u{2E0C9}; +var \u{2E0CA}; +var \u{2E0CB}; +var \u{2E0CC}; +var \u{2E0CD}; +var \u{2E0CE}; +var \u{2E0CF}; +var \u{2E0D0}; +var \u{2E0D1}; +var \u{2E0D2}; +var \u{2E0D3}; +var \u{2E0D4}; +var \u{2E0D5}; +var \u{2E0D6}; +var \u{2E0D7}; +var \u{2E0D8}; +var \u{2E0D9}; +var \u{2E0DA}; +var \u{2E0DB}; +var \u{2E0DC}; +var \u{2E0DD}; +var \u{2E0DE}; +var \u{2E0DF}; +var \u{2E0E0}; +var \u{2E0E1}; +var \u{2E0E2}; +var \u{2E0E3}; +var \u{2E0E4}; +var \u{2E0E5}; +var \u{2E0E6}; +var \u{2E0E7}; +var \u{2E0E8}; +var \u{2E0E9}; +var \u{2E0EA}; +var \u{2E0EB}; +var \u{2E0EC}; +var \u{2E0ED}; +var \u{2E0EE}; +var \u{2E0EF}; +var \u{2E0F0}; +var \u{2E0F1}; +var \u{2E0F2}; +var \u{2E0F3}; +var \u{2E0F4}; +var \u{2E0F5}; +var \u{2E0F6}; +var \u{2E0F7}; +var \u{2E0F8}; +var \u{2E0F9}; +var \u{2E0FA}; +var \u{2E0FB}; +var \u{2E0FC}; +var \u{2E0FD}; +var \u{2E0FE}; +var \u{2E0FF}; +var \u{2E100}; +var \u{2E101}; +var \u{2E102}; +var \u{2E103}; +var \u{2E104}; +var \u{2E105}; +var \u{2E106}; +var \u{2E107}; +var \u{2E108}; +var \u{2E109}; +var \u{2E10A}; +var \u{2E10B}; +var \u{2E10C}; +var \u{2E10D}; +var \u{2E10E}; +var \u{2E10F}; +var \u{2E110}; +var \u{2E111}; +var \u{2E112}; +var \u{2E113}; +var \u{2E114}; +var \u{2E115}; +var \u{2E116}; +var \u{2E117}; +var \u{2E118}; +var \u{2E119}; +var \u{2E11A}; +var \u{2E11B}; +var \u{2E11C}; +var \u{2E11D}; +var \u{2E11E}; +var \u{2E11F}; +var \u{2E120}; +var \u{2E121}; +var \u{2E122}; +var \u{2E123}; +var \u{2E124}; +var \u{2E125}; +var \u{2E126}; +var \u{2E127}; +var \u{2E128}; +var \u{2E129}; +var \u{2E12A}; +var \u{2E12B}; +var \u{2E12C}; +var \u{2E12D}; +var \u{2E12E}; +var \u{2E12F}; +var \u{2E130}; +var \u{2E131}; +var \u{2E132}; +var \u{2E133}; +var \u{2E134}; +var \u{2E135}; +var \u{2E136}; +var \u{2E137}; +var \u{2E138}; +var \u{2E139}; +var \u{2E13A}; +var \u{2E13B}; +var \u{2E13C}; +var \u{2E13D}; +var \u{2E13E}; +var \u{2E13F}; +var \u{2E140}; +var \u{2E141}; +var \u{2E142}; +var \u{2E143}; +var \u{2E144}; +var \u{2E145}; +var \u{2E146}; +var \u{2E147}; +var \u{2E148}; +var \u{2E149}; +var \u{2E14A}; +var \u{2E14B}; +var \u{2E14C}; +var \u{2E14D}; +var \u{2E14E}; +var \u{2E14F}; +var \u{2E150}; +var \u{2E151}; +var \u{2E152}; +var \u{2E153}; +var \u{2E154}; +var \u{2E155}; +var \u{2E156}; +var \u{2E157}; +var \u{2E158}; +var \u{2E159}; +var \u{2E15A}; +var \u{2E15B}; +var \u{2E15C}; +var \u{2E15D}; +var \u{2E15E}; +var \u{2E15F}; +var \u{2E160}; +var \u{2E161}; +var \u{2E162}; +var \u{2E163}; +var \u{2E164}; +var \u{2E165}; +var \u{2E166}; +var \u{2E167}; +var \u{2E168}; +var \u{2E169}; +var \u{2E16A}; +var \u{2E16B}; +var \u{2E16C}; +var \u{2E16D}; +var \u{2E16E}; +var \u{2E16F}; +var \u{2E170}; +var \u{2E171}; +var \u{2E172}; +var \u{2E173}; +var \u{2E174}; +var \u{2E175}; +var \u{2E176}; +var \u{2E177}; +var \u{2E178}; +var \u{2E179}; +var \u{2E17A}; +var \u{2E17B}; +var \u{2E17C}; +var \u{2E17D}; +var \u{2E17E}; +var \u{2E17F}; +var \u{2E180}; +var \u{2E181}; +var \u{2E182}; +var \u{2E183}; +var \u{2E184}; +var \u{2E185}; +var \u{2E186}; +var \u{2E187}; +var \u{2E188}; +var \u{2E189}; +var \u{2E18A}; +var \u{2E18B}; +var \u{2E18C}; +var \u{2E18D}; +var \u{2E18E}; +var \u{2E18F}; +var \u{2E190}; +var \u{2E191}; +var \u{2E192}; +var \u{2E193}; +var \u{2E194}; +var \u{2E195}; +var \u{2E196}; +var \u{2E197}; +var \u{2E198}; +var \u{2E199}; +var \u{2E19A}; +var \u{2E19B}; +var \u{2E19C}; +var \u{2E19D}; +var \u{2E19E}; +var \u{2E19F}; +var \u{2E1A0}; +var \u{2E1A1}; +var \u{2E1A2}; +var \u{2E1A3}; +var \u{2E1A4}; +var \u{2E1A5}; +var \u{2E1A6}; +var \u{2E1A7}; +var \u{2E1A8}; +var \u{2E1A9}; +var \u{2E1AA}; +var \u{2E1AB}; +var \u{2E1AC}; +var \u{2E1AD}; +var \u{2E1AE}; +var \u{2E1AF}; +var \u{2E1B0}; +var \u{2E1B1}; +var \u{2E1B2}; +var \u{2E1B3}; +var \u{2E1B4}; +var \u{2E1B5}; +var \u{2E1B6}; +var \u{2E1B7}; +var \u{2E1B8}; +var \u{2E1B9}; +var \u{2E1BA}; +var \u{2E1BB}; +var \u{2E1BC}; +var \u{2E1BD}; +var \u{2E1BE}; +var \u{2E1BF}; +var \u{2E1C0}; +var \u{2E1C1}; +var \u{2E1C2}; +var \u{2E1C3}; +var \u{2E1C4}; +var \u{2E1C5}; +var \u{2E1C6}; +var \u{2E1C7}; +var \u{2E1C8}; +var \u{2E1C9}; +var \u{2E1CA}; +var \u{2E1CB}; +var \u{2E1CC}; +var \u{2E1CD}; +var \u{2E1CE}; +var \u{2E1CF}; +var \u{2E1D0}; +var \u{2E1D1}; +var \u{2E1D2}; +var \u{2E1D3}; +var \u{2E1D4}; +var \u{2E1D5}; +var \u{2E1D6}; +var \u{2E1D7}; +var \u{2E1D8}; +var \u{2E1D9}; +var \u{2E1DA}; +var \u{2E1DB}; +var \u{2E1DC}; +var \u{2E1DD}; +var \u{2E1DE}; +var \u{2E1DF}; +var \u{2E1E0}; +var \u{2E1E1}; +var \u{2E1E2}; +var \u{2E1E3}; +var \u{2E1E4}; +var \u{2E1E5}; +var \u{2E1E6}; +var \u{2E1E7}; +var \u{2E1E8}; +var \u{2E1E9}; +var \u{2E1EA}; +var \u{2E1EB}; +var \u{2E1EC}; +var \u{2E1ED}; +var \u{2E1EE}; +var \u{2E1EF}; +var \u{2E1F0}; +var \u{2E1F1}; +var \u{2E1F2}; +var \u{2E1F3}; +var \u{2E1F4}; +var \u{2E1F5}; +var \u{2E1F6}; +var \u{2E1F7}; +var \u{2E1F8}; +var \u{2E1F9}; +var \u{2E1FA}; +var \u{2E1FB}; +var \u{2E1FC}; +var \u{2E1FD}; +var \u{2E1FE}; +var \u{2E1FF}; +var \u{2E200}; +var \u{2E201}; +var \u{2E202}; +var \u{2E203}; +var \u{2E204}; +var \u{2E205}; +var \u{2E206}; +var \u{2E207}; +var \u{2E208}; +var \u{2E209}; +var \u{2E20A}; +var \u{2E20B}; +var \u{2E20C}; +var \u{2E20D}; +var \u{2E20E}; +var \u{2E20F}; +var \u{2E210}; +var \u{2E211}; +var \u{2E212}; +var \u{2E213}; +var \u{2E214}; +var \u{2E215}; +var \u{2E216}; +var \u{2E217}; +var \u{2E218}; +var \u{2E219}; +var \u{2E21A}; +var \u{2E21B}; +var \u{2E21C}; +var \u{2E21D}; +var \u{2E21E}; +var \u{2E21F}; +var \u{2E220}; +var \u{2E221}; +var \u{2E222}; +var \u{2E223}; +var \u{2E224}; +var \u{2E225}; +var \u{2E226}; +var \u{2E227}; +var \u{2E228}; +var \u{2E229}; +var \u{2E22A}; +var \u{2E22B}; +var \u{2E22C}; +var \u{2E22D}; +var \u{2E22E}; +var \u{2E22F}; +var \u{2E230}; +var \u{2E231}; +var \u{2E232}; +var \u{2E233}; +var \u{2E234}; +var \u{2E235}; +var \u{2E236}; +var \u{2E237}; +var \u{2E238}; +var \u{2E239}; +var \u{2E23A}; +var \u{2E23B}; +var \u{2E23C}; +var \u{2E23D}; +var \u{2E23E}; +var \u{2E23F}; +var \u{2E240}; +var \u{2E241}; +var \u{2E242}; +var \u{2E243}; +var \u{2E244}; +var \u{2E245}; +var \u{2E246}; +var \u{2E247}; +var \u{2E248}; +var \u{2E249}; +var \u{2E24A}; +var \u{2E24B}; +var \u{2E24C}; +var \u{2E24D}; +var \u{2E24E}; +var \u{2E24F}; +var \u{2E250}; +var \u{2E251}; +var \u{2E252}; +var \u{2E253}; +var \u{2E254}; +var \u{2E255}; +var \u{2E256}; +var \u{2E257}; +var \u{2E258}; +var \u{2E259}; +var \u{2E25A}; +var \u{2E25B}; +var \u{2E25C}; +var \u{2E25D}; +var \u{2E25E}; +var \u{2E25F}; +var \u{2E260}; +var \u{2E261}; +var \u{2E262}; +var \u{2E263}; +var \u{2E264}; +var \u{2E265}; +var \u{2E266}; +var \u{2E267}; +var \u{2E268}; +var \u{2E269}; +var \u{2E26A}; +var \u{2E26B}; +var \u{2E26C}; +var \u{2E26D}; +var \u{2E26E}; +var \u{2E26F}; +var \u{2E270}; +var \u{2E271}; +var \u{2E272}; +var \u{2E273}; +var \u{2E274}; +var \u{2E275}; +var \u{2E276}; +var \u{2E277}; +var \u{2E278}; +var \u{2E279}; +var \u{2E27A}; +var \u{2E27B}; +var \u{2E27C}; +var \u{2E27D}; +var \u{2E27E}; +var \u{2E27F}; +var \u{2E280}; +var \u{2E281}; +var \u{2E282}; +var \u{2E283}; +var \u{2E284}; +var \u{2E285}; +var \u{2E286}; +var \u{2E287}; +var \u{2E288}; +var \u{2E289}; +var \u{2E28A}; +var \u{2E28B}; +var \u{2E28C}; +var \u{2E28D}; +var \u{2E28E}; +var \u{2E28F}; +var \u{2E290}; +var \u{2E291}; +var \u{2E292}; +var \u{2E293}; +var \u{2E294}; +var \u{2E295}; +var \u{2E296}; +var \u{2E297}; +var \u{2E298}; +var \u{2E299}; +var \u{2E29A}; +var \u{2E29B}; +var \u{2E29C}; +var \u{2E29D}; +var \u{2E29E}; +var \u{2E29F}; +var \u{2E2A0}; +var \u{2E2A1}; +var \u{2E2A2}; +var \u{2E2A3}; +var \u{2E2A4}; +var \u{2E2A5}; +var \u{2E2A6}; +var \u{2E2A7}; +var \u{2E2A8}; +var \u{2E2A9}; +var \u{2E2AA}; +var \u{2E2AB}; +var \u{2E2AC}; +var \u{2E2AD}; +var \u{2E2AE}; +var \u{2E2AF}; +var \u{2E2B0}; +var \u{2E2B1}; +var \u{2E2B2}; +var \u{2E2B3}; +var \u{2E2B4}; +var \u{2E2B5}; +var \u{2E2B6}; +var \u{2E2B7}; +var \u{2E2B8}; +var \u{2E2B9}; +var \u{2E2BA}; +var \u{2E2BB}; +var \u{2E2BC}; +var \u{2E2BD}; +var \u{2E2BE}; +var \u{2E2BF}; +var \u{2E2C0}; +var \u{2E2C1}; +var \u{2E2C2}; +var \u{2E2C3}; +var \u{2E2C4}; +var \u{2E2C5}; +var \u{2E2C6}; +var \u{2E2C7}; +var \u{2E2C8}; +var \u{2E2C9}; +var \u{2E2CA}; +var \u{2E2CB}; +var \u{2E2CC}; +var \u{2E2CD}; +var \u{2E2CE}; +var \u{2E2CF}; +var \u{2E2D0}; +var \u{2E2D1}; +var \u{2E2D2}; +var \u{2E2D3}; +var \u{2E2D4}; +var \u{2E2D5}; +var \u{2E2D6}; +var \u{2E2D7}; +var \u{2E2D8}; +var \u{2E2D9}; +var \u{2E2DA}; +var \u{2E2DB}; +var \u{2E2DC}; +var \u{2E2DD}; +var \u{2E2DE}; +var \u{2E2DF}; +var \u{2E2E0}; +var \u{2E2E1}; +var \u{2E2E2}; +var \u{2E2E3}; +var \u{2E2E4}; +var \u{2E2E5}; +var \u{2E2E6}; +var \u{2E2E7}; +var \u{2E2E8}; +var \u{2E2E9}; +var \u{2E2EA}; +var \u{2E2EB}; +var \u{2E2EC}; +var \u{2E2ED}; +var \u{2E2EE}; +var \u{2E2EF}; +var \u{2E2F0}; +var \u{2E2F1}; +var \u{2E2F2}; +var \u{2E2F3}; +var \u{2E2F4}; +var \u{2E2F5}; +var \u{2E2F6}; +var \u{2E2F7}; +var \u{2E2F8}; +var \u{2E2F9}; +var \u{2E2FA}; +var \u{2E2FB}; +var \u{2E2FC}; +var \u{2E2FD}; +var \u{2E2FE}; +var \u{2E2FF}; +var \u{2E300}; +var \u{2E301}; +var \u{2E302}; +var \u{2E303}; +var \u{2E304}; +var \u{2E305}; +var \u{2E306}; +var \u{2E307}; +var \u{2E308}; +var \u{2E309}; +var \u{2E30A}; +var \u{2E30B}; +var \u{2E30C}; +var \u{2E30D}; +var \u{2E30E}; +var \u{2E30F}; +var \u{2E310}; +var \u{2E311}; +var \u{2E312}; +var \u{2E313}; +var \u{2E314}; +var \u{2E315}; +var \u{2E316}; +var \u{2E317}; +var \u{2E318}; +var \u{2E319}; +var \u{2E31A}; +var \u{2E31B}; +var \u{2E31C}; +var \u{2E31D}; +var \u{2E31E}; +var \u{2E31F}; +var \u{2E320}; +var \u{2E321}; +var \u{2E322}; +var \u{2E323}; +var \u{2E324}; +var \u{2E325}; +var \u{2E326}; +var \u{2E327}; +var \u{2E328}; +var \u{2E329}; +var \u{2E32A}; +var \u{2E32B}; +var \u{2E32C}; +var \u{2E32D}; +var \u{2E32E}; +var \u{2E32F}; +var \u{2E330}; +var \u{2E331}; +var \u{2E332}; +var \u{2E333}; +var \u{2E334}; +var \u{2E335}; +var \u{2E336}; +var \u{2E337}; +var \u{2E338}; +var \u{2E339}; +var \u{2E33A}; +var \u{2E33B}; +var \u{2E33C}; +var \u{2E33D}; +var \u{2E33E}; +var \u{2E33F}; +var \u{2E340}; +var \u{2E341}; +var \u{2E342}; +var \u{2E343}; +var \u{2E344}; +var \u{2E345}; +var \u{2E346}; +var \u{2E347}; +var \u{2E348}; +var \u{2E349}; +var \u{2E34A}; +var \u{2E34B}; +var \u{2E34C}; +var \u{2E34D}; +var \u{2E34E}; +var \u{2E34F}; +var \u{2E350}; +var \u{2E351}; +var \u{2E352}; +var \u{2E353}; +var \u{2E354}; +var \u{2E355}; +var \u{2E356}; +var \u{2E357}; +var \u{2E358}; +var \u{2E359}; +var \u{2E35A}; +var \u{2E35B}; +var \u{2E35C}; +var \u{2E35D}; +var \u{2E35E}; +var \u{2E35F}; +var \u{2E360}; +var \u{2E361}; +var \u{2E362}; +var \u{2E363}; +var \u{2E364}; +var \u{2E365}; +var \u{2E366}; +var \u{2E367}; +var \u{2E368}; +var \u{2E369}; +var \u{2E36A}; +var \u{2E36B}; +var \u{2E36C}; +var \u{2E36D}; +var \u{2E36E}; +var \u{2E36F}; +var \u{2E370}; +var \u{2E371}; +var \u{2E372}; +var \u{2E373}; +var \u{2E374}; +var \u{2E375}; +var \u{2E376}; +var \u{2E377}; +var \u{2E378}; +var \u{2E379}; +var \u{2E37A}; +var \u{2E37B}; +var \u{2E37C}; +var \u{2E37D}; +var \u{2E37E}; +var \u{2E37F}; +var \u{2E380}; +var \u{2E381}; +var \u{2E382}; +var \u{2E383}; +var \u{2E384}; +var \u{2E385}; +var \u{2E386}; +var \u{2E387}; +var \u{2E388}; +var \u{2E389}; +var \u{2E38A}; +var \u{2E38B}; +var \u{2E38C}; +var \u{2E38D}; +var \u{2E38E}; +var \u{2E38F}; +var \u{2E390}; +var \u{2E391}; +var \u{2E392}; +var \u{2E393}; +var \u{2E394}; +var \u{2E395}; +var \u{2E396}; +var \u{2E397}; +var \u{2E398}; +var \u{2E399}; +var \u{2E39A}; +var \u{2E39B}; +var \u{2E39C}; +var \u{2E39D}; +var \u{2E39E}; +var \u{2E39F}; +var \u{2E3A0}; +var \u{2E3A1}; +var \u{2E3A2}; +var \u{2E3A3}; +var \u{2E3A4}; +var \u{2E3A5}; +var \u{2E3A6}; +var \u{2E3A7}; +var \u{2E3A8}; +var \u{2E3A9}; +var \u{2E3AA}; +var \u{2E3AB}; +var \u{2E3AC}; +var \u{2E3AD}; +var \u{2E3AE}; +var \u{2E3AF}; +var \u{2E3B0}; +var \u{2E3B1}; +var \u{2E3B2}; +var \u{2E3B3}; +var \u{2E3B4}; +var \u{2E3B5}; +var \u{2E3B6}; +var \u{2E3B7}; +var \u{2E3B8}; +var \u{2E3B9}; +var \u{2E3BA}; +var \u{2E3BB}; +var \u{2E3BC}; +var \u{2E3BD}; +var \u{2E3BE}; +var \u{2E3BF}; +var \u{2E3C0}; +var \u{2E3C1}; +var \u{2E3C2}; +var \u{2E3C3}; +var \u{2E3C4}; +var \u{2E3C5}; +var \u{2E3C6}; +var \u{2E3C7}; +var \u{2E3C8}; +var \u{2E3C9}; +var \u{2E3CA}; +var \u{2E3CB}; +var \u{2E3CC}; +var \u{2E3CD}; +var \u{2E3CE}; +var \u{2E3CF}; +var \u{2E3D0}; +var \u{2E3D1}; +var \u{2E3D2}; +var \u{2E3D3}; +var \u{2E3D4}; +var \u{2E3D5}; +var \u{2E3D6}; +var \u{2E3D7}; +var \u{2E3D8}; +var \u{2E3D9}; +var \u{2E3DA}; +var \u{2E3DB}; +var \u{2E3DC}; +var \u{2E3DD}; +var \u{2E3DE}; +var \u{2E3DF}; +var \u{2E3E0}; +var \u{2E3E1}; +var \u{2E3E2}; +var \u{2E3E3}; +var \u{2E3E4}; +var \u{2E3E5}; +var \u{2E3E6}; +var \u{2E3E7}; +var \u{2E3E8}; +var \u{2E3E9}; +var \u{2E3EA}; +var \u{2E3EB}; +var \u{2E3EC}; +var \u{2E3ED}; +var \u{2E3EE}; +var \u{2E3EF}; +var \u{2E3F0}; +var \u{2E3F1}; +var \u{2E3F2}; +var \u{2E3F3}; +var \u{2E3F4}; +var \u{2E3F5}; +var \u{2E3F6}; +var \u{2E3F7}; +var \u{2E3F8}; +var \u{2E3F9}; +var \u{2E3FA}; +var \u{2E3FB}; +var \u{2E3FC}; +var \u{2E3FD}; +var \u{2E3FE}; +var \u{2E3FF}; +var \u{2E400}; +var \u{2E401}; +var \u{2E402}; +var \u{2E403}; +var \u{2E404}; +var \u{2E405}; +var \u{2E406}; +var \u{2E407}; +var \u{2E408}; +var \u{2E409}; +var \u{2E40A}; +var \u{2E40B}; +var \u{2E40C}; +var \u{2E40D}; +var \u{2E40E}; +var \u{2E40F}; +var \u{2E410}; +var \u{2E411}; +var \u{2E412}; +var \u{2E413}; +var \u{2E414}; +var \u{2E415}; +var \u{2E416}; +var \u{2E417}; +var \u{2E418}; +var \u{2E419}; +var \u{2E41A}; +var \u{2E41B}; +var \u{2E41C}; +var \u{2E41D}; +var \u{2E41E}; +var \u{2E41F}; +var \u{2E420}; +var \u{2E421}; +var \u{2E422}; +var \u{2E423}; +var \u{2E424}; +var \u{2E425}; +var \u{2E426}; +var \u{2E427}; +var \u{2E428}; +var \u{2E429}; +var \u{2E42A}; +var \u{2E42B}; +var \u{2E42C}; +var \u{2E42D}; +var \u{2E42E}; +var \u{2E42F}; +var \u{2E430}; +var \u{2E431}; +var \u{2E432}; +var \u{2E433}; +var \u{2E434}; +var \u{2E435}; +var \u{2E436}; +var \u{2E437}; +var \u{2E438}; +var \u{2E439}; +var \u{2E43A}; +var \u{2E43B}; +var \u{2E43C}; +var \u{2E43D}; +var \u{2E43E}; +var \u{2E43F}; +var \u{2E440}; +var \u{2E441}; +var \u{2E442}; +var \u{2E443}; +var \u{2E444}; +var \u{2E445}; +var \u{2E446}; +var \u{2E447}; +var \u{2E448}; +var \u{2E449}; +var \u{2E44A}; +var \u{2E44B}; +var \u{2E44C}; +var \u{2E44D}; +var \u{2E44E}; +var \u{2E44F}; +var \u{2E450}; +var \u{2E451}; +var \u{2E452}; +var \u{2E453}; +var \u{2E454}; +var \u{2E455}; +var \u{2E456}; +var \u{2E457}; +var \u{2E458}; +var \u{2E459}; +var \u{2E45A}; +var \u{2E45B}; +var \u{2E45C}; +var \u{2E45D}; +var \u{2E45E}; +var \u{2E45F}; +var \u{2E460}; +var \u{2E461}; +var \u{2E462}; +var \u{2E463}; +var \u{2E464}; +var \u{2E465}; +var \u{2E466}; +var \u{2E467}; +var \u{2E468}; +var \u{2E469}; +var \u{2E46A}; +var \u{2E46B}; +var \u{2E46C}; +var \u{2E46D}; +var \u{2E46E}; +var \u{2E46F}; +var \u{2E470}; +var \u{2E471}; +var \u{2E472}; +var \u{2E473}; +var \u{2E474}; +var \u{2E475}; +var \u{2E476}; +var \u{2E477}; +var \u{2E478}; +var \u{2E479}; +var \u{2E47A}; +var \u{2E47B}; +var \u{2E47C}; +var \u{2E47D}; +var \u{2E47E}; +var \u{2E47F}; +var \u{2E480}; +var \u{2E481}; +var \u{2E482}; +var \u{2E483}; +var \u{2E484}; +var \u{2E485}; +var \u{2E486}; +var \u{2E487}; +var \u{2E488}; +var \u{2E489}; +var \u{2E48A}; +var \u{2E48B}; +var \u{2E48C}; +var \u{2E48D}; +var \u{2E48E}; +var \u{2E48F}; +var \u{2E490}; +var \u{2E491}; +var \u{2E492}; +var \u{2E493}; +var \u{2E494}; +var \u{2E495}; +var \u{2E496}; +var \u{2E497}; +var \u{2E498}; +var \u{2E499}; +var \u{2E49A}; +var \u{2E49B}; +var \u{2E49C}; +var \u{2E49D}; +var \u{2E49E}; +var \u{2E49F}; +var \u{2E4A0}; +var \u{2E4A1}; +var \u{2E4A2}; +var \u{2E4A3}; +var \u{2E4A4}; +var \u{2E4A5}; +var \u{2E4A6}; +var \u{2E4A7}; +var \u{2E4A8}; +var \u{2E4A9}; +var \u{2E4AA}; +var \u{2E4AB}; +var \u{2E4AC}; +var \u{2E4AD}; +var \u{2E4AE}; +var \u{2E4AF}; +var \u{2E4B0}; +var \u{2E4B1}; +var \u{2E4B2}; +var \u{2E4B3}; +var \u{2E4B4}; +var \u{2E4B5}; +var \u{2E4B6}; +var \u{2E4B7}; +var \u{2E4B8}; +var \u{2E4B9}; +var \u{2E4BA}; +var \u{2E4BB}; +var \u{2E4BC}; +var \u{2E4BD}; +var \u{2E4BE}; +var \u{2E4BF}; +var \u{2E4C0}; +var \u{2E4C1}; +var \u{2E4C2}; +var \u{2E4C3}; +var \u{2E4C4}; +var \u{2E4C5}; +var \u{2E4C6}; +var \u{2E4C7}; +var \u{2E4C8}; +var \u{2E4C9}; +var \u{2E4CA}; +var \u{2E4CB}; +var \u{2E4CC}; +var \u{2E4CD}; +var \u{2E4CE}; +var \u{2E4CF}; +var \u{2E4D0}; +var \u{2E4D1}; +var \u{2E4D2}; +var \u{2E4D3}; +var \u{2E4D4}; +var \u{2E4D5}; +var \u{2E4D6}; +var \u{2E4D7}; +var \u{2E4D8}; +var \u{2E4D9}; +var \u{2E4DA}; +var \u{2E4DB}; +var \u{2E4DC}; +var \u{2E4DD}; +var \u{2E4DE}; +var \u{2E4DF}; +var \u{2E4E0}; +var \u{2E4E1}; +var \u{2E4E2}; +var \u{2E4E3}; +var \u{2E4E4}; +var \u{2E4E5}; +var \u{2E4E6}; +var \u{2E4E7}; +var \u{2E4E8}; +var \u{2E4E9}; +var \u{2E4EA}; +var \u{2E4EB}; +var \u{2E4EC}; +var \u{2E4ED}; +var \u{2E4EE}; +var \u{2E4EF}; +var \u{2E4F0}; +var \u{2E4F1}; +var \u{2E4F2}; +var \u{2E4F3}; +var \u{2E4F4}; +var \u{2E4F5}; +var \u{2E4F6}; +var \u{2E4F7}; +var \u{2E4F8}; +var \u{2E4F9}; +var \u{2E4FA}; +var \u{2E4FB}; +var \u{2E4FC}; +var \u{2E4FD}; +var \u{2E4FE}; +var \u{2E4FF}; +var \u{2E500}; +var \u{2E501}; +var \u{2E502}; +var \u{2E503}; +var \u{2E504}; +var \u{2E505}; +var \u{2E506}; +var \u{2E507}; +var \u{2E508}; +var \u{2E509}; +var \u{2E50A}; +var \u{2E50B}; +var \u{2E50C}; +var \u{2E50D}; +var \u{2E50E}; +var \u{2E50F}; +var \u{2E510}; +var \u{2E511}; +var \u{2E512}; +var \u{2E513}; +var \u{2E514}; +var \u{2E515}; +var \u{2E516}; +var \u{2E517}; +var \u{2E518}; +var \u{2E519}; +var \u{2E51A}; +var \u{2E51B}; +var \u{2E51C}; +var \u{2E51D}; +var \u{2E51E}; +var \u{2E51F}; +var \u{2E520}; +var \u{2E521}; +var \u{2E522}; +var \u{2E523}; +var \u{2E524}; +var \u{2E525}; +var \u{2E526}; +var \u{2E527}; +var \u{2E528}; +var \u{2E529}; +var \u{2E52A}; +var \u{2E52B}; +var \u{2E52C}; +var \u{2E52D}; +var \u{2E52E}; +var \u{2E52F}; +var \u{2E530}; +var \u{2E531}; +var \u{2E532}; +var \u{2E533}; +var \u{2E534}; +var \u{2E535}; +var \u{2E536}; +var \u{2E537}; +var \u{2E538}; +var \u{2E539}; +var \u{2E53A}; +var \u{2E53B}; +var \u{2E53C}; +var \u{2E53D}; +var \u{2E53E}; +var \u{2E53F}; +var \u{2E540}; +var \u{2E541}; +var \u{2E542}; +var \u{2E543}; +var \u{2E544}; +var \u{2E545}; +var \u{2E546}; +var \u{2E547}; +var \u{2E548}; +var \u{2E549}; +var \u{2E54A}; +var \u{2E54B}; +var \u{2E54C}; +var \u{2E54D}; +var \u{2E54E}; +var \u{2E54F}; +var \u{2E550}; +var \u{2E551}; +var \u{2E552}; +var \u{2E553}; +var \u{2E554}; +var \u{2E555}; +var \u{2E556}; +var \u{2E557}; +var \u{2E558}; +var \u{2E559}; +var \u{2E55A}; +var \u{2E55B}; +var \u{2E55C}; +var \u{2E55D}; +var \u{2E55E}; +var \u{2E55F}; +var \u{2E560}; +var \u{2E561}; +var \u{2E562}; +var \u{2E563}; +var \u{2E564}; +var \u{2E565}; +var \u{2E566}; +var \u{2E567}; +var \u{2E568}; +var \u{2E569}; +var \u{2E56A}; +var \u{2E56B}; +var \u{2E56C}; +var \u{2E56D}; +var \u{2E56E}; +var \u{2E56F}; +var \u{2E570}; +var \u{2E571}; +var \u{2E572}; +var \u{2E573}; +var \u{2E574}; +var \u{2E575}; +var \u{2E576}; +var \u{2E577}; +var \u{2E578}; +var \u{2E579}; +var \u{2E57A}; +var \u{2E57B}; +var \u{2E57C}; +var \u{2E57D}; +var \u{2E57E}; +var \u{2E57F}; +var \u{2E580}; +var \u{2E581}; +var \u{2E582}; +var \u{2E583}; +var \u{2E584}; +var \u{2E585}; +var \u{2E586}; +var \u{2E587}; +var \u{2E588}; +var \u{2E589}; +var \u{2E58A}; +var \u{2E58B}; +var \u{2E58C}; +var \u{2E58D}; +var \u{2E58E}; +var \u{2E58F}; +var \u{2E590}; +var \u{2E591}; +var \u{2E592}; +var \u{2E593}; +var \u{2E594}; +var \u{2E595}; +var \u{2E596}; +var \u{2E597}; +var \u{2E598}; +var \u{2E599}; +var \u{2E59A}; +var \u{2E59B}; +var \u{2E59C}; +var \u{2E59D}; +var \u{2E59E}; +var \u{2E59F}; +var \u{2E5A0}; +var \u{2E5A1}; +var \u{2E5A2}; +var \u{2E5A3}; +var \u{2E5A4}; +var \u{2E5A5}; +var \u{2E5A6}; +var \u{2E5A7}; +var \u{2E5A8}; +var \u{2E5A9}; +var \u{2E5AA}; +var \u{2E5AB}; +var \u{2E5AC}; +var \u{2E5AD}; +var \u{2E5AE}; +var \u{2E5AF}; +var \u{2E5B0}; +var \u{2E5B1}; +var \u{2E5B2}; +var \u{2E5B3}; +var \u{2E5B4}; +var \u{2E5B5}; +var \u{2E5B6}; +var \u{2E5B7}; +var \u{2E5B8}; +var \u{2E5B9}; +var \u{2E5BA}; +var \u{2E5BB}; +var \u{2E5BC}; +var \u{2E5BD}; +var \u{2E5BE}; +var \u{2E5BF}; +var \u{2E5C0}; +var \u{2E5C1}; +var \u{2E5C2}; +var \u{2E5C3}; +var \u{2E5C4}; +var \u{2E5C5}; +var \u{2E5C6}; +var \u{2E5C7}; +var \u{2E5C8}; +var \u{2E5C9}; +var \u{2E5CA}; +var \u{2E5CB}; +var \u{2E5CC}; +var \u{2E5CD}; +var \u{2E5CE}; +var \u{2E5CF}; +var \u{2E5D0}; +var \u{2E5D1}; +var \u{2E5D2}; +var \u{2E5D3}; +var \u{2E5D4}; +var \u{2E5D5}; +var \u{2E5D6}; +var \u{2E5D7}; +var \u{2E5D8}; +var \u{2E5D9}; +var \u{2E5DA}; +var \u{2E5DB}; +var \u{2E5DC}; +var \u{2E5DD}; +var \u{2E5DE}; +var \u{2E5DF}; +var \u{2E5E0}; +var \u{2E5E1}; +var \u{2E5E2}; +var \u{2E5E3}; +var \u{2E5E4}; +var \u{2E5E5}; +var \u{2E5E6}; +var \u{2E5E7}; +var \u{2E5E8}; +var \u{2E5E9}; +var \u{2E5EA}; +var \u{2E5EB}; +var \u{2E5EC}; +var \u{2E5ED}; +var \u{2E5EE}; +var \u{2E5EF}; +var \u{2E5F0}; +var \u{2E5F1}; +var \u{2E5F2}; +var \u{2E5F3}; +var \u{2E5F4}; +var \u{2E5F5}; +var \u{2E5F6}; +var \u{2E5F7}; +var \u{2E5F8}; +var \u{2E5F9}; +var \u{2E5FA}; +var \u{2E5FB}; +var \u{2E5FC}; +var \u{2E5FD}; +var \u{2E5FE}; +var \u{2E5FF}; +var \u{2E600}; +var \u{2E601}; +var \u{2E602}; +var \u{2E603}; +var \u{2E604}; +var \u{2E605}; +var \u{2E606}; +var \u{2E607}; +var \u{2E608}; +var \u{2E609}; +var \u{2E60A}; +var \u{2E60B}; +var \u{2E60C}; +var \u{2E60D}; +var \u{2E60E}; +var \u{2E60F}; +var \u{2E610}; +var \u{2E611}; +var \u{2E612}; +var \u{2E613}; +var \u{2E614}; +var \u{2E615}; +var \u{2E616}; +var \u{2E617}; +var \u{2E618}; +var \u{2E619}; +var \u{2E61A}; +var \u{2E61B}; +var \u{2E61C}; +var \u{2E61D}; +var \u{2E61E}; +var \u{2E61F}; +var \u{2E620}; +var \u{2E621}; +var \u{2E622}; +var \u{2E623}; +var \u{2E624}; +var \u{2E625}; +var \u{2E626}; +var \u{2E627}; +var \u{2E628}; +var \u{2E629}; +var \u{2E62A}; +var \u{2E62B}; +var \u{2E62C}; +var \u{2E62D}; +var \u{2E62E}; +var \u{2E62F}; +var \u{2E630}; +var \u{2E631}; +var \u{2E632}; +var \u{2E633}; +var \u{2E634}; +var \u{2E635}; +var \u{2E636}; +var \u{2E637}; +var \u{2E638}; +var \u{2E639}; +var \u{2E63A}; +var \u{2E63B}; +var \u{2E63C}; +var \u{2E63D}; +var \u{2E63E}; +var \u{2E63F}; +var \u{2E640}; +var \u{2E641}; +var \u{2E642}; +var \u{2E643}; +var \u{2E644}; +var \u{2E645}; +var \u{2E646}; +var \u{2E647}; +var \u{2E648}; +var \u{2E649}; +var \u{2E64A}; +var \u{2E64B}; +var \u{2E64C}; +var \u{2E64D}; +var \u{2E64E}; +var \u{2E64F}; +var \u{2E650}; +var \u{2E651}; +var \u{2E652}; +var \u{2E653}; +var \u{2E654}; +var \u{2E655}; +var \u{2E656}; +var \u{2E657}; +var \u{2E658}; +var \u{2E659}; +var \u{2E65A}; +var \u{2E65B}; +var \u{2E65C}; +var \u{2E65D}; +var \u{2E65E}; +var \u{2E65F}; +var \u{2E660}; +var \u{2E661}; +var \u{2E662}; +var \u{2E663}; +var \u{2E664}; +var \u{2E665}; +var \u{2E666}; +var \u{2E667}; +var \u{2E668}; +var \u{2E669}; +var \u{2E66A}; +var \u{2E66B}; +var \u{2E66C}; +var \u{2E66D}; +var \u{2E66E}; +var \u{2E66F}; +var \u{2E670}; +var \u{2E671}; +var \u{2E672}; +var \u{2E673}; +var \u{2E674}; +var \u{2E675}; +var \u{2E676}; +var \u{2E677}; +var \u{2E678}; +var \u{2E679}; +var \u{2E67A}; +var \u{2E67B}; +var \u{2E67C}; +var \u{2E67D}; +var \u{2E67E}; +var \u{2E67F}; +var \u{2E680}; +var \u{2E681}; +var \u{2E682}; +var \u{2E683}; +var \u{2E684}; +var \u{2E685}; +var \u{2E686}; +var \u{2E687}; +var \u{2E688}; +var \u{2E689}; +var \u{2E68A}; +var \u{2E68B}; +var \u{2E68C}; +var \u{2E68D}; +var \u{2E68E}; +var \u{2E68F}; +var \u{2E690}; +var \u{2E691}; +var \u{2E692}; +var \u{2E693}; +var \u{2E694}; +var \u{2E695}; +var \u{2E696}; +var \u{2E697}; +var \u{2E698}; +var \u{2E699}; +var \u{2E69A}; +var \u{2E69B}; +var \u{2E69C}; +var \u{2E69D}; +var \u{2E69E}; +var \u{2E69F}; +var \u{2E6A0}; +var \u{2E6A1}; +var \u{2E6A2}; +var \u{2E6A3}; +var \u{2E6A4}; +var \u{2E6A5}; +var \u{2E6A6}; +var \u{2E6A7}; +var \u{2E6A8}; +var \u{2E6A9}; +var \u{2E6AA}; +var \u{2E6AB}; +var \u{2E6AC}; +var \u{2E6AD}; +var \u{2E6AE}; +var \u{2E6AF}; +var \u{2E6B0}; +var \u{2E6B1}; +var \u{2E6B2}; +var \u{2E6B3}; +var \u{2E6B4}; +var \u{2E6B5}; +var \u{2E6B6}; +var \u{2E6B7}; +var \u{2E6B8}; +var \u{2E6B9}; +var \u{2E6BA}; +var \u{2E6BB}; +var \u{2E6BC}; +var \u{2E6BD}; +var \u{2E6BE}; +var \u{2E6BF}; +var \u{2E6C0}; +var \u{2E6C1}; +var \u{2E6C2}; +var \u{2E6C3}; +var \u{2E6C4}; +var \u{2E6C5}; +var \u{2E6C6}; +var \u{2E6C7}; +var \u{2E6C8}; +var \u{2E6C9}; +var \u{2E6CA}; +var \u{2E6CB}; +var \u{2E6CC}; +var \u{2E6CD}; +var \u{2E6CE}; +var \u{2E6CF}; +var \u{2E6D0}; +var \u{2E6D1}; +var \u{2E6D2}; +var \u{2E6D3}; +var \u{2E6D4}; +var \u{2E6D5}; +var \u{2E6D6}; +var \u{2E6D7}; +var \u{2E6D8}; +var \u{2E6D9}; +var \u{2E6DA}; +var \u{2E6DB}; +var \u{2E6DC}; +var \u{2E6DD}; +var \u{2E6DE}; +var \u{2E6DF}; +var \u{2E6E0}; +var \u{2E6E1}; +var \u{2E6E2}; +var \u{2E6E3}; +var \u{2E6E4}; +var \u{2E6E5}; +var \u{2E6E6}; +var \u{2E6E7}; +var \u{2E6E8}; +var \u{2E6E9}; +var \u{2E6EA}; +var \u{2E6EB}; +var \u{2E6EC}; +var \u{2E6ED}; +var \u{2E6EE}; +var \u{2E6EF}; +var \u{2E6F0}; +var \u{2E6F1}; +var \u{2E6F2}; +var \u{2E6F3}; +var \u{2E6F4}; +var \u{2E6F5}; +var \u{2E6F6}; +var \u{2E6F7}; +var \u{2E6F8}; +var \u{2E6F9}; +var \u{2E6FA}; +var \u{2E6FB}; +var \u{2E6FC}; +var \u{2E6FD}; +var \u{2E6FE}; +var \u{2E6FF}; +var \u{2E700}; +var \u{2E701}; +var \u{2E702}; +var \u{2E703}; +var \u{2E704}; +var \u{2E705}; +var \u{2E706}; +var \u{2E707}; +var \u{2E708}; +var \u{2E709}; +var \u{2E70A}; +var \u{2E70B}; +var \u{2E70C}; +var \u{2E70D}; +var \u{2E70E}; +var \u{2E70F}; +var \u{2E710}; +var \u{2E711}; +var \u{2E712}; +var \u{2E713}; +var \u{2E714}; +var \u{2E715}; +var \u{2E716}; +var \u{2E717}; +var \u{2E718}; +var \u{2E719}; +var \u{2E71A}; +var \u{2E71B}; +var \u{2E71C}; +var \u{2E71D}; +var \u{2E71E}; +var \u{2E71F}; +var \u{2E720}; +var \u{2E721}; +var \u{2E722}; +var \u{2E723}; +var \u{2E724}; +var \u{2E725}; +var \u{2E726}; +var \u{2E727}; +var \u{2E728}; +var \u{2E729}; +var \u{2E72A}; +var \u{2E72B}; +var \u{2E72C}; +var \u{2E72D}; +var \u{2E72E}; +var \u{2E72F}; +var \u{2E730}; +var \u{2E731}; +var \u{2E732}; +var \u{2E733}; +var \u{2E734}; +var \u{2E735}; +var \u{2E736}; +var \u{2E737}; +var \u{2E738}; +var \u{2E739}; +var \u{2E73A}; +var \u{2E73B}; +var \u{2E73C}; +var \u{2E73D}; +var \u{2E73E}; +var \u{2E73F}; +var \u{2E740}; +var \u{2E741}; +var \u{2E742}; +var \u{2E743}; +var \u{2E744}; +var \u{2E745}; +var \u{2E746}; +var \u{2E747}; +var \u{2E748}; +var \u{2E749}; +var \u{2E74A}; +var \u{2E74B}; +var \u{2E74C}; +var \u{2E74D}; +var \u{2E74E}; +var \u{2E74F}; +var \u{2E750}; +var \u{2E751}; +var \u{2E752}; +var \u{2E753}; +var \u{2E754}; +var \u{2E755}; +var \u{2E756}; +var \u{2E757}; +var \u{2E758}; +var \u{2E759}; +var \u{2E75A}; +var \u{2E75B}; +var \u{2E75C}; +var \u{2E75D}; +var \u{2E75E}; +var \u{2E75F}; +var \u{2E760}; +var \u{2E761}; +var \u{2E762}; +var \u{2E763}; +var \u{2E764}; +var \u{2E765}; +var \u{2E766}; +var \u{2E767}; +var \u{2E768}; +var \u{2E769}; +var \u{2E76A}; +var \u{2E76B}; +var \u{2E76C}; +var \u{2E76D}; +var \u{2E76E}; +var \u{2E76F}; +var \u{2E770}; +var \u{2E771}; +var \u{2E772}; +var \u{2E773}; +var \u{2E774}; +var \u{2E775}; +var \u{2E776}; +var \u{2E777}; +var \u{2E778}; +var \u{2E779}; +var \u{2E77A}; +var \u{2E77B}; +var \u{2E77C}; +var \u{2E77D}; +var \u{2E77E}; +var \u{2E77F}; +var \u{2E780}; +var \u{2E781}; +var \u{2E782}; +var \u{2E783}; +var \u{2E784}; +var \u{2E785}; +var \u{2E786}; +var \u{2E787}; +var \u{2E788}; +var \u{2E789}; +var \u{2E78A}; +var \u{2E78B}; +var \u{2E78C}; +var \u{2E78D}; +var \u{2E78E}; +var \u{2E78F}; +var \u{2E790}; +var \u{2E791}; +var \u{2E792}; +var \u{2E793}; +var \u{2E794}; +var \u{2E795}; +var \u{2E796}; +var \u{2E797}; +var \u{2E798}; +var \u{2E799}; +var \u{2E79A}; +var \u{2E79B}; +var \u{2E79C}; +var \u{2E79D}; +var \u{2E79E}; +var \u{2E79F}; +var \u{2E7A0}; +var \u{2E7A1}; +var \u{2E7A2}; +var \u{2E7A3}; +var \u{2E7A4}; +var \u{2E7A5}; +var \u{2E7A6}; +var \u{2E7A7}; +var \u{2E7A8}; +var \u{2E7A9}; +var \u{2E7AA}; +var \u{2E7AB}; +var \u{2E7AC}; +var \u{2E7AD}; +var \u{2E7AE}; +var \u{2E7AF}; +var \u{2E7B0}; +var \u{2E7B1}; +var \u{2E7B2}; +var \u{2E7B3}; +var \u{2E7B4}; +var \u{2E7B5}; +var \u{2E7B6}; +var \u{2E7B7}; +var \u{2E7B8}; +var \u{2E7B9}; +var \u{2E7BA}; +var \u{2E7BB}; +var \u{2E7BC}; +var \u{2E7BD}; +var \u{2E7BE}; +var \u{2E7BF}; +var \u{2E7C0}; +var \u{2E7C1}; +var \u{2E7C2}; +var \u{2E7C3}; +var \u{2E7C4}; +var \u{2E7C5}; +var \u{2E7C6}; +var \u{2E7C7}; +var \u{2E7C8}; +var \u{2E7C9}; +var \u{2E7CA}; +var \u{2E7CB}; +var \u{2E7CC}; +var \u{2E7CD}; +var \u{2E7CE}; +var \u{2E7CF}; +var \u{2E7D0}; +var \u{2E7D1}; +var \u{2E7D2}; +var \u{2E7D3}; +var \u{2E7D4}; +var \u{2E7D5}; +var \u{2E7D6}; +var \u{2E7D7}; +var \u{2E7D8}; +var \u{2E7D9}; +var \u{2E7DA}; +var \u{2E7DB}; +var \u{2E7DC}; +var \u{2E7DD}; +var \u{2E7DE}; +var \u{2E7DF}; +var \u{2E7E0}; +var \u{2E7E1}; +var \u{2E7E2}; +var \u{2E7E3}; +var \u{2E7E4}; +var \u{2E7E5}; +var \u{2E7E6}; +var \u{2E7E7}; +var \u{2E7E8}; +var \u{2E7E9}; +var \u{2E7EA}; +var \u{2E7EB}; +var \u{2E7EC}; +var \u{2E7ED}; +var \u{2E7EE}; +var \u{2E7EF}; +var \u{2E7F0}; +var \u{2E7F1}; +var \u{2E7F2}; +var \u{2E7F3}; +var \u{2E7F4}; +var \u{2E7F5}; +var \u{2E7F6}; +var \u{2E7F7}; +var \u{2E7F8}; +var \u{2E7F9}; +var \u{2E7FA}; +var \u{2E7FB}; +var \u{2E7FC}; +var \u{2E7FD}; +var \u{2E7FE}; +var \u{2E7FF}; +var \u{2E800}; +var \u{2E801}; +var \u{2E802}; +var \u{2E803}; +var \u{2E804}; +var \u{2E805}; +var \u{2E806}; +var \u{2E807}; +var \u{2E808}; +var \u{2E809}; +var \u{2E80A}; +var \u{2E80B}; +var \u{2E80C}; +var \u{2E80D}; +var \u{2E80E}; +var \u{2E80F}; +var \u{2E810}; +var \u{2E811}; +var \u{2E812}; +var \u{2E813}; +var \u{2E814}; +var \u{2E815}; +var \u{2E816}; +var \u{2E817}; +var \u{2E818}; +var \u{2E819}; +var \u{2E81A}; +var \u{2E81B}; +var \u{2E81C}; +var \u{2E81D}; +var \u{2E81E}; +var \u{2E81F}; +var \u{2E820}; +var \u{2E821}; +var \u{2E822}; +var \u{2E823}; +var \u{2E824}; +var \u{2E825}; +var \u{2E826}; +var \u{2E827}; +var \u{2E828}; +var \u{2E829}; +var \u{2E82A}; +var \u{2E82B}; +var \u{2E82C}; +var \u{2E82D}; +var \u{2E82E}; +var \u{2E82F}; +var \u{2E830}; +var \u{2E831}; +var \u{2E832}; +var \u{2E833}; +var \u{2E834}; +var \u{2E835}; +var \u{2E836}; +var \u{2E837}; +var \u{2E838}; +var \u{2E839}; +var \u{2E83A}; +var \u{2E83B}; +var \u{2E83C}; +var \u{2E83D}; +var \u{2E83E}; +var \u{2E83F}; +var \u{2E840}; +var \u{2E841}; +var \u{2E842}; +var \u{2E843}; +var \u{2E844}; +var \u{2E845}; +var \u{2E846}; +var \u{2E847}; +var \u{2E848}; +var \u{2E849}; +var \u{2E84A}; +var \u{2E84B}; +var \u{2E84C}; +var \u{2E84D}; +var \u{2E84E}; +var \u{2E84F}; +var \u{2E850}; +var \u{2E851}; +var \u{2E852}; +var \u{2E853}; +var \u{2E854}; +var \u{2E855}; +var \u{2E856}; +var \u{2E857}; +var \u{2E858}; +var \u{2E859}; +var \u{2E85A}; +var \u{2E85B}; +var \u{2E85C}; +var \u{2E85D}; +var \u{2E85E}; +var \u{2E85F}; +var \u{2E860}; +var \u{2E861}; +var \u{2E862}; +var \u{2E863}; +var \u{2E864}; +var \u{2E865}; +var \u{2E866}; +var \u{2E867}; +var \u{2E868}; +var \u{2E869}; +var \u{2E86A}; +var \u{2E86B}; +var \u{2E86C}; +var \u{2E86D}; +var \u{2E86E}; +var \u{2E86F}; +var \u{2E870}; +var \u{2E871}; +var \u{2E872}; +var \u{2E873}; +var \u{2E874}; +var \u{2E875}; +var \u{2E876}; +var \u{2E877}; +var \u{2E878}; +var \u{2E879}; +var \u{2E87A}; +var \u{2E87B}; +var \u{2E87C}; +var \u{2E87D}; +var \u{2E87E}; +var \u{2E87F}; +var \u{2E880}; +var \u{2E881}; +var \u{2E882}; +var \u{2E883}; +var \u{2E884}; +var \u{2E885}; +var \u{2E886}; +var \u{2E887}; +var \u{2E888}; +var \u{2E889}; +var \u{2E88A}; +var \u{2E88B}; +var \u{2E88C}; +var \u{2E88D}; +var \u{2E88E}; +var \u{2E88F}; +var \u{2E890}; +var \u{2E891}; +var \u{2E892}; +var \u{2E893}; +var \u{2E894}; +var \u{2E895}; +var \u{2E896}; +var \u{2E897}; +var \u{2E898}; +var \u{2E899}; +var \u{2E89A}; +var \u{2E89B}; +var \u{2E89C}; +var \u{2E89D}; +var \u{2E89E}; +var \u{2E89F}; +var \u{2E8A0}; +var \u{2E8A1}; +var \u{2E8A2}; +var \u{2E8A3}; +var \u{2E8A4}; +var \u{2E8A5}; +var \u{2E8A6}; +var \u{2E8A7}; +var \u{2E8A8}; +var \u{2E8A9}; +var \u{2E8AA}; +var \u{2E8AB}; +var \u{2E8AC}; +var \u{2E8AD}; +var \u{2E8AE}; +var \u{2E8AF}; +var \u{2E8B0}; +var \u{2E8B1}; +var \u{2E8B2}; +var \u{2E8B3}; +var \u{2E8B4}; +var \u{2E8B5}; +var \u{2E8B6}; +var \u{2E8B7}; +var \u{2E8B8}; +var \u{2E8B9}; +var \u{2E8BA}; +var \u{2E8BB}; +var \u{2E8BC}; +var \u{2E8BD}; +var \u{2E8BE}; +var \u{2E8BF}; +var \u{2E8C0}; +var \u{2E8C1}; +var \u{2E8C2}; +var \u{2E8C3}; +var \u{2E8C4}; +var \u{2E8C5}; +var \u{2E8C6}; +var \u{2E8C7}; +var \u{2E8C8}; +var \u{2E8C9}; +var \u{2E8CA}; +var \u{2E8CB}; +var \u{2E8CC}; +var \u{2E8CD}; +var \u{2E8CE}; +var \u{2E8CF}; +var \u{2E8D0}; +var \u{2E8D1}; +var \u{2E8D2}; +var \u{2E8D3}; +var \u{2E8D4}; +var \u{2E8D5}; +var \u{2E8D6}; +var \u{2E8D7}; +var \u{2E8D8}; +var \u{2E8D9}; +var \u{2E8DA}; +var \u{2E8DB}; +var \u{2E8DC}; +var \u{2E8DD}; +var \u{2E8DE}; +var \u{2E8DF}; +var \u{2E8E0}; +var \u{2E8E1}; +var \u{2E8E2}; +var \u{2E8E3}; +var \u{2E8E4}; +var \u{2E8E5}; +var \u{2E8E6}; +var \u{2E8E7}; +var \u{2E8E8}; +var \u{2E8E9}; +var \u{2E8EA}; +var \u{2E8EB}; +var \u{2E8EC}; +var \u{2E8ED}; +var \u{2E8EE}; +var \u{2E8EF}; +var \u{2E8F0}; +var \u{2E8F1}; +var \u{2E8F2}; +var \u{2E8F3}; +var \u{2E8F4}; +var \u{2E8F5}; +var \u{2E8F6}; +var \u{2E8F7}; +var \u{2E8F8}; +var \u{2E8F9}; +var \u{2E8FA}; +var \u{2E8FB}; +var \u{2E8FC}; +var \u{2E8FD}; +var \u{2E8FE}; +var \u{2E8FF}; +var \u{2E900}; +var \u{2E901}; +var \u{2E902}; +var \u{2E903}; +var \u{2E904}; +var \u{2E905}; +var \u{2E906}; +var \u{2E907}; +var \u{2E908}; +var \u{2E909}; +var \u{2E90A}; +var \u{2E90B}; +var \u{2E90C}; +var \u{2E90D}; +var \u{2E90E}; +var \u{2E90F}; +var \u{2E910}; +var \u{2E911}; +var \u{2E912}; +var \u{2E913}; +var \u{2E914}; +var \u{2E915}; +var \u{2E916}; +var \u{2E917}; +var \u{2E918}; +var \u{2E919}; +var \u{2E91A}; +var \u{2E91B}; +var \u{2E91C}; +var \u{2E91D}; +var \u{2E91E}; +var \u{2E91F}; +var \u{2E920}; +var \u{2E921}; +var \u{2E922}; +var \u{2E923}; +var \u{2E924}; +var \u{2E925}; +var \u{2E926}; +var \u{2E927}; +var \u{2E928}; +var \u{2E929}; +var \u{2E92A}; +var \u{2E92B}; +var \u{2E92C}; +var \u{2E92D}; +var \u{2E92E}; +var \u{2E92F}; +var \u{2E930}; +var \u{2E931}; +var \u{2E932}; +var \u{2E933}; +var \u{2E934}; +var \u{2E935}; +var \u{2E936}; +var \u{2E937}; +var \u{2E938}; +var \u{2E939}; +var \u{2E93A}; +var \u{2E93B}; +var \u{2E93C}; +var \u{2E93D}; +var \u{2E93E}; +var \u{2E93F}; +var \u{2E940}; +var \u{2E941}; +var \u{2E942}; +var \u{2E943}; +var \u{2E944}; +var \u{2E945}; +var \u{2E946}; +var \u{2E947}; +var \u{2E948}; +var \u{2E949}; +var \u{2E94A}; +var \u{2E94B}; +var \u{2E94C}; +var \u{2E94D}; +var \u{2E94E}; +var \u{2E94F}; +var \u{2E950}; +var \u{2E951}; +var \u{2E952}; +var \u{2E953}; +var \u{2E954}; +var \u{2E955}; +var \u{2E956}; +var \u{2E957}; +var \u{2E958}; +var \u{2E959}; +var \u{2E95A}; +var \u{2E95B}; +var \u{2E95C}; +var \u{2E95D}; +var \u{2E95E}; +var \u{2E95F}; +var \u{2E960}; +var \u{2E961}; +var \u{2E962}; +var \u{2E963}; +var \u{2E964}; +var \u{2E965}; +var \u{2E966}; +var \u{2E967}; +var \u{2E968}; +var \u{2E969}; +var \u{2E96A}; +var \u{2E96B}; +var \u{2E96C}; +var \u{2E96D}; +var \u{2E96E}; +var \u{2E96F}; +var \u{2E970}; +var \u{2E971}; +var \u{2E972}; +var \u{2E973}; +var \u{2E974}; +var \u{2E975}; +var \u{2E976}; +var \u{2E977}; +var \u{2E978}; +var \u{2E979}; +var \u{2E97A}; +var \u{2E97B}; +var \u{2E97C}; +var \u{2E97D}; +var \u{2E97E}; +var \u{2E97F}; +var \u{2E980}; +var \u{2E981}; +var \u{2E982}; +var \u{2E983}; +var \u{2E984}; +var \u{2E985}; +var \u{2E986}; +var \u{2E987}; +var \u{2E988}; +var \u{2E989}; +var \u{2E98A}; +var \u{2E98B}; +var \u{2E98C}; +var \u{2E98D}; +var \u{2E98E}; +var \u{2E98F}; +var \u{2E990}; +var \u{2E991}; +var \u{2E992}; +var \u{2E993}; +var \u{2E994}; +var \u{2E995}; +var \u{2E996}; +var \u{2E997}; +var \u{2E998}; +var \u{2E999}; +var \u{2E99A}; +var \u{2E99B}; +var \u{2E99C}; +var \u{2E99D}; +var \u{2E99E}; +var \u{2E99F}; +var \u{2E9A0}; +var \u{2E9A1}; +var \u{2E9A2}; +var \u{2E9A3}; +var \u{2E9A4}; +var \u{2E9A5}; +var \u{2E9A6}; +var \u{2E9A7}; +var \u{2E9A8}; +var \u{2E9A9}; +var \u{2E9AA}; +var \u{2E9AB}; +var \u{2E9AC}; +var \u{2E9AD}; +var \u{2E9AE}; +var \u{2E9AF}; +var \u{2E9B0}; +var \u{2E9B1}; +var \u{2E9B2}; +var \u{2E9B3}; +var \u{2E9B4}; +var \u{2E9B5}; +var \u{2E9B6}; +var \u{2E9B7}; +var \u{2E9B8}; +var \u{2E9B9}; +var \u{2E9BA}; +var \u{2E9BB}; +var \u{2E9BC}; +var \u{2E9BD}; +var \u{2E9BE}; +var \u{2E9BF}; +var \u{2E9C0}; +var \u{2E9C1}; +var \u{2E9C2}; +var \u{2E9C3}; +var \u{2E9C4}; +var \u{2E9C5}; +var \u{2E9C6}; +var \u{2E9C7}; +var \u{2E9C8}; +var \u{2E9C9}; +var \u{2E9CA}; +var \u{2E9CB}; +var \u{2E9CC}; +var \u{2E9CD}; +var \u{2E9CE}; +var \u{2E9CF}; +var \u{2E9D0}; +var \u{2E9D1}; +var \u{2E9D2}; +var \u{2E9D3}; +var \u{2E9D4}; +var \u{2E9D5}; +var \u{2E9D6}; +var \u{2E9D7}; +var \u{2E9D8}; +var \u{2E9D9}; +var \u{2E9DA}; +var \u{2E9DB}; +var \u{2E9DC}; +var \u{2E9DD}; +var \u{2E9DE}; +var \u{2E9DF}; +var \u{2E9E0}; +var \u{2E9E1}; +var \u{2E9E2}; +var \u{2E9E3}; +var \u{2E9E4}; +var \u{2E9E5}; +var \u{2E9E6}; +var \u{2E9E7}; +var \u{2E9E8}; +var \u{2E9E9}; +var \u{2E9EA}; +var \u{2E9EB}; +var \u{2E9EC}; +var \u{2E9ED}; +var \u{2E9EE}; +var \u{2E9EF}; +var \u{2E9F0}; +var \u{2E9F1}; +var \u{2E9F2}; +var \u{2E9F3}; +var \u{2E9F4}; +var \u{2E9F5}; +var \u{2E9F6}; +var \u{2E9F7}; +var \u{2E9F8}; +var \u{2E9F9}; +var \u{2E9FA}; +var \u{2E9FB}; +var \u{2E9FC}; +var \u{2E9FD}; +var \u{2E9FE}; +var \u{2E9FF}; +var \u{2EA00}; +var \u{2EA01}; +var \u{2EA02}; +var \u{2EA03}; +var \u{2EA04}; +var \u{2EA05}; +var \u{2EA06}; +var \u{2EA07}; +var \u{2EA08}; +var \u{2EA09}; +var \u{2EA0A}; +var \u{2EA0B}; +var \u{2EA0C}; +var \u{2EA0D}; +var \u{2EA0E}; +var \u{2EA0F}; +var \u{2EA10}; +var \u{2EA11}; +var \u{2EA12}; +var \u{2EA13}; +var \u{2EA14}; +var \u{2EA15}; +var \u{2EA16}; +var \u{2EA17}; +var \u{2EA18}; +var \u{2EA19}; +var \u{2EA1A}; +var \u{2EA1B}; +var \u{2EA1C}; +var \u{2EA1D}; +var \u{2EA1E}; +var \u{2EA1F}; +var \u{2EA20}; +var \u{2EA21}; +var \u{2EA22}; +var \u{2EA23}; +var \u{2EA24}; +var \u{2EA25}; +var \u{2EA26}; +var \u{2EA27}; +var \u{2EA28}; +var \u{2EA29}; +var \u{2EA2A}; +var \u{2EA2B}; +var \u{2EA2C}; +var \u{2EA2D}; +var \u{2EA2E}; +var \u{2EA2F}; +var \u{2EA30}; +var \u{2EA31}; +var \u{2EA32}; +var \u{2EA33}; +var \u{2EA34}; +var \u{2EA35}; +var \u{2EA36}; +var \u{2EA37}; +var \u{2EA38}; +var \u{2EA39}; +var \u{2EA3A}; +var \u{2EA3B}; +var \u{2EA3C}; +var \u{2EA3D}; +var \u{2EA3E}; +var \u{2EA3F}; +var \u{2EA40}; +var \u{2EA41}; +var \u{2EA42}; +var \u{2EA43}; +var \u{2EA44}; +var \u{2EA45}; +var \u{2EA46}; +var \u{2EA47}; +var \u{2EA48}; +var \u{2EA49}; +var \u{2EA4A}; +var \u{2EA4B}; +var \u{2EA4C}; +var \u{2EA4D}; +var \u{2EA4E}; +var \u{2EA4F}; +var \u{2EA50}; +var \u{2EA51}; +var \u{2EA52}; +var \u{2EA53}; +var \u{2EA54}; +var \u{2EA55}; +var \u{2EA56}; +var \u{2EA57}; +var \u{2EA58}; +var \u{2EA59}; +var \u{2EA5A}; +var \u{2EA5B}; +var \u{2EA5C}; +var \u{2EA5D}; +var \u{2EA5E}; +var \u{2EA5F}; +var \u{2EA60}; +var \u{2EA61}; +var \u{2EA62}; +var \u{2EA63}; +var \u{2EA64}; +var \u{2EA65}; +var \u{2EA66}; +var \u{2EA67}; +var \u{2EA68}; +var \u{2EA69}; +var \u{2EA6A}; +var \u{2EA6B}; +var \u{2EA6C}; +var \u{2EA6D}; +var \u{2EA6E}; +var \u{2EA6F}; +var \u{2EA70}; +var \u{2EA71}; +var \u{2EA72}; +var \u{2EA73}; +var \u{2EA74}; +var \u{2EA75}; +var \u{2EA76}; +var \u{2EA77}; +var \u{2EA78}; +var \u{2EA79}; +var \u{2EA7A}; +var \u{2EA7B}; +var \u{2EA7C}; +var \u{2EA7D}; +var \u{2EA7E}; +var \u{2EA7F}; +var \u{2EA80}; +var \u{2EA81}; +var \u{2EA82}; +var \u{2EA83}; +var \u{2EA84}; +var \u{2EA85}; +var \u{2EA86}; +var \u{2EA87}; +var \u{2EA88}; +var \u{2EA89}; +var \u{2EA8A}; +var \u{2EA8B}; +var \u{2EA8C}; +var \u{2EA8D}; +var \u{2EA8E}; +var \u{2EA8F}; +var \u{2EA90}; +var \u{2EA91}; +var \u{2EA92}; +var \u{2EA93}; +var \u{2EA94}; +var \u{2EA95}; +var \u{2EA96}; +var \u{2EA97}; +var \u{2EA98}; +var \u{2EA99}; +var \u{2EA9A}; +var \u{2EA9B}; +var \u{2EA9C}; +var \u{2EA9D}; +var \u{2EA9E}; +var \u{2EA9F}; +var \u{2EAA0}; +var \u{2EAA1}; +var \u{2EAA2}; +var \u{2EAA3}; +var \u{2EAA4}; +var \u{2EAA5}; +var \u{2EAA6}; +var \u{2EAA7}; +var \u{2EAA8}; +var \u{2EAA9}; +var \u{2EAAA}; +var \u{2EAAB}; +var \u{2EAAC}; +var \u{2EAAD}; +var \u{2EAAE}; +var \u{2EAAF}; +var \u{2EAB0}; +var \u{2EAB1}; +var \u{2EAB2}; +var \u{2EAB3}; +var \u{2EAB4}; +var \u{2EAB5}; +var \u{2EAB6}; +var \u{2EAB7}; +var \u{2EAB8}; +var \u{2EAB9}; +var \u{2EABA}; +var \u{2EABB}; +var \u{2EABC}; +var \u{2EABD}; +var \u{2EABE}; +var \u{2EABF}; +var \u{2EAC0}; +var \u{2EAC1}; +var \u{2EAC2}; +var \u{2EAC3}; +var \u{2EAC4}; +var \u{2EAC5}; +var \u{2EAC6}; +var \u{2EAC7}; +var \u{2EAC8}; +var \u{2EAC9}; +var \u{2EACA}; +var \u{2EACB}; +var \u{2EACC}; +var \u{2EACD}; +var \u{2EACE}; +var \u{2EACF}; +var \u{2EAD0}; +var \u{2EAD1}; +var \u{2EAD2}; +var \u{2EAD3}; +var \u{2EAD4}; +var \u{2EAD5}; +var \u{2EAD6}; +var \u{2EAD7}; +var \u{2EAD8}; +var \u{2EAD9}; +var \u{2EADA}; +var \u{2EADB}; +var \u{2EADC}; +var \u{2EADD}; +var \u{2EADE}; +var \u{2EADF}; +var \u{2EAE0}; +var \u{2EAE1}; +var \u{2EAE2}; +var \u{2EAE3}; +var \u{2EAE4}; +var \u{2EAE5}; +var \u{2EAE6}; +var \u{2EAE7}; +var \u{2EAE8}; +var \u{2EAE9}; +var \u{2EAEA}; +var \u{2EAEB}; +var \u{2EAEC}; +var \u{2EAED}; +var \u{2EAEE}; +var \u{2EAEF}; +var \u{2EAF0}; +var \u{2EAF1}; +var \u{2EAF2}; +var \u{2EAF3}; +var \u{2EAF4}; +var \u{2EAF5}; +var \u{2EAF6}; +var \u{2EAF7}; +var \u{2EAF8}; +var \u{2EAF9}; +var \u{2EAFA}; +var \u{2EAFB}; +var \u{2EAFC}; +var \u{2EAFD}; +var \u{2EAFE}; +var \u{2EAFF}; +var \u{2EB00}; +var \u{2EB01}; +var \u{2EB02}; +var \u{2EB03}; +var \u{2EB04}; +var \u{2EB05}; +var \u{2EB06}; +var \u{2EB07}; +var \u{2EB08}; +var \u{2EB09}; +var \u{2EB0A}; +var \u{2EB0B}; +var \u{2EB0C}; +var \u{2EB0D}; +var \u{2EB0E}; +var \u{2EB0F}; +var \u{2EB10}; +var \u{2EB11}; +var \u{2EB12}; +var \u{2EB13}; +var \u{2EB14}; +var \u{2EB15}; +var \u{2EB16}; +var \u{2EB17}; +var \u{2EB18}; +var \u{2EB19}; +var \u{2EB1A}; +var \u{2EB1B}; +var \u{2EB1C}; +var \u{2EB1D}; +var \u{2EB1E}; +var \u{2EB1F}; +var \u{2EB20}; +var \u{2EB21}; +var \u{2EB22}; +var \u{2EB23}; +var \u{2EB24}; +var \u{2EB25}; +var \u{2EB26}; +var \u{2EB27}; +var \u{2EB28}; +var \u{2EB29}; +var \u{2EB2A}; +var \u{2EB2B}; +var \u{2EB2C}; +var \u{2EB2D}; +var \u{2EB2E}; +var \u{2EB2F}; +var \u{2EB30}; +var \u{2EB31}; +var \u{2EB32}; +var \u{2EB33}; +var \u{2EB34}; +var \u{2EB35}; +var \u{2EB36}; +var \u{2EB37}; +var \u{2EB38}; +var \u{2EB39}; +var \u{2EB3A}; +var \u{2EB3B}; +var \u{2EB3C}; +var \u{2EB3D}; +var \u{2EB3E}; +var \u{2EB3F}; +var \u{2EB40}; +var \u{2EB41}; +var \u{2EB42}; +var \u{2EB43}; +var \u{2EB44}; +var \u{2EB45}; +var \u{2EB46}; +var \u{2EB47}; +var \u{2EB48}; +var \u{2EB49}; +var \u{2EB4A}; +var \u{2EB4B}; +var \u{2EB4C}; +var \u{2EB4D}; +var \u{2EB4E}; +var \u{2EB4F}; +var \u{2EB50}; +var \u{2EB51}; +var \u{2EB52}; +var \u{2EB53}; +var \u{2EB54}; +var \u{2EB55}; +var \u{2EB56}; +var \u{2EB57}; +var \u{2EB58}; +var \u{2EB59}; +var \u{2EB5A}; +var \u{2EB5B}; +var \u{2EB5C}; +var \u{2EB5D}; +var \u{2EB5E}; +var \u{2EB5F}; +var \u{2EB60}; +var \u{2EB61}; +var \u{2EB62}; +var \u{2EB63}; +var \u{2EB64}; +var \u{2EB65}; +var \u{2EB66}; +var \u{2EB67}; +var \u{2EB68}; +var \u{2EB69}; +var \u{2EB6A}; +var \u{2EB6B}; +var \u{2EB6C}; +var \u{2EB6D}; +var \u{2EB6E}; +var \u{2EB6F}; +var \u{2EB70}; +var \u{2EB71}; +var \u{2EB72}; +var \u{2EB73}; +var \u{2EB74}; +var \u{2EB75}; +var \u{2EB76}; +var \u{2EB77}; +var \u{2EB78}; +var \u{2EB79}; +var \u{2EB7A}; +var \u{2EB7B}; +var \u{2EB7C}; +var \u{2EB7D}; +var \u{2EB7E}; +var \u{2EB7F}; +var \u{2EB80}; +var \u{2EB81}; +var \u{2EB82}; +var \u{2EB83}; +var \u{2EB84}; +var \u{2EB85}; +var \u{2EB86}; +var \u{2EB87}; +var \u{2EB88}; +var \u{2EB89}; +var \u{2EB8A}; +var \u{2EB8B}; +var \u{2EB8C}; +var \u{2EB8D}; +var \u{2EB8E}; +var \u{2EB8F}; +var \u{2EB90}; +var \u{2EB91}; +var \u{2EB92}; +var \u{2EB93}; +var \u{2EB94}; +var \u{2EB95}; +var \u{2EB96}; +var \u{2EB97}; +var \u{2EB98}; +var \u{2EB99}; +var \u{2EB9A}; +var \u{2EB9B}; +var \u{2EB9C}; +var \u{2EB9D}; +var \u{2EB9E}; +var \u{2EB9F}; +var \u{2EBA0}; +var \u{2EBA1}; +var \u{2EBA2}; +var \u{2EBA3}; +var \u{2EBA4}; +var \u{2EBA5}; +var \u{2EBA6}; +var \u{2EBA7}; +var \u{2EBA8}; +var \u{2EBA9}; +var \u{2EBAA}; +var \u{2EBAB}; +var \u{2EBAC}; +var \u{2EBAD}; +var \u{2EBAE}; +var \u{2EBAF}; +var \u{2EBB0}; +var \u{2EBB1}; +var \u{2EBB2}; +var \u{2EBB3}; +var \u{2EBB4}; +var \u{2EBB5}; +var \u{2EBB6}; +var \u{2EBB7}; +var \u{2EBB8}; +var \u{2EBB9}; +var \u{2EBBA}; +var \u{2EBBB}; +var \u{2EBBC}; +var \u{2EBBD}; +var \u{2EBBE}; +var \u{2EBBF}; +var \u{2EBC0}; +var \u{2EBC1}; +var \u{2EBC2}; +var \u{2EBC3}; +var \u{2EBC4}; +var \u{2EBC5}; +var \u{2EBC6}; +var \u{2EBC7}; +var \u{2EBC8}; +var \u{2EBC9}; +var \u{2EBCA}; +var \u{2EBCB}; +var \u{2EBCC}; +var \u{2EBCD}; +var \u{2EBCE}; +var \u{2EBCF}; +var \u{2EBD0}; +var \u{2EBD1}; +var \u{2EBD2}; +var \u{2EBD3}; +var \u{2EBD4}; +var \u{2EBD5}; +var \u{2EBD6}; +var \u{2EBD7}; +var \u{2EBD8}; +var \u{2EBD9}; +var \u{2EBDA}; +var \u{2EBDB}; +var \u{2EBDC}; +var \u{2EBDD}; +var \u{2EBDE}; +var \u{2EBDF}; +var \u{2EBE0}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0.js new file mode 100644 index 000000000..450d68b54 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-10.0.0.js @@ -0,0 +1,8340 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v10.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var ࡠ; +var ࡡ; +var ࡢ; +var ࡣ; +var ࡤ; +var ࡥ; +var ࡦ; +var ࡧ; +var ࡨ; +var ࡩ; +var ࡪ; +var ৼ; +var ㄮ; +var 鿖; +var 鿗; +var 鿘; +var 鿙; +var 鿚; +var 鿛; +var 鿜; +var 鿝; +var 鿞; +var 鿟; +var 鿠; +var 鿡; +var 鿢; +var 鿣; +var 鿤; +var 鿥; +var 鿦; +var 鿧; +var 鿨; +var 鿩; +var 鿪; +var 𐌭; +var 𐌮; +var 𐌯; +var 𑨀; +var 𑨋; +var 𑨌; +var 𑨍; +var 𑨎; +var 𑨏; +var 𑨐; +var 𑨑; +var 𑨒; +var 𑨓; +var 𑨔; +var 𑨕; +var 𑨖; +var 𑨗; +var 𑨘; +var 𑨙; +var 𑨚; +var 𑨛; +var 𑨜; +var 𑨝; +var 𑨞; +var 𑨟; +var 𑨠; +var 𑨡; +var 𑨢; +var 𑨣; +var 𑨤; +var 𑨥; +var 𑨦; +var 𑨧; +var 𑨨; +var 𑨩; +var 𑨪; +var 𑨫; +var 𑨬; +var 𑨭; +var 𑨮; +var 𑨯; +var 𑨰; +var 𑨱; +var 𑨲; +var 𑨺; +var 𑩐; +var 𑩜; +var 𑩝; +var 𑩞; +var 𑩟; +var 𑩠; +var 𑩡; +var 𑩢; +var 𑩣; +var 𑩤; +var 𑩥; +var 𑩦; +var 𑩧; +var 𑩨; +var 𑩩; +var 𑩪; +var 𑩫; +var 𑩬; +var 𑩭; +var 𑩮; +var 𑩯; +var 𑩰; +var 𑩱; +var 𑩲; +var 𑩳; +var 𑩴; +var 𑩵; +var 𑩶; +var 𑩷; +var 𑩸; +var 𑩹; +var 𑩺; +var 𑩻; +var 𑩼; +var 𑩽; +var 𑩾; +var 𑩿; +var 𑪀; +var 𑪁; +var 𑪂; +var 𑪃; +var 𑪆; +var 𑪇; +var 𑪈; +var 𑪉; +var 𑴀; +var 𑴁; +var 𑴂; +var 𑴃; +var 𑴄; +var 𑴅; +var 𑴆; +var 𑴈; +var 𑴉; +var 𑴋; +var 𑴌; +var 𑴍; +var 𑴎; +var 𑴏; +var 𑴐; +var 𑴑; +var 𑴒; +var 𑴓; +var 𑴔; +var 𑴕; +var 𑴖; +var 𑴗; +var 𑴘; +var 𑴙; +var 𑴚; +var 𑴛; +var 𑴜; +var 𑴝; +var 𑴞; +var 𑴟; +var 𑴠; +var 𑴡; +var 𑴢; +var 𑴣; +var 𑴤; +var 𑴥; +var 𑴦; +var 𑴧; +var 𑴨; +var 𑴩; +var 𑴪; +var 𑴫; +var 𑴬; +var 𑴭; +var 𑴮; +var 𑴯; +var 𑴰; +var 𑵆; +var 𖿡; +var 𛀂; +var 𛀃; +var 𛀄; +var 𛀅; +var 𛀆; +var 𛀇; +var 𛀈; +var 𛀉; +var 𛀊; +var 𛀋; +var 𛀌; +var 𛀍; +var 𛀎; +var 𛀏; +var 𛀐; +var 𛀑; +var 𛀒; +var 𛀓; +var 𛀔; +var 𛀕; +var 𛀖; +var 𛀗; +var 𛀘; +var 𛀙; +var 𛀚; +var 𛀛; +var 𛀜; +var 𛀝; +var 𛀞; +var 𛀟; +var 𛀠; +var 𛀡; +var 𛀢; +var 𛀣; +var 𛀤; +var 𛀥; +var 𛀦; +var 𛀧; +var 𛀨; +var 𛀩; +var 𛀪; +var 𛀫; +var 𛀬; +var 𛀭; +var 𛀮; +var 𛀯; +var 𛀰; +var 𛀱; +var 𛀲; +var 𛀳; +var 𛀴; +var 𛀵; +var 𛀶; +var 𛀷; +var 𛀸; +var 𛀹; +var 𛀺; +var 𛀻; +var 𛀼; +var 𛀽; +var 𛀾; +var 𛀿; +var 𛁀; +var 𛁁; +var 𛁂; +var 𛁃; +var 𛁄; +var 𛁅; +var 𛁆; +var 𛁇; +var 𛁈; +var 𛁉; +var 𛁊; +var 𛁋; +var 𛁌; +var 𛁍; +var 𛁎; +var 𛁏; +var 𛁐; +var 𛁑; +var 𛁒; +var 𛁓; +var 𛁔; +var 𛁕; +var 𛁖; +var 𛁗; +var 𛁘; +var 𛁙; +var 𛁚; +var 𛁛; +var 𛁜; +var 𛁝; +var 𛁞; +var 𛁟; +var 𛁠; +var 𛁡; +var 𛁢; +var 𛁣; +var 𛁤; +var 𛁥; +var 𛁦; +var 𛁧; +var 𛁨; +var 𛁩; +var 𛁪; +var 𛁫; +var 𛁬; +var 𛁭; +var 𛁮; +var 𛁯; +var 𛁰; +var 𛁱; +var 𛁲; +var 𛁳; +var 𛁴; +var 𛁵; +var 𛁶; +var 𛁷; +var 𛁸; +var 𛁹; +var 𛁺; +var 𛁻; +var 𛁼; +var 𛁽; +var 𛁾; +var 𛁿; +var 𛂀; +var 𛂁; +var 𛂂; +var 𛂃; +var 𛂄; +var 𛂅; +var 𛂆; +var 𛂇; +var 𛂈; +var 𛂉; +var 𛂊; +var 𛂋; +var 𛂌; +var 𛂍; +var 𛂎; +var 𛂏; +var 𛂐; +var 𛂑; +var 𛂒; +var 𛂓; +var 𛂔; +var 𛂕; +var 𛂖; +var 𛂗; +var 𛂘; +var 𛂙; +var 𛂚; +var 𛂛; +var 𛂜; +var 𛂝; +var 𛂞; +var 𛂟; +var 𛂠; +var 𛂡; +var 𛂢; +var 𛂣; +var 𛂤; +var 𛂥; +var 𛂦; +var 𛂧; +var 𛂨; +var 𛂩; +var 𛂪; +var 𛂫; +var 𛂬; +var 𛂭; +var 𛂮; +var 𛂯; +var 𛂰; +var 𛂱; +var 𛂲; +var 𛂳; +var 𛂴; +var 𛂵; +var 𛂶; +var 𛂷; +var 𛂸; +var 𛂹; +var 𛂺; +var 𛂻; +var 𛂼; +var 𛂽; +var 𛂾; +var 𛂿; +var 𛃀; +var 𛃁; +var 𛃂; +var 𛃃; +var 𛃄; +var 𛃅; +var 𛃆; +var 𛃇; +var 𛃈; +var 𛃉; +var 𛃊; +var 𛃋; +var 𛃌; +var 𛃍; +var 𛃎; +var 𛃏; +var 𛃐; +var 𛃑; +var 𛃒; +var 𛃓; +var 𛃔; +var 𛃕; +var 𛃖; +var 𛃗; +var 𛃘; +var 𛃙; +var 𛃚; +var 𛃛; +var 𛃜; +var 𛃝; +var 𛃞; +var 𛃟; +var 𛃠; +var 𛃡; +var 𛃢; +var 𛃣; +var 𛃤; +var 𛃥; +var 𛃦; +var 𛃧; +var 𛃨; +var 𛃩; +var 𛃪; +var 𛃫; +var 𛃬; +var 𛃭; +var 𛃮; +var 𛃯; +var 𛃰; +var 𛃱; +var 𛃲; +var 𛃳; +var 𛃴; +var 𛃵; +var 𛃶; +var 𛃷; +var 𛃸; +var 𛃹; +var 𛃺; +var 𛃻; +var 𛃼; +var 𛃽; +var 𛃾; +var 𛃿; +var 𛄀; +var 𛄁; +var 𛄂; +var 𛄃; +var 𛄄; +var 𛄅; +var 𛄆; +var 𛄇; +var 𛄈; +var 𛄉; +var 𛄊; +var 𛄋; +var 𛄌; +var 𛄍; +var 𛄎; +var 𛄏; +var 𛄐; +var 𛄑; +var 𛄒; +var 𛄓; +var 𛄔; +var 𛄕; +var 𛄖; +var 𛄗; +var 𛄘; +var 𛄙; +var 𛄚; +var 𛄛; +var 𛄜; +var 𛄝; +var 𛄞; +var 𛅰; +var 𛅱; +var 𛅲; +var 𛅳; +var 𛅴; +var 𛅵; +var 𛅶; +var 𛅷; +var 𛅸; +var 𛅹; +var 𛅺; +var 𛅻; +var 𛅼; +var 𛅽; +var 𛅾; +var 𛅿; +var 𛆀; +var 𛆁; +var 𛆂; +var 𛆃; +var 𛆄; +var 𛆅; +var 𛆆; +var 𛆇; +var 𛆈; +var 𛆉; +var 𛆊; +var 𛆋; +var 𛆌; +var 𛆍; +var 𛆎; +var 𛆏; +var 𛆐; +var 𛆑; +var 𛆒; +var 𛆓; +var 𛆔; +var 𛆕; +var 𛆖; +var 𛆗; +var 𛆘; +var 𛆙; +var 𛆚; +var 𛆛; +var 𛆜; +var 𛆝; +var 𛆞; +var 𛆟; +var 𛆠; +var 𛆡; +var 𛆢; +var 𛆣; +var 𛆤; +var 𛆥; +var 𛆦; +var 𛆧; +var 𛆨; +var 𛆩; +var 𛆪; +var 𛆫; +var 𛆬; +var 𛆭; +var 𛆮; +var 𛆯; +var 𛆰; +var 𛆱; +var 𛆲; +var 𛆳; +var 𛆴; +var 𛆵; +var 𛆶; +var 𛆷; +var 𛆸; +var 𛆹; +var 𛆺; +var 𛆻; +var 𛆼; +var 𛆽; +var 𛆾; +var 𛆿; +var 𛇀; +var 𛇁; +var 𛇂; +var 𛇃; +var 𛇄; +var 𛇅; +var 𛇆; +var 𛇇; +var 𛇈; +var 𛇉; +var 𛇊; +var 𛇋; +var 𛇌; +var 𛇍; +var 𛇎; +var 𛇏; +var 𛇐; +var 𛇑; +var 𛇒; +var 𛇓; +var 𛇔; +var 𛇕; +var 𛇖; +var 𛇗; +var 𛇘; +var 𛇙; +var 𛇚; +var 𛇛; +var 𛇜; +var 𛇝; +var 𛇞; +var 𛇟; +var 𛇠; +var 𛇡; +var 𛇢; +var 𛇣; +var 𛇤; +var 𛇥; +var 𛇦; +var 𛇧; +var 𛇨; +var 𛇩; +var 𛇪; +var 𛇫; +var 𛇬; +var 𛇭; +var 𛇮; +var 𛇯; +var 𛇰; +var 𛇱; +var 𛇲; +var 𛇳; +var 𛇴; +var 𛇵; +var 𛇶; +var 𛇷; +var 𛇸; +var 𛇹; +var 𛇺; +var 𛇻; +var 𛇼; +var 𛇽; +var 𛇾; +var 𛇿; +var 𛈀; +var 𛈁; +var 𛈂; +var 𛈃; +var 𛈄; +var 𛈅; +var 𛈆; +var 𛈇; +var 𛈈; +var 𛈉; +var 𛈊; +var 𛈋; +var 𛈌; +var 𛈍; +var 𛈎; +var 𛈏; +var 𛈐; +var 𛈑; +var 𛈒; +var 𛈓; +var 𛈔; +var 𛈕; +var 𛈖; +var 𛈗; +var 𛈘; +var 𛈙; +var 𛈚; +var 𛈛; +var 𛈜; +var 𛈝; +var 𛈞; +var 𛈟; +var 𛈠; +var 𛈡; +var 𛈢; +var 𛈣; +var 𛈤; +var 𛈥; +var 𛈦; +var 𛈧; +var 𛈨; +var 𛈩; +var 𛈪; +var 𛈫; +var 𛈬; +var 𛈭; +var 𛈮; +var 𛈯; +var 𛈰; +var 𛈱; +var 𛈲; +var 𛈳; +var 𛈴; +var 𛈵; +var 𛈶; +var 𛈷; +var 𛈸; +var 𛈹; +var 𛈺; +var 𛈻; +var 𛈼; +var 𛈽; +var 𛈾; +var 𛈿; +var 𛉀; +var 𛉁; +var 𛉂; +var 𛉃; +var 𛉄; +var 𛉅; +var 𛉆; +var 𛉇; +var 𛉈; +var 𛉉; +var 𛉊; +var 𛉋; +var 𛉌; +var 𛉍; +var 𛉎; +var 𛉏; +var 𛉐; +var 𛉑; +var 𛉒; +var 𛉓; +var 𛉔; +var 𛉕; +var 𛉖; +var 𛉗; +var 𛉘; +var 𛉙; +var 𛉚; +var 𛉛; +var 𛉜; +var 𛉝; +var 𛉞; +var 𛉟; +var 𛉠; +var 𛉡; +var 𛉢; +var 𛉣; +var 𛉤; +var 𛉥; +var 𛉦; +var 𛉧; +var 𛉨; +var 𛉩; +var 𛉪; +var 𛉫; +var 𛉬; +var 𛉭; +var 𛉮; +var 𛉯; +var 𛉰; +var 𛉱; +var 𛉲; +var 𛉳; +var 𛉴; +var 𛉵; +var 𛉶; +var 𛉷; +var 𛉸; +var 𛉹; +var 𛉺; +var 𛉻; +var 𛉼; +var 𛉽; +var 𛉾; +var 𛉿; +var 𛊀; +var 𛊁; +var 𛊂; +var 𛊃; +var 𛊄; +var 𛊅; +var 𛊆; +var 𛊇; +var 𛊈; +var 𛊉; +var 𛊊; +var 𛊋; +var 𛊌; +var 𛊍; +var 𛊎; +var 𛊏; +var 𛊐; +var 𛊑; +var 𛊒; +var 𛊓; +var 𛊔; +var 𛊕; +var 𛊖; +var 𛊗; +var 𛊘; +var 𛊙; +var 𛊚; +var 𛊛; +var 𛊜; +var 𛊝; +var 𛊞; +var 𛊟; +var 𛊠; +var 𛊡; +var 𛊢; +var 𛊣; +var 𛊤; +var 𛊥; +var 𛊦; +var 𛊧; +var 𛊨; +var 𛊩; +var 𛊪; +var 𛊫; +var 𛊬; +var 𛊭; +var 𛊮; +var 𛊯; +var 𛊰; +var 𛊱; +var 𛊲; +var 𛊳; +var 𛊴; +var 𛊵; +var 𛊶; +var 𛊷; +var 𛊸; +var 𛊹; +var 𛊺; +var 𛊻; +var 𛊼; +var 𛊽; +var 𛊾; +var 𛊿; +var 𛋀; +var 𛋁; +var 𛋂; +var 𛋃; +var 𛋄; +var 𛋅; +var 𛋆; +var 𛋇; +var 𛋈; +var 𛋉; +var 𛋊; +var 𛋋; +var 𛋌; +var 𛋍; +var 𛋎; +var 𛋏; +var 𛋐; +var 𛋑; +var 𛋒; +var 𛋓; +var 𛋔; +var 𛋕; +var 𛋖; +var 𛋗; +var 𛋘; +var 𛋙; +var 𛋚; +var 𛋛; +var 𛋜; +var 𛋝; +var 𛋞; +var 𛋟; +var 𛋠; +var 𛋡; +var 𛋢; +var 𛋣; +var 𛋤; +var 𛋥; +var 𛋦; +var 𛋧; +var 𛋨; +var 𛋩; +var 𛋪; +var 𛋫; +var 𛋬; +var 𛋭; +var 𛋮; +var 𛋯; +var 𛋰; +var 𛋱; +var 𛋲; +var 𛋳; +var 𛋴; +var 𛋵; +var 𛋶; +var 𛋷; +var 𛋸; +var 𛋹; +var 𛋺; +var 𛋻; +var 𬺰; +var 𬺱; +var 𬺲; +var 𬺳; +var 𬺴; +var 𬺵; +var 𬺶; +var 𬺷; +var 𬺸; +var 𬺹; +var 𬺺; +var 𬺻; +var 𬺼; +var 𬺽; +var 𬺾; +var 𬺿; +var 𬻀; +var 𬻁; +var 𬻂; +var 𬻃; +var 𬻄; +var 𬻅; +var 𬻆; +var 𬻇; +var 𬻈; +var 𬻉; +var 𬻊; +var 𬻋; +var 𬻌; +var 𬻍; +var 𬻎; +var 𬻏; +var 𬻐; +var 𬻑; +var 𬻒; +var 𬻓; +var 𬻔; +var 𬻕; +var 𬻖; +var 𬻗; +var 𬻘; +var 𬻙; +var 𬻚; +var 𬻛; +var 𬻜; +var 𬻝; +var 𬻞; +var 𬻟; +var 𬻠; +var 𬻡; +var 𬻢; +var 𬻣; +var 𬻤; +var 𬻥; +var 𬻦; +var 𬻧; +var 𬻨; +var 𬻩; +var 𬻪; +var 𬻫; +var 𬻬; +var 𬻭; +var 𬻮; +var 𬻯; +var 𬻰; +var 𬻱; +var 𬻲; +var 𬻳; +var 𬻴; +var 𬻵; +var 𬻶; +var 𬻷; +var 𬻸; +var 𬻹; +var 𬻺; +var 𬻻; +var 𬻼; +var 𬻽; +var 𬻾; +var 𬻿; +var 𬼀; +var 𬼁; +var 𬼂; +var 𬼃; +var 𬼄; +var 𬼅; +var 𬼆; +var 𬼇; +var 𬼈; +var 𬼉; +var 𬼊; +var 𬼋; +var 𬼌; +var 𬼍; +var 𬼎; +var 𬼏; +var 𬼐; +var 𬼑; +var 𬼒; +var 𬼓; +var 𬼔; +var 𬼕; +var 𬼖; +var 𬼗; +var 𬼘; +var 𬼙; +var 𬼚; +var 𬼛; +var 𬼜; +var 𬼝; +var 𬼞; +var 𬼟; +var 𬼠; +var 𬼡; +var 𬼢; +var 𬼣; +var 𬼤; +var 𬼥; +var 𬼦; +var 𬼧; +var 𬼨; +var 𬼩; +var 𬼪; +var 𬼫; +var 𬼬; +var 𬼭; +var 𬼮; +var 𬼯; +var 𬼰; +var 𬼱; +var 𬼲; +var 𬼳; +var 𬼴; +var 𬼵; +var 𬼶; +var 𬼷; +var 𬼸; +var 𬼹; +var 𬼺; +var 𬼻; +var 𬼼; +var 𬼽; +var 𬼾; +var 𬼿; +var 𬽀; +var 𬽁; +var 𬽂; +var 𬽃; +var 𬽄; +var 𬽅; +var 𬽆; +var 𬽇; +var 𬽈; +var 𬽉; +var 𬽊; +var 𬽋; +var 𬽌; +var 𬽍; +var 𬽎; +var 𬽏; +var 𬽐; +var 𬽑; +var 𬽒; +var 𬽓; +var 𬽔; +var 𬽕; +var 𬽖; +var 𬽗; +var 𬽘; +var 𬽙; +var 𬽚; +var 𬽛; +var 𬽜; +var 𬽝; +var 𬽞; +var 𬽟; +var 𬽠; +var 𬽡; +var 𬽢; +var 𬽣; +var 𬽤; +var 𬽥; +var 𬽦; +var 𬽧; +var 𬽨; +var 𬽩; +var 𬽪; +var 𬽫; +var 𬽬; +var 𬽭; +var 𬽮; +var 𬽯; +var 𬽰; +var 𬽱; +var 𬽲; +var 𬽳; +var 𬽴; +var 𬽵; +var 𬽶; +var 𬽷; +var 𬽸; +var 𬽹; +var 𬽺; +var 𬽻; +var 𬽼; +var 𬽽; +var 𬽾; +var 𬽿; +var 𬾀; +var 𬾁; +var 𬾂; +var 𬾃; +var 𬾄; +var 𬾅; +var 𬾆; +var 𬾇; +var 𬾈; +var 𬾉; +var 𬾊; +var 𬾋; +var 𬾌; +var 𬾍; +var 𬾎; +var 𬾏; +var 𬾐; +var 𬾑; +var 𬾒; +var 𬾓; +var 𬾔; +var 𬾕; +var 𬾖; +var 𬾗; +var 𬾘; +var 𬾙; +var 𬾚; +var 𬾛; +var 𬾜; +var 𬾝; +var 𬾞; +var 𬾟; +var 𬾠; +var 𬾡; +var 𬾢; +var 𬾣; +var 𬾤; +var 𬾥; +var 𬾦; +var 𬾧; +var 𬾨; +var 𬾩; +var 𬾪; +var 𬾫; +var 𬾬; +var 𬾭; +var 𬾮; +var 𬾯; +var 𬾰; +var 𬾱; +var 𬾲; +var 𬾳; +var 𬾴; +var 𬾵; +var 𬾶; +var 𬾷; +var 𬾸; +var 𬾹; +var 𬾺; +var 𬾻; +var 𬾼; +var 𬾽; +var 𬾾; +var 𬾿; +var 𬿀; +var 𬿁; +var 𬿂; +var 𬿃; +var 𬿄; +var 𬿅; +var 𬿆; +var 𬿇; +var 𬿈; +var 𬿉; +var 𬿊; +var 𬿋; +var 𬿌; +var 𬿍; +var 𬿎; +var 𬿏; +var 𬿐; +var 𬿑; +var 𬿒; +var 𬿓; +var 𬿔; +var 𬿕; +var 𬿖; +var 𬿗; +var 𬿘; +var 𬿙; +var 𬿚; +var 𬿛; +var 𬿜; +var 𬿝; +var 𬿞; +var 𬿟; +var 𬿠; +var 𬿡; +var 𬿢; +var 𬿣; +var 𬿤; +var 𬿥; +var 𬿦; +var 𬿧; +var 𬿨; +var 𬿩; +var 𬿪; +var 𬿫; +var 𬿬; +var 𬿭; +var 𬿮; +var 𬿯; +var 𬿰; +var 𬿱; +var 𬿲; +var 𬿳; +var 𬿴; +var 𬿵; +var 𬿶; +var 𬿷; +var 𬿸; +var 𬿹; +var 𬿺; +var 𬿻; +var 𬿼; +var 𬿽; +var 𬿾; +var 𬿿; +var 𭀀; +var 𭀁; +var 𭀂; +var 𭀃; +var 𭀄; +var 𭀅; +var 𭀆; +var 𭀇; +var 𭀈; +var 𭀉; +var 𭀊; +var 𭀋; +var 𭀌; +var 𭀍; +var 𭀎; +var 𭀏; +var 𭀐; +var 𭀑; +var 𭀒; +var 𭀓; +var 𭀔; +var 𭀕; +var 𭀖; +var 𭀗; +var 𭀘; +var 𭀙; +var 𭀚; +var 𭀛; +var 𭀜; +var 𭀝; +var 𭀞; +var 𭀟; +var 𭀠; +var 𭀡; +var 𭀢; +var 𭀣; +var 𭀤; +var 𭀥; +var 𭀦; +var 𭀧; +var 𭀨; +var 𭀩; +var 𭀪; +var 𭀫; +var 𭀬; +var 𭀭; +var 𭀮; +var 𭀯; +var 𭀰; +var 𭀱; +var 𭀲; +var 𭀳; +var 𭀴; +var 𭀵; +var 𭀶; +var 𭀷; +var 𭀸; +var 𭀹; +var 𭀺; +var 𭀻; +var 𭀼; +var 𭀽; +var 𭀾; +var 𭀿; +var 𭁀; +var 𭁁; +var 𭁂; +var 𭁃; +var 𭁄; +var 𭁅; +var 𭁆; +var 𭁇; +var 𭁈; +var 𭁉; +var 𭁊; +var 𭁋; +var 𭁌; +var 𭁍; +var 𭁎; +var 𭁏; +var 𭁐; +var 𭁑; +var 𭁒; +var 𭁓; +var 𭁔; +var 𭁕; +var 𭁖; +var 𭁗; +var 𭁘; +var 𭁙; +var 𭁚; +var 𭁛; +var 𭁜; +var 𭁝; +var 𭁞; +var 𭁟; +var 𭁠; +var 𭁡; +var 𭁢; +var 𭁣; +var 𭁤; +var 𭁥; +var 𭁦; +var 𭁧; +var 𭁨; +var 𭁩; +var 𭁪; +var 𭁫; +var 𭁬; +var 𭁭; +var 𭁮; +var 𭁯; +var 𭁰; +var 𭁱; +var 𭁲; +var 𭁳; +var 𭁴; +var 𭁵; +var 𭁶; +var 𭁷; +var 𭁸; +var 𭁹; +var 𭁺; +var 𭁻; +var 𭁼; +var 𭁽; +var 𭁾; +var 𭁿; +var 𭂀; +var 𭂁; +var 𭂂; +var 𭂃; +var 𭂄; +var 𭂅; +var 𭂆; +var 𭂇; +var 𭂈; +var 𭂉; +var 𭂊; +var 𭂋; +var 𭂌; +var 𭂍; +var 𭂎; +var 𭂏; +var 𭂐; +var 𭂑; +var 𭂒; +var 𭂓; +var 𭂔; +var 𭂕; +var 𭂖; +var 𭂗; +var 𭂘; +var 𭂙; +var 𭂚; +var 𭂛; +var 𭂜; +var 𭂝; +var 𭂞; +var 𭂟; +var 𭂠; +var 𭂡; +var 𭂢; +var 𭂣; +var 𭂤; +var 𭂥; +var 𭂦; +var 𭂧; +var 𭂨; +var 𭂩; +var 𭂪; +var 𭂫; +var 𭂬; +var 𭂭; +var 𭂮; +var 𭂯; +var 𭂰; +var 𭂱; +var 𭂲; +var 𭂳; +var 𭂴; +var 𭂵; +var 𭂶; +var 𭂷; +var 𭂸; +var 𭂹; +var 𭂺; +var 𭂻; +var 𭂼; +var 𭂽; +var 𭂾; +var 𭂿; +var 𭃀; +var 𭃁; +var 𭃂; +var 𭃃; +var 𭃄; +var 𭃅; +var 𭃆; +var 𭃇; +var 𭃈; +var 𭃉; +var 𭃊; +var 𭃋; +var 𭃌; +var 𭃍; +var 𭃎; +var 𭃏; +var 𭃐; +var 𭃑; +var 𭃒; +var 𭃓; +var 𭃔; +var 𭃕; +var 𭃖; +var 𭃗; +var 𭃘; +var 𭃙; +var 𭃚; +var 𭃛; +var 𭃜; +var 𭃝; +var 𭃞; +var 𭃟; +var 𭃠; +var 𭃡; +var 𭃢; +var 𭃣; +var 𭃤; +var 𭃥; +var 𭃦; +var 𭃧; +var 𭃨; +var 𭃩; +var 𭃪; +var 𭃫; +var 𭃬; +var 𭃭; +var 𭃮; +var 𭃯; +var 𭃰; +var 𭃱; +var 𭃲; +var 𭃳; +var 𭃴; +var 𭃵; +var 𭃶; +var 𭃷; +var 𭃸; +var 𭃹; +var 𭃺; +var 𭃻; +var 𭃼; +var 𭃽; +var 𭃾; +var 𭃿; +var 𭄀; +var 𭄁; +var 𭄂; +var 𭄃; +var 𭄄; +var 𭄅; +var 𭄆; +var 𭄇; +var 𭄈; +var 𭄉; +var 𭄊; +var 𭄋; +var 𭄌; +var 𭄍; +var 𭄎; +var 𭄏; +var 𭄐; +var 𭄑; +var 𭄒; +var 𭄓; +var 𭄔; +var 𭄕; +var 𭄖; +var 𭄗; +var 𭄘; +var 𭄙; +var 𭄚; +var 𭄛; +var 𭄜; +var 𭄝; +var 𭄞; +var 𭄟; +var 𭄠; +var 𭄡; +var 𭄢; +var 𭄣; +var 𭄤; +var 𭄥; +var 𭄦; +var 𭄧; +var 𭄨; +var 𭄩; +var 𭄪; +var 𭄫; +var 𭄬; +var 𭄭; +var 𭄮; +var 𭄯; +var 𭄰; +var 𭄱; +var 𭄲; +var 𭄳; +var 𭄴; +var 𭄵; +var 𭄶; +var 𭄷; +var 𭄸; +var 𭄹; +var 𭄺; +var 𭄻; +var 𭄼; +var 𭄽; +var 𭄾; +var 𭄿; +var 𭅀; +var 𭅁; +var 𭅂; +var 𭅃; +var 𭅄; +var 𭅅; +var 𭅆; +var 𭅇; +var 𭅈; +var 𭅉; +var 𭅊; +var 𭅋; +var 𭅌; +var 𭅍; +var 𭅎; +var 𭅏; +var 𭅐; +var 𭅑; +var 𭅒; +var 𭅓; +var 𭅔; +var 𭅕; +var 𭅖; +var 𭅗; +var 𭅘; +var 𭅙; +var 𭅚; +var 𭅛; +var 𭅜; +var 𭅝; +var 𭅞; +var 𭅟; +var 𭅠; +var 𭅡; +var 𭅢; +var 𭅣; +var 𭅤; +var 𭅥; +var 𭅦; +var 𭅧; +var 𭅨; +var 𭅩; +var 𭅪; +var 𭅫; +var 𭅬; +var 𭅭; +var 𭅮; +var 𭅯; +var 𭅰; +var 𭅱; +var 𭅲; +var 𭅳; +var 𭅴; +var 𭅵; +var 𭅶; +var 𭅷; +var 𭅸; +var 𭅹; +var 𭅺; +var 𭅻; +var 𭅼; +var 𭅽; +var 𭅾; +var 𭅿; +var 𭆀; +var 𭆁; +var 𭆂; +var 𭆃; +var 𭆄; +var 𭆅; +var 𭆆; +var 𭆇; +var 𭆈; +var 𭆉; +var 𭆊; +var 𭆋; +var 𭆌; +var 𭆍; +var 𭆎; +var 𭆏; +var 𭆐; +var 𭆑; +var 𭆒; +var 𭆓; +var 𭆔; +var 𭆕; +var 𭆖; +var 𭆗; +var 𭆘; +var 𭆙; +var 𭆚; +var 𭆛; +var 𭆜; +var 𭆝; +var 𭆞; +var 𭆟; +var 𭆠; +var 𭆡; +var 𭆢; +var 𭆣; +var 𭆤; +var 𭆥; +var 𭆦; +var 𭆧; +var 𭆨; +var 𭆩; +var 𭆪; +var 𭆫; +var 𭆬; +var 𭆭; +var 𭆮; +var 𭆯; +var 𭆰; +var 𭆱; +var 𭆲; +var 𭆳; +var 𭆴; +var 𭆵; +var 𭆶; +var 𭆷; +var 𭆸; +var 𭆹; +var 𭆺; +var 𭆻; +var 𭆼; +var 𭆽; +var 𭆾; +var 𭆿; +var 𭇀; +var 𭇁; +var 𭇂; +var 𭇃; +var 𭇄; +var 𭇅; +var 𭇆; +var 𭇇; +var 𭇈; +var 𭇉; +var 𭇊; +var 𭇋; +var 𭇌; +var 𭇍; +var 𭇎; +var 𭇏; +var 𭇐; +var 𭇑; +var 𭇒; +var 𭇓; +var 𭇔; +var 𭇕; +var 𭇖; +var 𭇗; +var 𭇘; +var 𭇙; +var 𭇚; +var 𭇛; +var 𭇜; +var 𭇝; +var 𭇞; +var 𭇟; +var 𭇠; +var 𭇡; +var 𭇢; +var 𭇣; +var 𭇤; +var 𭇥; +var 𭇦; +var 𭇧; +var 𭇨; +var 𭇩; +var 𭇪; +var 𭇫; +var 𭇬; +var 𭇭; +var 𭇮; +var 𭇯; +var 𭇰; +var 𭇱; +var 𭇲; +var 𭇳; +var 𭇴; +var 𭇵; +var 𭇶; +var 𭇷; +var 𭇸; +var 𭇹; +var 𭇺; +var 𭇻; +var 𭇼; +var 𭇽; +var 𭇾; +var 𭇿; +var 𭈀; +var 𭈁; +var 𭈂; +var 𭈃; +var 𭈄; +var 𭈅; +var 𭈆; +var 𭈇; +var 𭈈; +var 𭈉; +var 𭈊; +var 𭈋; +var 𭈌; +var 𭈍; +var 𭈎; +var 𭈏; +var 𭈐; +var 𭈑; +var 𭈒; +var 𭈓; +var 𭈔; +var 𭈕; +var 𭈖; +var 𭈗; +var 𭈘; +var 𭈙; +var 𭈚; +var 𭈛; +var 𭈜; +var 𭈝; +var 𭈞; +var 𭈟; +var 𭈠; +var 𭈡; +var 𭈢; +var 𭈣; +var 𭈤; +var 𭈥; +var 𭈦; +var 𭈧; +var 𭈨; +var 𭈩; +var 𭈪; +var 𭈫; +var 𭈬; +var 𭈭; +var 𭈮; +var 𭈯; +var 𭈰; +var 𭈱; +var 𭈲; +var 𭈳; +var 𭈴; +var 𭈵; +var 𭈶; +var 𭈷; +var 𭈸; +var 𭈹; +var 𭈺; +var 𭈻; +var 𭈼; +var 𭈽; +var 𭈾; +var 𭈿; +var 𭉀; +var 𭉁; +var 𭉂; +var 𭉃; +var 𭉄; +var 𭉅; +var 𭉆; +var 𭉇; +var 𭉈; +var 𭉉; +var 𭉊; +var 𭉋; +var 𭉌; +var 𭉍; +var 𭉎; +var 𭉏; +var 𭉐; +var 𭉑; +var 𭉒; +var 𭉓; +var 𭉔; +var 𭉕; +var 𭉖; +var 𭉗; +var 𭉘; +var 𭉙; +var 𭉚; +var 𭉛; +var 𭉜; +var 𭉝; +var 𭉞; +var 𭉟; +var 𭉠; +var 𭉡; +var 𭉢; +var 𭉣; +var 𭉤; +var 𭉥; +var 𭉦; +var 𭉧; +var 𭉨; +var 𭉩; +var 𭉪; +var 𭉫; +var 𭉬; +var 𭉭; +var 𭉮; +var 𭉯; +var 𭉰; +var 𭉱; +var 𭉲; +var 𭉳; +var 𭉴; +var 𭉵; +var 𭉶; +var 𭉷; +var 𭉸; +var 𭉹; +var 𭉺; +var 𭉻; +var 𭉼; +var 𭉽; +var 𭉾; +var 𭉿; +var 𭊀; +var 𭊁; +var 𭊂; +var 𭊃; +var 𭊄; +var 𭊅; +var 𭊆; +var 𭊇; +var 𭊈; +var 𭊉; +var 𭊊; +var 𭊋; +var 𭊌; +var 𭊍; +var 𭊎; +var 𭊏; +var 𭊐; +var 𭊑; +var 𭊒; +var 𭊓; +var 𭊔; +var 𭊕; +var 𭊖; +var 𭊗; +var 𭊘; +var 𭊙; +var 𭊚; +var 𭊛; +var 𭊜; +var 𭊝; +var 𭊞; +var 𭊟; +var 𭊠; +var 𭊡; +var 𭊢; +var 𭊣; +var 𭊤; +var 𭊥; +var 𭊦; +var 𭊧; +var 𭊨; +var 𭊩; +var 𭊪; +var 𭊫; +var 𭊬; +var 𭊭; +var 𭊮; +var 𭊯; +var 𭊰; +var 𭊱; +var 𭊲; +var 𭊳; +var 𭊴; +var 𭊵; +var 𭊶; +var 𭊷; +var 𭊸; +var 𭊹; +var 𭊺; +var 𭊻; +var 𭊼; +var 𭊽; +var 𭊾; +var 𭊿; +var 𭋀; +var 𭋁; +var 𭋂; +var 𭋃; +var 𭋄; +var 𭋅; +var 𭋆; +var 𭋇; +var 𭋈; +var 𭋉; +var 𭋊; +var 𭋋; +var 𭋌; +var 𭋍; +var 𭋎; +var 𭋏; +var 𭋐; +var 𭋑; +var 𭋒; +var 𭋓; +var 𭋔; +var 𭋕; +var 𭋖; +var 𭋗; +var 𭋘; +var 𭋙; +var 𭋚; +var 𭋛; +var 𭋜; +var 𭋝; +var 𭋞; +var 𭋟; +var 𭋠; +var 𭋡; +var 𭋢; +var 𭋣; +var 𭋤; +var 𭋥; +var 𭋦; +var 𭋧; +var 𭋨; +var 𭋩; +var 𭋪; +var 𭋫; +var 𭋬; +var 𭋭; +var 𭋮; +var 𭋯; +var 𭋰; +var 𭋱; +var 𭋲; +var 𭋳; +var 𭋴; +var 𭋵; +var 𭋶; +var 𭋷; +var 𭋸; +var 𭋹; +var 𭋺; +var 𭋻; +var 𭋼; +var 𭋽; +var 𭋾; +var 𭋿; +var 𭌀; +var 𭌁; +var 𭌂; +var 𭌃; +var 𭌄; +var 𭌅; +var 𭌆; +var 𭌇; +var 𭌈; +var 𭌉; +var 𭌊; +var 𭌋; +var 𭌌; +var 𭌍; +var 𭌎; +var 𭌏; +var 𭌐; +var 𭌑; +var 𭌒; +var 𭌓; +var 𭌔; +var 𭌕; +var 𭌖; +var 𭌗; +var 𭌘; +var 𭌙; +var 𭌚; +var 𭌛; +var 𭌜; +var 𭌝; +var 𭌞; +var 𭌟; +var 𭌠; +var 𭌡; +var 𭌢; +var 𭌣; +var 𭌤; +var 𭌥; +var 𭌦; +var 𭌧; +var 𭌨; +var 𭌩; +var 𭌪; +var 𭌫; +var 𭌬; +var 𭌭; +var 𭌮; +var 𭌯; +var 𭌰; +var 𭌱; +var 𭌲; +var 𭌳; +var 𭌴; +var 𭌵; +var 𭌶; +var 𭌷; +var 𭌸; +var 𭌹; +var 𭌺; +var 𭌻; +var 𭌼; +var 𭌽; +var 𭌾; +var 𭌿; +var 𭍀; +var 𭍁; +var 𭍂; +var 𭍃; +var 𭍄; +var 𭍅; +var 𭍆; +var 𭍇; +var 𭍈; +var 𭍉; +var 𭍊; +var 𭍋; +var 𭍌; +var 𭍍; +var 𭍎; +var 𭍏; +var 𭍐; +var 𭍑; +var 𭍒; +var 𭍓; +var 𭍔; +var 𭍕; +var 𭍖; +var 𭍗; +var 𭍘; +var 𭍙; +var 𭍚; +var 𭍛; +var 𭍜; +var 𭍝; +var 𭍞; +var 𭍟; +var 𭍠; +var 𭍡; +var 𭍢; +var 𭍣; +var 𭍤; +var 𭍥; +var 𭍦; +var 𭍧; +var 𭍨; +var 𭍩; +var 𭍪; +var 𭍫; +var 𭍬; +var 𭍭; +var 𭍮; +var 𭍯; +var 𭍰; +var 𭍱; +var 𭍲; +var 𭍳; +var 𭍴; +var 𭍵; +var 𭍶; +var 𭍷; +var 𭍸; +var 𭍹; +var 𭍺; +var 𭍻; +var 𭍼; +var 𭍽; +var 𭍾; +var 𭍿; +var 𭎀; +var 𭎁; +var 𭎂; +var 𭎃; +var 𭎄; +var 𭎅; +var 𭎆; +var 𭎇; +var 𭎈; +var 𭎉; +var 𭎊; +var 𭎋; +var 𭎌; +var 𭎍; +var 𭎎; +var 𭎏; +var 𭎐; +var 𭎑; +var 𭎒; +var 𭎓; +var 𭎔; +var 𭎕; +var 𭎖; +var 𭎗; +var 𭎘; +var 𭎙; +var 𭎚; +var 𭎛; +var 𭎜; +var 𭎝; +var 𭎞; +var 𭎟; +var 𭎠; +var 𭎡; +var 𭎢; +var 𭎣; +var 𭎤; +var 𭎥; +var 𭎦; +var 𭎧; +var 𭎨; +var 𭎩; +var 𭎪; +var 𭎫; +var 𭎬; +var 𭎭; +var 𭎮; +var 𭎯; +var 𭎰; +var 𭎱; +var 𭎲; +var 𭎳; +var 𭎴; +var 𭎵; +var 𭎶; +var 𭎷; +var 𭎸; +var 𭎹; +var 𭎺; +var 𭎻; +var 𭎼; +var 𭎽; +var 𭎾; +var 𭎿; +var 𭏀; +var 𭏁; +var 𭏂; +var 𭏃; +var 𭏄; +var 𭏅; +var 𭏆; +var 𭏇; +var 𭏈; +var 𭏉; +var 𭏊; +var 𭏋; +var 𭏌; +var 𭏍; +var 𭏎; +var 𭏏; +var 𭏐; +var 𭏑; +var 𭏒; +var 𭏓; +var 𭏔; +var 𭏕; +var 𭏖; +var 𭏗; +var 𭏘; +var 𭏙; +var 𭏚; +var 𭏛; +var 𭏜; +var 𭏝; +var 𭏞; +var 𭏟; +var 𭏠; +var 𭏡; +var 𭏢; +var 𭏣; +var 𭏤; +var 𭏥; +var 𭏦; +var 𭏧; +var 𭏨; +var 𭏩; +var 𭏪; +var 𭏫; +var 𭏬; +var 𭏭; +var 𭏮; +var 𭏯; +var 𭏰; +var 𭏱; +var 𭏲; +var 𭏳; +var 𭏴; +var 𭏵; +var 𭏶; +var 𭏷; +var 𭏸; +var 𭏹; +var 𭏺; +var 𭏻; +var 𭏼; +var 𭏽; +var 𭏾; +var 𭏿; +var 𭐀; +var 𭐁; +var 𭐂; +var 𭐃; +var 𭐄; +var 𭐅; +var 𭐆; +var 𭐇; +var 𭐈; +var 𭐉; +var 𭐊; +var 𭐋; +var 𭐌; +var 𭐍; +var 𭐎; +var 𭐏; +var 𭐐; +var 𭐑; +var 𭐒; +var 𭐓; +var 𭐔; +var 𭐕; +var 𭐖; +var 𭐗; +var 𭐘; +var 𭐙; +var 𭐚; +var 𭐛; +var 𭐜; +var 𭐝; +var 𭐞; +var 𭐟; +var 𭐠; +var 𭐡; +var 𭐢; +var 𭐣; +var 𭐤; +var 𭐥; +var 𭐦; +var 𭐧; +var 𭐨; +var 𭐩; +var 𭐪; +var 𭐫; +var 𭐬; +var 𭐭; +var 𭐮; +var 𭐯; +var 𭐰; +var 𭐱; +var 𭐲; +var 𭐳; +var 𭐴; +var 𭐵; +var 𭐶; +var 𭐷; +var 𭐸; +var 𭐹; +var 𭐺; +var 𭐻; +var 𭐼; +var 𭐽; +var 𭐾; +var 𭐿; +var 𭑀; +var 𭑁; +var 𭑂; +var 𭑃; +var 𭑄; +var 𭑅; +var 𭑆; +var 𭑇; +var 𭑈; +var 𭑉; +var 𭑊; +var 𭑋; +var 𭑌; +var 𭑍; +var 𭑎; +var 𭑏; +var 𭑐; +var 𭑑; +var 𭑒; +var 𭑓; +var 𭑔; +var 𭑕; +var 𭑖; +var 𭑗; +var 𭑘; +var 𭑙; +var 𭑚; +var 𭑛; +var 𭑜; +var 𭑝; +var 𭑞; +var 𭑟; +var 𭑠; +var 𭑡; +var 𭑢; +var 𭑣; +var 𭑤; +var 𭑥; +var 𭑦; +var 𭑧; +var 𭑨; +var 𭑩; +var 𭑪; +var 𭑫; +var 𭑬; +var 𭑭; +var 𭑮; +var 𭑯; +var 𭑰; +var 𭑱; +var 𭑲; +var 𭑳; +var 𭑴; +var 𭑵; +var 𭑶; +var 𭑷; +var 𭑸; +var 𭑹; +var 𭑺; +var 𭑻; +var 𭑼; +var 𭑽; +var 𭑾; +var 𭑿; +var 𭒀; +var 𭒁; +var 𭒂; +var 𭒃; +var 𭒄; +var 𭒅; +var 𭒆; +var 𭒇; +var 𭒈; +var 𭒉; +var 𭒊; +var 𭒋; +var 𭒌; +var 𭒍; +var 𭒎; +var 𭒏; +var 𭒐; +var 𭒑; +var 𭒒; +var 𭒓; +var 𭒔; +var 𭒕; +var 𭒖; +var 𭒗; +var 𭒘; +var 𭒙; +var 𭒚; +var 𭒛; +var 𭒜; +var 𭒝; +var 𭒞; +var 𭒟; +var 𭒠; +var 𭒡; +var 𭒢; +var 𭒣; +var 𭒤; +var 𭒥; +var 𭒦; +var 𭒧; +var 𭒨; +var 𭒩; +var 𭒪; +var 𭒫; +var 𭒬; +var 𭒭; +var 𭒮; +var 𭒯; +var 𭒰; +var 𭒱; +var 𭒲; +var 𭒳; +var 𭒴; +var 𭒵; +var 𭒶; +var 𭒷; +var 𭒸; +var 𭒹; +var 𭒺; +var 𭒻; +var 𭒼; +var 𭒽; +var 𭒾; +var 𭒿; +var 𭓀; +var 𭓁; +var 𭓂; +var 𭓃; +var 𭓄; +var 𭓅; +var 𭓆; +var 𭓇; +var 𭓈; +var 𭓉; +var 𭓊; +var 𭓋; +var 𭓌; +var 𭓍; +var 𭓎; +var 𭓏; +var 𭓐; +var 𭓑; +var 𭓒; +var 𭓓; +var 𭓔; +var 𭓕; +var 𭓖; +var 𭓗; +var 𭓘; +var 𭓙; +var 𭓚; +var 𭓛; +var 𭓜; +var 𭓝; +var 𭓞; +var 𭓟; +var 𭓠; +var 𭓡; +var 𭓢; +var 𭓣; +var 𭓤; +var 𭓥; +var 𭓦; +var 𭓧; +var 𭓨; +var 𭓩; +var 𭓪; +var 𭓫; +var 𭓬; +var 𭓭; +var 𭓮; +var 𭓯; +var 𭓰; +var 𭓱; +var 𭓲; +var 𭓳; +var 𭓴; +var 𭓵; +var 𭓶; +var 𭓷; +var 𭓸; +var 𭓹; +var 𭓺; +var 𭓻; +var 𭓼; +var 𭓽; +var 𭓾; +var 𭓿; +var 𭔀; +var 𭔁; +var 𭔂; +var 𭔃; +var 𭔄; +var 𭔅; +var 𭔆; +var 𭔇; +var 𭔈; +var 𭔉; +var 𭔊; +var 𭔋; +var 𭔌; +var 𭔍; +var 𭔎; +var 𭔏; +var 𭔐; +var 𭔑; +var 𭔒; +var 𭔓; +var 𭔔; +var 𭔕; +var 𭔖; +var 𭔗; +var 𭔘; +var 𭔙; +var 𭔚; +var 𭔛; +var 𭔜; +var 𭔝; +var 𭔞; +var 𭔟; +var 𭔠; +var 𭔡; +var 𭔢; +var 𭔣; +var 𭔤; +var 𭔥; +var 𭔦; +var 𭔧; +var 𭔨; +var 𭔩; +var 𭔪; +var 𭔫; +var 𭔬; +var 𭔭; +var 𭔮; +var 𭔯; +var 𭔰; +var 𭔱; +var 𭔲; +var 𭔳; +var 𭔴; +var 𭔵; +var 𭔶; +var 𭔷; +var 𭔸; +var 𭔹; +var 𭔺; +var 𭔻; +var 𭔼; +var 𭔽; +var 𭔾; +var 𭔿; +var 𭕀; +var 𭕁; +var 𭕂; +var 𭕃; +var 𭕄; +var 𭕅; +var 𭕆; +var 𭕇; +var 𭕈; +var 𭕉; +var 𭕊; +var 𭕋; +var 𭕌; +var 𭕍; +var 𭕎; +var 𭕏; +var 𭕐; +var 𭕑; +var 𭕒; +var 𭕓; +var 𭕔; +var 𭕕; +var 𭕖; +var 𭕗; +var 𭕘; +var 𭕙; +var 𭕚; +var 𭕛; +var 𭕜; +var 𭕝; +var 𭕞; +var 𭕟; +var 𭕠; +var 𭕡; +var 𭕢; +var 𭕣; +var 𭕤; +var 𭕥; +var 𭕦; +var 𭕧; +var 𭕨; +var 𭕩; +var 𭕪; +var 𭕫; +var 𭕬; +var 𭕭; +var 𭕮; +var 𭕯; +var 𭕰; +var 𭕱; +var 𭕲; +var 𭕳; +var 𭕴; +var 𭕵; +var 𭕶; +var 𭕷; +var 𭕸; +var 𭕹; +var 𭕺; +var 𭕻; +var 𭕼; +var 𭕽; +var 𭕾; +var 𭕿; +var 𭖀; +var 𭖁; +var 𭖂; +var 𭖃; +var 𭖄; +var 𭖅; +var 𭖆; +var 𭖇; +var 𭖈; +var 𭖉; +var 𭖊; +var 𭖋; +var 𭖌; +var 𭖍; +var 𭖎; +var 𭖏; +var 𭖐; +var 𭖑; +var 𭖒; +var 𭖓; +var 𭖔; +var 𭖕; +var 𭖖; +var 𭖗; +var 𭖘; +var 𭖙; +var 𭖚; +var 𭖛; +var 𭖜; +var 𭖝; +var 𭖞; +var 𭖟; +var 𭖠; +var 𭖡; +var 𭖢; +var 𭖣; +var 𭖤; +var 𭖥; +var 𭖦; +var 𭖧; +var 𭖨; +var 𭖩; +var 𭖪; +var 𭖫; +var 𭖬; +var 𭖭; +var 𭖮; +var 𭖯; +var 𭖰; +var 𭖱; +var 𭖲; +var 𭖳; +var 𭖴; +var 𭖵; +var 𭖶; +var 𭖷; +var 𭖸; +var 𭖹; +var 𭖺; +var 𭖻; +var 𭖼; +var 𭖽; +var 𭖾; +var 𭖿; +var 𭗀; +var 𭗁; +var 𭗂; +var 𭗃; +var 𭗄; +var 𭗅; +var 𭗆; +var 𭗇; +var 𭗈; +var 𭗉; +var 𭗊; +var 𭗋; +var 𭗌; +var 𭗍; +var 𭗎; +var 𭗏; +var 𭗐; +var 𭗑; +var 𭗒; +var 𭗓; +var 𭗔; +var 𭗕; +var 𭗖; +var 𭗗; +var 𭗘; +var 𭗙; +var 𭗚; +var 𭗛; +var 𭗜; +var 𭗝; +var 𭗞; +var 𭗟; +var 𭗠; +var 𭗡; +var 𭗢; +var 𭗣; +var 𭗤; +var 𭗥; +var 𭗦; +var 𭗧; +var 𭗨; +var 𭗩; +var 𭗪; +var 𭗫; +var 𭗬; +var 𭗭; +var 𭗮; +var 𭗯; +var 𭗰; +var 𭗱; +var 𭗲; +var 𭗳; +var 𭗴; +var 𭗵; +var 𭗶; +var 𭗷; +var 𭗸; +var 𭗹; +var 𭗺; +var 𭗻; +var 𭗼; +var 𭗽; +var 𭗾; +var 𭗿; +var 𭘀; +var 𭘁; +var 𭘂; +var 𭘃; +var 𭘄; +var 𭘅; +var 𭘆; +var 𭘇; +var 𭘈; +var 𭘉; +var 𭘊; +var 𭘋; +var 𭘌; +var 𭘍; +var 𭘎; +var 𭘏; +var 𭘐; +var 𭘑; +var 𭘒; +var 𭘓; +var 𭘔; +var 𭘕; +var 𭘖; +var 𭘗; +var 𭘘; +var 𭘙; +var 𭘚; +var 𭘛; +var 𭘜; +var 𭘝; +var 𭘞; +var 𭘟; +var 𭘠; +var 𭘡; +var 𭘢; +var 𭘣; +var 𭘤; +var 𭘥; +var 𭘦; +var 𭘧; +var 𭘨; +var 𭘩; +var 𭘪; +var 𭘫; +var 𭘬; +var 𭘭; +var 𭘮; +var 𭘯; +var 𭘰; +var 𭘱; +var 𭘲; +var 𭘳; +var 𭘴; +var 𭘵; +var 𭘶; +var 𭘷; +var 𭘸; +var 𭘹; +var 𭘺; +var 𭘻; +var 𭘼; +var 𭘽; +var 𭘾; +var 𭘿; +var 𭙀; +var 𭙁; +var 𭙂; +var 𭙃; +var 𭙄; +var 𭙅; +var 𭙆; +var 𭙇; +var 𭙈; +var 𭙉; +var 𭙊; +var 𭙋; +var 𭙌; +var 𭙍; +var 𭙎; +var 𭙏; +var 𭙐; +var 𭙑; +var 𭙒; +var 𭙓; +var 𭙔; +var 𭙕; +var 𭙖; +var 𭙗; +var 𭙘; +var 𭙙; +var 𭙚; +var 𭙛; +var 𭙜; +var 𭙝; +var 𭙞; +var 𭙟; +var 𭙠; +var 𭙡; +var 𭙢; +var 𭙣; +var 𭙤; +var 𭙥; +var 𭙦; +var 𭙧; +var 𭙨; +var 𭙩; +var 𭙪; +var 𭙫; +var 𭙬; +var 𭙭; +var 𭙮; +var 𭙯; +var 𭙰; +var 𭙱; +var 𭙲; +var 𭙳; +var 𭙴; +var 𭙵; +var 𭙶; +var 𭙷; +var 𭙸; +var 𭙹; +var 𭙺; +var 𭙻; +var 𭙼; +var 𭙽; +var 𭙾; +var 𭙿; +var 𭚀; +var 𭚁; +var 𭚂; +var 𭚃; +var 𭚄; +var 𭚅; +var 𭚆; +var 𭚇; +var 𭚈; +var 𭚉; +var 𭚊; +var 𭚋; +var 𭚌; +var 𭚍; +var 𭚎; +var 𭚏; +var 𭚐; +var 𭚑; +var 𭚒; +var 𭚓; +var 𭚔; +var 𭚕; +var 𭚖; +var 𭚗; +var 𭚘; +var 𭚙; +var 𭚚; +var 𭚛; +var 𭚜; +var 𭚝; +var 𭚞; +var 𭚟; +var 𭚠; +var 𭚡; +var 𭚢; +var 𭚣; +var 𭚤; +var 𭚥; +var 𭚦; +var 𭚧; +var 𭚨; +var 𭚩; +var 𭚪; +var 𭚫; +var 𭚬; +var 𭚭; +var 𭚮; +var 𭚯; +var 𭚰; +var 𭚱; +var 𭚲; +var 𭚳; +var 𭚴; +var 𭚵; +var 𭚶; +var 𭚷; +var 𭚸; +var 𭚹; +var 𭚺; +var 𭚻; +var 𭚼; +var 𭚽; +var 𭚾; +var 𭚿; +var 𭛀; +var 𭛁; +var 𭛂; +var 𭛃; +var 𭛄; +var 𭛅; +var 𭛆; +var 𭛇; +var 𭛈; +var 𭛉; +var 𭛊; +var 𭛋; +var 𭛌; +var 𭛍; +var 𭛎; +var 𭛏; +var 𭛐; +var 𭛑; +var 𭛒; +var 𭛓; +var 𭛔; +var 𭛕; +var 𭛖; +var 𭛗; +var 𭛘; +var 𭛙; +var 𭛚; +var 𭛛; +var 𭛜; +var 𭛝; +var 𭛞; +var 𭛟; +var 𭛠; +var 𭛡; +var 𭛢; +var 𭛣; +var 𭛤; +var 𭛥; +var 𭛦; +var 𭛧; +var 𭛨; +var 𭛩; +var 𭛪; +var 𭛫; +var 𭛬; +var 𭛭; +var 𭛮; +var 𭛯; +var 𭛰; +var 𭛱; +var 𭛲; +var 𭛳; +var 𭛴; +var 𭛵; +var 𭛶; +var 𭛷; +var 𭛸; +var 𭛹; +var 𭛺; +var 𭛻; +var 𭛼; +var 𭛽; +var 𭛾; +var 𭛿; +var 𭜀; +var 𭜁; +var 𭜂; +var 𭜃; +var 𭜄; +var 𭜅; +var 𭜆; +var 𭜇; +var 𭜈; +var 𭜉; +var 𭜊; +var 𭜋; +var 𭜌; +var 𭜍; +var 𭜎; +var 𭜏; +var 𭜐; +var 𭜑; +var 𭜒; +var 𭜓; +var 𭜔; +var 𭜕; +var 𭜖; +var 𭜗; +var 𭜘; +var 𭜙; +var 𭜚; +var 𭜛; +var 𭜜; +var 𭜝; +var 𭜞; +var 𭜟; +var 𭜠; +var 𭜡; +var 𭜢; +var 𭜣; +var 𭜤; +var 𭜥; +var 𭜦; +var 𭜧; +var 𭜨; +var 𭜩; +var 𭜪; +var 𭜫; +var 𭜬; +var 𭜭; +var 𭜮; +var 𭜯; +var 𭜰; +var 𭜱; +var 𭜲; +var 𭜳; +var 𭜴; +var 𭜵; +var 𭜶; +var 𭜷; +var 𭜸; +var 𭜹; +var 𭜺; +var 𭜻; +var 𭜼; +var 𭜽; +var 𭜾; +var 𭜿; +var 𭝀; +var 𭝁; +var 𭝂; +var 𭝃; +var 𭝄; +var 𭝅; +var 𭝆; +var 𭝇; +var 𭝈; +var 𭝉; +var 𭝊; +var 𭝋; +var 𭝌; +var 𭝍; +var 𭝎; +var 𭝏; +var 𭝐; +var 𭝑; +var 𭝒; +var 𭝓; +var 𭝔; +var 𭝕; +var 𭝖; +var 𭝗; +var 𭝘; +var 𭝙; +var 𭝚; +var 𭝛; +var 𭝜; +var 𭝝; +var 𭝞; +var 𭝟; +var 𭝠; +var 𭝡; +var 𭝢; +var 𭝣; +var 𭝤; +var 𭝥; +var 𭝦; +var 𭝧; +var 𭝨; +var 𭝩; +var 𭝪; +var 𭝫; +var 𭝬; +var 𭝭; +var 𭝮; +var 𭝯; +var 𭝰; +var 𭝱; +var 𭝲; +var 𭝳; +var 𭝴; +var 𭝵; +var 𭝶; +var 𭝷; +var 𭝸; +var 𭝹; +var 𭝺; +var 𭝻; +var 𭝼; +var 𭝽; +var 𭝾; +var 𭝿; +var 𭞀; +var 𭞁; +var 𭞂; +var 𭞃; +var 𭞄; +var 𭞅; +var 𭞆; +var 𭞇; +var 𭞈; +var 𭞉; +var 𭞊; +var 𭞋; +var 𭞌; +var 𭞍; +var 𭞎; +var 𭞏; +var 𭞐; +var 𭞑; +var 𭞒; +var 𭞓; +var 𭞔; +var 𭞕; +var 𭞖; +var 𭞗; +var 𭞘; +var 𭞙; +var 𭞚; +var 𭞛; +var 𭞜; +var 𭞝; +var 𭞞; +var 𭞟; +var 𭞠; +var 𭞡; +var 𭞢; +var 𭞣; +var 𭞤; +var 𭞥; +var 𭞦; +var 𭞧; +var 𭞨; +var 𭞩; +var 𭞪; +var 𭞫; +var 𭞬; +var 𭞭; +var 𭞮; +var 𭞯; +var 𭞰; +var 𭞱; +var 𭞲; +var 𭞳; +var 𭞴; +var 𭞵; +var 𭞶; +var 𭞷; +var 𭞸; +var 𭞹; +var 𭞺; +var 𭞻; +var 𭞼; +var 𭞽; +var 𭞾; +var 𭞿; +var 𭟀; +var 𭟁; +var 𭟂; +var 𭟃; +var 𭟄; +var 𭟅; +var 𭟆; +var 𭟇; +var 𭟈; +var 𭟉; +var 𭟊; +var 𭟋; +var 𭟌; +var 𭟍; +var 𭟎; +var 𭟏; +var 𭟐; +var 𭟑; +var 𭟒; +var 𭟓; +var 𭟔; +var 𭟕; +var 𭟖; +var 𭟗; +var 𭟘; +var 𭟙; +var 𭟚; +var 𭟛; +var 𭟜; +var 𭟝; +var 𭟞; +var 𭟟; +var 𭟠; +var 𭟡; +var 𭟢; +var 𭟣; +var 𭟤; +var 𭟥; +var 𭟦; +var 𭟧; +var 𭟨; +var 𭟩; +var 𭟪; +var 𭟫; +var 𭟬; +var 𭟭; +var 𭟮; +var 𭟯; +var 𭟰; +var 𭟱; +var 𭟲; +var 𭟳; +var 𭟴; +var 𭟵; +var 𭟶; +var 𭟷; +var 𭟸; +var 𭟹; +var 𭟺; +var 𭟻; +var 𭟼; +var 𭟽; +var 𭟾; +var 𭟿; +var 𭠀; +var 𭠁; +var 𭠂; +var 𭠃; +var 𭠄; +var 𭠅; +var 𭠆; +var 𭠇; +var 𭠈; +var 𭠉; +var 𭠊; +var 𭠋; +var 𭠌; +var 𭠍; +var 𭠎; +var 𭠏; +var 𭠐; +var 𭠑; +var 𭠒; +var 𭠓; +var 𭠔; +var 𭠕; +var 𭠖; +var 𭠗; +var 𭠘; +var 𭠙; +var 𭠚; +var 𭠛; +var 𭠜; +var 𭠝; +var 𭠞; +var 𭠟; +var 𭠠; +var 𭠡; +var 𭠢; +var 𭠣; +var 𭠤; +var 𭠥; +var 𭠦; +var 𭠧; +var 𭠨; +var 𭠩; +var 𭠪; +var 𭠫; +var 𭠬; +var 𭠭; +var 𭠮; +var 𭠯; +var 𭠰; +var 𭠱; +var 𭠲; +var 𭠳; +var 𭠴; +var 𭠵; +var 𭠶; +var 𭠷; +var 𭠸; +var 𭠹; +var 𭠺; +var 𭠻; +var 𭠼; +var 𭠽; +var 𭠾; +var 𭠿; +var 𭡀; +var 𭡁; +var 𭡂; +var 𭡃; +var 𭡄; +var 𭡅; +var 𭡆; +var 𭡇; +var 𭡈; +var 𭡉; +var 𭡊; +var 𭡋; +var 𭡌; +var 𭡍; +var 𭡎; +var 𭡏; +var 𭡐; +var 𭡑; +var 𭡒; +var 𭡓; +var 𭡔; +var 𭡕; +var 𭡖; +var 𭡗; +var 𭡘; +var 𭡙; +var 𭡚; +var 𭡛; +var 𭡜; +var 𭡝; +var 𭡞; +var 𭡟; +var 𭡠; +var 𭡡; +var 𭡢; +var 𭡣; +var 𭡤; +var 𭡥; +var 𭡦; +var 𭡧; +var 𭡨; +var 𭡩; +var 𭡪; +var 𭡫; +var 𭡬; +var 𭡭; +var 𭡮; +var 𭡯; +var 𭡰; +var 𭡱; +var 𭡲; +var 𭡳; +var 𭡴; +var 𭡵; +var 𭡶; +var 𭡷; +var 𭡸; +var 𭡹; +var 𭡺; +var 𭡻; +var 𭡼; +var 𭡽; +var 𭡾; +var 𭡿; +var 𭢀; +var 𭢁; +var 𭢂; +var 𭢃; +var 𭢄; +var 𭢅; +var 𭢆; +var 𭢇; +var 𭢈; +var 𭢉; +var 𭢊; +var 𭢋; +var 𭢌; +var 𭢍; +var 𭢎; +var 𭢏; +var 𭢐; +var 𭢑; +var 𭢒; +var 𭢓; +var 𭢔; +var 𭢕; +var 𭢖; +var 𭢗; +var 𭢘; +var 𭢙; +var 𭢚; +var 𭢛; +var 𭢜; +var 𭢝; +var 𭢞; +var 𭢟; +var 𭢠; +var 𭢡; +var 𭢢; +var 𭢣; +var 𭢤; +var 𭢥; +var 𭢦; +var 𭢧; +var 𭢨; +var 𭢩; +var 𭢪; +var 𭢫; +var 𭢬; +var 𭢭; +var 𭢮; +var 𭢯; +var 𭢰; +var 𭢱; +var 𭢲; +var 𭢳; +var 𭢴; +var 𭢵; +var 𭢶; +var 𭢷; +var 𭢸; +var 𭢹; +var 𭢺; +var 𭢻; +var 𭢼; +var 𭢽; +var 𭢾; +var 𭢿; +var 𭣀; +var 𭣁; +var 𭣂; +var 𭣃; +var 𭣄; +var 𭣅; +var 𭣆; +var 𭣇; +var 𭣈; +var 𭣉; +var 𭣊; +var 𭣋; +var 𭣌; +var 𭣍; +var 𭣎; +var 𭣏; +var 𭣐; +var 𭣑; +var 𭣒; +var 𭣓; +var 𭣔; +var 𭣕; +var 𭣖; +var 𭣗; +var 𭣘; +var 𭣙; +var 𭣚; +var 𭣛; +var 𭣜; +var 𭣝; +var 𭣞; +var 𭣟; +var 𭣠; +var 𭣡; +var 𭣢; +var 𭣣; +var 𭣤; +var 𭣥; +var 𭣦; +var 𭣧; +var 𭣨; +var 𭣩; +var 𭣪; +var 𭣫; +var 𭣬; +var 𭣭; +var 𭣮; +var 𭣯; +var 𭣰; +var 𭣱; +var 𭣲; +var 𭣳; +var 𭣴; +var 𭣵; +var 𭣶; +var 𭣷; +var 𭣸; +var 𭣹; +var 𭣺; +var 𭣻; +var 𭣼; +var 𭣽; +var 𭣾; +var 𭣿; +var 𭤀; +var 𭤁; +var 𭤂; +var 𭤃; +var 𭤄; +var 𭤅; +var 𭤆; +var 𭤇; +var 𭤈; +var 𭤉; +var 𭤊; +var 𭤋; +var 𭤌; +var 𭤍; +var 𭤎; +var 𭤏; +var 𭤐; +var 𭤑; +var 𭤒; +var 𭤓; +var 𭤔; +var 𭤕; +var 𭤖; +var 𭤗; +var 𭤘; +var 𭤙; +var 𭤚; +var 𭤛; +var 𭤜; +var 𭤝; +var 𭤞; +var 𭤟; +var 𭤠; +var 𭤡; +var 𭤢; +var 𭤣; +var 𭤤; +var 𭤥; +var 𭤦; +var 𭤧; +var 𭤨; +var 𭤩; +var 𭤪; +var 𭤫; +var 𭤬; +var 𭤭; +var 𭤮; +var 𭤯; +var 𭤰; +var 𭤱; +var 𭤲; +var 𭤳; +var 𭤴; +var 𭤵; +var 𭤶; +var 𭤷; +var 𭤸; +var 𭤹; +var 𭤺; +var 𭤻; +var 𭤼; +var 𭤽; +var 𭤾; +var 𭤿; +var 𭥀; +var 𭥁; +var 𭥂; +var 𭥃; +var 𭥄; +var 𭥅; +var 𭥆; +var 𭥇; +var 𭥈; +var 𭥉; +var 𭥊; +var 𭥋; +var 𭥌; +var 𭥍; +var 𭥎; +var 𭥏; +var 𭥐; +var 𭥑; +var 𭥒; +var 𭥓; +var 𭥔; +var 𭥕; +var 𭥖; +var 𭥗; +var 𭥘; +var 𭥙; +var 𭥚; +var 𭥛; +var 𭥜; +var 𭥝; +var 𭥞; +var 𭥟; +var 𭥠; +var 𭥡; +var 𭥢; +var 𭥣; +var 𭥤; +var 𭥥; +var 𭥦; +var 𭥧; +var 𭥨; +var 𭥩; +var 𭥪; +var 𭥫; +var 𭥬; +var 𭥭; +var 𭥮; +var 𭥯; +var 𭥰; +var 𭥱; +var 𭥲; +var 𭥳; +var 𭥴; +var 𭥵; +var 𭥶; +var 𭥷; +var 𭥸; +var 𭥹; +var 𭥺; +var 𭥻; +var 𭥼; +var 𭥽; +var 𭥾; +var 𭥿; +var 𭦀; +var 𭦁; +var 𭦂; +var 𭦃; +var 𭦄; +var 𭦅; +var 𭦆; +var 𭦇; +var 𭦈; +var 𭦉; +var 𭦊; +var 𭦋; +var 𭦌; +var 𭦍; +var 𭦎; +var 𭦏; +var 𭦐; +var 𭦑; +var 𭦒; +var 𭦓; +var 𭦔; +var 𭦕; +var 𭦖; +var 𭦗; +var 𭦘; +var 𭦙; +var 𭦚; +var 𭦛; +var 𭦜; +var 𭦝; +var 𭦞; +var 𭦟; +var 𭦠; +var 𭦡; +var 𭦢; +var 𭦣; +var 𭦤; +var 𭦥; +var 𭦦; +var 𭦧; +var 𭦨; +var 𭦩; +var 𭦪; +var 𭦫; +var 𭦬; +var 𭦭; +var 𭦮; +var 𭦯; +var 𭦰; +var 𭦱; +var 𭦲; +var 𭦳; +var 𭦴; +var 𭦵; +var 𭦶; +var 𭦷; +var 𭦸; +var 𭦹; +var 𭦺; +var 𭦻; +var 𭦼; +var 𭦽; +var 𭦾; +var 𭦿; +var 𭧀; +var 𭧁; +var 𭧂; +var 𭧃; +var 𭧄; +var 𭧅; +var 𭧆; +var 𭧇; +var 𭧈; +var 𭧉; +var 𭧊; +var 𭧋; +var 𭧌; +var 𭧍; +var 𭧎; +var 𭧏; +var 𭧐; +var 𭧑; +var 𭧒; +var 𭧓; +var 𭧔; +var 𭧕; +var 𭧖; +var 𭧗; +var 𭧘; +var 𭧙; +var 𭧚; +var 𭧛; +var 𭧜; +var 𭧝; +var 𭧞; +var 𭧟; +var 𭧠; +var 𭧡; +var 𭧢; +var 𭧣; +var 𭧤; +var 𭧥; +var 𭧦; +var 𭧧; +var 𭧨; +var 𭧩; +var 𭧪; +var 𭧫; +var 𭧬; +var 𭧭; +var 𭧮; +var 𭧯; +var 𭧰; +var 𭧱; +var 𭧲; +var 𭧳; +var 𭧴; +var 𭧵; +var 𭧶; +var 𭧷; +var 𭧸; +var 𭧹; +var 𭧺; +var 𭧻; +var 𭧼; +var 𭧽; +var 𭧾; +var 𭧿; +var 𭨀; +var 𭨁; +var 𭨂; +var 𭨃; +var 𭨄; +var 𭨅; +var 𭨆; +var 𭨇; +var 𭨈; +var 𭨉; +var 𭨊; +var 𭨋; +var 𭨌; +var 𭨍; +var 𭨎; +var 𭨏; +var 𭨐; +var 𭨑; +var 𭨒; +var 𭨓; +var 𭨔; +var 𭨕; +var 𭨖; +var 𭨗; +var 𭨘; +var 𭨙; +var 𭨚; +var 𭨛; +var 𭨜; +var 𭨝; +var 𭨞; +var 𭨟; +var 𭨠; +var 𭨡; +var 𭨢; +var 𭨣; +var 𭨤; +var 𭨥; +var 𭨦; +var 𭨧; +var 𭨨; +var 𭨩; +var 𭨪; +var 𭨫; +var 𭨬; +var 𭨭; +var 𭨮; +var 𭨯; +var 𭨰; +var 𭨱; +var 𭨲; +var 𭨳; +var 𭨴; +var 𭨵; +var 𭨶; +var 𭨷; +var 𭨸; +var 𭨹; +var 𭨺; +var 𭨻; +var 𭨼; +var 𭨽; +var 𭨾; +var 𭨿; +var 𭩀; +var 𭩁; +var 𭩂; +var 𭩃; +var 𭩄; +var 𭩅; +var 𭩆; +var 𭩇; +var 𭩈; +var 𭩉; +var 𭩊; +var 𭩋; +var 𭩌; +var 𭩍; +var 𭩎; +var 𭩏; +var 𭩐; +var 𭩑; +var 𭩒; +var 𭩓; +var 𭩔; +var 𭩕; +var 𭩖; +var 𭩗; +var 𭩘; +var 𭩙; +var 𭩚; +var 𭩛; +var 𭩜; +var 𭩝; +var 𭩞; +var 𭩟; +var 𭩠; +var 𭩡; +var 𭩢; +var 𭩣; +var 𭩤; +var 𭩥; +var 𭩦; +var 𭩧; +var 𭩨; +var 𭩩; +var 𭩪; +var 𭩫; +var 𭩬; +var 𭩭; +var 𭩮; +var 𭩯; +var 𭩰; +var 𭩱; +var 𭩲; +var 𭩳; +var 𭩴; +var 𭩵; +var 𭩶; +var 𭩷; +var 𭩸; +var 𭩹; +var 𭩺; +var 𭩻; +var 𭩼; +var 𭩽; +var 𭩾; +var 𭩿; +var 𭪀; +var 𭪁; +var 𭪂; +var 𭪃; +var 𭪄; +var 𭪅; +var 𭪆; +var 𭪇; +var 𭪈; +var 𭪉; +var 𭪊; +var 𭪋; +var 𭪌; +var 𭪍; +var 𭪎; +var 𭪏; +var 𭪐; +var 𭪑; +var 𭪒; +var 𭪓; +var 𭪔; +var 𭪕; +var 𭪖; +var 𭪗; +var 𭪘; +var 𭪙; +var 𭪚; +var 𭪛; +var 𭪜; +var 𭪝; +var 𭪞; +var 𭪟; +var 𭪠; +var 𭪡; +var 𭪢; +var 𭪣; +var 𭪤; +var 𭪥; +var 𭪦; +var 𭪧; +var 𭪨; +var 𭪩; +var 𭪪; +var 𭪫; +var 𭪬; +var 𭪭; +var 𭪮; +var 𭪯; +var 𭪰; +var 𭪱; +var 𭪲; +var 𭪳; +var 𭪴; +var 𭪵; +var 𭪶; +var 𭪷; +var 𭪸; +var 𭪹; +var 𭪺; +var 𭪻; +var 𭪼; +var 𭪽; +var 𭪾; +var 𭪿; +var 𭫀; +var 𭫁; +var 𭫂; +var 𭫃; +var 𭫄; +var 𭫅; +var 𭫆; +var 𭫇; +var 𭫈; +var 𭫉; +var 𭫊; +var 𭫋; +var 𭫌; +var 𭫍; +var 𭫎; +var 𭫏; +var 𭫐; +var 𭫑; +var 𭫒; +var 𭫓; +var 𭫔; +var 𭫕; +var 𭫖; +var 𭫗; +var 𭫘; +var 𭫙; +var 𭫚; +var 𭫛; +var 𭫜; +var 𭫝; +var 𭫞; +var 𭫟; +var 𭫠; +var 𭫡; +var 𭫢; +var 𭫣; +var 𭫤; +var 𭫥; +var 𭫦; +var 𭫧; +var 𭫨; +var 𭫩; +var 𭫪; +var 𭫫; +var 𭫬; +var 𭫭; +var 𭫮; +var 𭫯; +var 𭫰; +var 𭫱; +var 𭫲; +var 𭫳; +var 𭫴; +var 𭫵; +var 𭫶; +var 𭫷; +var 𭫸; +var 𭫹; +var 𭫺; +var 𭫻; +var 𭫼; +var 𭫽; +var 𭫾; +var 𭫿; +var 𭬀; +var 𭬁; +var 𭬂; +var 𭬃; +var 𭬄; +var 𭬅; +var 𭬆; +var 𭬇; +var 𭬈; +var 𭬉; +var 𭬊; +var 𭬋; +var 𭬌; +var 𭬍; +var 𭬎; +var 𭬏; +var 𭬐; +var 𭬑; +var 𭬒; +var 𭬓; +var 𭬔; +var 𭬕; +var 𭬖; +var 𭬗; +var 𭬘; +var 𭬙; +var 𭬚; +var 𭬛; +var 𭬜; +var 𭬝; +var 𭬞; +var 𭬟; +var 𭬠; +var 𭬡; +var 𭬢; +var 𭬣; +var 𭬤; +var 𭬥; +var 𭬦; +var 𭬧; +var 𭬨; +var 𭬩; +var 𭬪; +var 𭬫; +var 𭬬; +var 𭬭; +var 𭬮; +var 𭬯; +var 𭬰; +var 𭬱; +var 𭬲; +var 𭬳; +var 𭬴; +var 𭬵; +var 𭬶; +var 𭬷; +var 𭬸; +var 𭬹; +var 𭬺; +var 𭬻; +var 𭬼; +var 𭬽; +var 𭬾; +var 𭬿; +var 𭭀; +var 𭭁; +var 𭭂; +var 𭭃; +var 𭭄; +var 𭭅; +var 𭭆; +var 𭭇; +var 𭭈; +var 𭭉; +var 𭭊; +var 𭭋; +var 𭭌; +var 𭭍; +var 𭭎; +var 𭭏; +var 𭭐; +var 𭭑; +var 𭭒; +var 𭭓; +var 𭭔; +var 𭭕; +var 𭭖; +var 𭭗; +var 𭭘; +var 𭭙; +var 𭭚; +var 𭭛; +var 𭭜; +var 𭭝; +var 𭭞; +var 𭭟; +var 𭭠; +var 𭭡; +var 𭭢; +var 𭭣; +var 𭭤; +var 𭭥; +var 𭭦; +var 𭭧; +var 𭭨; +var 𭭩; +var 𭭪; +var 𭭫; +var 𭭬; +var 𭭭; +var 𭭮; +var 𭭯; +var 𭭰; +var 𭭱; +var 𭭲; +var 𭭳; +var 𭭴; +var 𭭵; +var 𭭶; +var 𭭷; +var 𭭸; +var 𭭹; +var 𭭺; +var 𭭻; +var 𭭼; +var 𭭽; +var 𭭾; +var 𭭿; +var 𭮀; +var 𭮁; +var 𭮂; +var 𭮃; +var 𭮄; +var 𭮅; +var 𭮆; +var 𭮇; +var 𭮈; +var 𭮉; +var 𭮊; +var 𭮋; +var 𭮌; +var 𭮍; +var 𭮎; +var 𭮏; +var 𭮐; +var 𭮑; +var 𭮒; +var 𭮓; +var 𭮔; +var 𭮕; +var 𭮖; +var 𭮗; +var 𭮘; +var 𭮙; +var 𭮚; +var 𭮛; +var 𭮜; +var 𭮝; +var 𭮞; +var 𭮟; +var 𭮠; +var 𭮡; +var 𭮢; +var 𭮣; +var 𭮤; +var 𭮥; +var 𭮦; +var 𭮧; +var 𭮨; +var 𭮩; +var 𭮪; +var 𭮫; +var 𭮬; +var 𭮭; +var 𭮮; +var 𭮯; +var 𭮰; +var 𭮱; +var 𭮲; +var 𭮳; +var 𭮴; +var 𭮵; +var 𭮶; +var 𭮷; +var 𭮸; +var 𭮹; +var 𭮺; +var 𭮻; +var 𭮼; +var 𭮽; +var 𭮾; +var 𭮿; +var 𭯀; +var 𭯁; +var 𭯂; +var 𭯃; +var 𭯄; +var 𭯅; +var 𭯆; +var 𭯇; +var 𭯈; +var 𭯉; +var 𭯊; +var 𭯋; +var 𭯌; +var 𭯍; +var 𭯎; +var 𭯏; +var 𭯐; +var 𭯑; +var 𭯒; +var 𭯓; +var 𭯔; +var 𭯕; +var 𭯖; +var 𭯗; +var 𭯘; +var 𭯙; +var 𭯚; +var 𭯛; +var 𭯜; +var 𭯝; +var 𭯞; +var 𭯟; +var 𭯠; +var 𭯡; +var 𭯢; +var 𭯣; +var 𭯤; +var 𭯥; +var 𭯦; +var 𭯧; +var 𭯨; +var 𭯩; +var 𭯪; +var 𭯫; +var 𭯬; +var 𭯭; +var 𭯮; +var 𭯯; +var 𭯰; +var 𭯱; +var 𭯲; +var 𭯳; +var 𭯴; +var 𭯵; +var 𭯶; +var 𭯷; +var 𭯸; +var 𭯹; +var 𭯺; +var 𭯻; +var 𭯼; +var 𭯽; +var 𭯾; +var 𭯿; +var 𭰀; +var 𭰁; +var 𭰂; +var 𭰃; +var 𭰄; +var 𭰅; +var 𭰆; +var 𭰇; +var 𭰈; +var 𭰉; +var 𭰊; +var 𭰋; +var 𭰌; +var 𭰍; +var 𭰎; +var 𭰏; +var 𭰐; +var 𭰑; +var 𭰒; +var 𭰓; +var 𭰔; +var 𭰕; +var 𭰖; +var 𭰗; +var 𭰘; +var 𭰙; +var 𭰚; +var 𭰛; +var 𭰜; +var 𭰝; +var 𭰞; +var 𭰟; +var 𭰠; +var 𭰡; +var 𭰢; +var 𭰣; +var 𭰤; +var 𭰥; +var 𭰦; +var 𭰧; +var 𭰨; +var 𭰩; +var 𭰪; +var 𭰫; +var 𭰬; +var 𭰭; +var 𭰮; +var 𭰯; +var 𭰰; +var 𭰱; +var 𭰲; +var 𭰳; +var 𭰴; +var 𭰵; +var 𭰶; +var 𭰷; +var 𭰸; +var 𭰹; +var 𭰺; +var 𭰻; +var 𭰼; +var 𭰽; +var 𭰾; +var 𭰿; +var 𭱀; +var 𭱁; +var 𭱂; +var 𭱃; +var 𭱄; +var 𭱅; +var 𭱆; +var 𭱇; +var 𭱈; +var 𭱉; +var 𭱊; +var 𭱋; +var 𭱌; +var 𭱍; +var 𭱎; +var 𭱏; +var 𭱐; +var 𭱑; +var 𭱒; +var 𭱓; +var 𭱔; +var 𭱕; +var 𭱖; +var 𭱗; +var 𭱘; +var 𭱙; +var 𭱚; +var 𭱛; +var 𭱜; +var 𭱝; +var 𭱞; +var 𭱟; +var 𭱠; +var 𭱡; +var 𭱢; +var 𭱣; +var 𭱤; +var 𭱥; +var 𭱦; +var 𭱧; +var 𭱨; +var 𭱩; +var 𭱪; +var 𭱫; +var 𭱬; +var 𭱭; +var 𭱮; +var 𭱯; +var 𭱰; +var 𭱱; +var 𭱲; +var 𭱳; +var 𭱴; +var 𭱵; +var 𭱶; +var 𭱷; +var 𭱸; +var 𭱹; +var 𭱺; +var 𭱻; +var 𭱼; +var 𭱽; +var 𭱾; +var 𭱿; +var 𭲀; +var 𭲁; +var 𭲂; +var 𭲃; +var 𭲄; +var 𭲅; +var 𭲆; +var 𭲇; +var 𭲈; +var 𭲉; +var 𭲊; +var 𭲋; +var 𭲌; +var 𭲍; +var 𭲎; +var 𭲏; +var 𭲐; +var 𭲑; +var 𭲒; +var 𭲓; +var 𭲔; +var 𭲕; +var 𭲖; +var 𭲗; +var 𭲘; +var 𭲙; +var 𭲚; +var 𭲛; +var 𭲜; +var 𭲝; +var 𭲞; +var 𭲟; +var 𭲠; +var 𭲡; +var 𭲢; +var 𭲣; +var 𭲤; +var 𭲥; +var 𭲦; +var 𭲧; +var 𭲨; +var 𭲩; +var 𭲪; +var 𭲫; +var 𭲬; +var 𭲭; +var 𭲮; +var 𭲯; +var 𭲰; +var 𭲱; +var 𭲲; +var 𭲳; +var 𭲴; +var 𭲵; +var 𭲶; +var 𭲷; +var 𭲸; +var 𭲹; +var 𭲺; +var 𭲻; +var 𭲼; +var 𭲽; +var 𭲾; +var 𭲿; +var 𭳀; +var 𭳁; +var 𭳂; +var 𭳃; +var 𭳄; +var 𭳅; +var 𭳆; +var 𭳇; +var 𭳈; +var 𭳉; +var 𭳊; +var 𭳋; +var 𭳌; +var 𭳍; +var 𭳎; +var 𭳏; +var 𭳐; +var 𭳑; +var 𭳒; +var 𭳓; +var 𭳔; +var 𭳕; +var 𭳖; +var 𭳗; +var 𭳘; +var 𭳙; +var 𭳚; +var 𭳛; +var 𭳜; +var 𭳝; +var 𭳞; +var 𭳟; +var 𭳠; +var 𭳡; +var 𭳢; +var 𭳣; +var 𭳤; +var 𭳥; +var 𭳦; +var 𭳧; +var 𭳨; +var 𭳩; +var 𭳪; +var 𭳫; +var 𭳬; +var 𭳭; +var 𭳮; +var 𭳯; +var 𭳰; +var 𭳱; +var 𭳲; +var 𭳳; +var 𭳴; +var 𭳵; +var 𭳶; +var 𭳷; +var 𭳸; +var 𭳹; +var 𭳺; +var 𭳻; +var 𭳼; +var 𭳽; +var 𭳾; +var 𭳿; +var 𭴀; +var 𭴁; +var 𭴂; +var 𭴃; +var 𭴄; +var 𭴅; +var 𭴆; +var 𭴇; +var 𭴈; +var 𭴉; +var 𭴊; +var 𭴋; +var 𭴌; +var 𭴍; +var 𭴎; +var 𭴏; +var 𭴐; +var 𭴑; +var 𭴒; +var 𭴓; +var 𭴔; +var 𭴕; +var 𭴖; +var 𭴗; +var 𭴘; +var 𭴙; +var 𭴚; +var 𭴛; +var 𭴜; +var 𭴝; +var 𭴞; +var 𭴟; +var 𭴠; +var 𭴡; +var 𭴢; +var 𭴣; +var 𭴤; +var 𭴥; +var 𭴦; +var 𭴧; +var 𭴨; +var 𭴩; +var 𭴪; +var 𭴫; +var 𭴬; +var 𭴭; +var 𭴮; +var 𭴯; +var 𭴰; +var 𭴱; +var 𭴲; +var 𭴳; +var 𭴴; +var 𭴵; +var 𭴶; +var 𭴷; +var 𭴸; +var 𭴹; +var 𭴺; +var 𭴻; +var 𭴼; +var 𭴽; +var 𭴾; +var 𭴿; +var 𭵀; +var 𭵁; +var 𭵂; +var 𭵃; +var 𭵄; +var 𭵅; +var 𭵆; +var 𭵇; +var 𭵈; +var 𭵉; +var 𭵊; +var 𭵋; +var 𭵌; +var 𭵍; +var 𭵎; +var 𭵏; +var 𭵐; +var 𭵑; +var 𭵒; +var 𭵓; +var 𭵔; +var 𭵕; +var 𭵖; +var 𭵗; +var 𭵘; +var 𭵙; +var 𭵚; +var 𭵛; +var 𭵜; +var 𭵝; +var 𭵞; +var 𭵟; +var 𭵠; +var 𭵡; +var 𭵢; +var 𭵣; +var 𭵤; +var 𭵥; +var 𭵦; +var 𭵧; +var 𭵨; +var 𭵩; +var 𭵪; +var 𭵫; +var 𭵬; +var 𭵭; +var 𭵮; +var 𭵯; +var 𭵰; +var 𭵱; +var 𭵲; +var 𭵳; +var 𭵴; +var 𭵵; +var 𭵶; +var 𭵷; +var 𭵸; +var 𭵹; +var 𭵺; +var 𭵻; +var 𭵼; +var 𭵽; +var 𭵾; +var 𭵿; +var 𭶀; +var 𭶁; +var 𭶂; +var 𭶃; +var 𭶄; +var 𭶅; +var 𭶆; +var 𭶇; +var 𭶈; +var 𭶉; +var 𭶊; +var 𭶋; +var 𭶌; +var 𭶍; +var 𭶎; +var 𭶏; +var 𭶐; +var 𭶑; +var 𭶒; +var 𭶓; +var 𭶔; +var 𭶕; +var 𭶖; +var 𭶗; +var 𭶘; +var 𭶙; +var 𭶚; +var 𭶛; +var 𭶜; +var 𭶝; +var 𭶞; +var 𭶟; +var 𭶠; +var 𭶡; +var 𭶢; +var 𭶣; +var 𭶤; +var 𭶥; +var 𭶦; +var 𭶧; +var 𭶨; +var 𭶩; +var 𭶪; +var 𭶫; +var 𭶬; +var 𭶭; +var 𭶮; +var 𭶯; +var 𭶰; +var 𭶱; +var 𭶲; +var 𭶳; +var 𭶴; +var 𭶵; +var 𭶶; +var 𭶷; +var 𭶸; +var 𭶹; +var 𭶺; +var 𭶻; +var 𭶼; +var 𭶽; +var 𭶾; +var 𭶿; +var 𭷀; +var 𭷁; +var 𭷂; +var 𭷃; +var 𭷄; +var 𭷅; +var 𭷆; +var 𭷇; +var 𭷈; +var 𭷉; +var 𭷊; +var 𭷋; +var 𭷌; +var 𭷍; +var 𭷎; +var 𭷏; +var 𭷐; +var 𭷑; +var 𭷒; +var 𭷓; +var 𭷔; +var 𭷕; +var 𭷖; +var 𭷗; +var 𭷘; +var 𭷙; +var 𭷚; +var 𭷛; +var 𭷜; +var 𭷝; +var 𭷞; +var 𭷟; +var 𭷠; +var 𭷡; +var 𭷢; +var 𭷣; +var 𭷤; +var 𭷥; +var 𭷦; +var 𭷧; +var 𭷨; +var 𭷩; +var 𭷪; +var 𭷫; +var 𭷬; +var 𭷭; +var 𭷮; +var 𭷯; +var 𭷰; +var 𭷱; +var 𭷲; +var 𭷳; +var 𭷴; +var 𭷵; +var 𭷶; +var 𭷷; +var 𭷸; +var 𭷹; +var 𭷺; +var 𭷻; +var 𭷼; +var 𭷽; +var 𭷾; +var 𭷿; +var 𭸀; +var 𭸁; +var 𭸂; +var 𭸃; +var 𭸄; +var 𭸅; +var 𭸆; +var 𭸇; +var 𭸈; +var 𭸉; +var 𭸊; +var 𭸋; +var 𭸌; +var 𭸍; +var 𭸎; +var 𭸏; +var 𭸐; +var 𭸑; +var 𭸒; +var 𭸓; +var 𭸔; +var 𭸕; +var 𭸖; +var 𭸗; +var 𭸘; +var 𭸙; +var 𭸚; +var 𭸛; +var 𭸜; +var 𭸝; +var 𭸞; +var 𭸟; +var 𭸠; +var 𭸡; +var 𭸢; +var 𭸣; +var 𭸤; +var 𭸥; +var 𭸦; +var 𭸧; +var 𭸨; +var 𭸩; +var 𭸪; +var 𭸫; +var 𭸬; +var 𭸭; +var 𭸮; +var 𭸯; +var 𭸰; +var 𭸱; +var 𭸲; +var 𭸳; +var 𭸴; +var 𭸵; +var 𭸶; +var 𭸷; +var 𭸸; +var 𭸹; +var 𭸺; +var 𭸻; +var 𭸼; +var 𭸽; +var 𭸾; +var 𭸿; +var 𭹀; +var 𭹁; +var 𭹂; +var 𭹃; +var 𭹄; +var 𭹅; +var 𭹆; +var 𭹇; +var 𭹈; +var 𭹉; +var 𭹊; +var 𭹋; +var 𭹌; +var 𭹍; +var 𭹎; +var 𭹏; +var 𭹐; +var 𭹑; +var 𭹒; +var 𭹓; +var 𭹔; +var 𭹕; +var 𭹖; +var 𭹗; +var 𭹘; +var 𭹙; +var 𭹚; +var 𭹛; +var 𭹜; +var 𭹝; +var 𭹞; +var 𭹟; +var 𭹠; +var 𭹡; +var 𭹢; +var 𭹣; +var 𭹤; +var 𭹥; +var 𭹦; +var 𭹧; +var 𭹨; +var 𭹩; +var 𭹪; +var 𭹫; +var 𭹬; +var 𭹭; +var 𭹮; +var 𭹯; +var 𭹰; +var 𭹱; +var 𭹲; +var 𭹳; +var 𭹴; +var 𭹵; +var 𭹶; +var 𭹷; +var 𭹸; +var 𭹹; +var 𭹺; +var 𭹻; +var 𭹼; +var 𭹽; +var 𭹾; +var 𭹿; +var 𭺀; +var 𭺁; +var 𭺂; +var 𭺃; +var 𭺄; +var 𭺅; +var 𭺆; +var 𭺇; +var 𭺈; +var 𭺉; +var 𭺊; +var 𭺋; +var 𭺌; +var 𭺍; +var 𭺎; +var 𭺏; +var 𭺐; +var 𭺑; +var 𭺒; +var 𭺓; +var 𭺔; +var 𭺕; +var 𭺖; +var 𭺗; +var 𭺘; +var 𭺙; +var 𭺚; +var 𭺛; +var 𭺜; +var 𭺝; +var 𭺞; +var 𭺟; +var 𭺠; +var 𭺡; +var 𭺢; +var 𭺣; +var 𭺤; +var 𭺥; +var 𭺦; +var 𭺧; +var 𭺨; +var 𭺩; +var 𭺪; +var 𭺫; +var 𭺬; +var 𭺭; +var 𭺮; +var 𭺯; +var 𭺰; +var 𭺱; +var 𭺲; +var 𭺳; +var 𭺴; +var 𭺵; +var 𭺶; +var 𭺷; +var 𭺸; +var 𭺹; +var 𭺺; +var 𭺻; +var 𭺼; +var 𭺽; +var 𭺾; +var 𭺿; +var 𭻀; +var 𭻁; +var 𭻂; +var 𭻃; +var 𭻄; +var 𭻅; +var 𭻆; +var 𭻇; +var 𭻈; +var 𭻉; +var 𭻊; +var 𭻋; +var 𭻌; +var 𭻍; +var 𭻎; +var 𭻏; +var 𭻐; +var 𭻑; +var 𭻒; +var 𭻓; +var 𭻔; +var 𭻕; +var 𭻖; +var 𭻗; +var 𭻘; +var 𭻙; +var 𭻚; +var 𭻛; +var 𭻜; +var 𭻝; +var 𭻞; +var 𭻟; +var 𭻠; +var 𭻡; +var 𭻢; +var 𭻣; +var 𭻤; +var 𭻥; +var 𭻦; +var 𭻧; +var 𭻨; +var 𭻩; +var 𭻪; +var 𭻫; +var 𭻬; +var 𭻭; +var 𭻮; +var 𭻯; +var 𭻰; +var 𭻱; +var 𭻲; +var 𭻳; +var 𭻴; +var 𭻵; +var 𭻶; +var 𭻷; +var 𭻸; +var 𭻹; +var 𭻺; +var 𭻻; +var 𭻼; +var 𭻽; +var 𭻾; +var 𭻿; +var 𭼀; +var 𭼁; +var 𭼂; +var 𭼃; +var 𭼄; +var 𭼅; +var 𭼆; +var 𭼇; +var 𭼈; +var 𭼉; +var 𭼊; +var 𭼋; +var 𭼌; +var 𭼍; +var 𭼎; +var 𭼏; +var 𭼐; +var 𭼑; +var 𭼒; +var 𭼓; +var 𭼔; +var 𭼕; +var 𭼖; +var 𭼗; +var 𭼘; +var 𭼙; +var 𭼚; +var 𭼛; +var 𭼜; +var 𭼝; +var 𭼞; +var 𭼟; +var 𭼠; +var 𭼡; +var 𭼢; +var 𭼣; +var 𭼤; +var 𭼥; +var 𭼦; +var 𭼧; +var 𭼨; +var 𭼩; +var 𭼪; +var 𭼫; +var 𭼬; +var 𭼭; +var 𭼮; +var 𭼯; +var 𭼰; +var 𭼱; +var 𭼲; +var 𭼳; +var 𭼴; +var 𭼵; +var 𭼶; +var 𭼷; +var 𭼸; +var 𭼹; +var 𭼺; +var 𭼻; +var 𭼼; +var 𭼽; +var 𭼾; +var 𭼿; +var 𭽀; +var 𭽁; +var 𭽂; +var 𭽃; +var 𭽄; +var 𭽅; +var 𭽆; +var 𭽇; +var 𭽈; +var 𭽉; +var 𭽊; +var 𭽋; +var 𭽌; +var 𭽍; +var 𭽎; +var 𭽏; +var 𭽐; +var 𭽑; +var 𭽒; +var 𭽓; +var 𭽔; +var 𭽕; +var 𭽖; +var 𭽗; +var 𭽘; +var 𭽙; +var 𭽚; +var 𭽛; +var 𭽜; +var 𭽝; +var 𭽞; +var 𭽟; +var 𭽠; +var 𭽡; +var 𭽢; +var 𭽣; +var 𭽤; +var 𭽥; +var 𭽦; +var 𭽧; +var 𭽨; +var 𭽩; +var 𭽪; +var 𭽫; +var 𭽬; +var 𭽭; +var 𭽮; +var 𭽯; +var 𭽰; +var 𭽱; +var 𭽲; +var 𭽳; +var 𭽴; +var 𭽵; +var 𭽶; +var 𭽷; +var 𭽸; +var 𭽹; +var 𭽺; +var 𭽻; +var 𭽼; +var 𭽽; +var 𭽾; +var 𭽿; +var 𭾀; +var 𭾁; +var 𭾂; +var 𭾃; +var 𭾄; +var 𭾅; +var 𭾆; +var 𭾇; +var 𭾈; +var 𭾉; +var 𭾊; +var 𭾋; +var 𭾌; +var 𭾍; +var 𭾎; +var 𭾏; +var 𭾐; +var 𭾑; +var 𭾒; +var 𭾓; +var 𭾔; +var 𭾕; +var 𭾖; +var 𭾗; +var 𭾘; +var 𭾙; +var 𭾚; +var 𭾛; +var 𭾜; +var 𭾝; +var 𭾞; +var 𭾟; +var 𭾠; +var 𭾡; +var 𭾢; +var 𭾣; +var 𭾤; +var 𭾥; +var 𭾦; +var 𭾧; +var 𭾨; +var 𭾩; +var 𭾪; +var 𭾫; +var 𭾬; +var 𭾭; +var 𭾮; +var 𭾯; +var 𭾰; +var 𭾱; +var 𭾲; +var 𭾳; +var 𭾴; +var 𭾵; +var 𭾶; +var 𭾷; +var 𭾸; +var 𭾹; +var 𭾺; +var 𭾻; +var 𭾼; +var 𭾽; +var 𭾾; +var 𭾿; +var 𭿀; +var 𭿁; +var 𭿂; +var 𭿃; +var 𭿄; +var 𭿅; +var 𭿆; +var 𭿇; +var 𭿈; +var 𭿉; +var 𭿊; +var 𭿋; +var 𭿌; +var 𭿍; +var 𭿎; +var 𭿏; +var 𭿐; +var 𭿑; +var 𭿒; +var 𭿓; +var 𭿔; +var 𭿕; +var 𭿖; +var 𭿗; +var 𭿘; +var 𭿙; +var 𭿚; +var 𭿛; +var 𭿜; +var 𭿝; +var 𭿞; +var 𭿟; +var 𭿠; +var 𭿡; +var 𭿢; +var 𭿣; +var 𭿤; +var 𭿥; +var 𭿦; +var 𭿧; +var 𭿨; +var 𭿩; +var 𭿪; +var 𭿫; +var 𭿬; +var 𭿭; +var 𭿮; +var 𭿯; +var 𭿰; +var 𭿱; +var 𭿲; +var 𭿳; +var 𭿴; +var 𭿵; +var 𭿶; +var 𭿷; +var 𭿸; +var 𭿹; +var 𭿺; +var 𭿻; +var 𭿼; +var 𭿽; +var 𭿾; +var 𭿿; +var 𮀀; +var 𮀁; +var 𮀂; +var 𮀃; +var 𮀄; +var 𮀅; +var 𮀆; +var 𮀇; +var 𮀈; +var 𮀉; +var 𮀊; +var 𮀋; +var 𮀌; +var 𮀍; +var 𮀎; +var 𮀏; +var 𮀐; +var 𮀑; +var 𮀒; +var 𮀓; +var 𮀔; +var 𮀕; +var 𮀖; +var 𮀗; +var 𮀘; +var 𮀙; +var 𮀚; +var 𮀛; +var 𮀜; +var 𮀝; +var 𮀞; +var 𮀟; +var 𮀠; +var 𮀡; +var 𮀢; +var 𮀣; +var 𮀤; +var 𮀥; +var 𮀦; +var 𮀧; +var 𮀨; +var 𮀩; +var 𮀪; +var 𮀫; +var 𮀬; +var 𮀭; +var 𮀮; +var 𮀯; +var 𮀰; +var 𮀱; +var 𮀲; +var 𮀳; +var 𮀴; +var 𮀵; +var 𮀶; +var 𮀷; +var 𮀸; +var 𮀹; +var 𮀺; +var 𮀻; +var 𮀼; +var 𮀽; +var 𮀾; +var 𮀿; +var 𮁀; +var 𮁁; +var 𮁂; +var 𮁃; +var 𮁄; +var 𮁅; +var 𮁆; +var 𮁇; +var 𮁈; +var 𮁉; +var 𮁊; +var 𮁋; +var 𮁌; +var 𮁍; +var 𮁎; +var 𮁏; +var 𮁐; +var 𮁑; +var 𮁒; +var 𮁓; +var 𮁔; +var 𮁕; +var 𮁖; +var 𮁗; +var 𮁘; +var 𮁙; +var 𮁚; +var 𮁛; +var 𮁜; +var 𮁝; +var 𮁞; +var 𮁟; +var 𮁠; +var 𮁡; +var 𮁢; +var 𮁣; +var 𮁤; +var 𮁥; +var 𮁦; +var 𮁧; +var 𮁨; +var 𮁩; +var 𮁪; +var 𮁫; +var 𮁬; +var 𮁭; +var 𮁮; +var 𮁯; +var 𮁰; +var 𮁱; +var 𮁲; +var 𮁳; +var 𮁴; +var 𮁵; +var 𮁶; +var 𮁷; +var 𮁸; +var 𮁹; +var 𮁺; +var 𮁻; +var 𮁼; +var 𮁽; +var 𮁾; +var 𮁿; +var 𮂀; +var 𮂁; +var 𮂂; +var 𮂃; +var 𮂄; +var 𮂅; +var 𮂆; +var 𮂇; +var 𮂈; +var 𮂉; +var 𮂊; +var 𮂋; +var 𮂌; +var 𮂍; +var 𮂎; +var 𮂏; +var 𮂐; +var 𮂑; +var 𮂒; +var 𮂓; +var 𮂔; +var 𮂕; +var 𮂖; +var 𮂗; +var 𮂘; +var 𮂙; +var 𮂚; +var 𮂛; +var 𮂜; +var 𮂝; +var 𮂞; +var 𮂟; +var 𮂠; +var 𮂡; +var 𮂢; +var 𮂣; +var 𮂤; +var 𮂥; +var 𮂦; +var 𮂧; +var 𮂨; +var 𮂩; +var 𮂪; +var 𮂫; +var 𮂬; +var 𮂭; +var 𮂮; +var 𮂯; +var 𮂰; +var 𮂱; +var 𮂲; +var 𮂳; +var 𮂴; +var 𮂵; +var 𮂶; +var 𮂷; +var 𮂸; +var 𮂹; +var 𮂺; +var 𮂻; +var 𮂼; +var 𮂽; +var 𮂾; +var 𮂿; +var 𮃀; +var 𮃁; +var 𮃂; +var 𮃃; +var 𮃄; +var 𮃅; +var 𮃆; +var 𮃇; +var 𮃈; +var 𮃉; +var 𮃊; +var 𮃋; +var 𮃌; +var 𮃍; +var 𮃎; +var 𮃏; +var 𮃐; +var 𮃑; +var 𮃒; +var 𮃓; +var 𮃔; +var 𮃕; +var 𮃖; +var 𮃗; +var 𮃘; +var 𮃙; +var 𮃚; +var 𮃛; +var 𮃜; +var 𮃝; +var 𮃞; +var 𮃟; +var 𮃠; +var 𮃡; +var 𮃢; +var 𮃣; +var 𮃤; +var 𮃥; +var 𮃦; +var 𮃧; +var 𮃨; +var 𮃩; +var 𮃪; +var 𮃫; +var 𮃬; +var 𮃭; +var 𮃮; +var 𮃯; +var 𮃰; +var 𮃱; +var 𮃲; +var 𮃳; +var 𮃴; +var 𮃵; +var 𮃶; +var 𮃷; +var 𮃸; +var 𮃹; +var 𮃺; +var 𮃻; +var 𮃼; +var 𮃽; +var 𮃾; +var 𮃿; +var 𮄀; +var 𮄁; +var 𮄂; +var 𮄃; +var 𮄄; +var 𮄅; +var 𮄆; +var 𮄇; +var 𮄈; +var 𮄉; +var 𮄊; +var 𮄋; +var 𮄌; +var 𮄍; +var 𮄎; +var 𮄏; +var 𮄐; +var 𮄑; +var 𮄒; +var 𮄓; +var 𮄔; +var 𮄕; +var 𮄖; +var 𮄗; +var 𮄘; +var 𮄙; +var 𮄚; +var 𮄛; +var 𮄜; +var 𮄝; +var 𮄞; +var 𮄟; +var 𮄠; +var 𮄡; +var 𮄢; +var 𮄣; +var 𮄤; +var 𮄥; +var 𮄦; +var 𮄧; +var 𮄨; +var 𮄩; +var 𮄪; +var 𮄫; +var 𮄬; +var 𮄭; +var 𮄮; +var 𮄯; +var 𮄰; +var 𮄱; +var 𮄲; +var 𮄳; +var 𮄴; +var 𮄵; +var 𮄶; +var 𮄷; +var 𮄸; +var 𮄹; +var 𮄺; +var 𮄻; +var 𮄼; +var 𮄽; +var 𮄾; +var 𮄿; +var 𮅀; +var 𮅁; +var 𮅂; +var 𮅃; +var 𮅄; +var 𮅅; +var 𮅆; +var 𮅇; +var 𮅈; +var 𮅉; +var 𮅊; +var 𮅋; +var 𮅌; +var 𮅍; +var 𮅎; +var 𮅏; +var 𮅐; +var 𮅑; +var 𮅒; +var 𮅓; +var 𮅔; +var 𮅕; +var 𮅖; +var 𮅗; +var 𮅘; +var 𮅙; +var 𮅚; +var 𮅛; +var 𮅜; +var 𮅝; +var 𮅞; +var 𮅟; +var 𮅠; +var 𮅡; +var 𮅢; +var 𮅣; +var 𮅤; +var 𮅥; +var 𮅦; +var 𮅧; +var 𮅨; +var 𮅩; +var 𮅪; +var 𮅫; +var 𮅬; +var 𮅭; +var 𮅮; +var 𮅯; +var 𮅰; +var 𮅱; +var 𮅲; +var 𮅳; +var 𮅴; +var 𮅵; +var 𮅶; +var 𮅷; +var 𮅸; +var 𮅹; +var 𮅺; +var 𮅻; +var 𮅼; +var 𮅽; +var 𮅾; +var 𮅿; +var 𮆀; +var 𮆁; +var 𮆂; +var 𮆃; +var 𮆄; +var 𮆅; +var 𮆆; +var 𮆇; +var 𮆈; +var 𮆉; +var 𮆊; +var 𮆋; +var 𮆌; +var 𮆍; +var 𮆎; +var 𮆏; +var 𮆐; +var 𮆑; +var 𮆒; +var 𮆓; +var 𮆔; +var 𮆕; +var 𮆖; +var 𮆗; +var 𮆘; +var 𮆙; +var 𮆚; +var 𮆛; +var 𮆜; +var 𮆝; +var 𮆞; +var 𮆟; +var 𮆠; +var 𮆡; +var 𮆢; +var 𮆣; +var 𮆤; +var 𮆥; +var 𮆦; +var 𮆧; +var 𮆨; +var 𮆩; +var 𮆪; +var 𮆫; +var 𮆬; +var 𮆭; +var 𮆮; +var 𮆯; +var 𮆰; +var 𮆱; +var 𮆲; +var 𮆳; +var 𮆴; +var 𮆵; +var 𮆶; +var 𮆷; +var 𮆸; +var 𮆹; +var 𮆺; +var 𮆻; +var 𮆼; +var 𮆽; +var 𮆾; +var 𮆿; +var 𮇀; +var 𮇁; +var 𮇂; +var 𮇃; +var 𮇄; +var 𮇅; +var 𮇆; +var 𮇇; +var 𮇈; +var 𮇉; +var 𮇊; +var 𮇋; +var 𮇌; +var 𮇍; +var 𮇎; +var 𮇏; +var 𮇐; +var 𮇑; +var 𮇒; +var 𮇓; +var 𮇔; +var 𮇕; +var 𮇖; +var 𮇗; +var 𮇘; +var 𮇙; +var 𮇚; +var 𮇛; +var 𮇜; +var 𮇝; +var 𮇞; +var 𮇟; +var 𮇠; +var 𮇡; +var 𮇢; +var 𮇣; +var 𮇤; +var 𮇥; +var 𮇦; +var 𮇧; +var 𮇨; +var 𮇩; +var 𮇪; +var 𮇫; +var 𮇬; +var 𮇭; +var 𮇮; +var 𮇯; +var 𮇰; +var 𮇱; +var 𮇲; +var 𮇳; +var 𮇴; +var 𮇵; +var 𮇶; +var 𮇷; +var 𮇸; +var 𮇹; +var 𮇺; +var 𮇻; +var 𮇼; +var 𮇽; +var 𮇾; +var 𮇿; +var 𮈀; +var 𮈁; +var 𮈂; +var 𮈃; +var 𮈄; +var 𮈅; +var 𮈆; +var 𮈇; +var 𮈈; +var 𮈉; +var 𮈊; +var 𮈋; +var 𮈌; +var 𮈍; +var 𮈎; +var 𮈏; +var 𮈐; +var 𮈑; +var 𮈒; +var 𮈓; +var 𮈔; +var 𮈕; +var 𮈖; +var 𮈗; +var 𮈘; +var 𮈙; +var 𮈚; +var 𮈛; +var 𮈜; +var 𮈝; +var 𮈞; +var 𮈟; +var 𮈠; +var 𮈡; +var 𮈢; +var 𮈣; +var 𮈤; +var 𮈥; +var 𮈦; +var 𮈧; +var 𮈨; +var 𮈩; +var 𮈪; +var 𮈫; +var 𮈬; +var 𮈭; +var 𮈮; +var 𮈯; +var 𮈰; +var 𮈱; +var 𮈲; +var 𮈳; +var 𮈴; +var 𮈵; +var 𮈶; +var 𮈷; +var 𮈸; +var 𮈹; +var 𮈺; +var 𮈻; +var 𮈼; +var 𮈽; +var 𮈾; +var 𮈿; +var 𮉀; +var 𮉁; +var 𮉂; +var 𮉃; +var 𮉄; +var 𮉅; +var 𮉆; +var 𮉇; +var 𮉈; +var 𮉉; +var 𮉊; +var 𮉋; +var 𮉌; +var 𮉍; +var 𮉎; +var 𮉏; +var 𮉐; +var 𮉑; +var 𮉒; +var 𮉓; +var 𮉔; +var 𮉕; +var 𮉖; +var 𮉗; +var 𮉘; +var 𮉙; +var 𮉚; +var 𮉛; +var 𮉜; +var 𮉝; +var 𮉞; +var 𮉟; +var 𮉠; +var 𮉡; +var 𮉢; +var 𮉣; +var 𮉤; +var 𮉥; +var 𮉦; +var 𮉧; +var 𮉨; +var 𮉩; +var 𮉪; +var 𮉫; +var 𮉬; +var 𮉭; +var 𮉮; +var 𮉯; +var 𮉰; +var 𮉱; +var 𮉲; +var 𮉳; +var 𮉴; +var 𮉵; +var 𮉶; +var 𮉷; +var 𮉸; +var 𮉹; +var 𮉺; +var 𮉻; +var 𮉼; +var 𮉽; +var 𮉾; +var 𮉿; +var 𮊀; +var 𮊁; +var 𮊂; +var 𮊃; +var 𮊄; +var 𮊅; +var 𮊆; +var 𮊇; +var 𮊈; +var 𮊉; +var 𮊊; +var 𮊋; +var 𮊌; +var 𮊍; +var 𮊎; +var 𮊏; +var 𮊐; +var 𮊑; +var 𮊒; +var 𮊓; +var 𮊔; +var 𮊕; +var 𮊖; +var 𮊗; +var 𮊘; +var 𮊙; +var 𮊚; +var 𮊛; +var 𮊜; +var 𮊝; +var 𮊞; +var 𮊟; +var 𮊠; +var 𮊡; +var 𮊢; +var 𮊣; +var 𮊤; +var 𮊥; +var 𮊦; +var 𮊧; +var 𮊨; +var 𮊩; +var 𮊪; +var 𮊫; +var 𮊬; +var 𮊭; +var 𮊮; +var 𮊯; +var 𮊰; +var 𮊱; +var 𮊲; +var 𮊳; +var 𮊴; +var 𮊵; +var 𮊶; +var 𮊷; +var 𮊸; +var 𮊹; +var 𮊺; +var 𮊻; +var 𮊼; +var 𮊽; +var 𮊾; +var 𮊿; +var 𮋀; +var 𮋁; +var 𮋂; +var 𮋃; +var 𮋄; +var 𮋅; +var 𮋆; +var 𮋇; +var 𮋈; +var 𮋉; +var 𮋊; +var 𮋋; +var 𮋌; +var 𮋍; +var 𮋎; +var 𮋏; +var 𮋐; +var 𮋑; +var 𮋒; +var 𮋓; +var 𮋔; +var 𮋕; +var 𮋖; +var 𮋗; +var 𮋘; +var 𮋙; +var 𮋚; +var 𮋛; +var 𮋜; +var 𮋝; +var 𮋞; +var 𮋟; +var 𮋠; +var 𮋡; +var 𮋢; +var 𮋣; +var 𮋤; +var 𮋥; +var 𮋦; +var 𮋧; +var 𮋨; +var 𮋩; +var 𮋪; +var 𮋫; +var 𮋬; +var 𮋭; +var 𮋮; +var 𮋯; +var 𮋰; +var 𮋱; +var 𮋲; +var 𮋳; +var 𮋴; +var 𮋵; +var 𮋶; +var 𮋷; +var 𮋸; +var 𮋹; +var 𮋺; +var 𮋻; +var 𮋼; +var 𮋽; +var 𮋾; +var 𮋿; +var 𮌀; +var 𮌁; +var 𮌂; +var 𮌃; +var 𮌄; +var 𮌅; +var 𮌆; +var 𮌇; +var 𮌈; +var 𮌉; +var 𮌊; +var 𮌋; +var 𮌌; +var 𮌍; +var 𮌎; +var 𮌏; +var 𮌐; +var 𮌑; +var 𮌒; +var 𮌓; +var 𮌔; +var 𮌕; +var 𮌖; +var 𮌗; +var 𮌘; +var 𮌙; +var 𮌚; +var 𮌛; +var 𮌜; +var 𮌝; +var 𮌞; +var 𮌟; +var 𮌠; +var 𮌡; +var 𮌢; +var 𮌣; +var 𮌤; +var 𮌥; +var 𮌦; +var 𮌧; +var 𮌨; +var 𮌩; +var 𮌪; +var 𮌫; +var 𮌬; +var 𮌭; +var 𮌮; +var 𮌯; +var 𮌰; +var 𮌱; +var 𮌲; +var 𮌳; +var 𮌴; +var 𮌵; +var 𮌶; +var 𮌷; +var 𮌸; +var 𮌹; +var 𮌺; +var 𮌻; +var 𮌼; +var 𮌽; +var 𮌾; +var 𮌿; +var 𮍀; +var 𮍁; +var 𮍂; +var 𮍃; +var 𮍄; +var 𮍅; +var 𮍆; +var 𮍇; +var 𮍈; +var 𮍉; +var 𮍊; +var 𮍋; +var 𮍌; +var 𮍍; +var 𮍎; +var 𮍏; +var 𮍐; +var 𮍑; +var 𮍒; +var 𮍓; +var 𮍔; +var 𮍕; +var 𮍖; +var 𮍗; +var 𮍘; +var 𮍙; +var 𮍚; +var 𮍛; +var 𮍜; +var 𮍝; +var 𮍞; +var 𮍟; +var 𮍠; +var 𮍡; +var 𮍢; +var 𮍣; +var 𮍤; +var 𮍥; +var 𮍦; +var 𮍧; +var 𮍨; +var 𮍩; +var 𮍪; +var 𮍫; +var 𮍬; +var 𮍭; +var 𮍮; +var 𮍯; +var 𮍰; +var 𮍱; +var 𮍲; +var 𮍳; +var 𮍴; +var 𮍵; +var 𮍶; +var 𮍷; +var 𮍸; +var 𮍹; +var 𮍺; +var 𮍻; +var 𮍼; +var 𮍽; +var 𮍾; +var 𮍿; +var 𮎀; +var 𮎁; +var 𮎂; +var 𮎃; +var 𮎄; +var 𮎅; +var 𮎆; +var 𮎇; +var 𮎈; +var 𮎉; +var 𮎊; +var 𮎋; +var 𮎌; +var 𮎍; +var 𮎎; +var 𮎏; +var 𮎐; +var 𮎑; +var 𮎒; +var 𮎓; +var 𮎔; +var 𮎕; +var 𮎖; +var 𮎗; +var 𮎘; +var 𮎙; +var 𮎚; +var 𮎛; +var 𮎜; +var 𮎝; +var 𮎞; +var 𮎟; +var 𮎠; +var 𮎡; +var 𮎢; +var 𮎣; +var 𮎤; +var 𮎥; +var 𮎦; +var 𮎧; +var 𮎨; +var 𮎩; +var 𮎪; +var 𮎫; +var 𮎬; +var 𮎭; +var 𮎮; +var 𮎯; +var 𮎰; +var 𮎱; +var 𮎲; +var 𮎳; +var 𮎴; +var 𮎵; +var 𮎶; +var 𮎷; +var 𮎸; +var 𮎹; +var 𮎺; +var 𮎻; +var 𮎼; +var 𮎽; +var 𮎾; +var 𮎿; +var 𮏀; +var 𮏁; +var 𮏂; +var 𮏃; +var 𮏄; +var 𮏅; +var 𮏆; +var 𮏇; +var 𮏈; +var 𮏉; +var 𮏊; +var 𮏋; +var 𮏌; +var 𮏍; +var 𮏎; +var 𮏏; +var 𮏐; +var 𮏑; +var 𮏒; +var 𮏓; +var 𮏔; +var 𮏕; +var 𮏖; +var 𮏗; +var 𮏘; +var 𮏙; +var 𮏚; +var 𮏛; +var 𮏜; +var 𮏝; +var 𮏞; +var 𮏟; +var 𮏠; +var 𮏡; +var 𮏢; +var 𮏣; +var 𮏤; +var 𮏥; +var 𮏦; +var 𮏧; +var 𮏨; +var 𮏩; +var 𮏪; +var 𮏫; +var 𮏬; +var 𮏭; +var 𮏮; +var 𮏯; +var 𮏰; +var 𮏱; +var 𮏲; +var 𮏳; +var 𮏴; +var 𮏵; +var 𮏶; +var 𮏷; +var 𮏸; +var 𮏹; +var 𮏺; +var 𮏻; +var 𮏼; +var 𮏽; +var 𮏾; +var 𮏿; +var 𮐀; +var 𮐁; +var 𮐂; +var 𮐃; +var 𮐄; +var 𮐅; +var 𮐆; +var 𮐇; +var 𮐈; +var 𮐉; +var 𮐊; +var 𮐋; +var 𮐌; +var 𮐍; +var 𮐎; +var 𮐏; +var 𮐐; +var 𮐑; +var 𮐒; +var 𮐓; +var 𮐔; +var 𮐕; +var 𮐖; +var 𮐗; +var 𮐘; +var 𮐙; +var 𮐚; +var 𮐛; +var 𮐜; +var 𮐝; +var 𮐞; +var 𮐟; +var 𮐠; +var 𮐡; +var 𮐢; +var 𮐣; +var 𮐤; +var 𮐥; +var 𮐦; +var 𮐧; +var 𮐨; +var 𮐩; +var 𮐪; +var 𮐫; +var 𮐬; +var 𮐭; +var 𮐮; +var 𮐯; +var 𮐰; +var 𮐱; +var 𮐲; +var 𮐳; +var 𮐴; +var 𮐵; +var 𮐶; +var 𮐷; +var 𮐸; +var 𮐹; +var 𮐺; +var 𮐻; +var 𮐼; +var 𮐽; +var 𮐾; +var 𮐿; +var 𮑀; +var 𮑁; +var 𮑂; +var 𮑃; +var 𮑄; +var 𮑅; +var 𮑆; +var 𮑇; +var 𮑈; +var 𮑉; +var 𮑊; +var 𮑋; +var 𮑌; +var 𮑍; +var 𮑎; +var 𮑏; +var 𮑐; +var 𮑑; +var 𮑒; +var 𮑓; +var 𮑔; +var 𮑕; +var 𮑖; +var 𮑗; +var 𮑘; +var 𮑙; +var 𮑚; +var 𮑛; +var 𮑜; +var 𮑝; +var 𮑞; +var 𮑟; +var 𮑠; +var 𮑡; +var 𮑢; +var 𮑣; +var 𮑤; +var 𮑥; +var 𮑦; +var 𮑧; +var 𮑨; +var 𮑩; +var 𮑪; +var 𮑫; +var 𮑬; +var 𮑭; +var 𮑮; +var 𮑯; +var 𮑰; +var 𮑱; +var 𮑲; +var 𮑳; +var 𮑴; +var 𮑵; +var 𮑶; +var 𮑷; +var 𮑸; +var 𮑹; +var 𮑺; +var 𮑻; +var 𮑼; +var 𮑽; +var 𮑾; +var 𮑿; +var 𮒀; +var 𮒁; +var 𮒂; +var 𮒃; +var 𮒄; +var 𮒅; +var 𮒆; +var 𮒇; +var 𮒈; +var 𮒉; +var 𮒊; +var 𮒋; +var 𮒌; +var 𮒍; +var 𮒎; +var 𮒏; +var 𮒐; +var 𮒑; +var 𮒒; +var 𮒓; +var 𮒔; +var 𮒕; +var 𮒖; +var 𮒗; +var 𮒘; +var 𮒙; +var 𮒚; +var 𮒛; +var 𮒜; +var 𮒝; +var 𮒞; +var 𮒟; +var 𮒠; +var 𮒡; +var 𮒢; +var 𮒣; +var 𮒤; +var 𮒥; +var 𮒦; +var 𮒧; +var 𮒨; +var 𮒩; +var 𮒪; +var 𮒫; +var 𮒬; +var 𮒭; +var 𮒮; +var 𮒯; +var 𮒰; +var 𮒱; +var 𮒲; +var 𮒳; +var 𮒴; +var 𮒵; +var 𮒶; +var 𮒷; +var 𮒸; +var 𮒹; +var 𮒺; +var 𮒻; +var 𮒼; +var 𮒽; +var 𮒾; +var 𮒿; +var 𮓀; +var 𮓁; +var 𮓂; +var 𮓃; +var 𮓄; +var 𮓅; +var 𮓆; +var 𮓇; +var 𮓈; +var 𮓉; +var 𮓊; +var 𮓋; +var 𮓌; +var 𮓍; +var 𮓎; +var 𮓏; +var 𮓐; +var 𮓑; +var 𮓒; +var 𮓓; +var 𮓔; +var 𮓕; +var 𮓖; +var 𮓗; +var 𮓘; +var 𮓙; +var 𮓚; +var 𮓛; +var 𮓜; +var 𮓝; +var 𮓞; +var 𮓟; +var 𮓠; +var 𮓡; +var 𮓢; +var 𮓣; +var 𮓤; +var 𮓥; +var 𮓦; +var 𮓧; +var 𮓨; +var 𮓩; +var 𮓪; +var 𮓫; +var 𮓬; +var 𮓭; +var 𮓮; +var 𮓯; +var 𮓰; +var 𮓱; +var 𮓲; +var 𮓳; +var 𮓴; +var 𮓵; +var 𮓶; +var 𮓷; +var 𮓸; +var 𮓹; +var 𮓺; +var 𮓻; +var 𮓼; +var 𮓽; +var 𮓾; +var 𮓿; +var 𮔀; +var 𮔁; +var 𮔂; +var 𮔃; +var 𮔄; +var 𮔅; +var 𮔆; +var 𮔇; +var 𮔈; +var 𮔉; +var 𮔊; +var 𮔋; +var 𮔌; +var 𮔍; +var 𮔎; +var 𮔏; +var 𮔐; +var 𮔑; +var 𮔒; +var 𮔓; +var 𮔔; +var 𮔕; +var 𮔖; +var 𮔗; +var 𮔘; +var 𮔙; +var 𮔚; +var 𮔛; +var 𮔜; +var 𮔝; +var 𮔞; +var 𮔟; +var 𮔠; +var 𮔡; +var 𮔢; +var 𮔣; +var 𮔤; +var 𮔥; +var 𮔦; +var 𮔧; +var 𮔨; +var 𮔩; +var 𮔪; +var 𮔫; +var 𮔬; +var 𮔭; +var 𮔮; +var 𮔯; +var 𮔰; +var 𮔱; +var 𮔲; +var 𮔳; +var 𮔴; +var 𮔵; +var 𮔶; +var 𮔷; +var 𮔸; +var 𮔹; +var 𮔺; +var 𮔻; +var 𮔼; +var 𮔽; +var 𮔾; +var 𮔿; +var 𮕀; +var 𮕁; +var 𮕂; +var 𮕃; +var 𮕄; +var 𮕅; +var 𮕆; +var 𮕇; +var 𮕈; +var 𮕉; +var 𮕊; +var 𮕋; +var 𮕌; +var 𮕍; +var 𮕎; +var 𮕏; +var 𮕐; +var 𮕑; +var 𮕒; +var 𮕓; +var 𮕔; +var 𮕕; +var 𮕖; +var 𮕗; +var 𮕘; +var 𮕙; +var 𮕚; +var 𮕛; +var 𮕜; +var 𮕝; +var 𮕞; +var 𮕟; +var 𮕠; +var 𮕡; +var 𮕢; +var 𮕣; +var 𮕤; +var 𮕥; +var 𮕦; +var 𮕧; +var 𮕨; +var 𮕩; +var 𮕪; +var 𮕫; +var 𮕬; +var 𮕭; +var 𮕮; +var 𮕯; +var 𮕰; +var 𮕱; +var 𮕲; +var 𮕳; +var 𮕴; +var 𮕵; +var 𮕶; +var 𮕷; +var 𮕸; +var 𮕹; +var 𮕺; +var 𮕻; +var 𮕼; +var 𮕽; +var 𮕾; +var 𮕿; +var 𮖀; +var 𮖁; +var 𮖂; +var 𮖃; +var 𮖄; +var 𮖅; +var 𮖆; +var 𮖇; +var 𮖈; +var 𮖉; +var 𮖊; +var 𮖋; +var 𮖌; +var 𮖍; +var 𮖎; +var 𮖏; +var 𮖐; +var 𮖑; +var 𮖒; +var 𮖓; +var 𮖔; +var 𮖕; +var 𮖖; +var 𮖗; +var 𮖘; +var 𮖙; +var 𮖚; +var 𮖛; +var 𮖜; +var 𮖝; +var 𮖞; +var 𮖟; +var 𮖠; +var 𮖡; +var 𮖢; +var 𮖣; +var 𮖤; +var 𮖥; +var 𮖦; +var 𮖧; +var 𮖨; +var 𮖩; +var 𮖪; +var 𮖫; +var 𮖬; +var 𮖭; +var 𮖮; +var 𮖯; +var 𮖰; +var 𮖱; +var 𮖲; +var 𮖳; +var 𮖴; +var 𮖵; +var 𮖶; +var 𮖷; +var 𮖸; +var 𮖹; +var 𮖺; +var 𮖻; +var 𮖼; +var 𮖽; +var 𮖾; +var 𮖿; +var 𮗀; +var 𮗁; +var 𮗂; +var 𮗃; +var 𮗄; +var 𮗅; +var 𮗆; +var 𮗇; +var 𮗈; +var 𮗉; +var 𮗊; +var 𮗋; +var 𮗌; +var 𮗍; +var 𮗎; +var 𮗏; +var 𮗐; +var 𮗑; +var 𮗒; +var 𮗓; +var 𮗔; +var 𮗕; +var 𮗖; +var 𮗗; +var 𮗘; +var 𮗙; +var 𮗚; +var 𮗛; +var 𮗜; +var 𮗝; +var 𮗞; +var 𮗟; +var 𮗠; +var 𮗡; +var 𮗢; +var 𮗣; +var 𮗤; +var 𮗥; +var 𮗦; +var 𮗧; +var 𮗨; +var 𮗩; +var 𮗪; +var 𮗫; +var 𮗬; +var 𮗭; +var 𮗮; +var 𮗯; +var 𮗰; +var 𮗱; +var 𮗲; +var 𮗳; +var 𮗴; +var 𮗵; +var 𮗶; +var 𮗷; +var 𮗸; +var 𮗹; +var 𮗺; +var 𮗻; +var 𮗼; +var 𮗽; +var 𮗾; +var 𮗿; +var 𮘀; +var 𮘁; +var 𮘂; +var 𮘃; +var 𮘄; +var 𮘅; +var 𮘆; +var 𮘇; +var 𮘈; +var 𮘉; +var 𮘊; +var 𮘋; +var 𮘌; +var 𮘍; +var 𮘎; +var 𮘏; +var 𮘐; +var 𮘑; +var 𮘒; +var 𮘓; +var 𮘔; +var 𮘕; +var 𮘖; +var 𮘗; +var 𮘘; +var 𮘙; +var 𮘚; +var 𮘛; +var 𮘜; +var 𮘝; +var 𮘞; +var 𮘟; +var 𮘠; +var 𮘡; +var 𮘢; +var 𮘣; +var 𮘤; +var 𮘥; +var 𮘦; +var 𮘧; +var 𮘨; +var 𮘩; +var 𮘪; +var 𮘫; +var 𮘬; +var 𮘭; +var 𮘮; +var 𮘯; +var 𮘰; +var 𮘱; +var 𮘲; +var 𮘳; +var 𮘴; +var 𮘵; +var 𮘶; +var 𮘷; +var 𮘸; +var 𮘹; +var 𮘺; +var 𮘻; +var 𮘼; +var 𮘽; +var 𮘾; +var 𮘿; +var 𮙀; +var 𮙁; +var 𮙂; +var 𮙃; +var 𮙄; +var 𮙅; +var 𮙆; +var 𮙇; +var 𮙈; +var 𮙉; +var 𮙊; +var 𮙋; +var 𮙌; +var 𮙍; +var 𮙎; +var 𮙏; +var 𮙐; +var 𮙑; +var 𮙒; +var 𮙓; +var 𮙔; +var 𮙕; +var 𮙖; +var 𮙗; +var 𮙘; +var 𮙙; +var 𮙚; +var 𮙛; +var 𮙜; +var 𮙝; +var 𮙞; +var 𮙟; +var 𮙠; +var 𮙡; +var 𮙢; +var 𮙣; +var 𮙤; +var 𮙥; +var 𮙦; +var 𮙧; +var 𮙨; +var 𮙩; +var 𮙪; +var 𮙫; +var 𮙬; +var 𮙭; +var 𮙮; +var 𮙯; +var 𮙰; +var 𮙱; +var 𮙲; +var 𮙳; +var 𮙴; +var 𮙵; +var 𮙶; +var 𮙷; +var 𮙸; +var 𮙹; +var 𮙺; +var 𮙻; +var 𮙼; +var 𮙽; +var 𮙾; +var 𮙿; +var 𮚀; +var 𮚁; +var 𮚂; +var 𮚃; +var 𮚄; +var 𮚅; +var 𮚆; +var 𮚇; +var 𮚈; +var 𮚉; +var 𮚊; +var 𮚋; +var 𮚌; +var 𮚍; +var 𮚎; +var 𮚏; +var 𮚐; +var 𮚑; +var 𮚒; +var 𮚓; +var 𮚔; +var 𮚕; +var 𮚖; +var 𮚗; +var 𮚘; +var 𮚙; +var 𮚚; +var 𮚛; +var 𮚜; +var 𮚝; +var 𮚞; +var 𮚟; +var 𮚠; +var 𮚡; +var 𮚢; +var 𮚣; +var 𮚤; +var 𮚥; +var 𮚦; +var 𮚧; +var 𮚨; +var 𮚩; +var 𮚪; +var 𮚫; +var 𮚬; +var 𮚭; +var 𮚮; +var 𮚯; +var 𮚰; +var 𮚱; +var 𮚲; +var 𮚳; +var 𮚴; +var 𮚵; +var 𮚶; +var 𮚷; +var 𮚸; +var 𮚹; +var 𮚺; +var 𮚻; +var 𮚼; +var 𮚽; +var 𮚾; +var 𮚿; +var 𮛀; +var 𮛁; +var 𮛂; +var 𮛃; +var 𮛄; +var 𮛅; +var 𮛆; +var 𮛇; +var 𮛈; +var 𮛉; +var 𮛊; +var 𮛋; +var 𮛌; +var 𮛍; +var 𮛎; +var 𮛏; +var 𮛐; +var 𮛑; +var 𮛒; +var 𮛓; +var 𮛔; +var 𮛕; +var 𮛖; +var 𮛗; +var 𮛘; +var 𮛙; +var 𮛚; +var 𮛛; +var 𮛜; +var 𮛝; +var 𮛞; +var 𮛟; +var 𮛠; +var 𮛡; +var 𮛢; +var 𮛣; +var 𮛤; +var 𮛥; +var 𮛦; +var 𮛧; +var 𮛨; +var 𮛩; +var 𮛪; +var 𮛫; +var 𮛬; +var 𮛭; +var 𮛮; +var 𮛯; +var 𮛰; +var 𮛱; +var 𮛲; +var 𮛳; +var 𮛴; +var 𮛵; +var 𮛶; +var 𮛷; +var 𮛸; +var 𮛹; +var 𮛺; +var 𮛻; +var 𮛼; +var 𮛽; +var 𮛾; +var 𮛿; +var 𮜀; +var 𮜁; +var 𮜂; +var 𮜃; +var 𮜄; +var 𮜅; +var 𮜆; +var 𮜇; +var 𮜈; +var 𮜉; +var 𮜊; +var 𮜋; +var 𮜌; +var 𮜍; +var 𮜎; +var 𮜏; +var 𮜐; +var 𮜑; +var 𮜒; +var 𮜓; +var 𮜔; +var 𮜕; +var 𮜖; +var 𮜗; +var 𮜘; +var 𮜙; +var 𮜚; +var 𮜛; +var 𮜜; +var 𮜝; +var 𮜞; +var 𮜟; +var 𮜠; +var 𮜡; +var 𮜢; +var 𮜣; +var 𮜤; +var 𮜥; +var 𮜦; +var 𮜧; +var 𮜨; +var 𮜩; +var 𮜪; +var 𮜫; +var 𮜬; +var 𮜭; +var 𮜮; +var 𮜯; +var 𮜰; +var 𮜱; +var 𮜲; +var 𮜳; +var 𮜴; +var 𮜵; +var 𮜶; +var 𮜷; +var 𮜸; +var 𮜹; +var 𮜺; +var 𮜻; +var 𮜼; +var 𮜽; +var 𮜾; +var 𮜿; +var 𮝀; +var 𮝁; +var 𮝂; +var 𮝃; +var 𮝄; +var 𮝅; +var 𮝆; +var 𮝇; +var 𮝈; +var 𮝉; +var 𮝊; +var 𮝋; +var 𮝌; +var 𮝍; +var 𮝎; +var 𮝏; +var 𮝐; +var 𮝑; +var 𮝒; +var 𮝓; +var 𮝔; +var 𮝕; +var 𮝖; +var 𮝗; +var 𮝘; +var 𮝙; +var 𮝚; +var 𮝛; +var 𮝜; +var 𮝝; +var 𮝞; +var 𮝟; +var 𮝠; +var 𮝡; +var 𮝢; +var 𮝣; +var 𮝤; +var 𮝥; +var 𮝦; +var 𮝧; +var 𮝨; +var 𮝩; +var 𮝪; +var 𮝫; +var 𮝬; +var 𮝭; +var 𮝮; +var 𮝯; +var 𮝰; +var 𮝱; +var 𮝲; +var 𮝳; +var 𮝴; +var 𮝵; +var 𮝶; +var 𮝷; +var 𮝸; +var 𮝹; +var 𮝺; +var 𮝻; +var 𮝼; +var 𮝽; +var 𮝾; +var 𮝿; +var 𮞀; +var 𮞁; +var 𮞂; +var 𮞃; +var 𮞄; +var 𮞅; +var 𮞆; +var 𮞇; +var 𮞈; +var 𮞉; +var 𮞊; +var 𮞋; +var 𮞌; +var 𮞍; +var 𮞎; +var 𮞏; +var 𮞐; +var 𮞑; +var 𮞒; +var 𮞓; +var 𮞔; +var 𮞕; +var 𮞖; +var 𮞗; +var 𮞘; +var 𮞙; +var 𮞚; +var 𮞛; +var 𮞜; +var 𮞝; +var 𮞞; +var 𮞟; +var 𮞠; +var 𮞡; +var 𮞢; +var 𮞣; +var 𮞤; +var 𮞥; +var 𮞦; +var 𮞧; +var 𮞨; +var 𮞩; +var 𮞪; +var 𮞫; +var 𮞬; +var 𮞭; +var 𮞮; +var 𮞯; +var 𮞰; +var 𮞱; +var 𮞲; +var 𮞳; +var 𮞴; +var 𮞵; +var 𮞶; +var 𮞷; +var 𮞸; +var 𮞹; +var 𮞺; +var 𮞻; +var 𮞼; +var 𮞽; +var 𮞾; +var 𮞿; +var 𮟀; +var 𮟁; +var 𮟂; +var 𮟃; +var 𮟄; +var 𮟅; +var 𮟆; +var 𮟇; +var 𮟈; +var 𮟉; +var 𮟊; +var 𮟋; +var 𮟌; +var 𮟍; +var 𮟎; +var 𮟏; +var 𮟐; +var 𮟑; +var 𮟒; +var 𮟓; +var 𮟔; +var 𮟕; +var 𮟖; +var 𮟗; +var 𮟘; +var 𮟙; +var 𮟚; +var 𮟛; +var 𮟜; +var 𮟝; +var 𮟞; +var 𮟟; +var 𮟠; +var 𮟡; +var 𮟢; +var 𮟣; +var 𮟤; +var 𮟥; +var 𮟦; +var 𮟧; +var 𮟨; +var 𮟩; +var 𮟪; +var 𮟫; +var 𮟬; +var 𮟭; +var 𮟮; +var 𮟯; +var 𮟰; +var 𮟱; +var 𮟲; +var 𮟳; +var 𮟴; +var 𮟵; +var 𮟶; +var 𮟷; +var 𮟸; +var 𮟹; +var 𮟺; +var 𮟻; +var 𮟼; +var 𮟽; +var 𮟾; +var 𮟿; +var 𮠀; +var 𮠁; +var 𮠂; +var 𮠃; +var 𮠄; +var 𮠅; +var 𮠆; +var 𮠇; +var 𮠈; +var 𮠉; +var 𮠊; +var 𮠋; +var 𮠌; +var 𮠍; +var 𮠎; +var 𮠏; +var 𮠐; +var 𮠑; +var 𮠒; +var 𮠓; +var 𮠔; +var 𮠕; +var 𮠖; +var 𮠗; +var 𮠘; +var 𮠙; +var 𮠚; +var 𮠛; +var 𮠜; +var 𮠝; +var 𮠞; +var 𮠟; +var 𮠠; +var 𮠡; +var 𮠢; +var 𮠣; +var 𮠤; +var 𮠥; +var 𮠦; +var 𮠧; +var 𮠨; +var 𮠩; +var 𮠪; +var 𮠫; +var 𮠬; +var 𮠭; +var 𮠮; +var 𮠯; +var 𮠰; +var 𮠱; +var 𮠲; +var 𮠳; +var 𮠴; +var 𮠵; +var 𮠶; +var 𮠷; +var 𮠸; +var 𮠹; +var 𮠺; +var 𮠻; +var 𮠼; +var 𮠽; +var 𮠾; +var 𮠿; +var 𮡀; +var 𮡁; +var 𮡂; +var 𮡃; +var 𮡄; +var 𮡅; +var 𮡆; +var 𮡇; +var 𮡈; +var 𮡉; +var 𮡊; +var 𮡋; +var 𮡌; +var 𮡍; +var 𮡎; +var 𮡏; +var 𮡐; +var 𮡑; +var 𮡒; +var 𮡓; +var 𮡔; +var 𮡕; +var 𮡖; +var 𮡗; +var 𮡘; +var 𮡙; +var 𮡚; +var 𮡛; +var 𮡜; +var 𮡝; +var 𮡞; +var 𮡟; +var 𮡠; +var 𮡡; +var 𮡢; +var 𮡣; +var 𮡤; +var 𮡥; +var 𮡦; +var 𮡧; +var 𮡨; +var 𮡩; +var 𮡪; +var 𮡫; +var 𮡬; +var 𮡭; +var 𮡮; +var 𮡯; +var 𮡰; +var 𮡱; +var 𮡲; +var 𮡳; +var 𮡴; +var 𮡵; +var 𮡶; +var 𮡷; +var 𮡸; +var 𮡹; +var 𮡺; +var 𮡻; +var 𮡼; +var 𮡽; +var 𮡾; +var 𮡿; +var 𮢀; +var 𮢁; +var 𮢂; +var 𮢃; +var 𮢄; +var 𮢅; +var 𮢆; +var 𮢇; +var 𮢈; +var 𮢉; +var 𮢊; +var 𮢋; +var 𮢌; +var 𮢍; +var 𮢎; +var 𮢏; +var 𮢐; +var 𮢑; +var 𮢒; +var 𮢓; +var 𮢔; +var 𮢕; +var 𮢖; +var 𮢗; +var 𮢘; +var 𮢙; +var 𮢚; +var 𮢛; +var 𮢜; +var 𮢝; +var 𮢞; +var 𮢟; +var 𮢠; +var 𮢡; +var 𮢢; +var 𮢣; +var 𮢤; +var 𮢥; +var 𮢦; +var 𮢧; +var 𮢨; +var 𮢩; +var 𮢪; +var 𮢫; +var 𮢬; +var 𮢭; +var 𮢮; +var 𮢯; +var 𮢰; +var 𮢱; +var 𮢲; +var 𮢳; +var 𮢴; +var 𮢵; +var 𮢶; +var 𮢷; +var 𮢸; +var 𮢹; +var 𮢺; +var 𮢻; +var 𮢼; +var 𮢽; +var 𮢾; +var 𮢿; +var 𮣀; +var 𮣁; +var 𮣂; +var 𮣃; +var 𮣄; +var 𮣅; +var 𮣆; +var 𮣇; +var 𮣈; +var 𮣉; +var 𮣊; +var 𮣋; +var 𮣌; +var 𮣍; +var 𮣎; +var 𮣏; +var 𮣐; +var 𮣑; +var 𮣒; +var 𮣓; +var 𮣔; +var 𮣕; +var 𮣖; +var 𮣗; +var 𮣘; +var 𮣙; +var 𮣚; +var 𮣛; +var 𮣜; +var 𮣝; +var 𮣞; +var 𮣟; +var 𮣠; +var 𮣡; +var 𮣢; +var 𮣣; +var 𮣤; +var 𮣥; +var 𮣦; +var 𮣧; +var 𮣨; +var 𮣩; +var 𮣪; +var 𮣫; +var 𮣬; +var 𮣭; +var 𮣮; +var 𮣯; +var 𮣰; +var 𮣱; +var 𮣲; +var 𮣳; +var 𮣴; +var 𮣵; +var 𮣶; +var 𮣷; +var 𮣸; +var 𮣹; +var 𮣺; +var 𮣻; +var 𮣼; +var 𮣽; +var 𮣾; +var 𮣿; +var 𮤀; +var 𮤁; +var 𮤂; +var 𮤃; +var 𮤄; +var 𮤅; +var 𮤆; +var 𮤇; +var 𮤈; +var 𮤉; +var 𮤊; +var 𮤋; +var 𮤌; +var 𮤍; +var 𮤎; +var 𮤏; +var 𮤐; +var 𮤑; +var 𮤒; +var 𮤓; +var 𮤔; +var 𮤕; +var 𮤖; +var 𮤗; +var 𮤘; +var 𮤙; +var 𮤚; +var 𮤛; +var 𮤜; +var 𮤝; +var 𮤞; +var 𮤟; +var 𮤠; +var 𮤡; +var 𮤢; +var 𮤣; +var 𮤤; +var 𮤥; +var 𮤦; +var 𮤧; +var 𮤨; +var 𮤩; +var 𮤪; +var 𮤫; +var 𮤬; +var 𮤭; +var 𮤮; +var 𮤯; +var 𮤰; +var 𮤱; +var 𮤲; +var 𮤳; +var 𮤴; +var 𮤵; +var 𮤶; +var 𮤷; +var 𮤸; +var 𮤹; +var 𮤺; +var 𮤻; +var 𮤼; +var 𮤽; +var 𮤾; +var 𮤿; +var 𮥀; +var 𮥁; +var 𮥂; +var 𮥃; +var 𮥄; +var 𮥅; +var 𮥆; +var 𮥇; +var 𮥈; +var 𮥉; +var 𮥊; +var 𮥋; +var 𮥌; +var 𮥍; +var 𮥎; +var 𮥏; +var 𮥐; +var 𮥑; +var 𮥒; +var 𮥓; +var 𮥔; +var 𮥕; +var 𮥖; +var 𮥗; +var 𮥘; +var 𮥙; +var 𮥚; +var 𮥛; +var 𮥜; +var 𮥝; +var 𮥞; +var 𮥟; +var 𮥠; +var 𮥡; +var 𮥢; +var 𮥣; +var 𮥤; +var 𮥥; +var 𮥦; +var 𮥧; +var 𮥨; +var 𮥩; +var 𮥪; +var 𮥫; +var 𮥬; +var 𮥭; +var 𮥮; +var 𮥯; +var 𮥰; +var 𮥱; +var 𮥲; +var 𮥳; +var 𮥴; +var 𮥵; +var 𮥶; +var 𮥷; +var 𮥸; +var 𮥹; +var 𮥺; +var 𮥻; +var 𮥼; +var 𮥽; +var 𮥾; +var 𮥿; +var 𮦀; +var 𮦁; +var 𮦂; +var 𮦃; +var 𮦄; +var 𮦅; +var 𮦆; +var 𮦇; +var 𮦈; +var 𮦉; +var 𮦊; +var 𮦋; +var 𮦌; +var 𮦍; +var 𮦎; +var 𮦏; +var 𮦐; +var 𮦑; +var 𮦒; +var 𮦓; +var 𮦔; +var 𮦕; +var 𮦖; +var 𮦗; +var 𮦘; +var 𮦙; +var 𮦚; +var 𮦛; +var 𮦜; +var 𮦝; +var 𮦞; +var 𮦟; +var 𮦠; +var 𮦡; +var 𮦢; +var 𮦣; +var 𮦤; +var 𮦥; +var 𮦦; +var 𮦧; +var 𮦨; +var 𮦩; +var 𮦪; +var 𮦫; +var 𮦬; +var 𮦭; +var 𮦮; +var 𮦯; +var 𮦰; +var 𮦱; +var 𮦲; +var 𮦳; +var 𮦴; +var 𮦵; +var 𮦶; +var 𮦷; +var 𮦸; +var 𮦹; +var 𮦺; +var 𮦻; +var 𮦼; +var 𮦽; +var 𮦾; +var 𮦿; +var 𮧀; +var 𮧁; +var 𮧂; +var 𮧃; +var 𮧄; +var 𮧅; +var 𮧆; +var 𮧇; +var 𮧈; +var 𮧉; +var 𮧊; +var 𮧋; +var 𮧌; +var 𮧍; +var 𮧎; +var 𮧏; +var 𮧐; +var 𮧑; +var 𮧒; +var 𮧓; +var 𮧔; +var 𮧕; +var 𮧖; +var 𮧗; +var 𮧘; +var 𮧙; +var 𮧚; +var 𮧛; +var 𮧜; +var 𮧝; +var 𮧞; +var 𮧟; +var 𮧠; +var 𮧡; +var 𮧢; +var 𮧣; +var 𮧤; +var 𮧥; +var 𮧦; +var 𮧧; +var 𮧨; +var 𮧩; +var 𮧪; +var 𮧫; +var 𮧬; +var 𮧭; +var 𮧮; +var 𮧯; +var 𮧰; +var 𮧱; +var 𮧲; +var 𮧳; +var 𮧴; +var 𮧵; +var 𮧶; +var 𮧷; +var 𮧸; +var 𮧹; +var 𮧺; +var 𮧻; +var 𮧼; +var 𮧽; +var 𮧾; +var 𮧿; +var 𮨀; +var 𮨁; +var 𮨂; +var 𮨃; +var 𮨄; +var 𮨅; +var 𮨆; +var 𮨇; +var 𮨈; +var 𮨉; +var 𮨊; +var 𮨋; +var 𮨌; +var 𮨍; +var 𮨎; +var 𮨏; +var 𮨐; +var 𮨑; +var 𮨒; +var 𮨓; +var 𮨔; +var 𮨕; +var 𮨖; +var 𮨗; +var 𮨘; +var 𮨙; +var 𮨚; +var 𮨛; +var 𮨜; +var 𮨝; +var 𮨞; +var 𮨟; +var 𮨠; +var 𮨡; +var 𮨢; +var 𮨣; +var 𮨤; +var 𮨥; +var 𮨦; +var 𮨧; +var 𮨨; +var 𮨩; +var 𮨪; +var 𮨫; +var 𮨬; +var 𮨭; +var 𮨮; +var 𮨯; +var 𮨰; +var 𮨱; +var 𮨲; +var 𮨳; +var 𮨴; +var 𮨵; +var 𮨶; +var 𮨷; +var 𮨸; +var 𮨹; +var 𮨺; +var 𮨻; +var 𮨼; +var 𮨽; +var 𮨾; +var 𮨿; +var 𮩀; +var 𮩁; +var 𮩂; +var 𮩃; +var 𮩄; +var 𮩅; +var 𮩆; +var 𮩇; +var 𮩈; +var 𮩉; +var 𮩊; +var 𮩋; +var 𮩌; +var 𮩍; +var 𮩎; +var 𮩏; +var 𮩐; +var 𮩑; +var 𮩒; +var 𮩓; +var 𮩔; +var 𮩕; +var 𮩖; +var 𮩗; +var 𮩘; +var 𮩙; +var 𮩚; +var 𮩛; +var 𮩜; +var 𮩝; +var 𮩞; +var 𮩟; +var 𮩠; +var 𮩡; +var 𮩢; +var 𮩣; +var 𮩤; +var 𮩥; +var 𮩦; +var 𮩧; +var 𮩨; +var 𮩩; +var 𮩪; +var 𮩫; +var 𮩬; +var 𮩭; +var 𮩮; +var 𮩯; +var 𮩰; +var 𮩱; +var 𮩲; +var 𮩳; +var 𮩴; +var 𮩵; +var 𮩶; +var 𮩷; +var 𮩸; +var 𮩹; +var 𮩺; +var 𮩻; +var 𮩼; +var 𮩽; +var 𮩾; +var 𮩿; +var 𮪀; +var 𮪁; +var 𮪂; +var 𮪃; +var 𮪄; +var 𮪅; +var 𮪆; +var 𮪇; +var 𮪈; +var 𮪉; +var 𮪊; +var 𮪋; +var 𮪌; +var 𮪍; +var 𮪎; +var 𮪏; +var 𮪐; +var 𮪑; +var 𮪒; +var 𮪓; +var 𮪔; +var 𮪕; +var 𮪖; +var 𮪗; +var 𮪘; +var 𮪙; +var 𮪚; +var 𮪛; +var 𮪜; +var 𮪝; +var 𮪞; +var 𮪟; +var 𮪠; +var 𮪡; +var 𮪢; +var 𮪣; +var 𮪤; +var 𮪥; +var 𮪦; +var 𮪧; +var 𮪨; +var 𮪩; +var 𮪪; +var 𮪫; +var 𮪬; +var 𮪭; +var 𮪮; +var 𮪯; +var 𮪰; +var 𮪱; +var 𮪲; +var 𮪳; +var 𮪴; +var 𮪵; +var 𮪶; +var 𮪷; +var 𮪸; +var 𮪹; +var 𮪺; +var 𮪻; +var 𮪼; +var 𮪽; +var 𮪾; +var 𮪿; +var 𮫀; +var 𮫁; +var 𮫂; +var 𮫃; +var 𮫄; +var 𮫅; +var 𮫆; +var 𮫇; +var 𮫈; +var 𮫉; +var 𮫊; +var 𮫋; +var 𮫌; +var 𮫍; +var 𮫎; +var 𮫏; +var 𮫐; +var 𮫑; +var 𮫒; +var 𮫓; +var 𮫔; +var 𮫕; +var 𮫖; +var 𮫗; +var 𮫘; +var 𮫙; +var 𮫚; +var 𮫛; +var 𮫜; +var 𮫝; +var 𮫞; +var 𮫟; +var 𮫠; +var 𮫡; +var 𮫢; +var 𮫣; +var 𮫤; +var 𮫥; +var 𮫦; +var 𮫧; +var 𮫨; +var 𮫩; +var 𮫪; +var 𮫫; +var 𮫬; +var 𮫭; +var 𮫮; +var 𮫯; +var 𮫰; +var 𮫱; +var 𮫲; +var 𮫳; +var 𮫴; +var 𮫵; +var 𮫶; +var 𮫷; +var 𮫸; +var 𮫹; +var 𮫺; +var 𮫻; +var 𮫼; +var 𮫽; +var 𮫾; +var 𮫿; +var 𮬀; +var 𮬁; +var 𮬂; +var 𮬃; +var 𮬄; +var 𮬅; +var 𮬆; +var 𮬇; +var 𮬈; +var 𮬉; +var 𮬊; +var 𮬋; +var 𮬌; +var 𮬍; +var 𮬎; +var 𮬏; +var 𮬐; +var 𮬑; +var 𮬒; +var 𮬓; +var 𮬔; +var 𮬕; +var 𮬖; +var 𮬗; +var 𮬘; +var 𮬙; +var 𮬚; +var 𮬛; +var 𮬜; +var 𮬝; +var 𮬞; +var 𮬟; +var 𮬠; +var 𮬡; +var 𮬢; +var 𮬣; +var 𮬤; +var 𮬥; +var 𮬦; +var 𮬧; +var 𮬨; +var 𮬩; +var 𮬪; +var 𮬫; +var 𮬬; +var 𮬭; +var 𮬮; +var 𮬯; +var 𮬰; +var 𮬱; +var 𮬲; +var 𮬳; +var 𮬴; +var 𮬵; +var 𮬶; +var 𮬷; +var 𮬸; +var 𮬹; +var 𮬺; +var 𮬻; +var 𮬼; +var 𮬽; +var 𮬾; +var 𮬿; +var 𮭀; +var 𮭁; +var 𮭂; +var 𮭃; +var 𮭄; +var 𮭅; +var 𮭆; +var 𮭇; +var 𮭈; +var 𮭉; +var 𮭊; +var 𮭋; +var 𮭌; +var 𮭍; +var 𮭎; +var 𮭏; +var 𮭐; +var 𮭑; +var 𮭒; +var 𮭓; +var 𮭔; +var 𮭕; +var 𮭖; +var 𮭗; +var 𮭘; +var 𮭙; +var 𮭚; +var 𮭛; +var 𮭜; +var 𮭝; +var 𮭞; +var 𮭟; +var 𮭠; +var 𮭡; +var 𮭢; +var 𮭣; +var 𮭤; +var 𮭥; +var 𮭦; +var 𮭧; +var 𮭨; +var 𮭩; +var 𮭪; +var 𮭫; +var 𮭬; +var 𮭭; +var 𮭮; +var 𮭯; +var 𮭰; +var 𮭱; +var 𮭲; +var 𮭳; +var 𮭴; +var 𮭵; +var 𮭶; +var 𮭷; +var 𮭸; +var 𮭹; +var 𮭺; +var 𮭻; +var 𮭼; +var 𮭽; +var 𮭾; +var 𮭿; +var 𮮀; +var 𮮁; +var 𮮂; +var 𮮃; +var 𮮄; +var 𮮅; +var 𮮆; +var 𮮇; +var 𮮈; +var 𮮉; +var 𮮊; +var 𮮋; +var 𮮌; +var 𮮍; +var 𮮎; +var 𮮏; +var 𮮐; +var 𮮑; +var 𮮒; +var 𮮓; +var 𮮔; +var 𮮕; +var 𮮖; +var 𮮗; +var 𮮘; +var 𮮙; +var 𮮚; +var 𮮛; +var 𮮜; +var 𮮝; +var 𮮞; +var 𮮟; +var 𮮠; +var 𮮡; +var 𮮢; +var 𮮣; +var 𮮤; +var 𮮥; +var 𮮦; +var 𮮧; +var 𮮨; +var 𮮩; +var 𮮪; +var 𮮫; +var 𮮬; +var 𮮭; +var 𮮮; +var 𮮯; +var 𮮰; +var 𮮱; +var 𮮲; +var 𮮳; +var 𮮴; +var 𮮵; +var 𮮶; +var 𮮷; +var 𮮸; +var 𮮹; +var 𮮺; +var 𮮻; +var 𮮼; +var 𮮽; +var 𮮾; +var 𮮿; +var 𮯀; +var 𮯁; +var 𮯂; +var 𮯃; +var 𮯄; +var 𮯅; +var 𮯆; +var 𮯇; +var 𮯈; +var 𮯉; +var 𮯊; +var 𮯋; +var 𮯌; +var 𮯍; +var 𮯎; +var 𮯏; +var 𮯐; +var 𮯑; +var 𮯒; +var 𮯓; +var 𮯔; +var 𮯕; +var 𮯖; +var 𮯗; +var 𮯘; +var 𮯙; +var 𮯚; +var 𮯛; +var 𮯜; +var 𮯝; +var 𮯞; +var 𮯟; +var 𮯠; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0-class-escaped.js new file mode 100644 index 000000000..47189db76 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0-class-escaped.js @@ -0,0 +1,345 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v11.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u0560; + #\u0588; + #\u05EF; + #\u1878; + #\u1C90; + #\u1C91; + #\u1C92; + #\u1C93; + #\u1C94; + #\u1C95; + #\u1C96; + #\u1C97; + #\u1C98; + #\u1C99; + #\u1C9A; + #\u1C9B; + #\u1C9C; + #\u1C9D; + #\u1C9E; + #\u1C9F; + #\u1CA0; + #\u1CA1; + #\u1CA2; + #\u1CA3; + #\u1CA4; + #\u1CA5; + #\u1CA6; + #\u1CA7; + #\u1CA8; + #\u1CA9; + #\u1CAA; + #\u1CAB; + #\u1CAC; + #\u1CAD; + #\u1CAE; + #\u1CAF; + #\u1CB0; + #\u1CB1; + #\u1CB2; + #\u1CB3; + #\u1CB4; + #\u1CB5; + #\u1CB6; + #\u1CB7; + #\u1CB8; + #\u1CB9; + #\u1CBA; + #\u1CBD; + #\u1CBE; + #\u1CBF; + #\u312F; + #\u9FEB; + #\u9FEC; + #\u9FED; + #\u9FEE; + #\u9FEF; + #\uA7AF; + #\uA7B8; + #\uA7B9; + #\uA8FE; + #\u{10A34}; + #\u{10A35}; + #\u{10D00}; + #\u{10D01}; + #\u{10D02}; + #\u{10D03}; + #\u{10D04}; + #\u{10D05}; + #\u{10D06}; + #\u{10D07}; + #\u{10D08}; + #\u{10D09}; + #\u{10D0A}; + #\u{10D0B}; + #\u{10D0C}; + #\u{10D0D}; + #\u{10D0E}; + #\u{10D0F}; + #\u{10D10}; + #\u{10D11}; + #\u{10D12}; + #\u{10D13}; + #\u{10D14}; + #\u{10D15}; + #\u{10D16}; + #\u{10D17}; + #\u{10D18}; + #\u{10D19}; + #\u{10D1A}; + #\u{10D1B}; + #\u{10D1C}; + #\u{10D1D}; + #\u{10D1E}; + #\u{10D1F}; + #\u{10D20}; + #\u{10D21}; + #\u{10D22}; + #\u{10D23}; + #\u{10F00}; + #\u{10F01}; + #\u{10F02}; + #\u{10F03}; + #\u{10F04}; + #\u{10F05}; + #\u{10F06}; + #\u{10F07}; + #\u{10F08}; + #\u{10F09}; + #\u{10F0A}; + #\u{10F0B}; + #\u{10F0C}; + #\u{10F0D}; + #\u{10F0E}; + #\u{10F0F}; + #\u{10F10}; + #\u{10F11}; + #\u{10F12}; + #\u{10F13}; + #\u{10F14}; + #\u{10F15}; + #\u{10F16}; + #\u{10F17}; + #\u{10F18}; + #\u{10F19}; + #\u{10F1A}; + #\u{10F1B}; + #\u{10F1C}; + #\u{10F27}; + #\u{10F30}; + #\u{10F31}; + #\u{10F32}; + #\u{10F33}; + #\u{10F34}; + #\u{10F35}; + #\u{10F36}; + #\u{10F37}; + #\u{10F38}; + #\u{10F39}; + #\u{10F3A}; + #\u{10F3B}; + #\u{10F3C}; + #\u{10F3D}; + #\u{10F3E}; + #\u{10F3F}; + #\u{10F40}; + #\u{10F41}; + #\u{10F42}; + #\u{10F43}; + #\u{10F44}; + #\u{10F45}; + #\u{11144}; + #\u{1171A}; + #\u{11800}; + #\u{11801}; + #\u{11802}; + #\u{11803}; + #\u{11804}; + #\u{11805}; + #\u{11806}; + #\u{11807}; + #\u{11808}; + #\u{11809}; + #\u{1180A}; + #\u{1180B}; + #\u{1180C}; + #\u{1180D}; + #\u{1180E}; + #\u{1180F}; + #\u{11810}; + #\u{11811}; + #\u{11812}; + #\u{11813}; + #\u{11814}; + #\u{11815}; + #\u{11816}; + #\u{11817}; + #\u{11818}; + #\u{11819}; + #\u{1181A}; + #\u{1181B}; + #\u{1181C}; + #\u{1181D}; + #\u{1181E}; + #\u{1181F}; + #\u{11820}; + #\u{11821}; + #\u{11822}; + #\u{11823}; + #\u{11824}; + #\u{11825}; + #\u{11826}; + #\u{11827}; + #\u{11828}; + #\u{11829}; + #\u{1182A}; + #\u{1182B}; + #\u{11A9D}; + #\u{11D60}; + #\u{11D61}; + #\u{11D62}; + #\u{11D63}; + #\u{11D64}; + #\u{11D65}; + #\u{11D67}; + #\u{11D68}; + #\u{11D6A}; + #\u{11D6B}; + #\u{11D6C}; + #\u{11D6D}; + #\u{11D6E}; + #\u{11D6F}; + #\u{11D70}; + #\u{11D71}; + #\u{11D72}; + #\u{11D73}; + #\u{11D74}; + #\u{11D75}; + #\u{11D76}; + #\u{11D77}; + #\u{11D78}; + #\u{11D79}; + #\u{11D7A}; + #\u{11D7B}; + #\u{11D7C}; + #\u{11D7D}; + #\u{11D7E}; + #\u{11D7F}; + #\u{11D80}; + #\u{11D81}; + #\u{11D82}; + #\u{11D83}; + #\u{11D84}; + #\u{11D85}; + #\u{11D86}; + #\u{11D87}; + #\u{11D88}; + #\u{11D89}; + #\u{11D98}; + #\u{11EE0}; + #\u{11EE1}; + #\u{11EE2}; + #\u{11EE3}; + #\u{11EE4}; + #\u{11EE5}; + #\u{11EE6}; + #\u{11EE7}; + #\u{11EE8}; + #\u{11EE9}; + #\u{11EEA}; + #\u{11EEB}; + #\u{11EEC}; + #\u{11EED}; + #\u{11EEE}; + #\u{11EEF}; + #\u{11EF0}; + #\u{11EF1}; + #\u{11EF2}; + #\u{16E40}; + #\u{16E41}; + #\u{16E42}; + #\u{16E43}; + #\u{16E44}; + #\u{16E45}; + #\u{16E46}; + #\u{16E47}; + #\u{16E48}; + #\u{16E49}; + #\u{16E4A}; + #\u{16E4B}; + #\u{16E4C}; + #\u{16E4D}; + #\u{16E4E}; + #\u{16E4F}; + #\u{16E50}; + #\u{16E51}; + #\u{16E52}; + #\u{16E53}; + #\u{16E54}; + #\u{16E55}; + #\u{16E56}; + #\u{16E57}; + #\u{16E58}; + #\u{16E59}; + #\u{16E5A}; + #\u{16E5B}; + #\u{16E5C}; + #\u{16E5D}; + #\u{16E5E}; + #\u{16E5F}; + #\u{16E60}; + #\u{16E61}; + #\u{16E62}; + #\u{16E63}; + #\u{16E64}; + #\u{16E65}; + #\u{16E66}; + #\u{16E67}; + #\u{16E68}; + #\u{16E69}; + #\u{16E6A}; + #\u{16E6B}; + #\u{16E6C}; + #\u{16E6D}; + #\u{16E6E}; + #\u{16E6F}; + #\u{16E70}; + #\u{16E71}; + #\u{16E72}; + #\u{16E73}; + #\u{16E74}; + #\u{16E75}; + #\u{16E76}; + #\u{16E77}; + #\u{16E78}; + #\u{16E79}; + #\u{16E7A}; + #\u{16E7B}; + #\u{16E7C}; + #\u{16E7D}; + #\u{16E7E}; + #\u{16E7F}; + #\u{187ED}; + #\u{187EE}; + #\u{187EF}; + #\u{187F0}; + #\u{187F1}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0-class.js new file mode 100644 index 000000000..72731d6e0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0-class.js @@ -0,0 +1,342 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v11.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #ՠ; + #ֈ; + #ׯ; + #ᡸ; + #Ა; + #Ბ; + #Გ; + #Დ; + #Ე; + #Ვ; + #Ზ; + #Თ; + #Ი; + #Კ; + #Ლ; + #Მ; + #Ნ; + #Ო; + #Პ; + #Ჟ; + #Რ; + #Ს; + #Ტ; + #Უ; + #Ფ; + #Ქ; + #Ღ; + #Ყ; + #Შ; + #Ჩ; + #Ც; + #Ძ; + #Წ; + #Ჭ; + #Ხ; + #Ჯ; + #Ჰ; + #Ჱ; + #Ჲ; + #Ჳ; + #Ჴ; + #Ჵ; + #Ჶ; + #Ჷ; + #Ჸ; + #Ჹ; + #Ჺ; + #Ჽ; + #Ჾ; + #Ჿ; + #ㄯ; + #鿫; + #鿬; + #鿭; + #鿮; + #鿯; + #ꞯ; + #Ꞹ; + #ꞹ; + #ꣾ; + #𐨴; + #𐨵; + #𐴀; + #𐴁; + #𐴂; + #𐴃; + #𐴄; + #𐴅; + #𐴆; + #𐴇; + #𐴈; + #𐴉; + #𐴊; + #𐴋; + #𐴌; + #𐴍; + #𐴎; + #𐴏; + #𐴐; + #𐴑; + #𐴒; + #𐴓; + #𐴔; + #𐴕; + #𐴖; + #𐴗; + #𐴘; + #𐴙; + #𐴚; + #𐴛; + #𐴜; + #𐴝; + #𐴞; + #𐴟; + #𐴠; + #𐴡; + #𐴢; + #𐴣; + #𐼀; + #𐼁; + #𐼂; + #𐼃; + #𐼄; + #𐼅; + #𐼆; + #𐼇; + #𐼈; + #𐼉; + #𐼊; + #𐼋; + #𐼌; + #𐼍; + #𐼎; + #𐼏; + #𐼐; + #𐼑; + #𐼒; + #𐼓; + #𐼔; + #𐼕; + #𐼖; + #𐼗; + #𐼘; + #𐼙; + #𐼚; + #𐼛; + #𐼜; + #𐼧; + #𐼰; + #𐼱; + #𐼲; + #𐼳; + #𐼴; + #𐼵; + #𐼶; + #𐼷; + #𐼸; + #𐼹; + #𐼺; + #𐼻; + #𐼼; + #𐼽; + #𐼾; + #𐼿; + #𐽀; + #𐽁; + #𐽂; + #𐽃; + #𐽄; + #𐽅; + #𑅄; + #𑜚; + #𑠀; + #𑠁; + #𑠂; + #𑠃; + #𑠄; + #𑠅; + #𑠆; + #𑠇; + #𑠈; + #𑠉; + #𑠊; + #𑠋; + #𑠌; + #𑠍; + #𑠎; + #𑠏; + #𑠐; + #𑠑; + #𑠒; + #𑠓; + #𑠔; + #𑠕; + #𑠖; + #𑠗; + #𑠘; + #𑠙; + #𑠚; + #𑠛; + #𑠜; + #𑠝; + #𑠞; + #𑠟; + #𑠠; + #𑠡; + #𑠢; + #𑠣; + #𑠤; + #𑠥; + #𑠦; + #𑠧; + #𑠨; + #𑠩; + #𑠪; + #𑠫; + #𑪝; + #𑵠; + #𑵡; + #𑵢; + #𑵣; + #𑵤; + #𑵥; + #𑵧; + #𑵨; + #𑵪; + #𑵫; + #𑵬; + #𑵭; + #𑵮; + #𑵯; + #𑵰; + #𑵱; + #𑵲; + #𑵳; + #𑵴; + #𑵵; + #𑵶; + #𑵷; + #𑵸; + #𑵹; + #𑵺; + #𑵻; + #𑵼; + #𑵽; + #𑵾; + #𑵿; + #𑶀; + #𑶁; + #𑶂; + #𑶃; + #𑶄; + #𑶅; + #𑶆; + #𑶇; + #𑶈; + #𑶉; + #𑶘; + #𑻠; + #𑻡; + #𑻢; + #𑻣; + #𑻤; + #𑻥; + #𑻦; + #𑻧; + #𑻨; + #𑻩; + #𑻪; + #𑻫; + #𑻬; + #𑻭; + #𑻮; + #𑻯; + #𑻰; + #𑻱; + #𑻲; + #𖹀; + #𖹁; + #𖹂; + #𖹃; + #𖹄; + #𖹅; + #𖹆; + #𖹇; + #𖹈; + #𖹉; + #𖹊; + #𖹋; + #𖹌; + #𖹍; + #𖹎; + #𖹏; + #𖹐; + #𖹑; + #𖹒; + #𖹓; + #𖹔; + #𖹕; + #𖹖; + #𖹗; + #𖹘; + #𖹙; + #𖹚; + #𖹛; + #𖹜; + #𖹝; + #𖹞; + #𖹟; + #𖹠; + #𖹡; + #𖹢; + #𖹣; + #𖹤; + #𖹥; + #𖹦; + #𖹧; + #𖹨; + #𖹩; + #𖹪; + #𖹫; + #𖹬; + #𖹭; + #𖹮; + #𖹯; + #𖹰; + #𖹱; + #𖹲; + #𖹳; + #𖹴; + #𖹵; + #𖹶; + #𖹷; + #𖹸; + #𖹹; + #𖹺; + #𖹻; + #𖹼; + #𖹽; + #𖹾; + #𖹿; + #𘟭; + #𘟮; + #𘟯; + #𘟰; + #𘟱; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0-escaped.js new file mode 100644 index 000000000..d0a8b26ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0-escaped.js @@ -0,0 +1,341 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v11.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u0560; +var \u0588; +var \u05EF; +var \u1878; +var \u1C90; +var \u1C91; +var \u1C92; +var \u1C93; +var \u1C94; +var \u1C95; +var \u1C96; +var \u1C97; +var \u1C98; +var \u1C99; +var \u1C9A; +var \u1C9B; +var \u1C9C; +var \u1C9D; +var \u1C9E; +var \u1C9F; +var \u1CA0; +var \u1CA1; +var \u1CA2; +var \u1CA3; +var \u1CA4; +var \u1CA5; +var \u1CA6; +var \u1CA7; +var \u1CA8; +var \u1CA9; +var \u1CAA; +var \u1CAB; +var \u1CAC; +var \u1CAD; +var \u1CAE; +var \u1CAF; +var \u1CB0; +var \u1CB1; +var \u1CB2; +var \u1CB3; +var \u1CB4; +var \u1CB5; +var \u1CB6; +var \u1CB7; +var \u1CB8; +var \u1CB9; +var \u1CBA; +var \u1CBD; +var \u1CBE; +var \u1CBF; +var \u312F; +var \u9FEB; +var \u9FEC; +var \u9FED; +var \u9FEE; +var \u9FEF; +var \uA7AF; +var \uA7B8; +var \uA7B9; +var \uA8FE; +var \u{10A34}; +var \u{10A35}; +var \u{10D00}; +var \u{10D01}; +var \u{10D02}; +var \u{10D03}; +var \u{10D04}; +var \u{10D05}; +var \u{10D06}; +var \u{10D07}; +var \u{10D08}; +var \u{10D09}; +var \u{10D0A}; +var \u{10D0B}; +var \u{10D0C}; +var \u{10D0D}; +var \u{10D0E}; +var \u{10D0F}; +var \u{10D10}; +var \u{10D11}; +var \u{10D12}; +var \u{10D13}; +var \u{10D14}; +var \u{10D15}; +var \u{10D16}; +var \u{10D17}; +var \u{10D18}; +var \u{10D19}; +var \u{10D1A}; +var \u{10D1B}; +var \u{10D1C}; +var \u{10D1D}; +var \u{10D1E}; +var \u{10D1F}; +var \u{10D20}; +var \u{10D21}; +var \u{10D22}; +var \u{10D23}; +var \u{10F00}; +var \u{10F01}; +var \u{10F02}; +var \u{10F03}; +var \u{10F04}; +var \u{10F05}; +var \u{10F06}; +var \u{10F07}; +var \u{10F08}; +var \u{10F09}; +var \u{10F0A}; +var \u{10F0B}; +var \u{10F0C}; +var \u{10F0D}; +var \u{10F0E}; +var \u{10F0F}; +var \u{10F10}; +var \u{10F11}; +var \u{10F12}; +var \u{10F13}; +var \u{10F14}; +var \u{10F15}; +var \u{10F16}; +var \u{10F17}; +var \u{10F18}; +var \u{10F19}; +var \u{10F1A}; +var \u{10F1B}; +var \u{10F1C}; +var \u{10F27}; +var \u{10F30}; +var \u{10F31}; +var \u{10F32}; +var \u{10F33}; +var \u{10F34}; +var \u{10F35}; +var \u{10F36}; +var \u{10F37}; +var \u{10F38}; +var \u{10F39}; +var \u{10F3A}; +var \u{10F3B}; +var \u{10F3C}; +var \u{10F3D}; +var \u{10F3E}; +var \u{10F3F}; +var \u{10F40}; +var \u{10F41}; +var \u{10F42}; +var \u{10F43}; +var \u{10F44}; +var \u{10F45}; +var \u{11144}; +var \u{1171A}; +var \u{11800}; +var \u{11801}; +var \u{11802}; +var \u{11803}; +var \u{11804}; +var \u{11805}; +var \u{11806}; +var \u{11807}; +var \u{11808}; +var \u{11809}; +var \u{1180A}; +var \u{1180B}; +var \u{1180C}; +var \u{1180D}; +var \u{1180E}; +var \u{1180F}; +var \u{11810}; +var \u{11811}; +var \u{11812}; +var \u{11813}; +var \u{11814}; +var \u{11815}; +var \u{11816}; +var \u{11817}; +var \u{11818}; +var \u{11819}; +var \u{1181A}; +var \u{1181B}; +var \u{1181C}; +var \u{1181D}; +var \u{1181E}; +var \u{1181F}; +var \u{11820}; +var \u{11821}; +var \u{11822}; +var \u{11823}; +var \u{11824}; +var \u{11825}; +var \u{11826}; +var \u{11827}; +var \u{11828}; +var \u{11829}; +var \u{1182A}; +var \u{1182B}; +var \u{11A9D}; +var \u{11D60}; +var \u{11D61}; +var \u{11D62}; +var \u{11D63}; +var \u{11D64}; +var \u{11D65}; +var \u{11D67}; +var \u{11D68}; +var \u{11D6A}; +var \u{11D6B}; +var \u{11D6C}; +var \u{11D6D}; +var \u{11D6E}; +var \u{11D6F}; +var \u{11D70}; +var \u{11D71}; +var \u{11D72}; +var \u{11D73}; +var \u{11D74}; +var \u{11D75}; +var \u{11D76}; +var \u{11D77}; +var \u{11D78}; +var \u{11D79}; +var \u{11D7A}; +var \u{11D7B}; +var \u{11D7C}; +var \u{11D7D}; +var \u{11D7E}; +var \u{11D7F}; +var \u{11D80}; +var \u{11D81}; +var \u{11D82}; +var \u{11D83}; +var \u{11D84}; +var \u{11D85}; +var \u{11D86}; +var \u{11D87}; +var \u{11D88}; +var \u{11D89}; +var \u{11D98}; +var \u{11EE0}; +var \u{11EE1}; +var \u{11EE2}; +var \u{11EE3}; +var \u{11EE4}; +var \u{11EE5}; +var \u{11EE6}; +var \u{11EE7}; +var \u{11EE8}; +var \u{11EE9}; +var \u{11EEA}; +var \u{11EEB}; +var \u{11EEC}; +var \u{11EED}; +var \u{11EEE}; +var \u{11EEF}; +var \u{11EF0}; +var \u{11EF1}; +var \u{11EF2}; +var \u{16E40}; +var \u{16E41}; +var \u{16E42}; +var \u{16E43}; +var \u{16E44}; +var \u{16E45}; +var \u{16E46}; +var \u{16E47}; +var \u{16E48}; +var \u{16E49}; +var \u{16E4A}; +var \u{16E4B}; +var \u{16E4C}; +var \u{16E4D}; +var \u{16E4E}; +var \u{16E4F}; +var \u{16E50}; +var \u{16E51}; +var \u{16E52}; +var \u{16E53}; +var \u{16E54}; +var \u{16E55}; +var \u{16E56}; +var \u{16E57}; +var \u{16E58}; +var \u{16E59}; +var \u{16E5A}; +var \u{16E5B}; +var \u{16E5C}; +var \u{16E5D}; +var \u{16E5E}; +var \u{16E5F}; +var \u{16E60}; +var \u{16E61}; +var \u{16E62}; +var \u{16E63}; +var \u{16E64}; +var \u{16E65}; +var \u{16E66}; +var \u{16E67}; +var \u{16E68}; +var \u{16E69}; +var \u{16E6A}; +var \u{16E6B}; +var \u{16E6C}; +var \u{16E6D}; +var \u{16E6E}; +var \u{16E6F}; +var \u{16E70}; +var \u{16E71}; +var \u{16E72}; +var \u{16E73}; +var \u{16E74}; +var \u{16E75}; +var \u{16E76}; +var \u{16E77}; +var \u{16E78}; +var \u{16E79}; +var \u{16E7A}; +var \u{16E7B}; +var \u{16E7C}; +var \u{16E7D}; +var \u{16E7E}; +var \u{16E7F}; +var \u{187ED}; +var \u{187EE}; +var \u{187EF}; +var \u{187F0}; +var \u{187F1}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0.js new file mode 100644 index 000000000..873928242 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-11.0.0.js @@ -0,0 +1,339 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v11.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var ՠ; +var ֈ; +var ׯ; +var ᡸ; +var Ა; +var Ბ; +var Გ; +var Დ; +var Ე; +var Ვ; +var Ზ; +var Თ; +var Ი; +var Კ; +var Ლ; +var Მ; +var Ნ; +var Ო; +var Პ; +var Ჟ; +var Რ; +var Ს; +var Ტ; +var Უ; +var Ფ; +var Ქ; +var Ღ; +var Ყ; +var Შ; +var Ჩ; +var Ც; +var Ძ; +var Წ; +var Ჭ; +var Ხ; +var Ჯ; +var Ჰ; +var Ჱ; +var Ჲ; +var Ჳ; +var Ჴ; +var Ჵ; +var Ჶ; +var Ჷ; +var Ჸ; +var Ჹ; +var Ჺ; +var Ჽ; +var Ჾ; +var Ჿ; +var ㄯ; +var 鿫; +var 鿬; +var 鿭; +var 鿮; +var 鿯; +var ꞯ; +var Ꞹ; +var ꞹ; +var ꣾ; +var 𐨴; +var 𐨵; +var 𐴀; +var 𐴁; +var 𐴂; +var 𐴃; +var 𐴄; +var 𐴅; +var 𐴆; +var 𐴇; +var 𐴈; +var 𐴉; +var 𐴊; +var 𐴋; +var 𐴌; +var 𐴍; +var 𐴎; +var 𐴏; +var 𐴐; +var 𐴑; +var 𐴒; +var 𐴓; +var 𐴔; +var 𐴕; +var 𐴖; +var 𐴗; +var 𐴘; +var 𐴙; +var 𐴚; +var 𐴛; +var 𐴜; +var 𐴝; +var 𐴞; +var 𐴟; +var 𐴠; +var 𐴡; +var 𐴢; +var 𐴣; +var 𐼀; +var 𐼁; +var 𐼂; +var 𐼃; +var 𐼄; +var 𐼅; +var 𐼆; +var 𐼇; +var 𐼈; +var 𐼉; +var 𐼊; +var 𐼋; +var 𐼌; +var 𐼍; +var 𐼎; +var 𐼏; +var 𐼐; +var 𐼑; +var 𐼒; +var 𐼓; +var 𐼔; +var 𐼕; +var 𐼖; +var 𐼗; +var 𐼘; +var 𐼙; +var 𐼚; +var 𐼛; +var 𐼜; +var 𐼧; +var 𐼰; +var 𐼱; +var 𐼲; +var 𐼳; +var 𐼴; +var 𐼵; +var 𐼶; +var 𐼷; +var 𐼸; +var 𐼹; +var 𐼺; +var 𐼻; +var 𐼼; +var 𐼽; +var 𐼾; +var 𐼿; +var 𐽀; +var 𐽁; +var 𐽂; +var 𐽃; +var 𐽄; +var 𐽅; +var 𑅄; +var 𑜚; +var 𑠀; +var 𑠁; +var 𑠂; +var 𑠃; +var 𑠄; +var 𑠅; +var 𑠆; +var 𑠇; +var 𑠈; +var 𑠉; +var 𑠊; +var 𑠋; +var 𑠌; +var 𑠍; +var 𑠎; +var 𑠏; +var 𑠐; +var 𑠑; +var 𑠒; +var 𑠓; +var 𑠔; +var 𑠕; +var 𑠖; +var 𑠗; +var 𑠘; +var 𑠙; +var 𑠚; +var 𑠛; +var 𑠜; +var 𑠝; +var 𑠞; +var 𑠟; +var 𑠠; +var 𑠡; +var 𑠢; +var 𑠣; +var 𑠤; +var 𑠥; +var 𑠦; +var 𑠧; +var 𑠨; +var 𑠩; +var 𑠪; +var 𑠫; +var 𑪝; +var 𑵠; +var 𑵡; +var 𑵢; +var 𑵣; +var 𑵤; +var 𑵥; +var 𑵧; +var 𑵨; +var 𑵪; +var 𑵫; +var 𑵬; +var 𑵭; +var 𑵮; +var 𑵯; +var 𑵰; +var 𑵱; +var 𑵲; +var 𑵳; +var 𑵴; +var 𑵵; +var 𑵶; +var 𑵷; +var 𑵸; +var 𑵹; +var 𑵺; +var 𑵻; +var 𑵼; +var 𑵽; +var 𑵾; +var 𑵿; +var 𑶀; +var 𑶁; +var 𑶂; +var 𑶃; +var 𑶄; +var 𑶅; +var 𑶆; +var 𑶇; +var 𑶈; +var 𑶉; +var 𑶘; +var 𑻠; +var 𑻡; +var 𑻢; +var 𑻣; +var 𑻤; +var 𑻥; +var 𑻦; +var 𑻧; +var 𑻨; +var 𑻩; +var 𑻪; +var 𑻫; +var 𑻬; +var 𑻭; +var 𑻮; +var 𑻯; +var 𑻰; +var 𑻱; +var 𑻲; +var 𖹀; +var 𖹁; +var 𖹂; +var 𖹃; +var 𖹄; +var 𖹅; +var 𖹆; +var 𖹇; +var 𖹈; +var 𖹉; +var 𖹊; +var 𖹋; +var 𖹌; +var 𖹍; +var 𖹎; +var 𖹏; +var 𖹐; +var 𖹑; +var 𖹒; +var 𖹓; +var 𖹔; +var 𖹕; +var 𖹖; +var 𖹗; +var 𖹘; +var 𖹙; +var 𖹚; +var 𖹛; +var 𖹜; +var 𖹝; +var 𖹞; +var 𖹟; +var 𖹠; +var 𖹡; +var 𖹢; +var 𖹣; +var 𖹤; +var 𖹥; +var 𖹦; +var 𖹧; +var 𖹨; +var 𖹩; +var 𖹪; +var 𖹫; +var 𖹬; +var 𖹭; +var 𖹮; +var 𖹯; +var 𖹰; +var 𖹱; +var 𖹲; +var 𖹳; +var 𖹴; +var 𖹵; +var 𖹶; +var 𖹷; +var 𖹸; +var 𖹹; +var 𖹺; +var 𖹻; +var 𖹼; +var 𖹽; +var 𖹾; +var 𖹿; +var 𘟭; +var 𘟮; +var 𘟯; +var 𘟰; +var 𘟱; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0-class-escaped.js new file mode 100644 index 000000000..08fee3267 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0-class-escaped.js @@ -0,0 +1,243 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v12.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u0E86; + #\u0E89; + #\u0E8C; + #\u0E8E; + #\u0E8F; + #\u0E90; + #\u0E91; + #\u0E92; + #\u0E93; + #\u0E98; + #\u0EA0; + #\u0EA8; + #\u0EA9; + #\u0EAC; + #\u1CF2; + #\u1CF3; + #\u1CFA; + #\uA7BA; + #\uA7BB; + #\uA7BC; + #\uA7BD; + #\uA7BE; + #\uA7BF; + #\uA7C2; + #\uA7C3; + #\uA7C4; + #\uA7C5; + #\uA7C6; + #\uAB66; + #\uAB67; + #\u{10FE0}; + #\u{10FE1}; + #\u{10FE2}; + #\u{10FE3}; + #\u{10FE4}; + #\u{10FE5}; + #\u{10FE6}; + #\u{10FE7}; + #\u{10FE8}; + #\u{10FE9}; + #\u{10FEA}; + #\u{10FEB}; + #\u{10FEC}; + #\u{10FED}; + #\u{10FEE}; + #\u{10FEF}; + #\u{10FF0}; + #\u{10FF1}; + #\u{10FF2}; + #\u{10FF3}; + #\u{10FF4}; + #\u{10FF5}; + #\u{10FF6}; + #\u{1145F}; + #\u{116B8}; + #\u{119A0}; + #\u{119A1}; + #\u{119A2}; + #\u{119A3}; + #\u{119A4}; + #\u{119A5}; + #\u{119A6}; + #\u{119A7}; + #\u{119AA}; + #\u{119AB}; + #\u{119AC}; + #\u{119AD}; + #\u{119AE}; + #\u{119AF}; + #\u{119B0}; + #\u{119B1}; + #\u{119B2}; + #\u{119B3}; + #\u{119B4}; + #\u{119B5}; + #\u{119B6}; + #\u{119B7}; + #\u{119B8}; + #\u{119B9}; + #\u{119BA}; + #\u{119BB}; + #\u{119BC}; + #\u{119BD}; + #\u{119BE}; + #\u{119BF}; + #\u{119C0}; + #\u{119C1}; + #\u{119C2}; + #\u{119C3}; + #\u{119C4}; + #\u{119C5}; + #\u{119C6}; + #\u{119C7}; + #\u{119C8}; + #\u{119C9}; + #\u{119CA}; + #\u{119CB}; + #\u{119CC}; + #\u{119CD}; + #\u{119CE}; + #\u{119CF}; + #\u{119D0}; + #\u{119E1}; + #\u{119E3}; + #\u{11A84}; + #\u{11A85}; + #\u{16F45}; + #\u{16F46}; + #\u{16F47}; + #\u{16F48}; + #\u{16F49}; + #\u{16F4A}; + #\u{16FE3}; + #\u{187F2}; + #\u{187F3}; + #\u{187F4}; + #\u{187F5}; + #\u{187F6}; + #\u{187F7}; + #\u{1B150}; + #\u{1B151}; + #\u{1B152}; + #\u{1B164}; + #\u{1B165}; + #\u{1B166}; + #\u{1B167}; + #\u{1E100}; + #\u{1E101}; + #\u{1E102}; + #\u{1E103}; + #\u{1E104}; + #\u{1E105}; + #\u{1E106}; + #\u{1E107}; + #\u{1E108}; + #\u{1E109}; + #\u{1E10A}; + #\u{1E10B}; + #\u{1E10C}; + #\u{1E10D}; + #\u{1E10E}; + #\u{1E10F}; + #\u{1E110}; + #\u{1E111}; + #\u{1E112}; + #\u{1E113}; + #\u{1E114}; + #\u{1E115}; + #\u{1E116}; + #\u{1E117}; + #\u{1E118}; + #\u{1E119}; + #\u{1E11A}; + #\u{1E11B}; + #\u{1E11C}; + #\u{1E11D}; + #\u{1E11E}; + #\u{1E11F}; + #\u{1E120}; + #\u{1E121}; + #\u{1E122}; + #\u{1E123}; + #\u{1E124}; + #\u{1E125}; + #\u{1E126}; + #\u{1E127}; + #\u{1E128}; + #\u{1E129}; + #\u{1E12A}; + #\u{1E12B}; + #\u{1E12C}; + #\u{1E137}; + #\u{1E138}; + #\u{1E139}; + #\u{1E13A}; + #\u{1E13B}; + #\u{1E13C}; + #\u{1E13D}; + #\u{1E14E}; + #\u{1E2C0}; + #\u{1E2C1}; + #\u{1E2C2}; + #\u{1E2C3}; + #\u{1E2C4}; + #\u{1E2C5}; + #\u{1E2C6}; + #\u{1E2C7}; + #\u{1E2C8}; + #\u{1E2C9}; + #\u{1E2CA}; + #\u{1E2CB}; + #\u{1E2CC}; + #\u{1E2CD}; + #\u{1E2CE}; + #\u{1E2CF}; + #\u{1E2D0}; + #\u{1E2D1}; + #\u{1E2D2}; + #\u{1E2D3}; + #\u{1E2D4}; + #\u{1E2D5}; + #\u{1E2D6}; + #\u{1E2D7}; + #\u{1E2D8}; + #\u{1E2D9}; + #\u{1E2DA}; + #\u{1E2DB}; + #\u{1E2DC}; + #\u{1E2DD}; + #\u{1E2DE}; + #\u{1E2DF}; + #\u{1E2E0}; + #\u{1E2E1}; + #\u{1E2E2}; + #\u{1E2E3}; + #\u{1E2E4}; + #\u{1E2E5}; + #\u{1E2E6}; + #\u{1E2E7}; + #\u{1E2E8}; + #\u{1E2E9}; + #\u{1E2EA}; + #\u{1E2EB}; + #\u{1E94B}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0-class.js new file mode 100644 index 000000000..a14bd47f5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0-class.js @@ -0,0 +1,240 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v12.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #ຆ; + #ຉ; + #ຌ; + #ຎ; + #ຏ; + #ຐ; + #ຑ; + #ຒ; + #ຓ; + #ຘ; + #ຠ; + #ຨ; + #ຩ; + #ຬ; + #ᳲ; + #ᳳ; + #ᳺ; + #Ꞻ; + #ꞻ; + #Ꞽ; + #ꞽ; + #Ꞿ; + #ꞿ; + #Ꟃ; + #ꟃ; + #Ꞔ; + #Ʂ; + #Ᶎ; + #ꭦ; + #ꭧ; + #𐿠; + #𐿡; + #𐿢; + #𐿣; + #𐿤; + #𐿥; + #𐿦; + #𐿧; + #𐿨; + #𐿩; + #𐿪; + #𐿫; + #𐿬; + #𐿭; + #𐿮; + #𐿯; + #𐿰; + #𐿱; + #𐿲; + #𐿳; + #𐿴; + #𐿵; + #𐿶; + #𑑟; + #𑚸; + #𑦠; + #𑦡; + #𑦢; + #𑦣; + #𑦤; + #𑦥; + #𑦦; + #𑦧; + #𑦪; + #𑦫; + #𑦬; + #𑦭; + #𑦮; + #𑦯; + #𑦰; + #𑦱; + #𑦲; + #𑦳; + #𑦴; + #𑦵; + #𑦶; + #𑦷; + #𑦸; + #𑦹; + #𑦺; + #𑦻; + #𑦼; + #𑦽; + #𑦾; + #𑦿; + #𑧀; + #𑧁; + #𑧂; + #𑧃; + #𑧄; + #𑧅; + #𑧆; + #𑧇; + #𑧈; + #𑧉; + #𑧊; + #𑧋; + #𑧌; + #𑧍; + #𑧎; + #𑧏; + #𑧐; + #𑧡; + #𑧣; + #𑪄; + #𑪅; + #𖽅; + #𖽆; + #𖽇; + #𖽈; + #𖽉; + #𖽊; + #𖿣; + #𘟲; + #𘟳; + #𘟴; + #𘟵; + #𘟶; + #𘟷; + #𛅐; + #𛅑; + #𛅒; + #𛅤; + #𛅥; + #𛅦; + #𛅧; + #𞄀; + #𞄁; + #𞄂; + #𞄃; + #𞄄; + #𞄅; + #𞄆; + #𞄇; + #𞄈; + #𞄉; + #𞄊; + #𞄋; + #𞄌; + #𞄍; + #𞄎; + #𞄏; + #𞄐; + #𞄑; + #𞄒; + #𞄓; + #𞄔; + #𞄕; + #𞄖; + #𞄗; + #𞄘; + #𞄙; + #𞄚; + #𞄛; + #𞄜; + #𞄝; + #𞄞; + #𞄟; + #𞄠; + #𞄡; + #𞄢; + #𞄣; + #𞄤; + #𞄥; + #𞄦; + #𞄧; + #𞄨; + #𞄩; + #𞄪; + #𞄫; + #𞄬; + #𞄷; + #𞄸; + #𞄹; + #𞄺; + #𞄻; + #𞄼; + #𞄽; + #𞅎; + #𞋀; + #𞋁; + #𞋂; + #𞋃; + #𞋄; + #𞋅; + #𞋆; + #𞋇; + #𞋈; + #𞋉; + #𞋊; + #𞋋; + #𞋌; + #𞋍; + #𞋎; + #𞋏; + #𞋐; + #𞋑; + #𞋒; + #𞋓; + #𞋔; + #𞋕; + #𞋖; + #𞋗; + #𞋘; + #𞋙; + #𞋚; + #𞋛; + #𞋜; + #𞋝; + #𞋞; + #𞋟; + #𞋠; + #𞋡; + #𞋢; + #𞋣; + #𞋤; + #𞋥; + #𞋦; + #𞋧; + #𞋨; + #𞋩; + #𞋪; + #𞋫; + #𞥋; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0-escaped.js new file mode 100644 index 000000000..c3baaa3f3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0-escaped.js @@ -0,0 +1,239 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v12.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u0E86; +var \u0E89; +var \u0E8C; +var \u0E8E; +var \u0E8F; +var \u0E90; +var \u0E91; +var \u0E92; +var \u0E93; +var \u0E98; +var \u0EA0; +var \u0EA8; +var \u0EA9; +var \u0EAC; +var \u1CF2; +var \u1CF3; +var \u1CFA; +var \uA7BA; +var \uA7BB; +var \uA7BC; +var \uA7BD; +var \uA7BE; +var \uA7BF; +var \uA7C2; +var \uA7C3; +var \uA7C4; +var \uA7C5; +var \uA7C6; +var \uAB66; +var \uAB67; +var \u{10FE0}; +var \u{10FE1}; +var \u{10FE2}; +var \u{10FE3}; +var \u{10FE4}; +var \u{10FE5}; +var \u{10FE6}; +var \u{10FE7}; +var \u{10FE8}; +var \u{10FE9}; +var \u{10FEA}; +var \u{10FEB}; +var \u{10FEC}; +var \u{10FED}; +var \u{10FEE}; +var \u{10FEF}; +var \u{10FF0}; +var \u{10FF1}; +var \u{10FF2}; +var \u{10FF3}; +var \u{10FF4}; +var \u{10FF5}; +var \u{10FF6}; +var \u{1145F}; +var \u{116B8}; +var \u{119A0}; +var \u{119A1}; +var \u{119A2}; +var \u{119A3}; +var \u{119A4}; +var \u{119A5}; +var \u{119A6}; +var \u{119A7}; +var \u{119AA}; +var \u{119AB}; +var \u{119AC}; +var \u{119AD}; +var \u{119AE}; +var \u{119AF}; +var \u{119B0}; +var \u{119B1}; +var \u{119B2}; +var \u{119B3}; +var \u{119B4}; +var \u{119B5}; +var \u{119B6}; +var \u{119B7}; +var \u{119B8}; +var \u{119B9}; +var \u{119BA}; +var \u{119BB}; +var \u{119BC}; +var \u{119BD}; +var \u{119BE}; +var \u{119BF}; +var \u{119C0}; +var \u{119C1}; +var \u{119C2}; +var \u{119C3}; +var \u{119C4}; +var \u{119C5}; +var \u{119C6}; +var \u{119C7}; +var \u{119C8}; +var \u{119C9}; +var \u{119CA}; +var \u{119CB}; +var \u{119CC}; +var \u{119CD}; +var \u{119CE}; +var \u{119CF}; +var \u{119D0}; +var \u{119E1}; +var \u{119E3}; +var \u{11A84}; +var \u{11A85}; +var \u{16F45}; +var \u{16F46}; +var \u{16F47}; +var \u{16F48}; +var \u{16F49}; +var \u{16F4A}; +var \u{16FE3}; +var \u{187F2}; +var \u{187F3}; +var \u{187F4}; +var \u{187F5}; +var \u{187F6}; +var \u{187F7}; +var \u{1B150}; +var \u{1B151}; +var \u{1B152}; +var \u{1B164}; +var \u{1B165}; +var \u{1B166}; +var \u{1B167}; +var \u{1E100}; +var \u{1E101}; +var \u{1E102}; +var \u{1E103}; +var \u{1E104}; +var \u{1E105}; +var \u{1E106}; +var \u{1E107}; +var \u{1E108}; +var \u{1E109}; +var \u{1E10A}; +var \u{1E10B}; +var \u{1E10C}; +var \u{1E10D}; +var \u{1E10E}; +var \u{1E10F}; +var \u{1E110}; +var \u{1E111}; +var \u{1E112}; +var \u{1E113}; +var \u{1E114}; +var \u{1E115}; +var \u{1E116}; +var \u{1E117}; +var \u{1E118}; +var \u{1E119}; +var \u{1E11A}; +var \u{1E11B}; +var \u{1E11C}; +var \u{1E11D}; +var \u{1E11E}; +var \u{1E11F}; +var \u{1E120}; +var \u{1E121}; +var \u{1E122}; +var \u{1E123}; +var \u{1E124}; +var \u{1E125}; +var \u{1E126}; +var \u{1E127}; +var \u{1E128}; +var \u{1E129}; +var \u{1E12A}; +var \u{1E12B}; +var \u{1E12C}; +var \u{1E137}; +var \u{1E138}; +var \u{1E139}; +var \u{1E13A}; +var \u{1E13B}; +var \u{1E13C}; +var \u{1E13D}; +var \u{1E14E}; +var \u{1E2C0}; +var \u{1E2C1}; +var \u{1E2C2}; +var \u{1E2C3}; +var \u{1E2C4}; +var \u{1E2C5}; +var \u{1E2C6}; +var \u{1E2C7}; +var \u{1E2C8}; +var \u{1E2C9}; +var \u{1E2CA}; +var \u{1E2CB}; +var \u{1E2CC}; +var \u{1E2CD}; +var \u{1E2CE}; +var \u{1E2CF}; +var \u{1E2D0}; +var \u{1E2D1}; +var \u{1E2D2}; +var \u{1E2D3}; +var \u{1E2D4}; +var \u{1E2D5}; +var \u{1E2D6}; +var \u{1E2D7}; +var \u{1E2D8}; +var \u{1E2D9}; +var \u{1E2DA}; +var \u{1E2DB}; +var \u{1E2DC}; +var \u{1E2DD}; +var \u{1E2DE}; +var \u{1E2DF}; +var \u{1E2E0}; +var \u{1E2E1}; +var \u{1E2E2}; +var \u{1E2E3}; +var \u{1E2E4}; +var \u{1E2E5}; +var \u{1E2E6}; +var \u{1E2E7}; +var \u{1E2E8}; +var \u{1E2E9}; +var \u{1E2EA}; +var \u{1E2EB}; +var \u{1E94B}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0.js new file mode 100644 index 000000000..c18854059 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-12.0.0.js @@ -0,0 +1,237 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v12.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var ຆ; +var ຉ; +var ຌ; +var ຎ; +var ຏ; +var ຐ; +var ຑ; +var ຒ; +var ຓ; +var ຘ; +var ຠ; +var ຨ; +var ຩ; +var ຬ; +var ᳲ; +var ᳳ; +var ᳺ; +var Ꞻ; +var ꞻ; +var Ꞽ; +var ꞽ; +var Ꞿ; +var ꞿ; +var Ꟃ; +var ꟃ; +var Ꞔ; +var Ʂ; +var Ᶎ; +var ꭦ; +var ꭧ; +var 𐿠; +var 𐿡; +var 𐿢; +var 𐿣; +var 𐿤; +var 𐿥; +var 𐿦; +var 𐿧; +var 𐿨; +var 𐿩; +var 𐿪; +var 𐿫; +var 𐿬; +var 𐿭; +var 𐿮; +var 𐿯; +var 𐿰; +var 𐿱; +var 𐿲; +var 𐿳; +var 𐿴; +var 𐿵; +var 𐿶; +var 𑑟; +var 𑚸; +var 𑦠; +var 𑦡; +var 𑦢; +var 𑦣; +var 𑦤; +var 𑦥; +var 𑦦; +var 𑦧; +var 𑦪; +var 𑦫; +var 𑦬; +var 𑦭; +var 𑦮; +var 𑦯; +var 𑦰; +var 𑦱; +var 𑦲; +var 𑦳; +var 𑦴; +var 𑦵; +var 𑦶; +var 𑦷; +var 𑦸; +var 𑦹; +var 𑦺; +var 𑦻; +var 𑦼; +var 𑦽; +var 𑦾; +var 𑦿; +var 𑧀; +var 𑧁; +var 𑧂; +var 𑧃; +var 𑧄; +var 𑧅; +var 𑧆; +var 𑧇; +var 𑧈; +var 𑧉; +var 𑧊; +var 𑧋; +var 𑧌; +var 𑧍; +var 𑧎; +var 𑧏; +var 𑧐; +var 𑧡; +var 𑧣; +var 𑪄; +var 𑪅; +var 𖽅; +var 𖽆; +var 𖽇; +var 𖽈; +var 𖽉; +var 𖽊; +var 𖿣; +var 𘟲; +var 𘟳; +var 𘟴; +var 𘟵; +var 𘟶; +var 𘟷; +var 𛅐; +var 𛅑; +var 𛅒; +var 𛅤; +var 𛅥; +var 𛅦; +var 𛅧; +var 𞄀; +var 𞄁; +var 𞄂; +var 𞄃; +var 𞄄; +var 𞄅; +var 𞄆; +var 𞄇; +var 𞄈; +var 𞄉; +var 𞄊; +var 𞄋; +var 𞄌; +var 𞄍; +var 𞄎; +var 𞄏; +var 𞄐; +var 𞄑; +var 𞄒; +var 𞄓; +var 𞄔; +var 𞄕; +var 𞄖; +var 𞄗; +var 𞄘; +var 𞄙; +var 𞄚; +var 𞄛; +var 𞄜; +var 𞄝; +var 𞄞; +var 𞄟; +var 𞄠; +var 𞄡; +var 𞄢; +var 𞄣; +var 𞄤; +var 𞄥; +var 𞄦; +var 𞄧; +var 𞄨; +var 𞄩; +var 𞄪; +var 𞄫; +var 𞄬; +var 𞄷; +var 𞄸; +var 𞄹; +var 𞄺; +var 𞄻; +var 𞄼; +var 𞄽; +var 𞅎; +var 𞋀; +var 𞋁; +var 𞋂; +var 𞋃; +var 𞋄; +var 𞋅; +var 𞋆; +var 𞋇; +var 𞋈; +var 𞋉; +var 𞋊; +var 𞋋; +var 𞋌; +var 𞋍; +var 𞋎; +var 𞋏; +var 𞋐; +var 𞋑; +var 𞋒; +var 𞋓; +var 𞋔; +var 𞋕; +var 𞋖; +var 𞋗; +var 𞋘; +var 𞋙; +var 𞋚; +var 𞋛; +var 𞋜; +var 𞋝; +var 𞋞; +var 𞋟; +var 𞋠; +var 𞋡; +var 𞋢; +var 𞋣; +var 𞋤; +var 𞋥; +var 𞋦; +var 𞋧; +var 𞋨; +var 𞋩; +var 𞋪; +var 𞋫; +var 𞥋; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0-class-escaped.js new file mode 100644 index 000000000..a8e1bf34e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0-class-escaped.js @@ -0,0 +1,5617 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v13.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u08BE; + #\u08BF; + #\u08C0; + #\u08C1; + #\u08C2; + #\u08C3; + #\u08C4; + #\u08C5; + #\u08C6; + #\u08C7; + #\u0D04; + #\u31BB; + #\u31BC; + #\u31BD; + #\u31BE; + #\u31BF; + #\u4DB6; + #\u4DB7; + #\u4DB8; + #\u4DB9; + #\u4DBA; + #\u4DBB; + #\u4DBC; + #\u4DBD; + #\u4DBE; + #\u4DBF; + #\u9FF0; + #\u9FF1; + #\u9FF2; + #\u9FF3; + #\u9FF4; + #\u9FF5; + #\u9FF6; + #\u9FF7; + #\u9FF8; + #\u9FF9; + #\u9FFA; + #\u9FFB; + #\u9FFC; + #\uA7C7; + #\uA7C8; + #\uA7C9; + #\uA7CA; + #\uA7F5; + #\uA7F6; + #\uAB68; + #\uAB69; + #\u{10E80}; + #\u{10E81}; + #\u{10E82}; + #\u{10E83}; + #\u{10E84}; + #\u{10E85}; + #\u{10E86}; + #\u{10E87}; + #\u{10E88}; + #\u{10E89}; + #\u{10E8A}; + #\u{10E8B}; + #\u{10E8C}; + #\u{10E8D}; + #\u{10E8E}; + #\u{10E8F}; + #\u{10E90}; + #\u{10E91}; + #\u{10E92}; + #\u{10E93}; + #\u{10E94}; + #\u{10E95}; + #\u{10E96}; + #\u{10E97}; + #\u{10E98}; + #\u{10E99}; + #\u{10E9A}; + #\u{10E9B}; + #\u{10E9C}; + #\u{10E9D}; + #\u{10E9E}; + #\u{10E9F}; + #\u{10EA0}; + #\u{10EA1}; + #\u{10EA2}; + #\u{10EA3}; + #\u{10EA4}; + #\u{10EA5}; + #\u{10EA6}; + #\u{10EA7}; + #\u{10EA8}; + #\u{10EA9}; + #\u{10EB0}; + #\u{10EB1}; + #\u{10FB0}; + #\u{10FB1}; + #\u{10FB2}; + #\u{10FB3}; + #\u{10FB4}; + #\u{10FB5}; + #\u{10FB6}; + #\u{10FB7}; + #\u{10FB8}; + #\u{10FB9}; + #\u{10FBA}; + #\u{10FBB}; + #\u{10FBC}; + #\u{10FBD}; + #\u{10FBE}; + #\u{10FBF}; + #\u{10FC0}; + #\u{10FC1}; + #\u{10FC2}; + #\u{10FC3}; + #\u{10FC4}; + #\u{11147}; + #\u{11460}; + #\u{11461}; + #\u{11900}; + #\u{11901}; + #\u{11902}; + #\u{11903}; + #\u{11904}; + #\u{11905}; + #\u{11906}; + #\u{11909}; + #\u{1190C}; + #\u{1190D}; + #\u{1190E}; + #\u{1190F}; + #\u{11910}; + #\u{11911}; + #\u{11912}; + #\u{11913}; + #\u{11915}; + #\u{11916}; + #\u{11918}; + #\u{11919}; + #\u{1191A}; + #\u{1191B}; + #\u{1191C}; + #\u{1191D}; + #\u{1191E}; + #\u{1191F}; + #\u{11920}; + #\u{11921}; + #\u{11922}; + #\u{11923}; + #\u{11924}; + #\u{11925}; + #\u{11926}; + #\u{11927}; + #\u{11928}; + #\u{11929}; + #\u{1192A}; + #\u{1192B}; + #\u{1192C}; + #\u{1192D}; + #\u{1192E}; + #\u{1192F}; + #\u{1193F}; + #\u{11941}; + #\u{11FB0}; + #\u{18AF3}; + #\u{18AF4}; + #\u{18AF5}; + #\u{18AF6}; + #\u{18AF7}; + #\u{18AF8}; + #\u{18AF9}; + #\u{18AFA}; + #\u{18AFB}; + #\u{18AFC}; + #\u{18AFD}; + #\u{18AFE}; + #\u{18AFF}; + #\u{18B00}; + #\u{18B01}; + #\u{18B02}; + #\u{18B03}; + #\u{18B04}; + #\u{18B05}; + #\u{18B06}; + #\u{18B07}; + #\u{18B08}; + #\u{18B09}; + #\u{18B0A}; + #\u{18B0B}; + #\u{18B0C}; + #\u{18B0D}; + #\u{18B0E}; + #\u{18B0F}; + #\u{18B10}; + #\u{18B11}; + #\u{18B12}; + #\u{18B13}; + #\u{18B14}; + #\u{18B15}; + #\u{18B16}; + #\u{18B17}; + #\u{18B18}; + #\u{18B19}; + #\u{18B1A}; + #\u{18B1B}; + #\u{18B1C}; + #\u{18B1D}; + #\u{18B1E}; + #\u{18B1F}; + #\u{18B20}; + #\u{18B21}; + #\u{18B22}; + #\u{18B23}; + #\u{18B24}; + #\u{18B25}; + #\u{18B26}; + #\u{18B27}; + #\u{18B28}; + #\u{18B29}; + #\u{18B2A}; + #\u{18B2B}; + #\u{18B2C}; + #\u{18B2D}; + #\u{18B2E}; + #\u{18B2F}; + #\u{18B30}; + #\u{18B31}; + #\u{18B32}; + #\u{18B33}; + #\u{18B34}; + #\u{18B35}; + #\u{18B36}; + #\u{18B37}; + #\u{18B38}; + #\u{18B39}; + #\u{18B3A}; + #\u{18B3B}; + #\u{18B3C}; + #\u{18B3D}; + #\u{18B3E}; + #\u{18B3F}; + #\u{18B40}; + #\u{18B41}; + #\u{18B42}; + #\u{18B43}; + #\u{18B44}; + #\u{18B45}; + #\u{18B46}; + #\u{18B47}; + #\u{18B48}; + #\u{18B49}; + #\u{18B4A}; + #\u{18B4B}; + #\u{18B4C}; + #\u{18B4D}; + #\u{18B4E}; + #\u{18B4F}; + #\u{18B50}; + #\u{18B51}; + #\u{18B52}; + #\u{18B53}; + #\u{18B54}; + #\u{18B55}; + #\u{18B56}; + #\u{18B57}; + #\u{18B58}; + #\u{18B59}; + #\u{18B5A}; + #\u{18B5B}; + #\u{18B5C}; + #\u{18B5D}; + #\u{18B5E}; + #\u{18B5F}; + #\u{18B60}; + #\u{18B61}; + #\u{18B62}; + #\u{18B63}; + #\u{18B64}; + #\u{18B65}; + #\u{18B66}; + #\u{18B67}; + #\u{18B68}; + #\u{18B69}; + #\u{18B6A}; + #\u{18B6B}; + #\u{18B6C}; + #\u{18B6D}; + #\u{18B6E}; + #\u{18B6F}; + #\u{18B70}; + #\u{18B71}; + #\u{18B72}; + #\u{18B73}; + #\u{18B74}; + #\u{18B75}; + #\u{18B76}; + #\u{18B77}; + #\u{18B78}; + #\u{18B79}; + #\u{18B7A}; + #\u{18B7B}; + #\u{18B7C}; + #\u{18B7D}; + #\u{18B7E}; + #\u{18B7F}; + #\u{18B80}; + #\u{18B81}; + #\u{18B82}; + #\u{18B83}; + #\u{18B84}; + #\u{18B85}; + #\u{18B86}; + #\u{18B87}; + #\u{18B88}; + #\u{18B89}; + #\u{18B8A}; + #\u{18B8B}; + #\u{18B8C}; + #\u{18B8D}; + #\u{18B8E}; + #\u{18B8F}; + #\u{18B90}; + #\u{18B91}; + #\u{18B92}; + #\u{18B93}; + #\u{18B94}; + #\u{18B95}; + #\u{18B96}; + #\u{18B97}; + #\u{18B98}; + #\u{18B99}; + #\u{18B9A}; + #\u{18B9B}; + #\u{18B9C}; + #\u{18B9D}; + #\u{18B9E}; + #\u{18B9F}; + #\u{18BA0}; + #\u{18BA1}; + #\u{18BA2}; + #\u{18BA3}; + #\u{18BA4}; + #\u{18BA5}; + #\u{18BA6}; + #\u{18BA7}; + #\u{18BA8}; + #\u{18BA9}; + #\u{18BAA}; + #\u{18BAB}; + #\u{18BAC}; + #\u{18BAD}; + #\u{18BAE}; + #\u{18BAF}; + #\u{18BB0}; + #\u{18BB1}; + #\u{18BB2}; + #\u{18BB3}; + #\u{18BB4}; + #\u{18BB5}; + #\u{18BB6}; + #\u{18BB7}; + #\u{18BB8}; + #\u{18BB9}; + #\u{18BBA}; + #\u{18BBB}; + #\u{18BBC}; + #\u{18BBD}; + #\u{18BBE}; + #\u{18BBF}; + #\u{18BC0}; + #\u{18BC1}; + #\u{18BC2}; + #\u{18BC3}; + #\u{18BC4}; + #\u{18BC5}; + #\u{18BC6}; + #\u{18BC7}; + #\u{18BC8}; + #\u{18BC9}; + #\u{18BCA}; + #\u{18BCB}; + #\u{18BCC}; + #\u{18BCD}; + #\u{18BCE}; + #\u{18BCF}; + #\u{18BD0}; + #\u{18BD1}; + #\u{18BD2}; + #\u{18BD3}; + #\u{18BD4}; + #\u{18BD5}; + #\u{18BD6}; + #\u{18BD7}; + #\u{18BD8}; + #\u{18BD9}; + #\u{18BDA}; + #\u{18BDB}; + #\u{18BDC}; + #\u{18BDD}; + #\u{18BDE}; + #\u{18BDF}; + #\u{18BE0}; + #\u{18BE1}; + #\u{18BE2}; + #\u{18BE3}; + #\u{18BE4}; + #\u{18BE5}; + #\u{18BE6}; + #\u{18BE7}; + #\u{18BE8}; + #\u{18BE9}; + #\u{18BEA}; + #\u{18BEB}; + #\u{18BEC}; + #\u{18BED}; + #\u{18BEE}; + #\u{18BEF}; + #\u{18BF0}; + #\u{18BF1}; + #\u{18BF2}; + #\u{18BF3}; + #\u{18BF4}; + #\u{18BF5}; + #\u{18BF6}; + #\u{18BF7}; + #\u{18BF8}; + #\u{18BF9}; + #\u{18BFA}; + #\u{18BFB}; + #\u{18BFC}; + #\u{18BFD}; + #\u{18BFE}; + #\u{18BFF}; + #\u{18C00}; + #\u{18C01}; + #\u{18C02}; + #\u{18C03}; + #\u{18C04}; + #\u{18C05}; + #\u{18C06}; + #\u{18C07}; + #\u{18C08}; + #\u{18C09}; + #\u{18C0A}; + #\u{18C0B}; + #\u{18C0C}; + #\u{18C0D}; + #\u{18C0E}; + #\u{18C0F}; + #\u{18C10}; + #\u{18C11}; + #\u{18C12}; + #\u{18C13}; + #\u{18C14}; + #\u{18C15}; + #\u{18C16}; + #\u{18C17}; + #\u{18C18}; + #\u{18C19}; + #\u{18C1A}; + #\u{18C1B}; + #\u{18C1C}; + #\u{18C1D}; + #\u{18C1E}; + #\u{18C1F}; + #\u{18C20}; + #\u{18C21}; + #\u{18C22}; + #\u{18C23}; + #\u{18C24}; + #\u{18C25}; + #\u{18C26}; + #\u{18C27}; + #\u{18C28}; + #\u{18C29}; + #\u{18C2A}; + #\u{18C2B}; + #\u{18C2C}; + #\u{18C2D}; + #\u{18C2E}; + #\u{18C2F}; + #\u{18C30}; + #\u{18C31}; + #\u{18C32}; + #\u{18C33}; + #\u{18C34}; + #\u{18C35}; + #\u{18C36}; + #\u{18C37}; + #\u{18C38}; + #\u{18C39}; + #\u{18C3A}; + #\u{18C3B}; + #\u{18C3C}; + #\u{18C3D}; + #\u{18C3E}; + #\u{18C3F}; + #\u{18C40}; + #\u{18C41}; + #\u{18C42}; + #\u{18C43}; + #\u{18C44}; + #\u{18C45}; + #\u{18C46}; + #\u{18C47}; + #\u{18C48}; + #\u{18C49}; + #\u{18C4A}; + #\u{18C4B}; + #\u{18C4C}; + #\u{18C4D}; + #\u{18C4E}; + #\u{18C4F}; + #\u{18C50}; + #\u{18C51}; + #\u{18C52}; + #\u{18C53}; + #\u{18C54}; + #\u{18C55}; + #\u{18C56}; + #\u{18C57}; + #\u{18C58}; + #\u{18C59}; + #\u{18C5A}; + #\u{18C5B}; + #\u{18C5C}; + #\u{18C5D}; + #\u{18C5E}; + #\u{18C5F}; + #\u{18C60}; + #\u{18C61}; + #\u{18C62}; + #\u{18C63}; + #\u{18C64}; + #\u{18C65}; + #\u{18C66}; + #\u{18C67}; + #\u{18C68}; + #\u{18C69}; + #\u{18C6A}; + #\u{18C6B}; + #\u{18C6C}; + #\u{18C6D}; + #\u{18C6E}; + #\u{18C6F}; + #\u{18C70}; + #\u{18C71}; + #\u{18C72}; + #\u{18C73}; + #\u{18C74}; + #\u{18C75}; + #\u{18C76}; + #\u{18C77}; + #\u{18C78}; + #\u{18C79}; + #\u{18C7A}; + #\u{18C7B}; + #\u{18C7C}; + #\u{18C7D}; + #\u{18C7E}; + #\u{18C7F}; + #\u{18C80}; + #\u{18C81}; + #\u{18C82}; + #\u{18C83}; + #\u{18C84}; + #\u{18C85}; + #\u{18C86}; + #\u{18C87}; + #\u{18C88}; + #\u{18C89}; + #\u{18C8A}; + #\u{18C8B}; + #\u{18C8C}; + #\u{18C8D}; + #\u{18C8E}; + #\u{18C8F}; + #\u{18C90}; + #\u{18C91}; + #\u{18C92}; + #\u{18C93}; + #\u{18C94}; + #\u{18C95}; + #\u{18C96}; + #\u{18C97}; + #\u{18C98}; + #\u{18C99}; + #\u{18C9A}; + #\u{18C9B}; + #\u{18C9C}; + #\u{18C9D}; + #\u{18C9E}; + #\u{18C9F}; + #\u{18CA0}; + #\u{18CA1}; + #\u{18CA2}; + #\u{18CA3}; + #\u{18CA4}; + #\u{18CA5}; + #\u{18CA6}; + #\u{18CA7}; + #\u{18CA8}; + #\u{18CA9}; + #\u{18CAA}; + #\u{18CAB}; + #\u{18CAC}; + #\u{18CAD}; + #\u{18CAE}; + #\u{18CAF}; + #\u{18CB0}; + #\u{18CB1}; + #\u{18CB2}; + #\u{18CB3}; + #\u{18CB4}; + #\u{18CB5}; + #\u{18CB6}; + #\u{18CB7}; + #\u{18CB8}; + #\u{18CB9}; + #\u{18CBA}; + #\u{18CBB}; + #\u{18CBC}; + #\u{18CBD}; + #\u{18CBE}; + #\u{18CBF}; + #\u{18CC0}; + #\u{18CC1}; + #\u{18CC2}; + #\u{18CC3}; + #\u{18CC4}; + #\u{18CC5}; + #\u{18CC6}; + #\u{18CC7}; + #\u{18CC8}; + #\u{18CC9}; + #\u{18CCA}; + #\u{18CCB}; + #\u{18CCC}; + #\u{18CCD}; + #\u{18CCE}; + #\u{18CCF}; + #\u{18CD0}; + #\u{18CD1}; + #\u{18CD2}; + #\u{18CD3}; + #\u{18CD4}; + #\u{18CD5}; + #\u{18D00}; + #\u{18D01}; + #\u{18D02}; + #\u{18D03}; + #\u{18D04}; + #\u{18D05}; + #\u{18D06}; + #\u{18D07}; + #\u{18D08}; + #\u{2A6D7}; + #\u{2A6D8}; + #\u{2A6D9}; + #\u{2A6DA}; + #\u{2A6DB}; + #\u{2A6DC}; + #\u{2A6DD}; + #\u{30000}; + #\u{30001}; + #\u{30002}; + #\u{30003}; + #\u{30004}; + #\u{30005}; + #\u{30006}; + #\u{30007}; + #\u{30008}; + #\u{30009}; + #\u{3000A}; + #\u{3000B}; + #\u{3000C}; + #\u{3000D}; + #\u{3000E}; + #\u{3000F}; + #\u{30010}; + #\u{30011}; + #\u{30012}; + #\u{30013}; + #\u{30014}; + #\u{30015}; + #\u{30016}; + #\u{30017}; + #\u{30018}; + #\u{30019}; + #\u{3001A}; + #\u{3001B}; + #\u{3001C}; + #\u{3001D}; + #\u{3001E}; + #\u{3001F}; + #\u{30020}; + #\u{30021}; + #\u{30022}; + #\u{30023}; + #\u{30024}; + #\u{30025}; + #\u{30026}; + #\u{30027}; + #\u{30028}; + #\u{30029}; + #\u{3002A}; + #\u{3002B}; + #\u{3002C}; + #\u{3002D}; + #\u{3002E}; + #\u{3002F}; + #\u{30030}; + #\u{30031}; + #\u{30032}; + #\u{30033}; + #\u{30034}; + #\u{30035}; + #\u{30036}; + #\u{30037}; + #\u{30038}; + #\u{30039}; + #\u{3003A}; + #\u{3003B}; + #\u{3003C}; + #\u{3003D}; + #\u{3003E}; + #\u{3003F}; + #\u{30040}; + #\u{30041}; + #\u{30042}; + #\u{30043}; + #\u{30044}; + #\u{30045}; + #\u{30046}; + #\u{30047}; + #\u{30048}; + #\u{30049}; + #\u{3004A}; + #\u{3004B}; + #\u{3004C}; + #\u{3004D}; + #\u{3004E}; + #\u{3004F}; + #\u{30050}; + #\u{30051}; + #\u{30052}; + #\u{30053}; + #\u{30054}; + #\u{30055}; + #\u{30056}; + #\u{30057}; + #\u{30058}; + #\u{30059}; + #\u{3005A}; + #\u{3005B}; + #\u{3005C}; + #\u{3005D}; + #\u{3005E}; + #\u{3005F}; + #\u{30060}; + #\u{30061}; + #\u{30062}; + #\u{30063}; + #\u{30064}; + #\u{30065}; + #\u{30066}; + #\u{30067}; + #\u{30068}; + #\u{30069}; + #\u{3006A}; + #\u{3006B}; + #\u{3006C}; + #\u{3006D}; + #\u{3006E}; + #\u{3006F}; + #\u{30070}; + #\u{30071}; + #\u{30072}; + #\u{30073}; + #\u{30074}; + #\u{30075}; + #\u{30076}; + #\u{30077}; + #\u{30078}; + #\u{30079}; + #\u{3007A}; + #\u{3007B}; + #\u{3007C}; + #\u{3007D}; + #\u{3007E}; + #\u{3007F}; + #\u{30080}; + #\u{30081}; + #\u{30082}; + #\u{30083}; + #\u{30084}; + #\u{30085}; + #\u{30086}; + #\u{30087}; + #\u{30088}; + #\u{30089}; + #\u{3008A}; + #\u{3008B}; + #\u{3008C}; + #\u{3008D}; + #\u{3008E}; + #\u{3008F}; + #\u{30090}; + #\u{30091}; + #\u{30092}; + #\u{30093}; + #\u{30094}; + #\u{30095}; + #\u{30096}; + #\u{30097}; + #\u{30098}; + #\u{30099}; + #\u{3009A}; + #\u{3009B}; + #\u{3009C}; + #\u{3009D}; + #\u{3009E}; + #\u{3009F}; + #\u{300A0}; + #\u{300A1}; + #\u{300A2}; + #\u{300A3}; + #\u{300A4}; + #\u{300A5}; + #\u{300A6}; + #\u{300A7}; + #\u{300A8}; + #\u{300A9}; + #\u{300AA}; + #\u{300AB}; + #\u{300AC}; + #\u{300AD}; + #\u{300AE}; + #\u{300AF}; + #\u{300B0}; + #\u{300B1}; + #\u{300B2}; + #\u{300B3}; + #\u{300B4}; + #\u{300B5}; + #\u{300B6}; + #\u{300B7}; + #\u{300B8}; + #\u{300B9}; + #\u{300BA}; + #\u{300BB}; + #\u{300BC}; + #\u{300BD}; + #\u{300BE}; + #\u{300BF}; + #\u{300C0}; + #\u{300C1}; + #\u{300C2}; + #\u{300C3}; + #\u{300C4}; + #\u{300C5}; + #\u{300C6}; + #\u{300C7}; + #\u{300C8}; + #\u{300C9}; + #\u{300CA}; + #\u{300CB}; + #\u{300CC}; + #\u{300CD}; + #\u{300CE}; + #\u{300CF}; + #\u{300D0}; + #\u{300D1}; + #\u{300D2}; + #\u{300D3}; + #\u{300D4}; + #\u{300D5}; + #\u{300D6}; + #\u{300D7}; + #\u{300D8}; + #\u{300D9}; + #\u{300DA}; + #\u{300DB}; + #\u{300DC}; + #\u{300DD}; + #\u{300DE}; + #\u{300DF}; + #\u{300E0}; + #\u{300E1}; + #\u{300E2}; + #\u{300E3}; + #\u{300E4}; + #\u{300E5}; + #\u{300E6}; + #\u{300E7}; + #\u{300E8}; + #\u{300E9}; + #\u{300EA}; + #\u{300EB}; + #\u{300EC}; + #\u{300ED}; + #\u{300EE}; + #\u{300EF}; + #\u{300F0}; + #\u{300F1}; + #\u{300F2}; + #\u{300F3}; + #\u{300F4}; + #\u{300F5}; + #\u{300F6}; + #\u{300F7}; + #\u{300F8}; + #\u{300F9}; + #\u{300FA}; + #\u{300FB}; + #\u{300FC}; + #\u{300FD}; + #\u{300FE}; + #\u{300FF}; + #\u{30100}; + #\u{30101}; + #\u{30102}; + #\u{30103}; + #\u{30104}; + #\u{30105}; + #\u{30106}; + #\u{30107}; + #\u{30108}; + #\u{30109}; + #\u{3010A}; + #\u{3010B}; + #\u{3010C}; + #\u{3010D}; + #\u{3010E}; + #\u{3010F}; + #\u{30110}; + #\u{30111}; + #\u{30112}; + #\u{30113}; + #\u{30114}; + #\u{30115}; + #\u{30116}; + #\u{30117}; + #\u{30118}; + #\u{30119}; + #\u{3011A}; + #\u{3011B}; + #\u{3011C}; + #\u{3011D}; + #\u{3011E}; + #\u{3011F}; + #\u{30120}; + #\u{30121}; + #\u{30122}; + #\u{30123}; + #\u{30124}; + #\u{30125}; + #\u{30126}; + #\u{30127}; + #\u{30128}; + #\u{30129}; + #\u{3012A}; + #\u{3012B}; + #\u{3012C}; + #\u{3012D}; + #\u{3012E}; + #\u{3012F}; + #\u{30130}; + #\u{30131}; + #\u{30132}; + #\u{30133}; + #\u{30134}; + #\u{30135}; + #\u{30136}; + #\u{30137}; + #\u{30138}; + #\u{30139}; + #\u{3013A}; + #\u{3013B}; + #\u{3013C}; + #\u{3013D}; + #\u{3013E}; + #\u{3013F}; + #\u{30140}; + #\u{30141}; + #\u{30142}; + #\u{30143}; + #\u{30144}; + #\u{30145}; + #\u{30146}; + #\u{30147}; + #\u{30148}; + #\u{30149}; + #\u{3014A}; + #\u{3014B}; + #\u{3014C}; + #\u{3014D}; + #\u{3014E}; + #\u{3014F}; + #\u{30150}; + #\u{30151}; + #\u{30152}; + #\u{30153}; + #\u{30154}; + #\u{30155}; + #\u{30156}; + #\u{30157}; + #\u{30158}; + #\u{30159}; + #\u{3015A}; + #\u{3015B}; + #\u{3015C}; + #\u{3015D}; + #\u{3015E}; + #\u{3015F}; + #\u{30160}; + #\u{30161}; + #\u{30162}; + #\u{30163}; + #\u{30164}; + #\u{30165}; + #\u{30166}; + #\u{30167}; + #\u{30168}; + #\u{30169}; + #\u{3016A}; + #\u{3016B}; + #\u{3016C}; + #\u{3016D}; + #\u{3016E}; + #\u{3016F}; + #\u{30170}; + #\u{30171}; + #\u{30172}; + #\u{30173}; + #\u{30174}; + #\u{30175}; + #\u{30176}; + #\u{30177}; + #\u{30178}; + #\u{30179}; + #\u{3017A}; + #\u{3017B}; + #\u{3017C}; + #\u{3017D}; + #\u{3017E}; + #\u{3017F}; + #\u{30180}; + #\u{30181}; + #\u{30182}; + #\u{30183}; + #\u{30184}; + #\u{30185}; + #\u{30186}; + #\u{30187}; + #\u{30188}; + #\u{30189}; + #\u{3018A}; + #\u{3018B}; + #\u{3018C}; + #\u{3018D}; + #\u{3018E}; + #\u{3018F}; + #\u{30190}; + #\u{30191}; + #\u{30192}; + #\u{30193}; + #\u{30194}; + #\u{30195}; + #\u{30196}; + #\u{30197}; + #\u{30198}; + #\u{30199}; + #\u{3019A}; + #\u{3019B}; + #\u{3019C}; + #\u{3019D}; + #\u{3019E}; + #\u{3019F}; + #\u{301A0}; + #\u{301A1}; + #\u{301A2}; + #\u{301A3}; + #\u{301A4}; + #\u{301A5}; + #\u{301A6}; + #\u{301A7}; + #\u{301A8}; + #\u{301A9}; + #\u{301AA}; + #\u{301AB}; + #\u{301AC}; + #\u{301AD}; + #\u{301AE}; + #\u{301AF}; + #\u{301B0}; + #\u{301B1}; + #\u{301B2}; + #\u{301B3}; + #\u{301B4}; + #\u{301B5}; + #\u{301B6}; + #\u{301B7}; + #\u{301B8}; + #\u{301B9}; + #\u{301BA}; + #\u{301BB}; + #\u{301BC}; + #\u{301BD}; + #\u{301BE}; + #\u{301BF}; + #\u{301C0}; + #\u{301C1}; + #\u{301C2}; + #\u{301C3}; + #\u{301C4}; + #\u{301C5}; + #\u{301C6}; + #\u{301C7}; + #\u{301C8}; + #\u{301C9}; + #\u{301CA}; + #\u{301CB}; + #\u{301CC}; + #\u{301CD}; + #\u{301CE}; + #\u{301CF}; + #\u{301D0}; + #\u{301D1}; + #\u{301D2}; + #\u{301D3}; + #\u{301D4}; + #\u{301D5}; + #\u{301D6}; + #\u{301D7}; + #\u{301D8}; + #\u{301D9}; + #\u{301DA}; + #\u{301DB}; + #\u{301DC}; + #\u{301DD}; + #\u{301DE}; + #\u{301DF}; + #\u{301E0}; + #\u{301E1}; + #\u{301E2}; + #\u{301E3}; + #\u{301E4}; + #\u{301E5}; + #\u{301E6}; + #\u{301E7}; + #\u{301E8}; + #\u{301E9}; + #\u{301EA}; + #\u{301EB}; + #\u{301EC}; + #\u{301ED}; + #\u{301EE}; + #\u{301EF}; + #\u{301F0}; + #\u{301F1}; + #\u{301F2}; + #\u{301F3}; + #\u{301F4}; + #\u{301F5}; + #\u{301F6}; + #\u{301F7}; + #\u{301F8}; + #\u{301F9}; + #\u{301FA}; + #\u{301FB}; + #\u{301FC}; + #\u{301FD}; + #\u{301FE}; + #\u{301FF}; + #\u{30200}; + #\u{30201}; + #\u{30202}; + #\u{30203}; + #\u{30204}; + #\u{30205}; + #\u{30206}; + #\u{30207}; + #\u{30208}; + #\u{30209}; + #\u{3020A}; + #\u{3020B}; + #\u{3020C}; + #\u{3020D}; + #\u{3020E}; + #\u{3020F}; + #\u{30210}; + #\u{30211}; + #\u{30212}; + #\u{30213}; + #\u{30214}; + #\u{30215}; + #\u{30216}; + #\u{30217}; + #\u{30218}; + #\u{30219}; + #\u{3021A}; + #\u{3021B}; + #\u{3021C}; + #\u{3021D}; + #\u{3021E}; + #\u{3021F}; + #\u{30220}; + #\u{30221}; + #\u{30222}; + #\u{30223}; + #\u{30224}; + #\u{30225}; + #\u{30226}; + #\u{30227}; + #\u{30228}; + #\u{30229}; + #\u{3022A}; + #\u{3022B}; + #\u{3022C}; + #\u{3022D}; + #\u{3022E}; + #\u{3022F}; + #\u{30230}; + #\u{30231}; + #\u{30232}; + #\u{30233}; + #\u{30234}; + #\u{30235}; + #\u{30236}; + #\u{30237}; + #\u{30238}; + #\u{30239}; + #\u{3023A}; + #\u{3023B}; + #\u{3023C}; + #\u{3023D}; + #\u{3023E}; + #\u{3023F}; + #\u{30240}; + #\u{30241}; + #\u{30242}; + #\u{30243}; + #\u{30244}; + #\u{30245}; + #\u{30246}; + #\u{30247}; + #\u{30248}; + #\u{30249}; + #\u{3024A}; + #\u{3024B}; + #\u{3024C}; + #\u{3024D}; + #\u{3024E}; + #\u{3024F}; + #\u{30250}; + #\u{30251}; + #\u{30252}; + #\u{30253}; + #\u{30254}; + #\u{30255}; + #\u{30256}; + #\u{30257}; + #\u{30258}; + #\u{30259}; + #\u{3025A}; + #\u{3025B}; + #\u{3025C}; + #\u{3025D}; + #\u{3025E}; + #\u{3025F}; + #\u{30260}; + #\u{30261}; + #\u{30262}; + #\u{30263}; + #\u{30264}; + #\u{30265}; + #\u{30266}; + #\u{30267}; + #\u{30268}; + #\u{30269}; + #\u{3026A}; + #\u{3026B}; + #\u{3026C}; + #\u{3026D}; + #\u{3026E}; + #\u{3026F}; + #\u{30270}; + #\u{30271}; + #\u{30272}; + #\u{30273}; + #\u{30274}; + #\u{30275}; + #\u{30276}; + #\u{30277}; + #\u{30278}; + #\u{30279}; + #\u{3027A}; + #\u{3027B}; + #\u{3027C}; + #\u{3027D}; + #\u{3027E}; + #\u{3027F}; + #\u{30280}; + #\u{30281}; + #\u{30282}; + #\u{30283}; + #\u{30284}; + #\u{30285}; + #\u{30286}; + #\u{30287}; + #\u{30288}; + #\u{30289}; + #\u{3028A}; + #\u{3028B}; + #\u{3028C}; + #\u{3028D}; + #\u{3028E}; + #\u{3028F}; + #\u{30290}; + #\u{30291}; + #\u{30292}; + #\u{30293}; + #\u{30294}; + #\u{30295}; + #\u{30296}; + #\u{30297}; + #\u{30298}; + #\u{30299}; + #\u{3029A}; + #\u{3029B}; + #\u{3029C}; + #\u{3029D}; + #\u{3029E}; + #\u{3029F}; + #\u{302A0}; + #\u{302A1}; + #\u{302A2}; + #\u{302A3}; + #\u{302A4}; + #\u{302A5}; + #\u{302A6}; + #\u{302A7}; + #\u{302A8}; + #\u{302A9}; + #\u{302AA}; + #\u{302AB}; + #\u{302AC}; + #\u{302AD}; + #\u{302AE}; + #\u{302AF}; + #\u{302B0}; + #\u{302B1}; + #\u{302B2}; + #\u{302B3}; + #\u{302B4}; + #\u{302B5}; + #\u{302B6}; + #\u{302B7}; + #\u{302B8}; + #\u{302B9}; + #\u{302BA}; + #\u{302BB}; + #\u{302BC}; + #\u{302BD}; + #\u{302BE}; + #\u{302BF}; + #\u{302C0}; + #\u{302C1}; + #\u{302C2}; + #\u{302C3}; + #\u{302C4}; + #\u{302C5}; + #\u{302C6}; + #\u{302C7}; + #\u{302C8}; + #\u{302C9}; + #\u{302CA}; + #\u{302CB}; + #\u{302CC}; + #\u{302CD}; + #\u{302CE}; + #\u{302CF}; + #\u{302D0}; + #\u{302D1}; + #\u{302D2}; + #\u{302D3}; + #\u{302D4}; + #\u{302D5}; + #\u{302D6}; + #\u{302D7}; + #\u{302D8}; + #\u{302D9}; + #\u{302DA}; + #\u{302DB}; + #\u{302DC}; + #\u{302DD}; + #\u{302DE}; + #\u{302DF}; + #\u{302E0}; + #\u{302E1}; + #\u{302E2}; + #\u{302E3}; + #\u{302E4}; + #\u{302E5}; + #\u{302E6}; + #\u{302E7}; + #\u{302E8}; + #\u{302E9}; + #\u{302EA}; + #\u{302EB}; + #\u{302EC}; + #\u{302ED}; + #\u{302EE}; + #\u{302EF}; + #\u{302F0}; + #\u{302F1}; + #\u{302F2}; + #\u{302F3}; + #\u{302F4}; + #\u{302F5}; + #\u{302F6}; + #\u{302F7}; + #\u{302F8}; + #\u{302F9}; + #\u{302FA}; + #\u{302FB}; + #\u{302FC}; + #\u{302FD}; + #\u{302FE}; + #\u{302FF}; + #\u{30300}; + #\u{30301}; + #\u{30302}; + #\u{30303}; + #\u{30304}; + #\u{30305}; + #\u{30306}; + #\u{30307}; + #\u{30308}; + #\u{30309}; + #\u{3030A}; + #\u{3030B}; + #\u{3030C}; + #\u{3030D}; + #\u{3030E}; + #\u{3030F}; + #\u{30310}; + #\u{30311}; + #\u{30312}; + #\u{30313}; + #\u{30314}; + #\u{30315}; + #\u{30316}; + #\u{30317}; + #\u{30318}; + #\u{30319}; + #\u{3031A}; + #\u{3031B}; + #\u{3031C}; + #\u{3031D}; + #\u{3031E}; + #\u{3031F}; + #\u{30320}; + #\u{30321}; + #\u{30322}; + #\u{30323}; + #\u{30324}; + #\u{30325}; + #\u{30326}; + #\u{30327}; + #\u{30328}; + #\u{30329}; + #\u{3032A}; + #\u{3032B}; + #\u{3032C}; + #\u{3032D}; + #\u{3032E}; + #\u{3032F}; + #\u{30330}; + #\u{30331}; + #\u{30332}; + #\u{30333}; + #\u{30334}; + #\u{30335}; + #\u{30336}; + #\u{30337}; + #\u{30338}; + #\u{30339}; + #\u{3033A}; + #\u{3033B}; + #\u{3033C}; + #\u{3033D}; + #\u{3033E}; + #\u{3033F}; + #\u{30340}; + #\u{30341}; + #\u{30342}; + #\u{30343}; + #\u{30344}; + #\u{30345}; + #\u{30346}; + #\u{30347}; + #\u{30348}; + #\u{30349}; + #\u{3034A}; + #\u{3034B}; + #\u{3034C}; + #\u{3034D}; + #\u{3034E}; + #\u{3034F}; + #\u{30350}; + #\u{30351}; + #\u{30352}; + #\u{30353}; + #\u{30354}; + #\u{30355}; + #\u{30356}; + #\u{30357}; + #\u{30358}; + #\u{30359}; + #\u{3035A}; + #\u{3035B}; + #\u{3035C}; + #\u{3035D}; + #\u{3035E}; + #\u{3035F}; + #\u{30360}; + #\u{30361}; + #\u{30362}; + #\u{30363}; + #\u{30364}; + #\u{30365}; + #\u{30366}; + #\u{30367}; + #\u{30368}; + #\u{30369}; + #\u{3036A}; + #\u{3036B}; + #\u{3036C}; + #\u{3036D}; + #\u{3036E}; + #\u{3036F}; + #\u{30370}; + #\u{30371}; + #\u{30372}; + #\u{30373}; + #\u{30374}; + #\u{30375}; + #\u{30376}; + #\u{30377}; + #\u{30378}; + #\u{30379}; + #\u{3037A}; + #\u{3037B}; + #\u{3037C}; + #\u{3037D}; + #\u{3037E}; + #\u{3037F}; + #\u{30380}; + #\u{30381}; + #\u{30382}; + #\u{30383}; + #\u{30384}; + #\u{30385}; + #\u{30386}; + #\u{30387}; + #\u{30388}; + #\u{30389}; + #\u{3038A}; + #\u{3038B}; + #\u{3038C}; + #\u{3038D}; + #\u{3038E}; + #\u{3038F}; + #\u{30390}; + #\u{30391}; + #\u{30392}; + #\u{30393}; + #\u{30394}; + #\u{30395}; + #\u{30396}; + #\u{30397}; + #\u{30398}; + #\u{30399}; + #\u{3039A}; + #\u{3039B}; + #\u{3039C}; + #\u{3039D}; + #\u{3039E}; + #\u{3039F}; + #\u{303A0}; + #\u{303A1}; + #\u{303A2}; + #\u{303A3}; + #\u{303A4}; + #\u{303A5}; + #\u{303A6}; + #\u{303A7}; + #\u{303A8}; + #\u{303A9}; + #\u{303AA}; + #\u{303AB}; + #\u{303AC}; + #\u{303AD}; + #\u{303AE}; + #\u{303AF}; + #\u{303B0}; + #\u{303B1}; + #\u{303B2}; + #\u{303B3}; + #\u{303B4}; + #\u{303B5}; + #\u{303B6}; + #\u{303B7}; + #\u{303B8}; + #\u{303B9}; + #\u{303BA}; + #\u{303BB}; + #\u{303BC}; + #\u{303BD}; + #\u{303BE}; + #\u{303BF}; + #\u{303C0}; + #\u{303C1}; + #\u{303C2}; + #\u{303C3}; + #\u{303C4}; + #\u{303C5}; + #\u{303C6}; + #\u{303C7}; + #\u{303C8}; + #\u{303C9}; + #\u{303CA}; + #\u{303CB}; + #\u{303CC}; + #\u{303CD}; + #\u{303CE}; + #\u{303CF}; + #\u{303D0}; + #\u{303D1}; + #\u{303D2}; + #\u{303D3}; + #\u{303D4}; + #\u{303D5}; + #\u{303D6}; + #\u{303D7}; + #\u{303D8}; + #\u{303D9}; + #\u{303DA}; + #\u{303DB}; + #\u{303DC}; + #\u{303DD}; + #\u{303DE}; + #\u{303DF}; + #\u{303E0}; + #\u{303E1}; + #\u{303E2}; + #\u{303E3}; + #\u{303E4}; + #\u{303E5}; + #\u{303E6}; + #\u{303E7}; + #\u{303E8}; + #\u{303E9}; + #\u{303EA}; + #\u{303EB}; + #\u{303EC}; + #\u{303ED}; + #\u{303EE}; + #\u{303EF}; + #\u{303F0}; + #\u{303F1}; + #\u{303F2}; + #\u{303F3}; + #\u{303F4}; + #\u{303F5}; + #\u{303F6}; + #\u{303F7}; + #\u{303F8}; + #\u{303F9}; + #\u{303FA}; + #\u{303FB}; + #\u{303FC}; + #\u{303FD}; + #\u{303FE}; + #\u{303FF}; + #\u{30400}; + #\u{30401}; + #\u{30402}; + #\u{30403}; + #\u{30404}; + #\u{30405}; + #\u{30406}; + #\u{30407}; + #\u{30408}; + #\u{30409}; + #\u{3040A}; + #\u{3040B}; + #\u{3040C}; + #\u{3040D}; + #\u{3040E}; + #\u{3040F}; + #\u{30410}; + #\u{30411}; + #\u{30412}; + #\u{30413}; + #\u{30414}; + #\u{30415}; + #\u{30416}; + #\u{30417}; + #\u{30418}; + #\u{30419}; + #\u{3041A}; + #\u{3041B}; + #\u{3041C}; + #\u{3041D}; + #\u{3041E}; + #\u{3041F}; + #\u{30420}; + #\u{30421}; + #\u{30422}; + #\u{30423}; + #\u{30424}; + #\u{30425}; + #\u{30426}; + #\u{30427}; + #\u{30428}; + #\u{30429}; + #\u{3042A}; + #\u{3042B}; + #\u{3042C}; + #\u{3042D}; + #\u{3042E}; + #\u{3042F}; + #\u{30430}; + #\u{30431}; + #\u{30432}; + #\u{30433}; + #\u{30434}; + #\u{30435}; + #\u{30436}; + #\u{30437}; + #\u{30438}; + #\u{30439}; + #\u{3043A}; + #\u{3043B}; + #\u{3043C}; + #\u{3043D}; + #\u{3043E}; + #\u{3043F}; + #\u{30440}; + #\u{30441}; + #\u{30442}; + #\u{30443}; + #\u{30444}; + #\u{30445}; + #\u{30446}; + #\u{30447}; + #\u{30448}; + #\u{30449}; + #\u{3044A}; + #\u{3044B}; + #\u{3044C}; + #\u{3044D}; + #\u{3044E}; + #\u{3044F}; + #\u{30450}; + #\u{30451}; + #\u{30452}; + #\u{30453}; + #\u{30454}; + #\u{30455}; + #\u{30456}; + #\u{30457}; + #\u{30458}; + #\u{30459}; + #\u{3045A}; + #\u{3045B}; + #\u{3045C}; + #\u{3045D}; + #\u{3045E}; + #\u{3045F}; + #\u{30460}; + #\u{30461}; + #\u{30462}; + #\u{30463}; + #\u{30464}; + #\u{30465}; + #\u{30466}; + #\u{30467}; + #\u{30468}; + #\u{30469}; + #\u{3046A}; + #\u{3046B}; + #\u{3046C}; + #\u{3046D}; + #\u{3046E}; + #\u{3046F}; + #\u{30470}; + #\u{30471}; + #\u{30472}; + #\u{30473}; + #\u{30474}; + #\u{30475}; + #\u{30476}; + #\u{30477}; + #\u{30478}; + #\u{30479}; + #\u{3047A}; + #\u{3047B}; + #\u{3047C}; + #\u{3047D}; + #\u{3047E}; + #\u{3047F}; + #\u{30480}; + #\u{30481}; + #\u{30482}; + #\u{30483}; + #\u{30484}; + #\u{30485}; + #\u{30486}; + #\u{30487}; + #\u{30488}; + #\u{30489}; + #\u{3048A}; + #\u{3048B}; + #\u{3048C}; + #\u{3048D}; + #\u{3048E}; + #\u{3048F}; + #\u{30490}; + #\u{30491}; + #\u{30492}; + #\u{30493}; + #\u{30494}; + #\u{30495}; + #\u{30496}; + #\u{30497}; + #\u{30498}; + #\u{30499}; + #\u{3049A}; + #\u{3049B}; + #\u{3049C}; + #\u{3049D}; + #\u{3049E}; + #\u{3049F}; + #\u{304A0}; + #\u{304A1}; + #\u{304A2}; + #\u{304A3}; + #\u{304A4}; + #\u{304A5}; + #\u{304A6}; + #\u{304A7}; + #\u{304A8}; + #\u{304A9}; + #\u{304AA}; + #\u{304AB}; + #\u{304AC}; + #\u{304AD}; + #\u{304AE}; + #\u{304AF}; + #\u{304B0}; + #\u{304B1}; + #\u{304B2}; + #\u{304B3}; + #\u{304B4}; + #\u{304B5}; + #\u{304B6}; + #\u{304B7}; + #\u{304B8}; + #\u{304B9}; + #\u{304BA}; + #\u{304BB}; + #\u{304BC}; + #\u{304BD}; + #\u{304BE}; + #\u{304BF}; + #\u{304C0}; + #\u{304C1}; + #\u{304C2}; + #\u{304C3}; + #\u{304C4}; + #\u{304C5}; + #\u{304C6}; + #\u{304C7}; + #\u{304C8}; + #\u{304C9}; + #\u{304CA}; + #\u{304CB}; + #\u{304CC}; + #\u{304CD}; + #\u{304CE}; + #\u{304CF}; + #\u{304D0}; + #\u{304D1}; + #\u{304D2}; + #\u{304D3}; + #\u{304D4}; + #\u{304D5}; + #\u{304D6}; + #\u{304D7}; + #\u{304D8}; + #\u{304D9}; + #\u{304DA}; + #\u{304DB}; + #\u{304DC}; + #\u{304DD}; + #\u{304DE}; + #\u{304DF}; + #\u{304E0}; + #\u{304E1}; + #\u{304E2}; + #\u{304E3}; + #\u{304E4}; + #\u{304E5}; + #\u{304E6}; + #\u{304E7}; + #\u{304E8}; + #\u{304E9}; + #\u{304EA}; + #\u{304EB}; + #\u{304EC}; + #\u{304ED}; + #\u{304EE}; + #\u{304EF}; + #\u{304F0}; + #\u{304F1}; + #\u{304F2}; + #\u{304F3}; + #\u{304F4}; + #\u{304F5}; + #\u{304F6}; + #\u{304F7}; + #\u{304F8}; + #\u{304F9}; + #\u{304FA}; + #\u{304FB}; + #\u{304FC}; + #\u{304FD}; + #\u{304FE}; + #\u{304FF}; + #\u{30500}; + #\u{30501}; + #\u{30502}; + #\u{30503}; + #\u{30504}; + #\u{30505}; + #\u{30506}; + #\u{30507}; + #\u{30508}; + #\u{30509}; + #\u{3050A}; + #\u{3050B}; + #\u{3050C}; + #\u{3050D}; + #\u{3050E}; + #\u{3050F}; + #\u{30510}; + #\u{30511}; + #\u{30512}; + #\u{30513}; + #\u{30514}; + #\u{30515}; + #\u{30516}; + #\u{30517}; + #\u{30518}; + #\u{30519}; + #\u{3051A}; + #\u{3051B}; + #\u{3051C}; + #\u{3051D}; + #\u{3051E}; + #\u{3051F}; + #\u{30520}; + #\u{30521}; + #\u{30522}; + #\u{30523}; + #\u{30524}; + #\u{30525}; + #\u{30526}; + #\u{30527}; + #\u{30528}; + #\u{30529}; + #\u{3052A}; + #\u{3052B}; + #\u{3052C}; + #\u{3052D}; + #\u{3052E}; + #\u{3052F}; + #\u{30530}; + #\u{30531}; + #\u{30532}; + #\u{30533}; + #\u{30534}; + #\u{30535}; + #\u{30536}; + #\u{30537}; + #\u{30538}; + #\u{30539}; + #\u{3053A}; + #\u{3053B}; + #\u{3053C}; + #\u{3053D}; + #\u{3053E}; + #\u{3053F}; + #\u{30540}; + #\u{30541}; + #\u{30542}; + #\u{30543}; + #\u{30544}; + #\u{30545}; + #\u{30546}; + #\u{30547}; + #\u{30548}; + #\u{30549}; + #\u{3054A}; + #\u{3054B}; + #\u{3054C}; + #\u{3054D}; + #\u{3054E}; + #\u{3054F}; + #\u{30550}; + #\u{30551}; + #\u{30552}; + #\u{30553}; + #\u{30554}; + #\u{30555}; + #\u{30556}; + #\u{30557}; + #\u{30558}; + #\u{30559}; + #\u{3055A}; + #\u{3055B}; + #\u{3055C}; + #\u{3055D}; + #\u{3055E}; + #\u{3055F}; + #\u{30560}; + #\u{30561}; + #\u{30562}; + #\u{30563}; + #\u{30564}; + #\u{30565}; + #\u{30566}; + #\u{30567}; + #\u{30568}; + #\u{30569}; + #\u{3056A}; + #\u{3056B}; + #\u{3056C}; + #\u{3056D}; + #\u{3056E}; + #\u{3056F}; + #\u{30570}; + #\u{30571}; + #\u{30572}; + #\u{30573}; + #\u{30574}; + #\u{30575}; + #\u{30576}; + #\u{30577}; + #\u{30578}; + #\u{30579}; + #\u{3057A}; + #\u{3057B}; + #\u{3057C}; + #\u{3057D}; + #\u{3057E}; + #\u{3057F}; + #\u{30580}; + #\u{30581}; + #\u{30582}; + #\u{30583}; + #\u{30584}; + #\u{30585}; + #\u{30586}; + #\u{30587}; + #\u{30588}; + #\u{30589}; + #\u{3058A}; + #\u{3058B}; + #\u{3058C}; + #\u{3058D}; + #\u{3058E}; + #\u{3058F}; + #\u{30590}; + #\u{30591}; + #\u{30592}; + #\u{30593}; + #\u{30594}; + #\u{30595}; + #\u{30596}; + #\u{30597}; + #\u{30598}; + #\u{30599}; + #\u{3059A}; + #\u{3059B}; + #\u{3059C}; + #\u{3059D}; + #\u{3059E}; + #\u{3059F}; + #\u{305A0}; + #\u{305A1}; + #\u{305A2}; + #\u{305A3}; + #\u{305A4}; + #\u{305A5}; + #\u{305A6}; + #\u{305A7}; + #\u{305A8}; + #\u{305A9}; + #\u{305AA}; + #\u{305AB}; + #\u{305AC}; + #\u{305AD}; + #\u{305AE}; + #\u{305AF}; + #\u{305B0}; + #\u{305B1}; + #\u{305B2}; + #\u{305B3}; + #\u{305B4}; + #\u{305B5}; + #\u{305B6}; + #\u{305B7}; + #\u{305B8}; + #\u{305B9}; + #\u{305BA}; + #\u{305BB}; + #\u{305BC}; + #\u{305BD}; + #\u{305BE}; + #\u{305BF}; + #\u{305C0}; + #\u{305C1}; + #\u{305C2}; + #\u{305C3}; + #\u{305C4}; + #\u{305C5}; + #\u{305C6}; + #\u{305C7}; + #\u{305C8}; + #\u{305C9}; + #\u{305CA}; + #\u{305CB}; + #\u{305CC}; + #\u{305CD}; + #\u{305CE}; + #\u{305CF}; + #\u{305D0}; + #\u{305D1}; + #\u{305D2}; + #\u{305D3}; + #\u{305D4}; + #\u{305D5}; + #\u{305D6}; + #\u{305D7}; + #\u{305D8}; + #\u{305D9}; + #\u{305DA}; + #\u{305DB}; + #\u{305DC}; + #\u{305DD}; + #\u{305DE}; + #\u{305DF}; + #\u{305E0}; + #\u{305E1}; + #\u{305E2}; + #\u{305E3}; + #\u{305E4}; + #\u{305E5}; + #\u{305E6}; + #\u{305E7}; + #\u{305E8}; + #\u{305E9}; + #\u{305EA}; + #\u{305EB}; + #\u{305EC}; + #\u{305ED}; + #\u{305EE}; + #\u{305EF}; + #\u{305F0}; + #\u{305F1}; + #\u{305F2}; + #\u{305F3}; + #\u{305F4}; + #\u{305F5}; + #\u{305F6}; + #\u{305F7}; + #\u{305F8}; + #\u{305F9}; + #\u{305FA}; + #\u{305FB}; + #\u{305FC}; + #\u{305FD}; + #\u{305FE}; + #\u{305FF}; + #\u{30600}; + #\u{30601}; + #\u{30602}; + #\u{30603}; + #\u{30604}; + #\u{30605}; + #\u{30606}; + #\u{30607}; + #\u{30608}; + #\u{30609}; + #\u{3060A}; + #\u{3060B}; + #\u{3060C}; + #\u{3060D}; + #\u{3060E}; + #\u{3060F}; + #\u{30610}; + #\u{30611}; + #\u{30612}; + #\u{30613}; + #\u{30614}; + #\u{30615}; + #\u{30616}; + #\u{30617}; + #\u{30618}; + #\u{30619}; + #\u{3061A}; + #\u{3061B}; + #\u{3061C}; + #\u{3061D}; + #\u{3061E}; + #\u{3061F}; + #\u{30620}; + #\u{30621}; + #\u{30622}; + #\u{30623}; + #\u{30624}; + #\u{30625}; + #\u{30626}; + #\u{30627}; + #\u{30628}; + #\u{30629}; + #\u{3062A}; + #\u{3062B}; + #\u{3062C}; + #\u{3062D}; + #\u{3062E}; + #\u{3062F}; + #\u{30630}; + #\u{30631}; + #\u{30632}; + #\u{30633}; + #\u{30634}; + #\u{30635}; + #\u{30636}; + #\u{30637}; + #\u{30638}; + #\u{30639}; + #\u{3063A}; + #\u{3063B}; + #\u{3063C}; + #\u{3063D}; + #\u{3063E}; + #\u{3063F}; + #\u{30640}; + #\u{30641}; + #\u{30642}; + #\u{30643}; + #\u{30644}; + #\u{30645}; + #\u{30646}; + #\u{30647}; + #\u{30648}; + #\u{30649}; + #\u{3064A}; + #\u{3064B}; + #\u{3064C}; + #\u{3064D}; + #\u{3064E}; + #\u{3064F}; + #\u{30650}; + #\u{30651}; + #\u{30652}; + #\u{30653}; + #\u{30654}; + #\u{30655}; + #\u{30656}; + #\u{30657}; + #\u{30658}; + #\u{30659}; + #\u{3065A}; + #\u{3065B}; + #\u{3065C}; + #\u{3065D}; + #\u{3065E}; + #\u{3065F}; + #\u{30660}; + #\u{30661}; + #\u{30662}; + #\u{30663}; + #\u{30664}; + #\u{30665}; + #\u{30666}; + #\u{30667}; + #\u{30668}; + #\u{30669}; + #\u{3066A}; + #\u{3066B}; + #\u{3066C}; + #\u{3066D}; + #\u{3066E}; + #\u{3066F}; + #\u{30670}; + #\u{30671}; + #\u{30672}; + #\u{30673}; + #\u{30674}; + #\u{30675}; + #\u{30676}; + #\u{30677}; + #\u{30678}; + #\u{30679}; + #\u{3067A}; + #\u{3067B}; + #\u{3067C}; + #\u{3067D}; + #\u{3067E}; + #\u{3067F}; + #\u{30680}; + #\u{30681}; + #\u{30682}; + #\u{30683}; + #\u{30684}; + #\u{30685}; + #\u{30686}; + #\u{30687}; + #\u{30688}; + #\u{30689}; + #\u{3068A}; + #\u{3068B}; + #\u{3068C}; + #\u{3068D}; + #\u{3068E}; + #\u{3068F}; + #\u{30690}; + #\u{30691}; + #\u{30692}; + #\u{30693}; + #\u{30694}; + #\u{30695}; + #\u{30696}; + #\u{30697}; + #\u{30698}; + #\u{30699}; + #\u{3069A}; + #\u{3069B}; + #\u{3069C}; + #\u{3069D}; + #\u{3069E}; + #\u{3069F}; + #\u{306A0}; + #\u{306A1}; + #\u{306A2}; + #\u{306A3}; + #\u{306A4}; + #\u{306A5}; + #\u{306A6}; + #\u{306A7}; + #\u{306A8}; + #\u{306A9}; + #\u{306AA}; + #\u{306AB}; + #\u{306AC}; + #\u{306AD}; + #\u{306AE}; + #\u{306AF}; + #\u{306B0}; + #\u{306B1}; + #\u{306B2}; + #\u{306B3}; + #\u{306B4}; + #\u{306B5}; + #\u{306B6}; + #\u{306B7}; + #\u{306B8}; + #\u{306B9}; + #\u{306BA}; + #\u{306BB}; + #\u{306BC}; + #\u{306BD}; + #\u{306BE}; + #\u{306BF}; + #\u{306C0}; + #\u{306C1}; + #\u{306C2}; + #\u{306C3}; + #\u{306C4}; + #\u{306C5}; + #\u{306C6}; + #\u{306C7}; + #\u{306C8}; + #\u{306C9}; + #\u{306CA}; + #\u{306CB}; + #\u{306CC}; + #\u{306CD}; + #\u{306CE}; + #\u{306CF}; + #\u{306D0}; + #\u{306D1}; + #\u{306D2}; + #\u{306D3}; + #\u{306D4}; + #\u{306D5}; + #\u{306D6}; + #\u{306D7}; + #\u{306D8}; + #\u{306D9}; + #\u{306DA}; + #\u{306DB}; + #\u{306DC}; + #\u{306DD}; + #\u{306DE}; + #\u{306DF}; + #\u{306E0}; + #\u{306E1}; + #\u{306E2}; + #\u{306E3}; + #\u{306E4}; + #\u{306E5}; + #\u{306E6}; + #\u{306E7}; + #\u{306E8}; + #\u{306E9}; + #\u{306EA}; + #\u{306EB}; + #\u{306EC}; + #\u{306ED}; + #\u{306EE}; + #\u{306EF}; + #\u{306F0}; + #\u{306F1}; + #\u{306F2}; + #\u{306F3}; + #\u{306F4}; + #\u{306F5}; + #\u{306F6}; + #\u{306F7}; + #\u{306F8}; + #\u{306F9}; + #\u{306FA}; + #\u{306FB}; + #\u{306FC}; + #\u{306FD}; + #\u{306FE}; + #\u{306FF}; + #\u{30700}; + #\u{30701}; + #\u{30702}; + #\u{30703}; + #\u{30704}; + #\u{30705}; + #\u{30706}; + #\u{30707}; + #\u{30708}; + #\u{30709}; + #\u{3070A}; + #\u{3070B}; + #\u{3070C}; + #\u{3070D}; + #\u{3070E}; + #\u{3070F}; + #\u{30710}; + #\u{30711}; + #\u{30712}; + #\u{30713}; + #\u{30714}; + #\u{30715}; + #\u{30716}; + #\u{30717}; + #\u{30718}; + #\u{30719}; + #\u{3071A}; + #\u{3071B}; + #\u{3071C}; + #\u{3071D}; + #\u{3071E}; + #\u{3071F}; + #\u{30720}; + #\u{30721}; + #\u{30722}; + #\u{30723}; + #\u{30724}; + #\u{30725}; + #\u{30726}; + #\u{30727}; + #\u{30728}; + #\u{30729}; + #\u{3072A}; + #\u{3072B}; + #\u{3072C}; + #\u{3072D}; + #\u{3072E}; + #\u{3072F}; + #\u{30730}; + #\u{30731}; + #\u{30732}; + #\u{30733}; + #\u{30734}; + #\u{30735}; + #\u{30736}; + #\u{30737}; + #\u{30738}; + #\u{30739}; + #\u{3073A}; + #\u{3073B}; + #\u{3073C}; + #\u{3073D}; + #\u{3073E}; + #\u{3073F}; + #\u{30740}; + #\u{30741}; + #\u{30742}; + #\u{30743}; + #\u{30744}; + #\u{30745}; + #\u{30746}; + #\u{30747}; + #\u{30748}; + #\u{30749}; + #\u{3074A}; + #\u{3074B}; + #\u{3074C}; + #\u{3074D}; + #\u{3074E}; + #\u{3074F}; + #\u{30750}; + #\u{30751}; + #\u{30752}; + #\u{30753}; + #\u{30754}; + #\u{30755}; + #\u{30756}; + #\u{30757}; + #\u{30758}; + #\u{30759}; + #\u{3075A}; + #\u{3075B}; + #\u{3075C}; + #\u{3075D}; + #\u{3075E}; + #\u{3075F}; + #\u{30760}; + #\u{30761}; + #\u{30762}; + #\u{30763}; + #\u{30764}; + #\u{30765}; + #\u{30766}; + #\u{30767}; + #\u{30768}; + #\u{30769}; + #\u{3076A}; + #\u{3076B}; + #\u{3076C}; + #\u{3076D}; + #\u{3076E}; + #\u{3076F}; + #\u{30770}; + #\u{30771}; + #\u{30772}; + #\u{30773}; + #\u{30774}; + #\u{30775}; + #\u{30776}; + #\u{30777}; + #\u{30778}; + #\u{30779}; + #\u{3077A}; + #\u{3077B}; + #\u{3077C}; + #\u{3077D}; + #\u{3077E}; + #\u{3077F}; + #\u{30780}; + #\u{30781}; + #\u{30782}; + #\u{30783}; + #\u{30784}; + #\u{30785}; + #\u{30786}; + #\u{30787}; + #\u{30788}; + #\u{30789}; + #\u{3078A}; + #\u{3078B}; + #\u{3078C}; + #\u{3078D}; + #\u{3078E}; + #\u{3078F}; + #\u{30790}; + #\u{30791}; + #\u{30792}; + #\u{30793}; + #\u{30794}; + #\u{30795}; + #\u{30796}; + #\u{30797}; + #\u{30798}; + #\u{30799}; + #\u{3079A}; + #\u{3079B}; + #\u{3079C}; + #\u{3079D}; + #\u{3079E}; + #\u{3079F}; + #\u{307A0}; + #\u{307A1}; + #\u{307A2}; + #\u{307A3}; + #\u{307A4}; + #\u{307A5}; + #\u{307A6}; + #\u{307A7}; + #\u{307A8}; + #\u{307A9}; + #\u{307AA}; + #\u{307AB}; + #\u{307AC}; + #\u{307AD}; + #\u{307AE}; + #\u{307AF}; + #\u{307B0}; + #\u{307B1}; + #\u{307B2}; + #\u{307B3}; + #\u{307B4}; + #\u{307B5}; + #\u{307B6}; + #\u{307B7}; + #\u{307B8}; + #\u{307B9}; + #\u{307BA}; + #\u{307BB}; + #\u{307BC}; + #\u{307BD}; + #\u{307BE}; + #\u{307BF}; + #\u{307C0}; + #\u{307C1}; + #\u{307C2}; + #\u{307C3}; + #\u{307C4}; + #\u{307C5}; + #\u{307C6}; + #\u{307C7}; + #\u{307C8}; + #\u{307C9}; + #\u{307CA}; + #\u{307CB}; + #\u{307CC}; + #\u{307CD}; + #\u{307CE}; + #\u{307CF}; + #\u{307D0}; + #\u{307D1}; + #\u{307D2}; + #\u{307D3}; + #\u{307D4}; + #\u{307D5}; + #\u{307D6}; + #\u{307D7}; + #\u{307D8}; + #\u{307D9}; + #\u{307DA}; + #\u{307DB}; + #\u{307DC}; + #\u{307DD}; + #\u{307DE}; + #\u{307DF}; + #\u{307E0}; + #\u{307E1}; + #\u{307E2}; + #\u{307E3}; + #\u{307E4}; + #\u{307E5}; + #\u{307E6}; + #\u{307E7}; + #\u{307E8}; + #\u{307E9}; + #\u{307EA}; + #\u{307EB}; + #\u{307EC}; + #\u{307ED}; + #\u{307EE}; + #\u{307EF}; + #\u{307F0}; + #\u{307F1}; + #\u{307F2}; + #\u{307F3}; + #\u{307F4}; + #\u{307F5}; + #\u{307F6}; + #\u{307F7}; + #\u{307F8}; + #\u{307F9}; + #\u{307FA}; + #\u{307FB}; + #\u{307FC}; + #\u{307FD}; + #\u{307FE}; + #\u{307FF}; + #\u{30800}; + #\u{30801}; + #\u{30802}; + #\u{30803}; + #\u{30804}; + #\u{30805}; + #\u{30806}; + #\u{30807}; + #\u{30808}; + #\u{30809}; + #\u{3080A}; + #\u{3080B}; + #\u{3080C}; + #\u{3080D}; + #\u{3080E}; + #\u{3080F}; + #\u{30810}; + #\u{30811}; + #\u{30812}; + #\u{30813}; + #\u{30814}; + #\u{30815}; + #\u{30816}; + #\u{30817}; + #\u{30818}; + #\u{30819}; + #\u{3081A}; + #\u{3081B}; + #\u{3081C}; + #\u{3081D}; + #\u{3081E}; + #\u{3081F}; + #\u{30820}; + #\u{30821}; + #\u{30822}; + #\u{30823}; + #\u{30824}; + #\u{30825}; + #\u{30826}; + #\u{30827}; + #\u{30828}; + #\u{30829}; + #\u{3082A}; + #\u{3082B}; + #\u{3082C}; + #\u{3082D}; + #\u{3082E}; + #\u{3082F}; + #\u{30830}; + #\u{30831}; + #\u{30832}; + #\u{30833}; + #\u{30834}; + #\u{30835}; + #\u{30836}; + #\u{30837}; + #\u{30838}; + #\u{30839}; + #\u{3083A}; + #\u{3083B}; + #\u{3083C}; + #\u{3083D}; + #\u{3083E}; + #\u{3083F}; + #\u{30840}; + #\u{30841}; + #\u{30842}; + #\u{30843}; + #\u{30844}; + #\u{30845}; + #\u{30846}; + #\u{30847}; + #\u{30848}; + #\u{30849}; + #\u{3084A}; + #\u{3084B}; + #\u{3084C}; + #\u{3084D}; + #\u{3084E}; + #\u{3084F}; + #\u{30850}; + #\u{30851}; + #\u{30852}; + #\u{30853}; + #\u{30854}; + #\u{30855}; + #\u{30856}; + #\u{30857}; + #\u{30858}; + #\u{30859}; + #\u{3085A}; + #\u{3085B}; + #\u{3085C}; + #\u{3085D}; + #\u{3085E}; + #\u{3085F}; + #\u{30860}; + #\u{30861}; + #\u{30862}; + #\u{30863}; + #\u{30864}; + #\u{30865}; + #\u{30866}; + #\u{30867}; + #\u{30868}; + #\u{30869}; + #\u{3086A}; + #\u{3086B}; + #\u{3086C}; + #\u{3086D}; + #\u{3086E}; + #\u{3086F}; + #\u{30870}; + #\u{30871}; + #\u{30872}; + #\u{30873}; + #\u{30874}; + #\u{30875}; + #\u{30876}; + #\u{30877}; + #\u{30878}; + #\u{30879}; + #\u{3087A}; + #\u{3087B}; + #\u{3087C}; + #\u{3087D}; + #\u{3087E}; + #\u{3087F}; + #\u{30880}; + #\u{30881}; + #\u{30882}; + #\u{30883}; + #\u{30884}; + #\u{30885}; + #\u{30886}; + #\u{30887}; + #\u{30888}; + #\u{30889}; + #\u{3088A}; + #\u{3088B}; + #\u{3088C}; + #\u{3088D}; + #\u{3088E}; + #\u{3088F}; + #\u{30890}; + #\u{30891}; + #\u{30892}; + #\u{30893}; + #\u{30894}; + #\u{30895}; + #\u{30896}; + #\u{30897}; + #\u{30898}; + #\u{30899}; + #\u{3089A}; + #\u{3089B}; + #\u{3089C}; + #\u{3089D}; + #\u{3089E}; + #\u{3089F}; + #\u{308A0}; + #\u{308A1}; + #\u{308A2}; + #\u{308A3}; + #\u{308A4}; + #\u{308A5}; + #\u{308A6}; + #\u{308A7}; + #\u{308A8}; + #\u{308A9}; + #\u{308AA}; + #\u{308AB}; + #\u{308AC}; + #\u{308AD}; + #\u{308AE}; + #\u{308AF}; + #\u{308B0}; + #\u{308B1}; + #\u{308B2}; + #\u{308B3}; + #\u{308B4}; + #\u{308B5}; + #\u{308B6}; + #\u{308B7}; + #\u{308B8}; + #\u{308B9}; + #\u{308BA}; + #\u{308BB}; + #\u{308BC}; + #\u{308BD}; + #\u{308BE}; + #\u{308BF}; + #\u{308C0}; + #\u{308C1}; + #\u{308C2}; + #\u{308C3}; + #\u{308C4}; + #\u{308C5}; + #\u{308C6}; + #\u{308C7}; + #\u{308C8}; + #\u{308C9}; + #\u{308CA}; + #\u{308CB}; + #\u{308CC}; + #\u{308CD}; + #\u{308CE}; + #\u{308CF}; + #\u{308D0}; + #\u{308D1}; + #\u{308D2}; + #\u{308D3}; + #\u{308D4}; + #\u{308D5}; + #\u{308D6}; + #\u{308D7}; + #\u{308D8}; + #\u{308D9}; + #\u{308DA}; + #\u{308DB}; + #\u{308DC}; + #\u{308DD}; + #\u{308DE}; + #\u{308DF}; + #\u{308E0}; + #\u{308E1}; + #\u{308E2}; + #\u{308E3}; + #\u{308E4}; + #\u{308E5}; + #\u{308E6}; + #\u{308E7}; + #\u{308E8}; + #\u{308E9}; + #\u{308EA}; + #\u{308EB}; + #\u{308EC}; + #\u{308ED}; + #\u{308EE}; + #\u{308EF}; + #\u{308F0}; + #\u{308F1}; + #\u{308F2}; + #\u{308F3}; + #\u{308F4}; + #\u{308F5}; + #\u{308F6}; + #\u{308F7}; + #\u{308F8}; + #\u{308F9}; + #\u{308FA}; + #\u{308FB}; + #\u{308FC}; + #\u{308FD}; + #\u{308FE}; + #\u{308FF}; + #\u{30900}; + #\u{30901}; + #\u{30902}; + #\u{30903}; + #\u{30904}; + #\u{30905}; + #\u{30906}; + #\u{30907}; + #\u{30908}; + #\u{30909}; + #\u{3090A}; + #\u{3090B}; + #\u{3090C}; + #\u{3090D}; + #\u{3090E}; + #\u{3090F}; + #\u{30910}; + #\u{30911}; + #\u{30912}; + #\u{30913}; + #\u{30914}; + #\u{30915}; + #\u{30916}; + #\u{30917}; + #\u{30918}; + #\u{30919}; + #\u{3091A}; + #\u{3091B}; + #\u{3091C}; + #\u{3091D}; + #\u{3091E}; + #\u{3091F}; + #\u{30920}; + #\u{30921}; + #\u{30922}; + #\u{30923}; + #\u{30924}; + #\u{30925}; + #\u{30926}; + #\u{30927}; + #\u{30928}; + #\u{30929}; + #\u{3092A}; + #\u{3092B}; + #\u{3092C}; + #\u{3092D}; + #\u{3092E}; + #\u{3092F}; + #\u{30930}; + #\u{30931}; + #\u{30932}; + #\u{30933}; + #\u{30934}; + #\u{30935}; + #\u{30936}; + #\u{30937}; + #\u{30938}; + #\u{30939}; + #\u{3093A}; + #\u{3093B}; + #\u{3093C}; + #\u{3093D}; + #\u{3093E}; + #\u{3093F}; + #\u{30940}; + #\u{30941}; + #\u{30942}; + #\u{30943}; + #\u{30944}; + #\u{30945}; + #\u{30946}; + #\u{30947}; + #\u{30948}; + #\u{30949}; + #\u{3094A}; + #\u{3094B}; + #\u{3094C}; + #\u{3094D}; + #\u{3094E}; + #\u{3094F}; + #\u{30950}; + #\u{30951}; + #\u{30952}; + #\u{30953}; + #\u{30954}; + #\u{30955}; + #\u{30956}; + #\u{30957}; + #\u{30958}; + #\u{30959}; + #\u{3095A}; + #\u{3095B}; + #\u{3095C}; + #\u{3095D}; + #\u{3095E}; + #\u{3095F}; + #\u{30960}; + #\u{30961}; + #\u{30962}; + #\u{30963}; + #\u{30964}; + #\u{30965}; + #\u{30966}; + #\u{30967}; + #\u{30968}; + #\u{30969}; + #\u{3096A}; + #\u{3096B}; + #\u{3096C}; + #\u{3096D}; + #\u{3096E}; + #\u{3096F}; + #\u{30970}; + #\u{30971}; + #\u{30972}; + #\u{30973}; + #\u{30974}; + #\u{30975}; + #\u{30976}; + #\u{30977}; + #\u{30978}; + #\u{30979}; + #\u{3097A}; + #\u{3097B}; + #\u{3097C}; + #\u{3097D}; + #\u{3097E}; + #\u{3097F}; + #\u{30980}; + #\u{30981}; + #\u{30982}; + #\u{30983}; + #\u{30984}; + #\u{30985}; + #\u{30986}; + #\u{30987}; + #\u{30988}; + #\u{30989}; + #\u{3098A}; + #\u{3098B}; + #\u{3098C}; + #\u{3098D}; + #\u{3098E}; + #\u{3098F}; + #\u{30990}; + #\u{30991}; + #\u{30992}; + #\u{30993}; + #\u{30994}; + #\u{30995}; + #\u{30996}; + #\u{30997}; + #\u{30998}; + #\u{30999}; + #\u{3099A}; + #\u{3099B}; + #\u{3099C}; + #\u{3099D}; + #\u{3099E}; + #\u{3099F}; + #\u{309A0}; + #\u{309A1}; + #\u{309A2}; + #\u{309A3}; + #\u{309A4}; + #\u{309A5}; + #\u{309A6}; + #\u{309A7}; + #\u{309A8}; + #\u{309A9}; + #\u{309AA}; + #\u{309AB}; + #\u{309AC}; + #\u{309AD}; + #\u{309AE}; + #\u{309AF}; + #\u{309B0}; + #\u{309B1}; + #\u{309B2}; + #\u{309B3}; + #\u{309B4}; + #\u{309B5}; + #\u{309B6}; + #\u{309B7}; + #\u{309B8}; + #\u{309B9}; + #\u{309BA}; + #\u{309BB}; + #\u{309BC}; + #\u{309BD}; + #\u{309BE}; + #\u{309BF}; + #\u{309C0}; + #\u{309C1}; + #\u{309C2}; + #\u{309C3}; + #\u{309C4}; + #\u{309C5}; + #\u{309C6}; + #\u{309C7}; + #\u{309C8}; + #\u{309C9}; + #\u{309CA}; + #\u{309CB}; + #\u{309CC}; + #\u{309CD}; + #\u{309CE}; + #\u{309CF}; + #\u{309D0}; + #\u{309D1}; + #\u{309D2}; + #\u{309D3}; + #\u{309D4}; + #\u{309D5}; + #\u{309D6}; + #\u{309D7}; + #\u{309D8}; + #\u{309D9}; + #\u{309DA}; + #\u{309DB}; + #\u{309DC}; + #\u{309DD}; + #\u{309DE}; + #\u{309DF}; + #\u{309E0}; + #\u{309E1}; + #\u{309E2}; + #\u{309E3}; + #\u{309E4}; + #\u{309E5}; + #\u{309E6}; + #\u{309E7}; + #\u{309E8}; + #\u{309E9}; + #\u{309EA}; + #\u{309EB}; + #\u{309EC}; + #\u{309ED}; + #\u{309EE}; + #\u{309EF}; + #\u{309F0}; + #\u{309F1}; + #\u{309F2}; + #\u{309F3}; + #\u{309F4}; + #\u{309F5}; + #\u{309F6}; + #\u{309F7}; + #\u{309F8}; + #\u{309F9}; + #\u{309FA}; + #\u{309FB}; + #\u{309FC}; + #\u{309FD}; + #\u{309FE}; + #\u{309FF}; + #\u{30A00}; + #\u{30A01}; + #\u{30A02}; + #\u{30A03}; + #\u{30A04}; + #\u{30A05}; + #\u{30A06}; + #\u{30A07}; + #\u{30A08}; + #\u{30A09}; + #\u{30A0A}; + #\u{30A0B}; + #\u{30A0C}; + #\u{30A0D}; + #\u{30A0E}; + #\u{30A0F}; + #\u{30A10}; + #\u{30A11}; + #\u{30A12}; + #\u{30A13}; + #\u{30A14}; + #\u{30A15}; + #\u{30A16}; + #\u{30A17}; + #\u{30A18}; + #\u{30A19}; + #\u{30A1A}; + #\u{30A1B}; + #\u{30A1C}; + #\u{30A1D}; + #\u{30A1E}; + #\u{30A1F}; + #\u{30A20}; + #\u{30A21}; + #\u{30A22}; + #\u{30A23}; + #\u{30A24}; + #\u{30A25}; + #\u{30A26}; + #\u{30A27}; + #\u{30A28}; + #\u{30A29}; + #\u{30A2A}; + #\u{30A2B}; + #\u{30A2C}; + #\u{30A2D}; + #\u{30A2E}; + #\u{30A2F}; + #\u{30A30}; + #\u{30A31}; + #\u{30A32}; + #\u{30A33}; + #\u{30A34}; + #\u{30A35}; + #\u{30A36}; + #\u{30A37}; + #\u{30A38}; + #\u{30A39}; + #\u{30A3A}; + #\u{30A3B}; + #\u{30A3C}; + #\u{30A3D}; + #\u{30A3E}; + #\u{30A3F}; + #\u{30A40}; + #\u{30A41}; + #\u{30A42}; + #\u{30A43}; + #\u{30A44}; + #\u{30A45}; + #\u{30A46}; + #\u{30A47}; + #\u{30A48}; + #\u{30A49}; + #\u{30A4A}; + #\u{30A4B}; + #\u{30A4C}; + #\u{30A4D}; + #\u{30A4E}; + #\u{30A4F}; + #\u{30A50}; + #\u{30A51}; + #\u{30A52}; + #\u{30A53}; + #\u{30A54}; + #\u{30A55}; + #\u{30A56}; + #\u{30A57}; + #\u{30A58}; + #\u{30A59}; + #\u{30A5A}; + #\u{30A5B}; + #\u{30A5C}; + #\u{30A5D}; + #\u{30A5E}; + #\u{30A5F}; + #\u{30A60}; + #\u{30A61}; + #\u{30A62}; + #\u{30A63}; + #\u{30A64}; + #\u{30A65}; + #\u{30A66}; + #\u{30A67}; + #\u{30A68}; + #\u{30A69}; + #\u{30A6A}; + #\u{30A6B}; + #\u{30A6C}; + #\u{30A6D}; + #\u{30A6E}; + #\u{30A6F}; + #\u{30A70}; + #\u{30A71}; + #\u{30A72}; + #\u{30A73}; + #\u{30A74}; + #\u{30A75}; + #\u{30A76}; + #\u{30A77}; + #\u{30A78}; + #\u{30A79}; + #\u{30A7A}; + #\u{30A7B}; + #\u{30A7C}; + #\u{30A7D}; + #\u{30A7E}; + #\u{30A7F}; + #\u{30A80}; + #\u{30A81}; + #\u{30A82}; + #\u{30A83}; + #\u{30A84}; + #\u{30A85}; + #\u{30A86}; + #\u{30A87}; + #\u{30A88}; + #\u{30A89}; + #\u{30A8A}; + #\u{30A8B}; + #\u{30A8C}; + #\u{30A8D}; + #\u{30A8E}; + #\u{30A8F}; + #\u{30A90}; + #\u{30A91}; + #\u{30A92}; + #\u{30A93}; + #\u{30A94}; + #\u{30A95}; + #\u{30A96}; + #\u{30A97}; + #\u{30A98}; + #\u{30A99}; + #\u{30A9A}; + #\u{30A9B}; + #\u{30A9C}; + #\u{30A9D}; + #\u{30A9E}; + #\u{30A9F}; + #\u{30AA0}; + #\u{30AA1}; + #\u{30AA2}; + #\u{30AA3}; + #\u{30AA4}; + #\u{30AA5}; + #\u{30AA6}; + #\u{30AA7}; + #\u{30AA8}; + #\u{30AA9}; + #\u{30AAA}; + #\u{30AAB}; + #\u{30AAC}; + #\u{30AAD}; + #\u{30AAE}; + #\u{30AAF}; + #\u{30AB0}; + #\u{30AB1}; + #\u{30AB2}; + #\u{30AB3}; + #\u{30AB4}; + #\u{30AB5}; + #\u{30AB6}; + #\u{30AB7}; + #\u{30AB8}; + #\u{30AB9}; + #\u{30ABA}; + #\u{30ABB}; + #\u{30ABC}; + #\u{30ABD}; + #\u{30ABE}; + #\u{30ABF}; + #\u{30AC0}; + #\u{30AC1}; + #\u{30AC2}; + #\u{30AC3}; + #\u{30AC4}; + #\u{30AC5}; + #\u{30AC6}; + #\u{30AC7}; + #\u{30AC8}; + #\u{30AC9}; + #\u{30ACA}; + #\u{30ACB}; + #\u{30ACC}; + #\u{30ACD}; + #\u{30ACE}; + #\u{30ACF}; + #\u{30AD0}; + #\u{30AD1}; + #\u{30AD2}; + #\u{30AD3}; + #\u{30AD4}; + #\u{30AD5}; + #\u{30AD6}; + #\u{30AD7}; + #\u{30AD8}; + #\u{30AD9}; + #\u{30ADA}; + #\u{30ADB}; + #\u{30ADC}; + #\u{30ADD}; + #\u{30ADE}; + #\u{30ADF}; + #\u{30AE0}; + #\u{30AE1}; + #\u{30AE2}; + #\u{30AE3}; + #\u{30AE4}; + #\u{30AE5}; + #\u{30AE6}; + #\u{30AE7}; + #\u{30AE8}; + #\u{30AE9}; + #\u{30AEA}; + #\u{30AEB}; + #\u{30AEC}; + #\u{30AED}; + #\u{30AEE}; + #\u{30AEF}; + #\u{30AF0}; + #\u{30AF1}; + #\u{30AF2}; + #\u{30AF3}; + #\u{30AF4}; + #\u{30AF5}; + #\u{30AF6}; + #\u{30AF7}; + #\u{30AF8}; + #\u{30AF9}; + #\u{30AFA}; + #\u{30AFB}; + #\u{30AFC}; + #\u{30AFD}; + #\u{30AFE}; + #\u{30AFF}; + #\u{30B00}; + #\u{30B01}; + #\u{30B02}; + #\u{30B03}; + #\u{30B04}; + #\u{30B05}; + #\u{30B06}; + #\u{30B07}; + #\u{30B08}; + #\u{30B09}; + #\u{30B0A}; + #\u{30B0B}; + #\u{30B0C}; + #\u{30B0D}; + #\u{30B0E}; + #\u{30B0F}; + #\u{30B10}; + #\u{30B11}; + #\u{30B12}; + #\u{30B13}; + #\u{30B14}; + #\u{30B15}; + #\u{30B16}; + #\u{30B17}; + #\u{30B18}; + #\u{30B19}; + #\u{30B1A}; + #\u{30B1B}; + #\u{30B1C}; + #\u{30B1D}; + #\u{30B1E}; + #\u{30B1F}; + #\u{30B20}; + #\u{30B21}; + #\u{30B22}; + #\u{30B23}; + #\u{30B24}; + #\u{30B25}; + #\u{30B26}; + #\u{30B27}; + #\u{30B28}; + #\u{30B29}; + #\u{30B2A}; + #\u{30B2B}; + #\u{30B2C}; + #\u{30B2D}; + #\u{30B2E}; + #\u{30B2F}; + #\u{30B30}; + #\u{30B31}; + #\u{30B32}; + #\u{30B33}; + #\u{30B34}; + #\u{30B35}; + #\u{30B36}; + #\u{30B37}; + #\u{30B38}; + #\u{30B39}; + #\u{30B3A}; + #\u{30B3B}; + #\u{30B3C}; + #\u{30B3D}; + #\u{30B3E}; + #\u{30B3F}; + #\u{30B40}; + #\u{30B41}; + #\u{30B42}; + #\u{30B43}; + #\u{30B44}; + #\u{30B45}; + #\u{30B46}; + #\u{30B47}; + #\u{30B48}; + #\u{30B49}; + #\u{30B4A}; + #\u{30B4B}; + #\u{30B4C}; + #\u{30B4D}; + #\u{30B4E}; + #\u{30B4F}; + #\u{30B50}; + #\u{30B51}; + #\u{30B52}; + #\u{30B53}; + #\u{30B54}; + #\u{30B55}; + #\u{30B56}; + #\u{30B57}; + #\u{30B58}; + #\u{30B59}; + #\u{30B5A}; + #\u{30B5B}; + #\u{30B5C}; + #\u{30B5D}; + #\u{30B5E}; + #\u{30B5F}; + #\u{30B60}; + #\u{30B61}; + #\u{30B62}; + #\u{30B63}; + #\u{30B64}; + #\u{30B65}; + #\u{30B66}; + #\u{30B67}; + #\u{30B68}; + #\u{30B69}; + #\u{30B6A}; + #\u{30B6B}; + #\u{30B6C}; + #\u{30B6D}; + #\u{30B6E}; + #\u{30B6F}; + #\u{30B70}; + #\u{30B71}; + #\u{30B72}; + #\u{30B73}; + #\u{30B74}; + #\u{30B75}; + #\u{30B76}; + #\u{30B77}; + #\u{30B78}; + #\u{30B79}; + #\u{30B7A}; + #\u{30B7B}; + #\u{30B7C}; + #\u{30B7D}; + #\u{30B7E}; + #\u{30B7F}; + #\u{30B80}; + #\u{30B81}; + #\u{30B82}; + #\u{30B83}; + #\u{30B84}; + #\u{30B85}; + #\u{30B86}; + #\u{30B87}; + #\u{30B88}; + #\u{30B89}; + #\u{30B8A}; + #\u{30B8B}; + #\u{30B8C}; + #\u{30B8D}; + #\u{30B8E}; + #\u{30B8F}; + #\u{30B90}; + #\u{30B91}; + #\u{30B92}; + #\u{30B93}; + #\u{30B94}; + #\u{30B95}; + #\u{30B96}; + #\u{30B97}; + #\u{30B98}; + #\u{30B99}; + #\u{30B9A}; + #\u{30B9B}; + #\u{30B9C}; + #\u{30B9D}; + #\u{30B9E}; + #\u{30B9F}; + #\u{30BA0}; + #\u{30BA1}; + #\u{30BA2}; + #\u{30BA3}; + #\u{30BA4}; + #\u{30BA5}; + #\u{30BA6}; + #\u{30BA7}; + #\u{30BA8}; + #\u{30BA9}; + #\u{30BAA}; + #\u{30BAB}; + #\u{30BAC}; + #\u{30BAD}; + #\u{30BAE}; + #\u{30BAF}; + #\u{30BB0}; + #\u{30BB1}; + #\u{30BB2}; + #\u{30BB3}; + #\u{30BB4}; + #\u{30BB5}; + #\u{30BB6}; + #\u{30BB7}; + #\u{30BB8}; + #\u{30BB9}; + #\u{30BBA}; + #\u{30BBB}; + #\u{30BBC}; + #\u{30BBD}; + #\u{30BBE}; + #\u{30BBF}; + #\u{30BC0}; + #\u{30BC1}; + #\u{30BC2}; + #\u{30BC3}; + #\u{30BC4}; + #\u{30BC5}; + #\u{30BC6}; + #\u{30BC7}; + #\u{30BC8}; + #\u{30BC9}; + #\u{30BCA}; + #\u{30BCB}; + #\u{30BCC}; + #\u{30BCD}; + #\u{30BCE}; + #\u{30BCF}; + #\u{30BD0}; + #\u{30BD1}; + #\u{30BD2}; + #\u{30BD3}; + #\u{30BD4}; + #\u{30BD5}; + #\u{30BD6}; + #\u{30BD7}; + #\u{30BD8}; + #\u{30BD9}; + #\u{30BDA}; + #\u{30BDB}; + #\u{30BDC}; + #\u{30BDD}; + #\u{30BDE}; + #\u{30BDF}; + #\u{30BE0}; + #\u{30BE1}; + #\u{30BE2}; + #\u{30BE3}; + #\u{30BE4}; + #\u{30BE5}; + #\u{30BE6}; + #\u{30BE7}; + #\u{30BE8}; + #\u{30BE9}; + #\u{30BEA}; + #\u{30BEB}; + #\u{30BEC}; + #\u{30BED}; + #\u{30BEE}; + #\u{30BEF}; + #\u{30BF0}; + #\u{30BF1}; + #\u{30BF2}; + #\u{30BF3}; + #\u{30BF4}; + #\u{30BF5}; + #\u{30BF6}; + #\u{30BF7}; + #\u{30BF8}; + #\u{30BF9}; + #\u{30BFA}; + #\u{30BFB}; + #\u{30BFC}; + #\u{30BFD}; + #\u{30BFE}; + #\u{30BFF}; + #\u{30C00}; + #\u{30C01}; + #\u{30C02}; + #\u{30C03}; + #\u{30C04}; + #\u{30C05}; + #\u{30C06}; + #\u{30C07}; + #\u{30C08}; + #\u{30C09}; + #\u{30C0A}; + #\u{30C0B}; + #\u{30C0C}; + #\u{30C0D}; + #\u{30C0E}; + #\u{30C0F}; + #\u{30C10}; + #\u{30C11}; + #\u{30C12}; + #\u{30C13}; + #\u{30C14}; + #\u{30C15}; + #\u{30C16}; + #\u{30C17}; + #\u{30C18}; + #\u{30C19}; + #\u{30C1A}; + #\u{30C1B}; + #\u{30C1C}; + #\u{30C1D}; + #\u{30C1E}; + #\u{30C1F}; + #\u{30C20}; + #\u{30C21}; + #\u{30C22}; + #\u{30C23}; + #\u{30C24}; + #\u{30C25}; + #\u{30C26}; + #\u{30C27}; + #\u{30C28}; + #\u{30C29}; + #\u{30C2A}; + #\u{30C2B}; + #\u{30C2C}; + #\u{30C2D}; + #\u{30C2E}; + #\u{30C2F}; + #\u{30C30}; + #\u{30C31}; + #\u{30C32}; + #\u{30C33}; + #\u{30C34}; + #\u{30C35}; + #\u{30C36}; + #\u{30C37}; + #\u{30C38}; + #\u{30C39}; + #\u{30C3A}; + #\u{30C3B}; + #\u{30C3C}; + #\u{30C3D}; + #\u{30C3E}; + #\u{30C3F}; + #\u{30C40}; + #\u{30C41}; + #\u{30C42}; + #\u{30C43}; + #\u{30C44}; + #\u{30C45}; + #\u{30C46}; + #\u{30C47}; + #\u{30C48}; + #\u{30C49}; + #\u{30C4A}; + #\u{30C4B}; + #\u{30C4C}; + #\u{30C4D}; + #\u{30C4E}; + #\u{30C4F}; + #\u{30C50}; + #\u{30C51}; + #\u{30C52}; + #\u{30C53}; + #\u{30C54}; + #\u{30C55}; + #\u{30C56}; + #\u{30C57}; + #\u{30C58}; + #\u{30C59}; + #\u{30C5A}; + #\u{30C5B}; + #\u{30C5C}; + #\u{30C5D}; + #\u{30C5E}; + #\u{30C5F}; + #\u{30C60}; + #\u{30C61}; + #\u{30C62}; + #\u{30C63}; + #\u{30C64}; + #\u{30C65}; + #\u{30C66}; + #\u{30C67}; + #\u{30C68}; + #\u{30C69}; + #\u{30C6A}; + #\u{30C6B}; + #\u{30C6C}; + #\u{30C6D}; + #\u{30C6E}; + #\u{30C6F}; + #\u{30C70}; + #\u{30C71}; + #\u{30C72}; + #\u{30C73}; + #\u{30C74}; + #\u{30C75}; + #\u{30C76}; + #\u{30C77}; + #\u{30C78}; + #\u{30C79}; + #\u{30C7A}; + #\u{30C7B}; + #\u{30C7C}; + #\u{30C7D}; + #\u{30C7E}; + #\u{30C7F}; + #\u{30C80}; + #\u{30C81}; + #\u{30C82}; + #\u{30C83}; + #\u{30C84}; + #\u{30C85}; + #\u{30C86}; + #\u{30C87}; + #\u{30C88}; + #\u{30C89}; + #\u{30C8A}; + #\u{30C8B}; + #\u{30C8C}; + #\u{30C8D}; + #\u{30C8E}; + #\u{30C8F}; + #\u{30C90}; + #\u{30C91}; + #\u{30C92}; + #\u{30C93}; + #\u{30C94}; + #\u{30C95}; + #\u{30C96}; + #\u{30C97}; + #\u{30C98}; + #\u{30C99}; + #\u{30C9A}; + #\u{30C9B}; + #\u{30C9C}; + #\u{30C9D}; + #\u{30C9E}; + #\u{30C9F}; + #\u{30CA0}; + #\u{30CA1}; + #\u{30CA2}; + #\u{30CA3}; + #\u{30CA4}; + #\u{30CA5}; + #\u{30CA6}; + #\u{30CA7}; + #\u{30CA8}; + #\u{30CA9}; + #\u{30CAA}; + #\u{30CAB}; + #\u{30CAC}; + #\u{30CAD}; + #\u{30CAE}; + #\u{30CAF}; + #\u{30CB0}; + #\u{30CB1}; + #\u{30CB2}; + #\u{30CB3}; + #\u{30CB4}; + #\u{30CB5}; + #\u{30CB6}; + #\u{30CB7}; + #\u{30CB8}; + #\u{30CB9}; + #\u{30CBA}; + #\u{30CBB}; + #\u{30CBC}; + #\u{30CBD}; + #\u{30CBE}; + #\u{30CBF}; + #\u{30CC0}; + #\u{30CC1}; + #\u{30CC2}; + #\u{30CC3}; + #\u{30CC4}; + #\u{30CC5}; + #\u{30CC6}; + #\u{30CC7}; + #\u{30CC8}; + #\u{30CC9}; + #\u{30CCA}; + #\u{30CCB}; + #\u{30CCC}; + #\u{30CCD}; + #\u{30CCE}; + #\u{30CCF}; + #\u{30CD0}; + #\u{30CD1}; + #\u{30CD2}; + #\u{30CD3}; + #\u{30CD4}; + #\u{30CD5}; + #\u{30CD6}; + #\u{30CD7}; + #\u{30CD8}; + #\u{30CD9}; + #\u{30CDA}; + #\u{30CDB}; + #\u{30CDC}; + #\u{30CDD}; + #\u{30CDE}; + #\u{30CDF}; + #\u{30CE0}; + #\u{30CE1}; + #\u{30CE2}; + #\u{30CE3}; + #\u{30CE4}; + #\u{30CE5}; + #\u{30CE6}; + #\u{30CE7}; + #\u{30CE8}; + #\u{30CE9}; + #\u{30CEA}; + #\u{30CEB}; + #\u{30CEC}; + #\u{30CED}; + #\u{30CEE}; + #\u{30CEF}; + #\u{30CF0}; + #\u{30CF1}; + #\u{30CF2}; + #\u{30CF3}; + #\u{30CF4}; + #\u{30CF5}; + #\u{30CF6}; + #\u{30CF7}; + #\u{30CF8}; + #\u{30CF9}; + #\u{30CFA}; + #\u{30CFB}; + #\u{30CFC}; + #\u{30CFD}; + #\u{30CFE}; + #\u{30CFF}; + #\u{30D00}; + #\u{30D01}; + #\u{30D02}; + #\u{30D03}; + #\u{30D04}; + #\u{30D05}; + #\u{30D06}; + #\u{30D07}; + #\u{30D08}; + #\u{30D09}; + #\u{30D0A}; + #\u{30D0B}; + #\u{30D0C}; + #\u{30D0D}; + #\u{30D0E}; + #\u{30D0F}; + #\u{30D10}; + #\u{30D11}; + #\u{30D12}; + #\u{30D13}; + #\u{30D14}; + #\u{30D15}; + #\u{30D16}; + #\u{30D17}; + #\u{30D18}; + #\u{30D19}; + #\u{30D1A}; + #\u{30D1B}; + #\u{30D1C}; + #\u{30D1D}; + #\u{30D1E}; + #\u{30D1F}; + #\u{30D20}; + #\u{30D21}; + #\u{30D22}; + #\u{30D23}; + #\u{30D24}; + #\u{30D25}; + #\u{30D26}; + #\u{30D27}; + #\u{30D28}; + #\u{30D29}; + #\u{30D2A}; + #\u{30D2B}; + #\u{30D2C}; + #\u{30D2D}; + #\u{30D2E}; + #\u{30D2F}; + #\u{30D30}; + #\u{30D31}; + #\u{30D32}; + #\u{30D33}; + #\u{30D34}; + #\u{30D35}; + #\u{30D36}; + #\u{30D37}; + #\u{30D38}; + #\u{30D39}; + #\u{30D3A}; + #\u{30D3B}; + #\u{30D3C}; + #\u{30D3D}; + #\u{30D3E}; + #\u{30D3F}; + #\u{30D40}; + #\u{30D41}; + #\u{30D42}; + #\u{30D43}; + #\u{30D44}; + #\u{30D45}; + #\u{30D46}; + #\u{30D47}; + #\u{30D48}; + #\u{30D49}; + #\u{30D4A}; + #\u{30D4B}; + #\u{30D4C}; + #\u{30D4D}; + #\u{30D4E}; + #\u{30D4F}; + #\u{30D50}; + #\u{30D51}; + #\u{30D52}; + #\u{30D53}; + #\u{30D54}; + #\u{30D55}; + #\u{30D56}; + #\u{30D57}; + #\u{30D58}; + #\u{30D59}; + #\u{30D5A}; + #\u{30D5B}; + #\u{30D5C}; + #\u{30D5D}; + #\u{30D5E}; + #\u{30D5F}; + #\u{30D60}; + #\u{30D61}; + #\u{30D62}; + #\u{30D63}; + #\u{30D64}; + #\u{30D65}; + #\u{30D66}; + #\u{30D67}; + #\u{30D68}; + #\u{30D69}; + #\u{30D6A}; + #\u{30D6B}; + #\u{30D6C}; + #\u{30D6D}; + #\u{30D6E}; + #\u{30D6F}; + #\u{30D70}; + #\u{30D71}; + #\u{30D72}; + #\u{30D73}; + #\u{30D74}; + #\u{30D75}; + #\u{30D76}; + #\u{30D77}; + #\u{30D78}; + #\u{30D79}; + #\u{30D7A}; + #\u{30D7B}; + #\u{30D7C}; + #\u{30D7D}; + #\u{30D7E}; + #\u{30D7F}; + #\u{30D80}; + #\u{30D81}; + #\u{30D82}; + #\u{30D83}; + #\u{30D84}; + #\u{30D85}; + #\u{30D86}; + #\u{30D87}; + #\u{30D88}; + #\u{30D89}; + #\u{30D8A}; + #\u{30D8B}; + #\u{30D8C}; + #\u{30D8D}; + #\u{30D8E}; + #\u{30D8F}; + #\u{30D90}; + #\u{30D91}; + #\u{30D92}; + #\u{30D93}; + #\u{30D94}; + #\u{30D95}; + #\u{30D96}; + #\u{30D97}; + #\u{30D98}; + #\u{30D99}; + #\u{30D9A}; + #\u{30D9B}; + #\u{30D9C}; + #\u{30D9D}; + #\u{30D9E}; + #\u{30D9F}; + #\u{30DA0}; + #\u{30DA1}; + #\u{30DA2}; + #\u{30DA3}; + #\u{30DA4}; + #\u{30DA5}; + #\u{30DA6}; + #\u{30DA7}; + #\u{30DA8}; + #\u{30DA9}; + #\u{30DAA}; + #\u{30DAB}; + #\u{30DAC}; + #\u{30DAD}; + #\u{30DAE}; + #\u{30DAF}; + #\u{30DB0}; + #\u{30DB1}; + #\u{30DB2}; + #\u{30DB3}; + #\u{30DB4}; + #\u{30DB5}; + #\u{30DB6}; + #\u{30DB7}; + #\u{30DB8}; + #\u{30DB9}; + #\u{30DBA}; + #\u{30DBB}; + #\u{30DBC}; + #\u{30DBD}; + #\u{30DBE}; + #\u{30DBF}; + #\u{30DC0}; + #\u{30DC1}; + #\u{30DC2}; + #\u{30DC3}; + #\u{30DC4}; + #\u{30DC5}; + #\u{30DC6}; + #\u{30DC7}; + #\u{30DC8}; + #\u{30DC9}; + #\u{30DCA}; + #\u{30DCB}; + #\u{30DCC}; + #\u{30DCD}; + #\u{30DCE}; + #\u{30DCF}; + #\u{30DD0}; + #\u{30DD1}; + #\u{30DD2}; + #\u{30DD3}; + #\u{30DD4}; + #\u{30DD5}; + #\u{30DD6}; + #\u{30DD7}; + #\u{30DD8}; + #\u{30DD9}; + #\u{30DDA}; + #\u{30DDB}; + #\u{30DDC}; + #\u{30DDD}; + #\u{30DDE}; + #\u{30DDF}; + #\u{30DE0}; + #\u{30DE1}; + #\u{30DE2}; + #\u{30DE3}; + #\u{30DE4}; + #\u{30DE5}; + #\u{30DE6}; + #\u{30DE7}; + #\u{30DE8}; + #\u{30DE9}; + #\u{30DEA}; + #\u{30DEB}; + #\u{30DEC}; + #\u{30DED}; + #\u{30DEE}; + #\u{30DEF}; + #\u{30DF0}; + #\u{30DF1}; + #\u{30DF2}; + #\u{30DF3}; + #\u{30DF4}; + #\u{30DF5}; + #\u{30DF6}; + #\u{30DF7}; + #\u{30DF8}; + #\u{30DF9}; + #\u{30DFA}; + #\u{30DFB}; + #\u{30DFC}; + #\u{30DFD}; + #\u{30DFE}; + #\u{30DFF}; + #\u{30E00}; + #\u{30E01}; + #\u{30E02}; + #\u{30E03}; + #\u{30E04}; + #\u{30E05}; + #\u{30E06}; + #\u{30E07}; + #\u{30E08}; + #\u{30E09}; + #\u{30E0A}; + #\u{30E0B}; + #\u{30E0C}; + #\u{30E0D}; + #\u{30E0E}; + #\u{30E0F}; + #\u{30E10}; + #\u{30E11}; + #\u{30E12}; + #\u{30E13}; + #\u{30E14}; + #\u{30E15}; + #\u{30E16}; + #\u{30E17}; + #\u{30E18}; + #\u{30E19}; + #\u{30E1A}; + #\u{30E1B}; + #\u{30E1C}; + #\u{30E1D}; + #\u{30E1E}; + #\u{30E1F}; + #\u{30E20}; + #\u{30E21}; + #\u{30E22}; + #\u{30E23}; + #\u{30E24}; + #\u{30E25}; + #\u{30E26}; + #\u{30E27}; + #\u{30E28}; + #\u{30E29}; + #\u{30E2A}; + #\u{30E2B}; + #\u{30E2C}; + #\u{30E2D}; + #\u{30E2E}; + #\u{30E2F}; + #\u{30E30}; + #\u{30E31}; + #\u{30E32}; + #\u{30E33}; + #\u{30E34}; + #\u{30E35}; + #\u{30E36}; + #\u{30E37}; + #\u{30E38}; + #\u{30E39}; + #\u{30E3A}; + #\u{30E3B}; + #\u{30E3C}; + #\u{30E3D}; + #\u{30E3E}; + #\u{30E3F}; + #\u{30E40}; + #\u{30E41}; + #\u{30E42}; + #\u{30E43}; + #\u{30E44}; + #\u{30E45}; + #\u{30E46}; + #\u{30E47}; + #\u{30E48}; + #\u{30E49}; + #\u{30E4A}; + #\u{30E4B}; + #\u{30E4C}; + #\u{30E4D}; + #\u{30E4E}; + #\u{30E4F}; + #\u{30E50}; + #\u{30E51}; + #\u{30E52}; + #\u{30E53}; + #\u{30E54}; + #\u{30E55}; + #\u{30E56}; + #\u{30E57}; + #\u{30E58}; + #\u{30E59}; + #\u{30E5A}; + #\u{30E5B}; + #\u{30E5C}; + #\u{30E5D}; + #\u{30E5E}; + #\u{30E5F}; + #\u{30E60}; + #\u{30E61}; + #\u{30E62}; + #\u{30E63}; + #\u{30E64}; + #\u{30E65}; + #\u{30E66}; + #\u{30E67}; + #\u{30E68}; + #\u{30E69}; + #\u{30E6A}; + #\u{30E6B}; + #\u{30E6C}; + #\u{30E6D}; + #\u{30E6E}; + #\u{30E6F}; + #\u{30E70}; + #\u{30E71}; + #\u{30E72}; + #\u{30E73}; + #\u{30E74}; + #\u{30E75}; + #\u{30E76}; + #\u{30E77}; + #\u{30E78}; + #\u{30E79}; + #\u{30E7A}; + #\u{30E7B}; + #\u{30E7C}; + #\u{30E7D}; + #\u{30E7E}; + #\u{30E7F}; + #\u{30E80}; + #\u{30E81}; + #\u{30E82}; + #\u{30E83}; + #\u{30E84}; + #\u{30E85}; + #\u{30E86}; + #\u{30E87}; + #\u{30E88}; + #\u{30E89}; + #\u{30E8A}; + #\u{30E8B}; + #\u{30E8C}; + #\u{30E8D}; + #\u{30E8E}; + #\u{30E8F}; + #\u{30E90}; + #\u{30E91}; + #\u{30E92}; + #\u{30E93}; + #\u{30E94}; + #\u{30E95}; + #\u{30E96}; + #\u{30E97}; + #\u{30E98}; + #\u{30E99}; + #\u{30E9A}; + #\u{30E9B}; + #\u{30E9C}; + #\u{30E9D}; + #\u{30E9E}; + #\u{30E9F}; + #\u{30EA0}; + #\u{30EA1}; + #\u{30EA2}; + #\u{30EA3}; + #\u{30EA4}; + #\u{30EA5}; + #\u{30EA6}; + #\u{30EA7}; + #\u{30EA8}; + #\u{30EA9}; + #\u{30EAA}; + #\u{30EAB}; + #\u{30EAC}; + #\u{30EAD}; + #\u{30EAE}; + #\u{30EAF}; + #\u{30EB0}; + #\u{30EB1}; + #\u{30EB2}; + #\u{30EB3}; + #\u{30EB4}; + #\u{30EB5}; + #\u{30EB6}; + #\u{30EB7}; + #\u{30EB8}; + #\u{30EB9}; + #\u{30EBA}; + #\u{30EBB}; + #\u{30EBC}; + #\u{30EBD}; + #\u{30EBE}; + #\u{30EBF}; + #\u{30EC0}; + #\u{30EC1}; + #\u{30EC2}; + #\u{30EC3}; + #\u{30EC4}; + #\u{30EC5}; + #\u{30EC6}; + #\u{30EC7}; + #\u{30EC8}; + #\u{30EC9}; + #\u{30ECA}; + #\u{30ECB}; + #\u{30ECC}; + #\u{30ECD}; + #\u{30ECE}; + #\u{30ECF}; + #\u{30ED0}; + #\u{30ED1}; + #\u{30ED2}; + #\u{30ED3}; + #\u{30ED4}; + #\u{30ED5}; + #\u{30ED6}; + #\u{30ED7}; + #\u{30ED8}; + #\u{30ED9}; + #\u{30EDA}; + #\u{30EDB}; + #\u{30EDC}; + #\u{30EDD}; + #\u{30EDE}; + #\u{30EDF}; + #\u{30EE0}; + #\u{30EE1}; + #\u{30EE2}; + #\u{30EE3}; + #\u{30EE4}; + #\u{30EE5}; + #\u{30EE6}; + #\u{30EE7}; + #\u{30EE8}; + #\u{30EE9}; + #\u{30EEA}; + #\u{30EEB}; + #\u{30EEC}; + #\u{30EED}; + #\u{30EEE}; + #\u{30EEF}; + #\u{30EF0}; + #\u{30EF1}; + #\u{30EF2}; + #\u{30EF3}; + #\u{30EF4}; + #\u{30EF5}; + #\u{30EF6}; + #\u{30EF7}; + #\u{30EF8}; + #\u{30EF9}; + #\u{30EFA}; + #\u{30EFB}; + #\u{30EFC}; + #\u{30EFD}; + #\u{30EFE}; + #\u{30EFF}; + #\u{30F00}; + #\u{30F01}; + #\u{30F02}; + #\u{30F03}; + #\u{30F04}; + #\u{30F05}; + #\u{30F06}; + #\u{30F07}; + #\u{30F08}; + #\u{30F09}; + #\u{30F0A}; + #\u{30F0B}; + #\u{30F0C}; + #\u{30F0D}; + #\u{30F0E}; + #\u{30F0F}; + #\u{30F10}; + #\u{30F11}; + #\u{30F12}; + #\u{30F13}; + #\u{30F14}; + #\u{30F15}; + #\u{30F16}; + #\u{30F17}; + #\u{30F18}; + #\u{30F19}; + #\u{30F1A}; + #\u{30F1B}; + #\u{30F1C}; + #\u{30F1D}; + #\u{30F1E}; + #\u{30F1F}; + #\u{30F20}; + #\u{30F21}; + #\u{30F22}; + #\u{30F23}; + #\u{30F24}; + #\u{30F25}; + #\u{30F26}; + #\u{30F27}; + #\u{30F28}; + #\u{30F29}; + #\u{30F2A}; + #\u{30F2B}; + #\u{30F2C}; + #\u{30F2D}; + #\u{30F2E}; + #\u{30F2F}; + #\u{30F30}; + #\u{30F31}; + #\u{30F32}; + #\u{30F33}; + #\u{30F34}; + #\u{30F35}; + #\u{30F36}; + #\u{30F37}; + #\u{30F38}; + #\u{30F39}; + #\u{30F3A}; + #\u{30F3B}; + #\u{30F3C}; + #\u{30F3D}; + #\u{30F3E}; + #\u{30F3F}; + #\u{30F40}; + #\u{30F41}; + #\u{30F42}; + #\u{30F43}; + #\u{30F44}; + #\u{30F45}; + #\u{30F46}; + #\u{30F47}; + #\u{30F48}; + #\u{30F49}; + #\u{30F4A}; + #\u{30F4B}; + #\u{30F4C}; + #\u{30F4D}; + #\u{30F4E}; + #\u{30F4F}; + #\u{30F50}; + #\u{30F51}; + #\u{30F52}; + #\u{30F53}; + #\u{30F54}; + #\u{30F55}; + #\u{30F56}; + #\u{30F57}; + #\u{30F58}; + #\u{30F59}; + #\u{30F5A}; + #\u{30F5B}; + #\u{30F5C}; + #\u{30F5D}; + #\u{30F5E}; + #\u{30F5F}; + #\u{30F60}; + #\u{30F61}; + #\u{30F62}; + #\u{30F63}; + #\u{30F64}; + #\u{30F65}; + #\u{30F66}; + #\u{30F67}; + #\u{30F68}; + #\u{30F69}; + #\u{30F6A}; + #\u{30F6B}; + #\u{30F6C}; + #\u{30F6D}; + #\u{30F6E}; + #\u{30F6F}; + #\u{30F70}; + #\u{30F71}; + #\u{30F72}; + #\u{30F73}; + #\u{30F74}; + #\u{30F75}; + #\u{30F76}; + #\u{30F77}; + #\u{30F78}; + #\u{30F79}; + #\u{30F7A}; + #\u{30F7B}; + #\u{30F7C}; + #\u{30F7D}; + #\u{30F7E}; + #\u{30F7F}; + #\u{30F80}; + #\u{30F81}; + #\u{30F82}; + #\u{30F83}; + #\u{30F84}; + #\u{30F85}; + #\u{30F86}; + #\u{30F87}; + #\u{30F88}; + #\u{30F89}; + #\u{30F8A}; + #\u{30F8B}; + #\u{30F8C}; + #\u{30F8D}; + #\u{30F8E}; + #\u{30F8F}; + #\u{30F90}; + #\u{30F91}; + #\u{30F92}; + #\u{30F93}; + #\u{30F94}; + #\u{30F95}; + #\u{30F96}; + #\u{30F97}; + #\u{30F98}; + #\u{30F99}; + #\u{30F9A}; + #\u{30F9B}; + #\u{30F9C}; + #\u{30F9D}; + #\u{30F9E}; + #\u{30F9F}; + #\u{30FA0}; + #\u{30FA1}; + #\u{30FA2}; + #\u{30FA3}; + #\u{30FA4}; + #\u{30FA5}; + #\u{30FA6}; + #\u{30FA7}; + #\u{30FA8}; + #\u{30FA9}; + #\u{30FAA}; + #\u{30FAB}; + #\u{30FAC}; + #\u{30FAD}; + #\u{30FAE}; + #\u{30FAF}; + #\u{30FB0}; + #\u{30FB1}; + #\u{30FB2}; + #\u{30FB3}; + #\u{30FB4}; + #\u{30FB5}; + #\u{30FB6}; + #\u{30FB7}; + #\u{30FB8}; + #\u{30FB9}; + #\u{30FBA}; + #\u{30FBB}; + #\u{30FBC}; + #\u{30FBD}; + #\u{30FBE}; + #\u{30FBF}; + #\u{30FC0}; + #\u{30FC1}; + #\u{30FC2}; + #\u{30FC3}; + #\u{30FC4}; + #\u{30FC5}; + #\u{30FC6}; + #\u{30FC7}; + #\u{30FC8}; + #\u{30FC9}; + #\u{30FCA}; + #\u{30FCB}; + #\u{30FCC}; + #\u{30FCD}; + #\u{30FCE}; + #\u{30FCF}; + #\u{30FD0}; + #\u{30FD1}; + #\u{30FD2}; + #\u{30FD3}; + #\u{30FD4}; + #\u{30FD5}; + #\u{30FD6}; + #\u{30FD7}; + #\u{30FD8}; + #\u{30FD9}; + #\u{30FDA}; + #\u{30FDB}; + #\u{30FDC}; + #\u{30FDD}; + #\u{30FDE}; + #\u{30FDF}; + #\u{30FE0}; + #\u{30FE1}; + #\u{30FE2}; + #\u{30FE3}; + #\u{30FE4}; + #\u{30FE5}; + #\u{30FE6}; + #\u{30FE7}; + #\u{30FE8}; + #\u{30FE9}; + #\u{30FEA}; + #\u{30FEB}; + #\u{30FEC}; + #\u{30FED}; + #\u{30FEE}; + #\u{30FEF}; + #\u{30FF0}; + #\u{30FF1}; + #\u{30FF2}; + #\u{30FF3}; + #\u{30FF4}; + #\u{30FF5}; + #\u{30FF6}; + #\u{30FF7}; + #\u{30FF8}; + #\u{30FF9}; + #\u{30FFA}; + #\u{30FFB}; + #\u{30FFC}; + #\u{30FFD}; + #\u{30FFE}; + #\u{30FFF}; + #\u{31000}; + #\u{31001}; + #\u{31002}; + #\u{31003}; + #\u{31004}; + #\u{31005}; + #\u{31006}; + #\u{31007}; + #\u{31008}; + #\u{31009}; + #\u{3100A}; + #\u{3100B}; + #\u{3100C}; + #\u{3100D}; + #\u{3100E}; + #\u{3100F}; + #\u{31010}; + #\u{31011}; + #\u{31012}; + #\u{31013}; + #\u{31014}; + #\u{31015}; + #\u{31016}; + #\u{31017}; + #\u{31018}; + #\u{31019}; + #\u{3101A}; + #\u{3101B}; + #\u{3101C}; + #\u{3101D}; + #\u{3101E}; + #\u{3101F}; + #\u{31020}; + #\u{31021}; + #\u{31022}; + #\u{31023}; + #\u{31024}; + #\u{31025}; + #\u{31026}; + #\u{31027}; + #\u{31028}; + #\u{31029}; + #\u{3102A}; + #\u{3102B}; + #\u{3102C}; + #\u{3102D}; + #\u{3102E}; + #\u{3102F}; + #\u{31030}; + #\u{31031}; + #\u{31032}; + #\u{31033}; + #\u{31034}; + #\u{31035}; + #\u{31036}; + #\u{31037}; + #\u{31038}; + #\u{31039}; + #\u{3103A}; + #\u{3103B}; + #\u{3103C}; + #\u{3103D}; + #\u{3103E}; + #\u{3103F}; + #\u{31040}; + #\u{31041}; + #\u{31042}; + #\u{31043}; + #\u{31044}; + #\u{31045}; + #\u{31046}; + #\u{31047}; + #\u{31048}; + #\u{31049}; + #\u{3104A}; + #\u{3104B}; + #\u{3104C}; + #\u{3104D}; + #\u{3104E}; + #\u{3104F}; + #\u{31050}; + #\u{31051}; + #\u{31052}; + #\u{31053}; + #\u{31054}; + #\u{31055}; + #\u{31056}; + #\u{31057}; + #\u{31058}; + #\u{31059}; + #\u{3105A}; + #\u{3105B}; + #\u{3105C}; + #\u{3105D}; + #\u{3105E}; + #\u{3105F}; + #\u{31060}; + #\u{31061}; + #\u{31062}; + #\u{31063}; + #\u{31064}; + #\u{31065}; + #\u{31066}; + #\u{31067}; + #\u{31068}; + #\u{31069}; + #\u{3106A}; + #\u{3106B}; + #\u{3106C}; + #\u{3106D}; + #\u{3106E}; + #\u{3106F}; + #\u{31070}; + #\u{31071}; + #\u{31072}; + #\u{31073}; + #\u{31074}; + #\u{31075}; + #\u{31076}; + #\u{31077}; + #\u{31078}; + #\u{31079}; + #\u{3107A}; + #\u{3107B}; + #\u{3107C}; + #\u{3107D}; + #\u{3107E}; + #\u{3107F}; + #\u{31080}; + #\u{31081}; + #\u{31082}; + #\u{31083}; + #\u{31084}; + #\u{31085}; + #\u{31086}; + #\u{31087}; + #\u{31088}; + #\u{31089}; + #\u{3108A}; + #\u{3108B}; + #\u{3108C}; + #\u{3108D}; + #\u{3108E}; + #\u{3108F}; + #\u{31090}; + #\u{31091}; + #\u{31092}; + #\u{31093}; + #\u{31094}; + #\u{31095}; + #\u{31096}; + #\u{31097}; + #\u{31098}; + #\u{31099}; + #\u{3109A}; + #\u{3109B}; + #\u{3109C}; + #\u{3109D}; + #\u{3109E}; + #\u{3109F}; + #\u{310A0}; + #\u{310A1}; + #\u{310A2}; + #\u{310A3}; + #\u{310A4}; + #\u{310A5}; + #\u{310A6}; + #\u{310A7}; + #\u{310A8}; + #\u{310A9}; + #\u{310AA}; + #\u{310AB}; + #\u{310AC}; + #\u{310AD}; + #\u{310AE}; + #\u{310AF}; + #\u{310B0}; + #\u{310B1}; + #\u{310B2}; + #\u{310B3}; + #\u{310B4}; + #\u{310B5}; + #\u{310B6}; + #\u{310B7}; + #\u{310B8}; + #\u{310B9}; + #\u{310BA}; + #\u{310BB}; + #\u{310BC}; + #\u{310BD}; + #\u{310BE}; + #\u{310BF}; + #\u{310C0}; + #\u{310C1}; + #\u{310C2}; + #\u{310C3}; + #\u{310C4}; + #\u{310C5}; + #\u{310C6}; + #\u{310C7}; + #\u{310C8}; + #\u{310C9}; + #\u{310CA}; + #\u{310CB}; + #\u{310CC}; + #\u{310CD}; + #\u{310CE}; + #\u{310CF}; + #\u{310D0}; + #\u{310D1}; + #\u{310D2}; + #\u{310D3}; + #\u{310D4}; + #\u{310D5}; + #\u{310D6}; + #\u{310D7}; + #\u{310D8}; + #\u{310D9}; + #\u{310DA}; + #\u{310DB}; + #\u{310DC}; + #\u{310DD}; + #\u{310DE}; + #\u{310DF}; + #\u{310E0}; + #\u{310E1}; + #\u{310E2}; + #\u{310E3}; + #\u{310E4}; + #\u{310E5}; + #\u{310E6}; + #\u{310E7}; + #\u{310E8}; + #\u{310E9}; + #\u{310EA}; + #\u{310EB}; + #\u{310EC}; + #\u{310ED}; + #\u{310EE}; + #\u{310EF}; + #\u{310F0}; + #\u{310F1}; + #\u{310F2}; + #\u{310F3}; + #\u{310F4}; + #\u{310F5}; + #\u{310F6}; + #\u{310F7}; + #\u{310F8}; + #\u{310F9}; + #\u{310FA}; + #\u{310FB}; + #\u{310FC}; + #\u{310FD}; + #\u{310FE}; + #\u{310FF}; + #\u{31100}; + #\u{31101}; + #\u{31102}; + #\u{31103}; + #\u{31104}; + #\u{31105}; + #\u{31106}; + #\u{31107}; + #\u{31108}; + #\u{31109}; + #\u{3110A}; + #\u{3110B}; + #\u{3110C}; + #\u{3110D}; + #\u{3110E}; + #\u{3110F}; + #\u{31110}; + #\u{31111}; + #\u{31112}; + #\u{31113}; + #\u{31114}; + #\u{31115}; + #\u{31116}; + #\u{31117}; + #\u{31118}; + #\u{31119}; + #\u{3111A}; + #\u{3111B}; + #\u{3111C}; + #\u{3111D}; + #\u{3111E}; + #\u{3111F}; + #\u{31120}; + #\u{31121}; + #\u{31122}; + #\u{31123}; + #\u{31124}; + #\u{31125}; + #\u{31126}; + #\u{31127}; + #\u{31128}; + #\u{31129}; + #\u{3112A}; + #\u{3112B}; + #\u{3112C}; + #\u{3112D}; + #\u{3112E}; + #\u{3112F}; + #\u{31130}; + #\u{31131}; + #\u{31132}; + #\u{31133}; + #\u{31134}; + #\u{31135}; + #\u{31136}; + #\u{31137}; + #\u{31138}; + #\u{31139}; + #\u{3113A}; + #\u{3113B}; + #\u{3113C}; + #\u{3113D}; + #\u{3113E}; + #\u{3113F}; + #\u{31140}; + #\u{31141}; + #\u{31142}; + #\u{31143}; + #\u{31144}; + #\u{31145}; + #\u{31146}; + #\u{31147}; + #\u{31148}; + #\u{31149}; + #\u{3114A}; + #\u{3114B}; + #\u{3114C}; + #\u{3114D}; + #\u{3114E}; + #\u{3114F}; + #\u{31150}; + #\u{31151}; + #\u{31152}; + #\u{31153}; + #\u{31154}; + #\u{31155}; + #\u{31156}; + #\u{31157}; + #\u{31158}; + #\u{31159}; + #\u{3115A}; + #\u{3115B}; + #\u{3115C}; + #\u{3115D}; + #\u{3115E}; + #\u{3115F}; + #\u{31160}; + #\u{31161}; + #\u{31162}; + #\u{31163}; + #\u{31164}; + #\u{31165}; + #\u{31166}; + #\u{31167}; + #\u{31168}; + #\u{31169}; + #\u{3116A}; + #\u{3116B}; + #\u{3116C}; + #\u{3116D}; + #\u{3116E}; + #\u{3116F}; + #\u{31170}; + #\u{31171}; + #\u{31172}; + #\u{31173}; + #\u{31174}; + #\u{31175}; + #\u{31176}; + #\u{31177}; + #\u{31178}; + #\u{31179}; + #\u{3117A}; + #\u{3117B}; + #\u{3117C}; + #\u{3117D}; + #\u{3117E}; + #\u{3117F}; + #\u{31180}; + #\u{31181}; + #\u{31182}; + #\u{31183}; + #\u{31184}; + #\u{31185}; + #\u{31186}; + #\u{31187}; + #\u{31188}; + #\u{31189}; + #\u{3118A}; + #\u{3118B}; + #\u{3118C}; + #\u{3118D}; + #\u{3118E}; + #\u{3118F}; + #\u{31190}; + #\u{31191}; + #\u{31192}; + #\u{31193}; + #\u{31194}; + #\u{31195}; + #\u{31196}; + #\u{31197}; + #\u{31198}; + #\u{31199}; + #\u{3119A}; + #\u{3119B}; + #\u{3119C}; + #\u{3119D}; + #\u{3119E}; + #\u{3119F}; + #\u{311A0}; + #\u{311A1}; + #\u{311A2}; + #\u{311A3}; + #\u{311A4}; + #\u{311A5}; + #\u{311A6}; + #\u{311A7}; + #\u{311A8}; + #\u{311A9}; + #\u{311AA}; + #\u{311AB}; + #\u{311AC}; + #\u{311AD}; + #\u{311AE}; + #\u{311AF}; + #\u{311B0}; + #\u{311B1}; + #\u{311B2}; + #\u{311B3}; + #\u{311B4}; + #\u{311B5}; + #\u{311B6}; + #\u{311B7}; + #\u{311B8}; + #\u{311B9}; + #\u{311BA}; + #\u{311BB}; + #\u{311BC}; + #\u{311BD}; + #\u{311BE}; + #\u{311BF}; + #\u{311C0}; + #\u{311C1}; + #\u{311C2}; + #\u{311C3}; + #\u{311C4}; + #\u{311C5}; + #\u{311C6}; + #\u{311C7}; + #\u{311C8}; + #\u{311C9}; + #\u{311CA}; + #\u{311CB}; + #\u{311CC}; + #\u{311CD}; + #\u{311CE}; + #\u{311CF}; + #\u{311D0}; + #\u{311D1}; + #\u{311D2}; + #\u{311D3}; + #\u{311D4}; + #\u{311D5}; + #\u{311D6}; + #\u{311D7}; + #\u{311D8}; + #\u{311D9}; + #\u{311DA}; + #\u{311DB}; + #\u{311DC}; + #\u{311DD}; + #\u{311DE}; + #\u{311DF}; + #\u{311E0}; + #\u{311E1}; + #\u{311E2}; + #\u{311E3}; + #\u{311E4}; + #\u{311E5}; + #\u{311E6}; + #\u{311E7}; + #\u{311E8}; + #\u{311E9}; + #\u{311EA}; + #\u{311EB}; + #\u{311EC}; + #\u{311ED}; + #\u{311EE}; + #\u{311EF}; + #\u{311F0}; + #\u{311F1}; + #\u{311F2}; + #\u{311F3}; + #\u{311F4}; + #\u{311F5}; + #\u{311F6}; + #\u{311F7}; + #\u{311F8}; + #\u{311F9}; + #\u{311FA}; + #\u{311FB}; + #\u{311FC}; + #\u{311FD}; + #\u{311FE}; + #\u{311FF}; + #\u{31200}; + #\u{31201}; + #\u{31202}; + #\u{31203}; + #\u{31204}; + #\u{31205}; + #\u{31206}; + #\u{31207}; + #\u{31208}; + #\u{31209}; + #\u{3120A}; + #\u{3120B}; + #\u{3120C}; + #\u{3120D}; + #\u{3120E}; + #\u{3120F}; + #\u{31210}; + #\u{31211}; + #\u{31212}; + #\u{31213}; + #\u{31214}; + #\u{31215}; + #\u{31216}; + #\u{31217}; + #\u{31218}; + #\u{31219}; + #\u{3121A}; + #\u{3121B}; + #\u{3121C}; + #\u{3121D}; + #\u{3121E}; + #\u{3121F}; + #\u{31220}; + #\u{31221}; + #\u{31222}; + #\u{31223}; + #\u{31224}; + #\u{31225}; + #\u{31226}; + #\u{31227}; + #\u{31228}; + #\u{31229}; + #\u{3122A}; + #\u{3122B}; + #\u{3122C}; + #\u{3122D}; + #\u{3122E}; + #\u{3122F}; + #\u{31230}; + #\u{31231}; + #\u{31232}; + #\u{31233}; + #\u{31234}; + #\u{31235}; + #\u{31236}; + #\u{31237}; + #\u{31238}; + #\u{31239}; + #\u{3123A}; + #\u{3123B}; + #\u{3123C}; + #\u{3123D}; + #\u{3123E}; + #\u{3123F}; + #\u{31240}; + #\u{31241}; + #\u{31242}; + #\u{31243}; + #\u{31244}; + #\u{31245}; + #\u{31246}; + #\u{31247}; + #\u{31248}; + #\u{31249}; + #\u{3124A}; + #\u{3124B}; + #\u{3124C}; + #\u{3124D}; + #\u{3124E}; + #\u{3124F}; + #\u{31250}; + #\u{31251}; + #\u{31252}; + #\u{31253}; + #\u{31254}; + #\u{31255}; + #\u{31256}; + #\u{31257}; + #\u{31258}; + #\u{31259}; + #\u{3125A}; + #\u{3125B}; + #\u{3125C}; + #\u{3125D}; + #\u{3125E}; + #\u{3125F}; + #\u{31260}; + #\u{31261}; + #\u{31262}; + #\u{31263}; + #\u{31264}; + #\u{31265}; + #\u{31266}; + #\u{31267}; + #\u{31268}; + #\u{31269}; + #\u{3126A}; + #\u{3126B}; + #\u{3126C}; + #\u{3126D}; + #\u{3126E}; + #\u{3126F}; + #\u{31270}; + #\u{31271}; + #\u{31272}; + #\u{31273}; + #\u{31274}; + #\u{31275}; + #\u{31276}; + #\u{31277}; + #\u{31278}; + #\u{31279}; + #\u{3127A}; + #\u{3127B}; + #\u{3127C}; + #\u{3127D}; + #\u{3127E}; + #\u{3127F}; + #\u{31280}; + #\u{31281}; + #\u{31282}; + #\u{31283}; + #\u{31284}; + #\u{31285}; + #\u{31286}; + #\u{31287}; + #\u{31288}; + #\u{31289}; + #\u{3128A}; + #\u{3128B}; + #\u{3128C}; + #\u{3128D}; + #\u{3128E}; + #\u{3128F}; + #\u{31290}; + #\u{31291}; + #\u{31292}; + #\u{31293}; + #\u{31294}; + #\u{31295}; + #\u{31296}; + #\u{31297}; + #\u{31298}; + #\u{31299}; + #\u{3129A}; + #\u{3129B}; + #\u{3129C}; + #\u{3129D}; + #\u{3129E}; + #\u{3129F}; + #\u{312A0}; + #\u{312A1}; + #\u{312A2}; + #\u{312A3}; + #\u{312A4}; + #\u{312A5}; + #\u{312A6}; + #\u{312A7}; + #\u{312A8}; + #\u{312A9}; + #\u{312AA}; + #\u{312AB}; + #\u{312AC}; + #\u{312AD}; + #\u{312AE}; + #\u{312AF}; + #\u{312B0}; + #\u{312B1}; + #\u{312B2}; + #\u{312B3}; + #\u{312B4}; + #\u{312B5}; + #\u{312B6}; + #\u{312B7}; + #\u{312B8}; + #\u{312B9}; + #\u{312BA}; + #\u{312BB}; + #\u{312BC}; + #\u{312BD}; + #\u{312BE}; + #\u{312BF}; + #\u{312C0}; + #\u{312C1}; + #\u{312C2}; + #\u{312C3}; + #\u{312C4}; + #\u{312C5}; + #\u{312C6}; + #\u{312C7}; + #\u{312C8}; + #\u{312C9}; + #\u{312CA}; + #\u{312CB}; + #\u{312CC}; + #\u{312CD}; + #\u{312CE}; + #\u{312CF}; + #\u{312D0}; + #\u{312D1}; + #\u{312D2}; + #\u{312D3}; + #\u{312D4}; + #\u{312D5}; + #\u{312D6}; + #\u{312D7}; + #\u{312D8}; + #\u{312D9}; + #\u{312DA}; + #\u{312DB}; + #\u{312DC}; + #\u{312DD}; + #\u{312DE}; + #\u{312DF}; + #\u{312E0}; + #\u{312E1}; + #\u{312E2}; + #\u{312E3}; + #\u{312E4}; + #\u{312E5}; + #\u{312E6}; + #\u{312E7}; + #\u{312E8}; + #\u{312E9}; + #\u{312EA}; + #\u{312EB}; + #\u{312EC}; + #\u{312ED}; + #\u{312EE}; + #\u{312EF}; + #\u{312F0}; + #\u{312F1}; + #\u{312F2}; + #\u{312F3}; + #\u{312F4}; + #\u{312F5}; + #\u{312F6}; + #\u{312F7}; + #\u{312F8}; + #\u{312F9}; + #\u{312FA}; + #\u{312FB}; + #\u{312FC}; + #\u{312FD}; + #\u{312FE}; + #\u{312FF}; + #\u{31300}; + #\u{31301}; + #\u{31302}; + #\u{31303}; + #\u{31304}; + #\u{31305}; + #\u{31306}; + #\u{31307}; + #\u{31308}; + #\u{31309}; + #\u{3130A}; + #\u{3130B}; + #\u{3130C}; + #\u{3130D}; + #\u{3130E}; + #\u{3130F}; + #\u{31310}; + #\u{31311}; + #\u{31312}; + #\u{31313}; + #\u{31314}; + #\u{31315}; + #\u{31316}; + #\u{31317}; + #\u{31318}; + #\u{31319}; + #\u{3131A}; + #\u{3131B}; + #\u{3131C}; + #\u{3131D}; + #\u{3131E}; + #\u{3131F}; + #\u{31320}; + #\u{31321}; + #\u{31322}; + #\u{31323}; + #\u{31324}; + #\u{31325}; + #\u{31326}; + #\u{31327}; + #\u{31328}; + #\u{31329}; + #\u{3132A}; + #\u{3132B}; + #\u{3132C}; + #\u{3132D}; + #\u{3132E}; + #\u{3132F}; + #\u{31330}; + #\u{31331}; + #\u{31332}; + #\u{31333}; + #\u{31334}; + #\u{31335}; + #\u{31336}; + #\u{31337}; + #\u{31338}; + #\u{31339}; + #\u{3133A}; + #\u{3133B}; + #\u{3133C}; + #\u{3133D}; + #\u{3133E}; + #\u{3133F}; + #\u{31340}; + #\u{31341}; + #\u{31342}; + #\u{31343}; + #\u{31344}; + #\u{31345}; + #\u{31346}; + #\u{31347}; + #\u{31348}; + #\u{31349}; + #\u{3134A}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0-class.js new file mode 100644 index 000000000..f0923e24e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0-class.js @@ -0,0 +1,5614 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v13.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #ࢾ; + #ࢿ; + #ࣀ; + #ࣁ; + #ࣂ; + #ࣃ; + #ࣄ; + #ࣅ; + #ࣆ; + #ࣇ; + #ഄ; + #ㆻ; + #ㆼ; + #ㆽ; + #ㆾ; + #ㆿ; + #䶶; + #䶷; + #䶸; + #䶹; + #䶺; + #䶻; + #䶼; + #䶽; + #䶾; + #䶿; + #鿰; + #鿱; + #鿲; + #鿳; + #鿴; + #鿵; + #鿶; + #鿷; + #鿸; + #鿹; + #鿺; + #鿻; + #鿼; + #Ꟈ; + #ꟈ; + #Ꟊ; + #ꟊ; + #Ꟶ; + #ꟶ; + #ꭨ; + #ꭩ; + #𐺀; + #𐺁; + #𐺂; + #𐺃; + #𐺄; + #𐺅; + #𐺆; + #𐺇; + #𐺈; + #𐺉; + #𐺊; + #𐺋; + #𐺌; + #𐺍; + #𐺎; + #𐺏; + #𐺐; + #𐺑; + #𐺒; + #𐺓; + #𐺔; + #𐺕; + #𐺖; + #𐺗; + #𐺘; + #𐺙; + #𐺚; + #𐺛; + #𐺜; + #𐺝; + #𐺞; + #𐺟; + #𐺠; + #𐺡; + #𐺢; + #𐺣; + #𐺤; + #𐺥; + #𐺦; + #𐺧; + #𐺨; + #𐺩; + #𐺰; + #𐺱; + #𐾰; + #𐾱; + #𐾲; + #𐾳; + #𐾴; + #𐾵; + #𐾶; + #𐾷; + #𐾸; + #𐾹; + #𐾺; + #𐾻; + #𐾼; + #𐾽; + #𐾾; + #𐾿; + #𐿀; + #𐿁; + #𐿂; + #𐿃; + #𐿄; + #𑅇; + #𑑠; + #𑑡; + #𑤀; + #𑤁; + #𑤂; + #𑤃; + #𑤄; + #𑤅; + #𑤆; + #𑤉; + #𑤌; + #𑤍; + #𑤎; + #𑤏; + #𑤐; + #𑤑; + #𑤒; + #𑤓; + #𑤕; + #𑤖; + #𑤘; + #𑤙; + #𑤚; + #𑤛; + #𑤜; + #𑤝; + #𑤞; + #𑤟; + #𑤠; + #𑤡; + #𑤢; + #𑤣; + #𑤤; + #𑤥; + #𑤦; + #𑤧; + #𑤨; + #𑤩; + #𑤪; + #𑤫; + #𑤬; + #𑤭; + #𑤮; + #𑤯; + #𑤿; + #𑥁; + #𑾰; + #𘫳; + #𘫴; + #𘫵; + #𘫶; + #𘫷; + #𘫸; + #𘫹; + #𘫺; + #𘫻; + #𘫼; + #𘫽; + #𘫾; + #𘫿; + #𘬀; + #𘬁; + #𘬂; + #𘬃; + #𘬄; + #𘬅; + #𘬆; + #𘬇; + #𘬈; + #𘬉; + #𘬊; + #𘬋; + #𘬌; + #𘬍; + #𘬎; + #𘬏; + #𘬐; + #𘬑; + #𘬒; + #𘬓; + #𘬔; + #𘬕; + #𘬖; + #𘬗; + #𘬘; + #𘬙; + #𘬚; + #𘬛; + #𘬜; + #𘬝; + #𘬞; + #𘬟; + #𘬠; + #𘬡; + #𘬢; + #𘬣; + #𘬤; + #𘬥; + #𘬦; + #𘬧; + #𘬨; + #𘬩; + #𘬪; + #𘬫; + #𘬬; + #𘬭; + #𘬮; + #𘬯; + #𘬰; + #𘬱; + #𘬲; + #𘬳; + #𘬴; + #𘬵; + #𘬶; + #𘬷; + #𘬸; + #𘬹; + #𘬺; + #𘬻; + #𘬼; + #𘬽; + #𘬾; + #𘬿; + #𘭀; + #𘭁; + #𘭂; + #𘭃; + #𘭄; + #𘭅; + #𘭆; + #𘭇; + #𘭈; + #𘭉; + #𘭊; + #𘭋; + #𘭌; + #𘭍; + #𘭎; + #𘭏; + #𘭐; + #𘭑; + #𘭒; + #𘭓; + #𘭔; + #𘭕; + #𘭖; + #𘭗; + #𘭘; + #𘭙; + #𘭚; + #𘭛; + #𘭜; + #𘭝; + #𘭞; + #𘭟; + #𘭠; + #𘭡; + #𘭢; + #𘭣; + #𘭤; + #𘭥; + #𘭦; + #𘭧; + #𘭨; + #𘭩; + #𘭪; + #𘭫; + #𘭬; + #𘭭; + #𘭮; + #𘭯; + #𘭰; + #𘭱; + #𘭲; + #𘭳; + #𘭴; + #𘭵; + #𘭶; + #𘭷; + #𘭸; + #𘭹; + #𘭺; + #𘭻; + #𘭼; + #𘭽; + #𘭾; + #𘭿; + #𘮀; + #𘮁; + #𘮂; + #𘮃; + #𘮄; + #𘮅; + #𘮆; + #𘮇; + #𘮈; + #𘮉; + #𘮊; + #𘮋; + #𘮌; + #𘮍; + #𘮎; + #𘮏; + #𘮐; + #𘮑; + #𘮒; + #𘮓; + #𘮔; + #𘮕; + #𘮖; + #𘮗; + #𘮘; + #𘮙; + #𘮚; + #𘮛; + #𘮜; + #𘮝; + #𘮞; + #𘮟; + #𘮠; + #𘮡; + #𘮢; + #𘮣; + #𘮤; + #𘮥; + #𘮦; + #𘮧; + #𘮨; + #𘮩; + #𘮪; + #𘮫; + #𘮬; + #𘮭; + #𘮮; + #𘮯; + #𘮰; + #𘮱; + #𘮲; + #𘮳; + #𘮴; + #𘮵; + #𘮶; + #𘮷; + #𘮸; + #𘮹; + #𘮺; + #𘮻; + #𘮼; + #𘮽; + #𘮾; + #𘮿; + #𘯀; + #𘯁; + #𘯂; + #𘯃; + #𘯄; + #𘯅; + #𘯆; + #𘯇; + #𘯈; + #𘯉; + #𘯊; + #𘯋; + #𘯌; + #𘯍; + #𘯎; + #𘯏; + #𘯐; + #𘯑; + #𘯒; + #𘯓; + #𘯔; + #𘯕; + #𘯖; + #𘯗; + #𘯘; + #𘯙; + #𘯚; + #𘯛; + #𘯜; + #𘯝; + #𘯞; + #𘯟; + #𘯠; + #𘯡; + #𘯢; + #𘯣; + #𘯤; + #𘯥; + #𘯦; + #𘯧; + #𘯨; + #𘯩; + #𘯪; + #𘯫; + #𘯬; + #𘯭; + #𘯮; + #𘯯; + #𘯰; + #𘯱; + #𘯲; + #𘯳; + #𘯴; + #𘯵; + #𘯶; + #𘯷; + #𘯸; + #𘯹; + #𘯺; + #𘯻; + #𘯼; + #𘯽; + #𘯾; + #𘯿; + #𘰀; + #𘰁; + #𘰂; + #𘰃; + #𘰄; + #𘰅; + #𘰆; + #𘰇; + #𘰈; + #𘰉; + #𘰊; + #𘰋; + #𘰌; + #𘰍; + #𘰎; + #𘰏; + #𘰐; + #𘰑; + #𘰒; + #𘰓; + #𘰔; + #𘰕; + #𘰖; + #𘰗; + #𘰘; + #𘰙; + #𘰚; + #𘰛; + #𘰜; + #𘰝; + #𘰞; + #𘰟; + #𘰠; + #𘰡; + #𘰢; + #𘰣; + #𘰤; + #𘰥; + #𘰦; + #𘰧; + #𘰨; + #𘰩; + #𘰪; + #𘰫; + #𘰬; + #𘰭; + #𘰮; + #𘰯; + #𘰰; + #𘰱; + #𘰲; + #𘰳; + #𘰴; + #𘰵; + #𘰶; + #𘰷; + #𘰸; + #𘰹; + #𘰺; + #𘰻; + #𘰼; + #𘰽; + #𘰾; + #𘰿; + #𘱀; + #𘱁; + #𘱂; + #𘱃; + #𘱄; + #𘱅; + #𘱆; + #𘱇; + #𘱈; + #𘱉; + #𘱊; + #𘱋; + #𘱌; + #𘱍; + #𘱎; + #𘱏; + #𘱐; + #𘱑; + #𘱒; + #𘱓; + #𘱔; + #𘱕; + #𘱖; + #𘱗; + #𘱘; + #𘱙; + #𘱚; + #𘱛; + #𘱜; + #𘱝; + #𘱞; + #𘱟; + #𘱠; + #𘱡; + #𘱢; + #𘱣; + #𘱤; + #𘱥; + #𘱦; + #𘱧; + #𘱨; + #𘱩; + #𘱪; + #𘱫; + #𘱬; + #𘱭; + #𘱮; + #𘱯; + #𘱰; + #𘱱; + #𘱲; + #𘱳; + #𘱴; + #𘱵; + #𘱶; + #𘱷; + #𘱸; + #𘱹; + #𘱺; + #𘱻; + #𘱼; + #𘱽; + #𘱾; + #𘱿; + #𘲀; + #𘲁; + #𘲂; + #𘲃; + #𘲄; + #𘲅; + #𘲆; + #𘲇; + #𘲈; + #𘲉; + #𘲊; + #𘲋; + #𘲌; + #𘲍; + #𘲎; + #𘲏; + #𘲐; + #𘲑; + #𘲒; + #𘲓; + #𘲔; + #𘲕; + #𘲖; + #𘲗; + #𘲘; + #𘲙; + #𘲚; + #𘲛; + #𘲜; + #𘲝; + #𘲞; + #𘲟; + #𘲠; + #𘲡; + #𘲢; + #𘲣; + #𘲤; + #𘲥; + #𘲦; + #𘲧; + #𘲨; + #𘲩; + #𘲪; + #𘲫; + #𘲬; + #𘲭; + #𘲮; + #𘲯; + #𘲰; + #𘲱; + #𘲲; + #𘲳; + #𘲴; + #𘲵; + #𘲶; + #𘲷; + #𘲸; + #𘲹; + #𘲺; + #𘲻; + #𘲼; + #𘲽; + #𘲾; + #𘲿; + #𘳀; + #𘳁; + #𘳂; + #𘳃; + #𘳄; + #𘳅; + #𘳆; + #𘳇; + #𘳈; + #𘳉; + #𘳊; + #𘳋; + #𘳌; + #𘳍; + #𘳎; + #𘳏; + #𘳐; + #𘳑; + #𘳒; + #𘳓; + #𘳔; + #𘳕; + #𘴀; + #𘴁; + #𘴂; + #𘴃; + #𘴄; + #𘴅; + #𘴆; + #𘴇; + #𘴈; + #𪛗; + #𪛘; + #𪛙; + #𪛚; + #𪛛; + #𪛜; + #𪛝; + #𰀀; + #𰀁; + #𰀂; + #𰀃; + #𰀄; + #𰀅; + #𰀆; + #𰀇; + #𰀈; + #𰀉; + #𰀊; + #𰀋; + #𰀌; + #𰀍; + #𰀎; + #𰀏; + #𰀐; + #𰀑; + #𰀒; + #𰀓; + #𰀔; + #𰀕; + #𰀖; + #𰀗; + #𰀘; + #𰀙; + #𰀚; + #𰀛; + #𰀜; + #𰀝; + #𰀞; + #𰀟; + #𰀠; + #𰀡; + #𰀢; + #𰀣; + #𰀤; + #𰀥; + #𰀦; + #𰀧; + #𰀨; + #𰀩; + #𰀪; + #𰀫; + #𰀬; + #𰀭; + #𰀮; + #𰀯; + #𰀰; + #𰀱; + #𰀲; + #𰀳; + #𰀴; + #𰀵; + #𰀶; + #𰀷; + #𰀸; + #𰀹; + #𰀺; + #𰀻; + #𰀼; + #𰀽; + #𰀾; + #𰀿; + #𰁀; + #𰁁; + #𰁂; + #𰁃; + #𰁄; + #𰁅; + #𰁆; + #𰁇; + #𰁈; + #𰁉; + #𰁊; + #𰁋; + #𰁌; + #𰁍; + #𰁎; + #𰁏; + #𰁐; + #𰁑; + #𰁒; + #𰁓; + #𰁔; + #𰁕; + #𰁖; + #𰁗; + #𰁘; + #𰁙; + #𰁚; + #𰁛; + #𰁜; + #𰁝; + #𰁞; + #𰁟; + #𰁠; + #𰁡; + #𰁢; + #𰁣; + #𰁤; + #𰁥; + #𰁦; + #𰁧; + #𰁨; + #𰁩; + #𰁪; + #𰁫; + #𰁬; + #𰁭; + #𰁮; + #𰁯; + #𰁰; + #𰁱; + #𰁲; + #𰁳; + #𰁴; + #𰁵; + #𰁶; + #𰁷; + #𰁸; + #𰁹; + #𰁺; + #𰁻; + #𰁼; + #𰁽; + #𰁾; + #𰁿; + #𰂀; + #𰂁; + #𰂂; + #𰂃; + #𰂄; + #𰂅; + #𰂆; + #𰂇; + #𰂈; + #𰂉; + #𰂊; + #𰂋; + #𰂌; + #𰂍; + #𰂎; + #𰂏; + #𰂐; + #𰂑; + #𰂒; + #𰂓; + #𰂔; + #𰂕; + #𰂖; + #𰂗; + #𰂘; + #𰂙; + #𰂚; + #𰂛; + #𰂜; + #𰂝; + #𰂞; + #𰂟; + #𰂠; + #𰂡; + #𰂢; + #𰂣; + #𰂤; + #𰂥; + #𰂦; + #𰂧; + #𰂨; + #𰂩; + #𰂪; + #𰂫; + #𰂬; + #𰂭; + #𰂮; + #𰂯; + #𰂰; + #𰂱; + #𰂲; + #𰂳; + #𰂴; + #𰂵; + #𰂶; + #𰂷; + #𰂸; + #𰂹; + #𰂺; + #𰂻; + #𰂼; + #𰂽; + #𰂾; + #𰂿; + #𰃀; + #𰃁; + #𰃂; + #𰃃; + #𰃄; + #𰃅; + #𰃆; + #𰃇; + #𰃈; + #𰃉; + #𰃊; + #𰃋; + #𰃌; + #𰃍; + #𰃎; + #𰃏; + #𰃐; + #𰃑; + #𰃒; + #𰃓; + #𰃔; + #𰃕; + #𰃖; + #𰃗; + #𰃘; + #𰃙; + #𰃚; + #𰃛; + #𰃜; + #𰃝; + #𰃞; + #𰃟; + #𰃠; + #𰃡; + #𰃢; + #𰃣; + #𰃤; + #𰃥; + #𰃦; + #𰃧; + #𰃨; + #𰃩; + #𰃪; + #𰃫; + #𰃬; + #𰃭; + #𰃮; + #𰃯; + #𰃰; + #𰃱; + #𰃲; + #𰃳; + #𰃴; + #𰃵; + #𰃶; + #𰃷; + #𰃸; + #𰃹; + #𰃺; + #𰃻; + #𰃼; + #𰃽; + #𰃾; + #𰃿; + #𰄀; + #𰄁; + #𰄂; + #𰄃; + #𰄄; + #𰄅; + #𰄆; + #𰄇; + #𰄈; + #𰄉; + #𰄊; + #𰄋; + #𰄌; + #𰄍; + #𰄎; + #𰄏; + #𰄐; + #𰄑; + #𰄒; + #𰄓; + #𰄔; + #𰄕; + #𰄖; + #𰄗; + #𰄘; + #𰄙; + #𰄚; + #𰄛; + #𰄜; + #𰄝; + #𰄞; + #𰄟; + #𰄠; + #𰄡; + #𰄢; + #𰄣; + #𰄤; + #𰄥; + #𰄦; + #𰄧; + #𰄨; + #𰄩; + #𰄪; + #𰄫; + #𰄬; + #𰄭; + #𰄮; + #𰄯; + #𰄰; + #𰄱; + #𰄲; + #𰄳; + #𰄴; + #𰄵; + #𰄶; + #𰄷; + #𰄸; + #𰄹; + #𰄺; + #𰄻; + #𰄼; + #𰄽; + #𰄾; + #𰄿; + #𰅀; + #𰅁; + #𰅂; + #𰅃; + #𰅄; + #𰅅; + #𰅆; + #𰅇; + #𰅈; + #𰅉; + #𰅊; + #𰅋; + #𰅌; + #𰅍; + #𰅎; + #𰅏; + #𰅐; + #𰅑; + #𰅒; + #𰅓; + #𰅔; + #𰅕; + #𰅖; + #𰅗; + #𰅘; + #𰅙; + #𰅚; + #𰅛; + #𰅜; + #𰅝; + #𰅞; + #𰅟; + #𰅠; + #𰅡; + #𰅢; + #𰅣; + #𰅤; + #𰅥; + #𰅦; + #𰅧; + #𰅨; + #𰅩; + #𰅪; + #𰅫; + #𰅬; + #𰅭; + #𰅮; + #𰅯; + #𰅰; + #𰅱; + #𰅲; + #𰅳; + #𰅴; + #𰅵; + #𰅶; + #𰅷; + #𰅸; + #𰅹; + #𰅺; + #𰅻; + #𰅼; + #𰅽; + #𰅾; + #𰅿; + #𰆀; + #𰆁; + #𰆂; + #𰆃; + #𰆄; + #𰆅; + #𰆆; + #𰆇; + #𰆈; + #𰆉; + #𰆊; + #𰆋; + #𰆌; + #𰆍; + #𰆎; + #𰆏; + #𰆐; + #𰆑; + #𰆒; + #𰆓; + #𰆔; + #𰆕; + #𰆖; + #𰆗; + #𰆘; + #𰆙; + #𰆚; + #𰆛; + #𰆜; + #𰆝; + #𰆞; + #𰆟; + #𰆠; + #𰆡; + #𰆢; + #𰆣; + #𰆤; + #𰆥; + #𰆦; + #𰆧; + #𰆨; + #𰆩; + #𰆪; + #𰆫; + #𰆬; + #𰆭; + #𰆮; + #𰆯; + #𰆰; + #𰆱; + #𰆲; + #𰆳; + #𰆴; + #𰆵; + #𰆶; + #𰆷; + #𰆸; + #𰆹; + #𰆺; + #𰆻; + #𰆼; + #𰆽; + #𰆾; + #𰆿; + #𰇀; + #𰇁; + #𰇂; + #𰇃; + #𰇄; + #𰇅; + #𰇆; + #𰇇; + #𰇈; + #𰇉; + #𰇊; + #𰇋; + #𰇌; + #𰇍; + #𰇎; + #𰇏; + #𰇐; + #𰇑; + #𰇒; + #𰇓; + #𰇔; + #𰇕; + #𰇖; + #𰇗; + #𰇘; + #𰇙; + #𰇚; + #𰇛; + #𰇜; + #𰇝; + #𰇞; + #𰇟; + #𰇠; + #𰇡; + #𰇢; + #𰇣; + #𰇤; + #𰇥; + #𰇦; + #𰇧; + #𰇨; + #𰇩; + #𰇪; + #𰇫; + #𰇬; + #𰇭; + #𰇮; + #𰇯; + #𰇰; + #𰇱; + #𰇲; + #𰇳; + #𰇴; + #𰇵; + #𰇶; + #𰇷; + #𰇸; + #𰇹; + #𰇺; + #𰇻; + #𰇼; + #𰇽; + #𰇾; + #𰇿; + #𰈀; + #𰈁; + #𰈂; + #𰈃; + #𰈄; + #𰈅; + #𰈆; + #𰈇; + #𰈈; + #𰈉; + #𰈊; + #𰈋; + #𰈌; + #𰈍; + #𰈎; + #𰈏; + #𰈐; + #𰈑; + #𰈒; + #𰈓; + #𰈔; + #𰈕; + #𰈖; + #𰈗; + #𰈘; + #𰈙; + #𰈚; + #𰈛; + #𰈜; + #𰈝; + #𰈞; + #𰈟; + #𰈠; + #𰈡; + #𰈢; + #𰈣; + #𰈤; + #𰈥; + #𰈦; + #𰈧; + #𰈨; + #𰈩; + #𰈪; + #𰈫; + #𰈬; + #𰈭; + #𰈮; + #𰈯; + #𰈰; + #𰈱; + #𰈲; + #𰈳; + #𰈴; + #𰈵; + #𰈶; + #𰈷; + #𰈸; + #𰈹; + #𰈺; + #𰈻; + #𰈼; + #𰈽; + #𰈾; + #𰈿; + #𰉀; + #𰉁; + #𰉂; + #𰉃; + #𰉄; + #𰉅; + #𰉆; + #𰉇; + #𰉈; + #𰉉; + #𰉊; + #𰉋; + #𰉌; + #𰉍; + #𰉎; + #𰉏; + #𰉐; + #𰉑; + #𰉒; + #𰉓; + #𰉔; + #𰉕; + #𰉖; + #𰉗; + #𰉘; + #𰉙; + #𰉚; + #𰉛; + #𰉜; + #𰉝; + #𰉞; + #𰉟; + #𰉠; + #𰉡; + #𰉢; + #𰉣; + #𰉤; + #𰉥; + #𰉦; + #𰉧; + #𰉨; + #𰉩; + #𰉪; + #𰉫; + #𰉬; + #𰉭; + #𰉮; + #𰉯; + #𰉰; + #𰉱; + #𰉲; + #𰉳; + #𰉴; + #𰉵; + #𰉶; + #𰉷; + #𰉸; + #𰉹; + #𰉺; + #𰉻; + #𰉼; + #𰉽; + #𰉾; + #𰉿; + #𰊀; + #𰊁; + #𰊂; + #𰊃; + #𰊄; + #𰊅; + #𰊆; + #𰊇; + #𰊈; + #𰊉; + #𰊊; + #𰊋; + #𰊌; + #𰊍; + #𰊎; + #𰊏; + #𰊐; + #𰊑; + #𰊒; + #𰊓; + #𰊔; + #𰊕; + #𰊖; + #𰊗; + #𰊘; + #𰊙; + #𰊚; + #𰊛; + #𰊜; + #𰊝; + #𰊞; + #𰊟; + #𰊠; + #𰊡; + #𰊢; + #𰊣; + #𰊤; + #𰊥; + #𰊦; + #𰊧; + #𰊨; + #𰊩; + #𰊪; + #𰊫; + #𰊬; + #𰊭; + #𰊮; + #𰊯; + #𰊰; + #𰊱; + #𰊲; + #𰊳; + #𰊴; + #𰊵; + #𰊶; + #𰊷; + #𰊸; + #𰊹; + #𰊺; + #𰊻; + #𰊼; + #𰊽; + #𰊾; + #𰊿; + #𰋀; + #𰋁; + #𰋂; + #𰋃; + #𰋄; + #𰋅; + #𰋆; + #𰋇; + #𰋈; + #𰋉; + #𰋊; + #𰋋; + #𰋌; + #𰋍; + #𰋎; + #𰋏; + #𰋐; + #𰋑; + #𰋒; + #𰋓; + #𰋔; + #𰋕; + #𰋖; + #𰋗; + #𰋘; + #𰋙; + #𰋚; + #𰋛; + #𰋜; + #𰋝; + #𰋞; + #𰋟; + #𰋠; + #𰋡; + #𰋢; + #𰋣; + #𰋤; + #𰋥; + #𰋦; + #𰋧; + #𰋨; + #𰋩; + #𰋪; + #𰋫; + #𰋬; + #𰋭; + #𰋮; + #𰋯; + #𰋰; + #𰋱; + #𰋲; + #𰋳; + #𰋴; + #𰋵; + #𰋶; + #𰋷; + #𰋸; + #𰋹; + #𰋺; + #𰋻; + #𰋼; + #𰋽; + #𰋾; + #𰋿; + #𰌀; + #𰌁; + #𰌂; + #𰌃; + #𰌄; + #𰌅; + #𰌆; + #𰌇; + #𰌈; + #𰌉; + #𰌊; + #𰌋; + #𰌌; + #𰌍; + #𰌎; + #𰌏; + #𰌐; + #𰌑; + #𰌒; + #𰌓; + #𰌔; + #𰌕; + #𰌖; + #𰌗; + #𰌘; + #𰌙; + #𰌚; + #𰌛; + #𰌜; + #𰌝; + #𰌞; + #𰌟; + #𰌠; + #𰌡; + #𰌢; + #𰌣; + #𰌤; + #𰌥; + #𰌦; + #𰌧; + #𰌨; + #𰌩; + #𰌪; + #𰌫; + #𰌬; + #𰌭; + #𰌮; + #𰌯; + #𰌰; + #𰌱; + #𰌲; + #𰌳; + #𰌴; + #𰌵; + #𰌶; + #𰌷; + #𰌸; + #𰌹; + #𰌺; + #𰌻; + #𰌼; + #𰌽; + #𰌾; + #𰌿; + #𰍀; + #𰍁; + #𰍂; + #𰍃; + #𰍄; + #𰍅; + #𰍆; + #𰍇; + #𰍈; + #𰍉; + #𰍊; + #𰍋; + #𰍌; + #𰍍; + #𰍎; + #𰍏; + #𰍐; + #𰍑; + #𰍒; + #𰍓; + #𰍔; + #𰍕; + #𰍖; + #𰍗; + #𰍘; + #𰍙; + #𰍚; + #𰍛; + #𰍜; + #𰍝; + #𰍞; + #𰍟; + #𰍠; + #𰍡; + #𰍢; + #𰍣; + #𰍤; + #𰍥; + #𰍦; + #𰍧; + #𰍨; + #𰍩; + #𰍪; + #𰍫; + #𰍬; + #𰍭; + #𰍮; + #𰍯; + #𰍰; + #𰍱; + #𰍲; + #𰍳; + #𰍴; + #𰍵; + #𰍶; + #𰍷; + #𰍸; + #𰍹; + #𰍺; + #𰍻; + #𰍼; + #𰍽; + #𰍾; + #𰍿; + #𰎀; + #𰎁; + #𰎂; + #𰎃; + #𰎄; + #𰎅; + #𰎆; + #𰎇; + #𰎈; + #𰎉; + #𰎊; + #𰎋; + #𰎌; + #𰎍; + #𰎎; + #𰎏; + #𰎐; + #𰎑; + #𰎒; + #𰎓; + #𰎔; + #𰎕; + #𰎖; + #𰎗; + #𰎘; + #𰎙; + #𰎚; + #𰎛; + #𰎜; + #𰎝; + #𰎞; + #𰎟; + #𰎠; + #𰎡; + #𰎢; + #𰎣; + #𰎤; + #𰎥; + #𰎦; + #𰎧; + #𰎨; + #𰎩; + #𰎪; + #𰎫; + #𰎬; + #𰎭; + #𰎮; + #𰎯; + #𰎰; + #𰎱; + #𰎲; + #𰎳; + #𰎴; + #𰎵; + #𰎶; + #𰎷; + #𰎸; + #𰎹; + #𰎺; + #𰎻; + #𰎼; + #𰎽; + #𰎾; + #𰎿; + #𰏀; + #𰏁; + #𰏂; + #𰏃; + #𰏄; + #𰏅; + #𰏆; + #𰏇; + #𰏈; + #𰏉; + #𰏊; + #𰏋; + #𰏌; + #𰏍; + #𰏎; + #𰏏; + #𰏐; + #𰏑; + #𰏒; + #𰏓; + #𰏔; + #𰏕; + #𰏖; + #𰏗; + #𰏘; + #𰏙; + #𰏚; + #𰏛; + #𰏜; + #𰏝; + #𰏞; + #𰏟; + #𰏠; + #𰏡; + #𰏢; + #𰏣; + #𰏤; + #𰏥; + #𰏦; + #𰏧; + #𰏨; + #𰏩; + #𰏪; + #𰏫; + #𰏬; + #𰏭; + #𰏮; + #𰏯; + #𰏰; + #𰏱; + #𰏲; + #𰏳; + #𰏴; + #𰏵; + #𰏶; + #𰏷; + #𰏸; + #𰏹; + #𰏺; + #𰏻; + #𰏼; + #𰏽; + #𰏾; + #𰏿; + #𰐀; + #𰐁; + #𰐂; + #𰐃; + #𰐄; + #𰐅; + #𰐆; + #𰐇; + #𰐈; + #𰐉; + #𰐊; + #𰐋; + #𰐌; + #𰐍; + #𰐎; + #𰐏; + #𰐐; + #𰐑; + #𰐒; + #𰐓; + #𰐔; + #𰐕; + #𰐖; + #𰐗; + #𰐘; + #𰐙; + #𰐚; + #𰐛; + #𰐜; + #𰐝; + #𰐞; + #𰐟; + #𰐠; + #𰐡; + #𰐢; + #𰐣; + #𰐤; + #𰐥; + #𰐦; + #𰐧; + #𰐨; + #𰐩; + #𰐪; + #𰐫; + #𰐬; + #𰐭; + #𰐮; + #𰐯; + #𰐰; + #𰐱; + #𰐲; + #𰐳; + #𰐴; + #𰐵; + #𰐶; + #𰐷; + #𰐸; + #𰐹; + #𰐺; + #𰐻; + #𰐼; + #𰐽; + #𰐾; + #𰐿; + #𰑀; + #𰑁; + #𰑂; + #𰑃; + #𰑄; + #𰑅; + #𰑆; + #𰑇; + #𰑈; + #𰑉; + #𰑊; + #𰑋; + #𰑌; + #𰑍; + #𰑎; + #𰑏; + #𰑐; + #𰑑; + #𰑒; + #𰑓; + #𰑔; + #𰑕; + #𰑖; + #𰑗; + #𰑘; + #𰑙; + #𰑚; + #𰑛; + #𰑜; + #𰑝; + #𰑞; + #𰑟; + #𰑠; + #𰑡; + #𰑢; + #𰑣; + #𰑤; + #𰑥; + #𰑦; + #𰑧; + #𰑨; + #𰑩; + #𰑪; + #𰑫; + #𰑬; + #𰑭; + #𰑮; + #𰑯; + #𰑰; + #𰑱; + #𰑲; + #𰑳; + #𰑴; + #𰑵; + #𰑶; + #𰑷; + #𰑸; + #𰑹; + #𰑺; + #𰑻; + #𰑼; + #𰑽; + #𰑾; + #𰑿; + #𰒀; + #𰒁; + #𰒂; + #𰒃; + #𰒄; + #𰒅; + #𰒆; + #𰒇; + #𰒈; + #𰒉; + #𰒊; + #𰒋; + #𰒌; + #𰒍; + #𰒎; + #𰒏; + #𰒐; + #𰒑; + #𰒒; + #𰒓; + #𰒔; + #𰒕; + #𰒖; + #𰒗; + #𰒘; + #𰒙; + #𰒚; + #𰒛; + #𰒜; + #𰒝; + #𰒞; + #𰒟; + #𰒠; + #𰒡; + #𰒢; + #𰒣; + #𰒤; + #𰒥; + #𰒦; + #𰒧; + #𰒨; + #𰒩; + #𰒪; + #𰒫; + #𰒬; + #𰒭; + #𰒮; + #𰒯; + #𰒰; + #𰒱; + #𰒲; + #𰒳; + #𰒴; + #𰒵; + #𰒶; + #𰒷; + #𰒸; + #𰒹; + #𰒺; + #𰒻; + #𰒼; + #𰒽; + #𰒾; + #𰒿; + #𰓀; + #𰓁; + #𰓂; + #𰓃; + #𰓄; + #𰓅; + #𰓆; + #𰓇; + #𰓈; + #𰓉; + #𰓊; + #𰓋; + #𰓌; + #𰓍; + #𰓎; + #𰓏; + #𰓐; + #𰓑; + #𰓒; + #𰓓; + #𰓔; + #𰓕; + #𰓖; + #𰓗; + #𰓘; + #𰓙; + #𰓚; + #𰓛; + #𰓜; + #𰓝; + #𰓞; + #𰓟; + #𰓠; + #𰓡; + #𰓢; + #𰓣; + #𰓤; + #𰓥; + #𰓦; + #𰓧; + #𰓨; + #𰓩; + #𰓪; + #𰓫; + #𰓬; + #𰓭; + #𰓮; + #𰓯; + #𰓰; + #𰓱; + #𰓲; + #𰓳; + #𰓴; + #𰓵; + #𰓶; + #𰓷; + #𰓸; + #𰓹; + #𰓺; + #𰓻; + #𰓼; + #𰓽; + #𰓾; + #𰓿; + #𰔀; + #𰔁; + #𰔂; + #𰔃; + #𰔄; + #𰔅; + #𰔆; + #𰔇; + #𰔈; + #𰔉; + #𰔊; + #𰔋; + #𰔌; + #𰔍; + #𰔎; + #𰔏; + #𰔐; + #𰔑; + #𰔒; + #𰔓; + #𰔔; + #𰔕; + #𰔖; + #𰔗; + #𰔘; + #𰔙; + #𰔚; + #𰔛; + #𰔜; + #𰔝; + #𰔞; + #𰔟; + #𰔠; + #𰔡; + #𰔢; + #𰔣; + #𰔤; + #𰔥; + #𰔦; + #𰔧; + #𰔨; + #𰔩; + #𰔪; + #𰔫; + #𰔬; + #𰔭; + #𰔮; + #𰔯; + #𰔰; + #𰔱; + #𰔲; + #𰔳; + #𰔴; + #𰔵; + #𰔶; + #𰔷; + #𰔸; + #𰔹; + #𰔺; + #𰔻; + #𰔼; + #𰔽; + #𰔾; + #𰔿; + #𰕀; + #𰕁; + #𰕂; + #𰕃; + #𰕄; + #𰕅; + #𰕆; + #𰕇; + #𰕈; + #𰕉; + #𰕊; + #𰕋; + #𰕌; + #𰕍; + #𰕎; + #𰕏; + #𰕐; + #𰕑; + #𰕒; + #𰕓; + #𰕔; + #𰕕; + #𰕖; + #𰕗; + #𰕘; + #𰕙; + #𰕚; + #𰕛; + #𰕜; + #𰕝; + #𰕞; + #𰕟; + #𰕠; + #𰕡; + #𰕢; + #𰕣; + #𰕤; + #𰕥; + #𰕦; + #𰕧; + #𰕨; + #𰕩; + #𰕪; + #𰕫; + #𰕬; + #𰕭; + #𰕮; + #𰕯; + #𰕰; + #𰕱; + #𰕲; + #𰕳; + #𰕴; + #𰕵; + #𰕶; + #𰕷; + #𰕸; + #𰕹; + #𰕺; + #𰕻; + #𰕼; + #𰕽; + #𰕾; + #𰕿; + #𰖀; + #𰖁; + #𰖂; + #𰖃; + #𰖄; + #𰖅; + #𰖆; + #𰖇; + #𰖈; + #𰖉; + #𰖊; + #𰖋; + #𰖌; + #𰖍; + #𰖎; + #𰖏; + #𰖐; + #𰖑; + #𰖒; + #𰖓; + #𰖔; + #𰖕; + #𰖖; + #𰖗; + #𰖘; + #𰖙; + #𰖚; + #𰖛; + #𰖜; + #𰖝; + #𰖞; + #𰖟; + #𰖠; + #𰖡; + #𰖢; + #𰖣; + #𰖤; + #𰖥; + #𰖦; + #𰖧; + #𰖨; + #𰖩; + #𰖪; + #𰖫; + #𰖬; + #𰖭; + #𰖮; + #𰖯; + #𰖰; + #𰖱; + #𰖲; + #𰖳; + #𰖴; + #𰖵; + #𰖶; + #𰖷; + #𰖸; + #𰖹; + #𰖺; + #𰖻; + #𰖼; + #𰖽; + #𰖾; + #𰖿; + #𰗀; + #𰗁; + #𰗂; + #𰗃; + #𰗄; + #𰗅; + #𰗆; + #𰗇; + #𰗈; + #𰗉; + #𰗊; + #𰗋; + #𰗌; + #𰗍; + #𰗎; + #𰗏; + #𰗐; + #𰗑; + #𰗒; + #𰗓; + #𰗔; + #𰗕; + #𰗖; + #𰗗; + #𰗘; + #𰗙; + #𰗚; + #𰗛; + #𰗜; + #𰗝; + #𰗞; + #𰗟; + #𰗠; + #𰗡; + #𰗢; + #𰗣; + #𰗤; + #𰗥; + #𰗦; + #𰗧; + #𰗨; + #𰗩; + #𰗪; + #𰗫; + #𰗬; + #𰗭; + #𰗮; + #𰗯; + #𰗰; + #𰗱; + #𰗲; + #𰗳; + #𰗴; + #𰗵; + #𰗶; + #𰗷; + #𰗸; + #𰗹; + #𰗺; + #𰗻; + #𰗼; + #𰗽; + #𰗾; + #𰗿; + #𰘀; + #𰘁; + #𰘂; + #𰘃; + #𰘄; + #𰘅; + #𰘆; + #𰘇; + #𰘈; + #𰘉; + #𰘊; + #𰘋; + #𰘌; + #𰘍; + #𰘎; + #𰘏; + #𰘐; + #𰘑; + #𰘒; + #𰘓; + #𰘔; + #𰘕; + #𰘖; + #𰘗; + #𰘘; + #𰘙; + #𰘚; + #𰘛; + #𰘜; + #𰘝; + #𰘞; + #𰘟; + #𰘠; + #𰘡; + #𰘢; + #𰘣; + #𰘤; + #𰘥; + #𰘦; + #𰘧; + #𰘨; + #𰘩; + #𰘪; + #𰘫; + #𰘬; + #𰘭; + #𰘮; + #𰘯; + #𰘰; + #𰘱; + #𰘲; + #𰘳; + #𰘴; + #𰘵; + #𰘶; + #𰘷; + #𰘸; + #𰘹; + #𰘺; + #𰘻; + #𰘼; + #𰘽; + #𰘾; + #𰘿; + #𰙀; + #𰙁; + #𰙂; + #𰙃; + #𰙄; + #𰙅; + #𰙆; + #𰙇; + #𰙈; + #𰙉; + #𰙊; + #𰙋; + #𰙌; + #𰙍; + #𰙎; + #𰙏; + #𰙐; + #𰙑; + #𰙒; + #𰙓; + #𰙔; + #𰙕; + #𰙖; + #𰙗; + #𰙘; + #𰙙; + #𰙚; + #𰙛; + #𰙜; + #𰙝; + #𰙞; + #𰙟; + #𰙠; + #𰙡; + #𰙢; + #𰙣; + #𰙤; + #𰙥; + #𰙦; + #𰙧; + #𰙨; + #𰙩; + #𰙪; + #𰙫; + #𰙬; + #𰙭; + #𰙮; + #𰙯; + #𰙰; + #𰙱; + #𰙲; + #𰙳; + #𰙴; + #𰙵; + #𰙶; + #𰙷; + #𰙸; + #𰙹; + #𰙺; + #𰙻; + #𰙼; + #𰙽; + #𰙾; + #𰙿; + #𰚀; + #𰚁; + #𰚂; + #𰚃; + #𰚄; + #𰚅; + #𰚆; + #𰚇; + #𰚈; + #𰚉; + #𰚊; + #𰚋; + #𰚌; + #𰚍; + #𰚎; + #𰚏; + #𰚐; + #𰚑; + #𰚒; + #𰚓; + #𰚔; + #𰚕; + #𰚖; + #𰚗; + #𰚘; + #𰚙; + #𰚚; + #𰚛; + #𰚜; + #𰚝; + #𰚞; + #𰚟; + #𰚠; + #𰚡; + #𰚢; + #𰚣; + #𰚤; + #𰚥; + #𰚦; + #𰚧; + #𰚨; + #𰚩; + #𰚪; + #𰚫; + #𰚬; + #𰚭; + #𰚮; + #𰚯; + #𰚰; + #𰚱; + #𰚲; + #𰚳; + #𰚴; + #𰚵; + #𰚶; + #𰚷; + #𰚸; + #𰚹; + #𰚺; + #𰚻; + #𰚼; + #𰚽; + #𰚾; + #𰚿; + #𰛀; + #𰛁; + #𰛂; + #𰛃; + #𰛄; + #𰛅; + #𰛆; + #𰛇; + #𰛈; + #𰛉; + #𰛊; + #𰛋; + #𰛌; + #𰛍; + #𰛎; + #𰛏; + #𰛐; + #𰛑; + #𰛒; + #𰛓; + #𰛔; + #𰛕; + #𰛖; + #𰛗; + #𰛘; + #𰛙; + #𰛚; + #𰛛; + #𰛜; + #𰛝; + #𰛞; + #𰛟; + #𰛠; + #𰛡; + #𰛢; + #𰛣; + #𰛤; + #𰛥; + #𰛦; + #𰛧; + #𰛨; + #𰛩; + #𰛪; + #𰛫; + #𰛬; + #𰛭; + #𰛮; + #𰛯; + #𰛰; + #𰛱; + #𰛲; + #𰛳; + #𰛴; + #𰛵; + #𰛶; + #𰛷; + #𰛸; + #𰛹; + #𰛺; + #𰛻; + #𰛼; + #𰛽; + #𰛾; + #𰛿; + #𰜀; + #𰜁; + #𰜂; + #𰜃; + #𰜄; + #𰜅; + #𰜆; + #𰜇; + #𰜈; + #𰜉; + #𰜊; + #𰜋; + #𰜌; + #𰜍; + #𰜎; + #𰜏; + #𰜐; + #𰜑; + #𰜒; + #𰜓; + #𰜔; + #𰜕; + #𰜖; + #𰜗; + #𰜘; + #𰜙; + #𰜚; + #𰜛; + #𰜜; + #𰜝; + #𰜞; + #𰜟; + #𰜠; + #𰜡; + #𰜢; + #𰜣; + #𰜤; + #𰜥; + #𰜦; + #𰜧; + #𰜨; + #𰜩; + #𰜪; + #𰜫; + #𰜬; + #𰜭; + #𰜮; + #𰜯; + #𰜰; + #𰜱; + #𰜲; + #𰜳; + #𰜴; + #𰜵; + #𰜶; + #𰜷; + #𰜸; + #𰜹; + #𰜺; + #𰜻; + #𰜼; + #𰜽; + #𰜾; + #𰜿; + #𰝀; + #𰝁; + #𰝂; + #𰝃; + #𰝄; + #𰝅; + #𰝆; + #𰝇; + #𰝈; + #𰝉; + #𰝊; + #𰝋; + #𰝌; + #𰝍; + #𰝎; + #𰝏; + #𰝐; + #𰝑; + #𰝒; + #𰝓; + #𰝔; + #𰝕; + #𰝖; + #𰝗; + #𰝘; + #𰝙; + #𰝚; + #𰝛; + #𰝜; + #𰝝; + #𰝞; + #𰝟; + #𰝠; + #𰝡; + #𰝢; + #𰝣; + #𰝤; + #𰝥; + #𰝦; + #𰝧; + #𰝨; + #𰝩; + #𰝪; + #𰝫; + #𰝬; + #𰝭; + #𰝮; + #𰝯; + #𰝰; + #𰝱; + #𰝲; + #𰝳; + #𰝴; + #𰝵; + #𰝶; + #𰝷; + #𰝸; + #𰝹; + #𰝺; + #𰝻; + #𰝼; + #𰝽; + #𰝾; + #𰝿; + #𰞀; + #𰞁; + #𰞂; + #𰞃; + #𰞄; + #𰞅; + #𰞆; + #𰞇; + #𰞈; + #𰞉; + #𰞊; + #𰞋; + #𰞌; + #𰞍; + #𰞎; + #𰞏; + #𰞐; + #𰞑; + #𰞒; + #𰞓; + #𰞔; + #𰞕; + #𰞖; + #𰞗; + #𰞘; + #𰞙; + #𰞚; + #𰞛; + #𰞜; + #𰞝; + #𰞞; + #𰞟; + #𰞠; + #𰞡; + #𰞢; + #𰞣; + #𰞤; + #𰞥; + #𰞦; + #𰞧; + #𰞨; + #𰞩; + #𰞪; + #𰞫; + #𰞬; + #𰞭; + #𰞮; + #𰞯; + #𰞰; + #𰞱; + #𰞲; + #𰞳; + #𰞴; + #𰞵; + #𰞶; + #𰞷; + #𰞸; + #𰞹; + #𰞺; + #𰞻; + #𰞼; + #𰞽; + #𰞾; + #𰞿; + #𰟀; + #𰟁; + #𰟂; + #𰟃; + #𰟄; + #𰟅; + #𰟆; + #𰟇; + #𰟈; + #𰟉; + #𰟊; + #𰟋; + #𰟌; + #𰟍; + #𰟎; + #𰟏; + #𰟐; + #𰟑; + #𰟒; + #𰟓; + #𰟔; + #𰟕; + #𰟖; + #𰟗; + #𰟘; + #𰟙; + #𰟚; + #𰟛; + #𰟜; + #𰟝; + #𰟞; + #𰟟; + #𰟠; + #𰟡; + #𰟢; + #𰟣; + #𰟤; + #𰟥; + #𰟦; + #𰟧; + #𰟨; + #𰟩; + #𰟪; + #𰟫; + #𰟬; + #𰟭; + #𰟮; + #𰟯; + #𰟰; + #𰟱; + #𰟲; + #𰟳; + #𰟴; + #𰟵; + #𰟶; + #𰟷; + #𰟸; + #𰟹; + #𰟺; + #𰟻; + #𰟼; + #𰟽; + #𰟾; + #𰟿; + #𰠀; + #𰠁; + #𰠂; + #𰠃; + #𰠄; + #𰠅; + #𰠆; + #𰠇; + #𰠈; + #𰠉; + #𰠊; + #𰠋; + #𰠌; + #𰠍; + #𰠎; + #𰠏; + #𰠐; + #𰠑; + #𰠒; + #𰠓; + #𰠔; + #𰠕; + #𰠖; + #𰠗; + #𰠘; + #𰠙; + #𰠚; + #𰠛; + #𰠜; + #𰠝; + #𰠞; + #𰠟; + #𰠠; + #𰠡; + #𰠢; + #𰠣; + #𰠤; + #𰠥; + #𰠦; + #𰠧; + #𰠨; + #𰠩; + #𰠪; + #𰠫; + #𰠬; + #𰠭; + #𰠮; + #𰠯; + #𰠰; + #𰠱; + #𰠲; + #𰠳; + #𰠴; + #𰠵; + #𰠶; + #𰠷; + #𰠸; + #𰠹; + #𰠺; + #𰠻; + #𰠼; + #𰠽; + #𰠾; + #𰠿; + #𰡀; + #𰡁; + #𰡂; + #𰡃; + #𰡄; + #𰡅; + #𰡆; + #𰡇; + #𰡈; + #𰡉; + #𰡊; + #𰡋; + #𰡌; + #𰡍; + #𰡎; + #𰡏; + #𰡐; + #𰡑; + #𰡒; + #𰡓; + #𰡔; + #𰡕; + #𰡖; + #𰡗; + #𰡘; + #𰡙; + #𰡚; + #𰡛; + #𰡜; + #𰡝; + #𰡞; + #𰡟; + #𰡠; + #𰡡; + #𰡢; + #𰡣; + #𰡤; + #𰡥; + #𰡦; + #𰡧; + #𰡨; + #𰡩; + #𰡪; + #𰡫; + #𰡬; + #𰡭; + #𰡮; + #𰡯; + #𰡰; + #𰡱; + #𰡲; + #𰡳; + #𰡴; + #𰡵; + #𰡶; + #𰡷; + #𰡸; + #𰡹; + #𰡺; + #𰡻; + #𰡼; + #𰡽; + #𰡾; + #𰡿; + #𰢀; + #𰢁; + #𰢂; + #𰢃; + #𰢄; + #𰢅; + #𰢆; + #𰢇; + #𰢈; + #𰢉; + #𰢊; + #𰢋; + #𰢌; + #𰢍; + #𰢎; + #𰢏; + #𰢐; + #𰢑; + #𰢒; + #𰢓; + #𰢔; + #𰢕; + #𰢖; + #𰢗; + #𰢘; + #𰢙; + #𰢚; + #𰢛; + #𰢜; + #𰢝; + #𰢞; + #𰢟; + #𰢠; + #𰢡; + #𰢢; + #𰢣; + #𰢤; + #𰢥; + #𰢦; + #𰢧; + #𰢨; + #𰢩; + #𰢪; + #𰢫; + #𰢬; + #𰢭; + #𰢮; + #𰢯; + #𰢰; + #𰢱; + #𰢲; + #𰢳; + #𰢴; + #𰢵; + #𰢶; + #𰢷; + #𰢸; + #𰢹; + #𰢺; + #𰢻; + #𰢼; + #𰢽; + #𰢾; + #𰢿; + #𰣀; + #𰣁; + #𰣂; + #𰣃; + #𰣄; + #𰣅; + #𰣆; + #𰣇; + #𰣈; + #𰣉; + #𰣊; + #𰣋; + #𰣌; + #𰣍; + #𰣎; + #𰣏; + #𰣐; + #𰣑; + #𰣒; + #𰣓; + #𰣔; + #𰣕; + #𰣖; + #𰣗; + #𰣘; + #𰣙; + #𰣚; + #𰣛; + #𰣜; + #𰣝; + #𰣞; + #𰣟; + #𰣠; + #𰣡; + #𰣢; + #𰣣; + #𰣤; + #𰣥; + #𰣦; + #𰣧; + #𰣨; + #𰣩; + #𰣪; + #𰣫; + #𰣬; + #𰣭; + #𰣮; + #𰣯; + #𰣰; + #𰣱; + #𰣲; + #𰣳; + #𰣴; + #𰣵; + #𰣶; + #𰣷; + #𰣸; + #𰣹; + #𰣺; + #𰣻; + #𰣼; + #𰣽; + #𰣾; + #𰣿; + #𰤀; + #𰤁; + #𰤂; + #𰤃; + #𰤄; + #𰤅; + #𰤆; + #𰤇; + #𰤈; + #𰤉; + #𰤊; + #𰤋; + #𰤌; + #𰤍; + #𰤎; + #𰤏; + #𰤐; + #𰤑; + #𰤒; + #𰤓; + #𰤔; + #𰤕; + #𰤖; + #𰤗; + #𰤘; + #𰤙; + #𰤚; + #𰤛; + #𰤜; + #𰤝; + #𰤞; + #𰤟; + #𰤠; + #𰤡; + #𰤢; + #𰤣; + #𰤤; + #𰤥; + #𰤦; + #𰤧; + #𰤨; + #𰤩; + #𰤪; + #𰤫; + #𰤬; + #𰤭; + #𰤮; + #𰤯; + #𰤰; + #𰤱; + #𰤲; + #𰤳; + #𰤴; + #𰤵; + #𰤶; + #𰤷; + #𰤸; + #𰤹; + #𰤺; + #𰤻; + #𰤼; + #𰤽; + #𰤾; + #𰤿; + #𰥀; + #𰥁; + #𰥂; + #𰥃; + #𰥄; + #𰥅; + #𰥆; + #𰥇; + #𰥈; + #𰥉; + #𰥊; + #𰥋; + #𰥌; + #𰥍; + #𰥎; + #𰥏; + #𰥐; + #𰥑; + #𰥒; + #𰥓; + #𰥔; + #𰥕; + #𰥖; + #𰥗; + #𰥘; + #𰥙; + #𰥚; + #𰥛; + #𰥜; + #𰥝; + #𰥞; + #𰥟; + #𰥠; + #𰥡; + #𰥢; + #𰥣; + #𰥤; + #𰥥; + #𰥦; + #𰥧; + #𰥨; + #𰥩; + #𰥪; + #𰥫; + #𰥬; + #𰥭; + #𰥮; + #𰥯; + #𰥰; + #𰥱; + #𰥲; + #𰥳; + #𰥴; + #𰥵; + #𰥶; + #𰥷; + #𰥸; + #𰥹; + #𰥺; + #𰥻; + #𰥼; + #𰥽; + #𰥾; + #𰥿; + #𰦀; + #𰦁; + #𰦂; + #𰦃; + #𰦄; + #𰦅; + #𰦆; + #𰦇; + #𰦈; + #𰦉; + #𰦊; + #𰦋; + #𰦌; + #𰦍; + #𰦎; + #𰦏; + #𰦐; + #𰦑; + #𰦒; + #𰦓; + #𰦔; + #𰦕; + #𰦖; + #𰦗; + #𰦘; + #𰦙; + #𰦚; + #𰦛; + #𰦜; + #𰦝; + #𰦞; + #𰦟; + #𰦠; + #𰦡; + #𰦢; + #𰦣; + #𰦤; + #𰦥; + #𰦦; + #𰦧; + #𰦨; + #𰦩; + #𰦪; + #𰦫; + #𰦬; + #𰦭; + #𰦮; + #𰦯; + #𰦰; + #𰦱; + #𰦲; + #𰦳; + #𰦴; + #𰦵; + #𰦶; + #𰦷; + #𰦸; + #𰦹; + #𰦺; + #𰦻; + #𰦼; + #𰦽; + #𰦾; + #𰦿; + #𰧀; + #𰧁; + #𰧂; + #𰧃; + #𰧄; + #𰧅; + #𰧆; + #𰧇; + #𰧈; + #𰧉; + #𰧊; + #𰧋; + #𰧌; + #𰧍; + #𰧎; + #𰧏; + #𰧐; + #𰧑; + #𰧒; + #𰧓; + #𰧔; + #𰧕; + #𰧖; + #𰧗; + #𰧘; + #𰧙; + #𰧚; + #𰧛; + #𰧜; + #𰧝; + #𰧞; + #𰧟; + #𰧠; + #𰧡; + #𰧢; + #𰧣; + #𰧤; + #𰧥; + #𰧦; + #𰧧; + #𰧨; + #𰧩; + #𰧪; + #𰧫; + #𰧬; + #𰧭; + #𰧮; + #𰧯; + #𰧰; + #𰧱; + #𰧲; + #𰧳; + #𰧴; + #𰧵; + #𰧶; + #𰧷; + #𰧸; + #𰧹; + #𰧺; + #𰧻; + #𰧼; + #𰧽; + #𰧾; + #𰧿; + #𰨀; + #𰨁; + #𰨂; + #𰨃; + #𰨄; + #𰨅; + #𰨆; + #𰨇; + #𰨈; + #𰨉; + #𰨊; + #𰨋; + #𰨌; + #𰨍; + #𰨎; + #𰨏; + #𰨐; + #𰨑; + #𰨒; + #𰨓; + #𰨔; + #𰨕; + #𰨖; + #𰨗; + #𰨘; + #𰨙; + #𰨚; + #𰨛; + #𰨜; + #𰨝; + #𰨞; + #𰨟; + #𰨠; + #𰨡; + #𰨢; + #𰨣; + #𰨤; + #𰨥; + #𰨦; + #𰨧; + #𰨨; + #𰨩; + #𰨪; + #𰨫; + #𰨬; + #𰨭; + #𰨮; + #𰨯; + #𰨰; + #𰨱; + #𰨲; + #𰨳; + #𰨴; + #𰨵; + #𰨶; + #𰨷; + #𰨸; + #𰨹; + #𰨺; + #𰨻; + #𰨼; + #𰨽; + #𰨾; + #𰨿; + #𰩀; + #𰩁; + #𰩂; + #𰩃; + #𰩄; + #𰩅; + #𰩆; + #𰩇; + #𰩈; + #𰩉; + #𰩊; + #𰩋; + #𰩌; + #𰩍; + #𰩎; + #𰩏; + #𰩐; + #𰩑; + #𰩒; + #𰩓; + #𰩔; + #𰩕; + #𰩖; + #𰩗; + #𰩘; + #𰩙; + #𰩚; + #𰩛; + #𰩜; + #𰩝; + #𰩞; + #𰩟; + #𰩠; + #𰩡; + #𰩢; + #𰩣; + #𰩤; + #𰩥; + #𰩦; + #𰩧; + #𰩨; + #𰩩; + #𰩪; + #𰩫; + #𰩬; + #𰩭; + #𰩮; + #𰩯; + #𰩰; + #𰩱; + #𰩲; + #𰩳; + #𰩴; + #𰩵; + #𰩶; + #𰩷; + #𰩸; + #𰩹; + #𰩺; + #𰩻; + #𰩼; + #𰩽; + #𰩾; + #𰩿; + #𰪀; + #𰪁; + #𰪂; + #𰪃; + #𰪄; + #𰪅; + #𰪆; + #𰪇; + #𰪈; + #𰪉; + #𰪊; + #𰪋; + #𰪌; + #𰪍; + #𰪎; + #𰪏; + #𰪐; + #𰪑; + #𰪒; + #𰪓; + #𰪔; + #𰪕; + #𰪖; + #𰪗; + #𰪘; + #𰪙; + #𰪚; + #𰪛; + #𰪜; + #𰪝; + #𰪞; + #𰪟; + #𰪠; + #𰪡; + #𰪢; + #𰪣; + #𰪤; + #𰪥; + #𰪦; + #𰪧; + #𰪨; + #𰪩; + #𰪪; + #𰪫; + #𰪬; + #𰪭; + #𰪮; + #𰪯; + #𰪰; + #𰪱; + #𰪲; + #𰪳; + #𰪴; + #𰪵; + #𰪶; + #𰪷; + #𰪸; + #𰪹; + #𰪺; + #𰪻; + #𰪼; + #𰪽; + #𰪾; + #𰪿; + #𰫀; + #𰫁; + #𰫂; + #𰫃; + #𰫄; + #𰫅; + #𰫆; + #𰫇; + #𰫈; + #𰫉; + #𰫊; + #𰫋; + #𰫌; + #𰫍; + #𰫎; + #𰫏; + #𰫐; + #𰫑; + #𰫒; + #𰫓; + #𰫔; + #𰫕; + #𰫖; + #𰫗; + #𰫘; + #𰫙; + #𰫚; + #𰫛; + #𰫜; + #𰫝; + #𰫞; + #𰫟; + #𰫠; + #𰫡; + #𰫢; + #𰫣; + #𰫤; + #𰫥; + #𰫦; + #𰫧; + #𰫨; + #𰫩; + #𰫪; + #𰫫; + #𰫬; + #𰫭; + #𰫮; + #𰫯; + #𰫰; + #𰫱; + #𰫲; + #𰫳; + #𰫴; + #𰫵; + #𰫶; + #𰫷; + #𰫸; + #𰫹; + #𰫺; + #𰫻; + #𰫼; + #𰫽; + #𰫾; + #𰫿; + #𰬀; + #𰬁; + #𰬂; + #𰬃; + #𰬄; + #𰬅; + #𰬆; + #𰬇; + #𰬈; + #𰬉; + #𰬊; + #𰬋; + #𰬌; + #𰬍; + #𰬎; + #𰬏; + #𰬐; + #𰬑; + #𰬒; + #𰬓; + #𰬔; + #𰬕; + #𰬖; + #𰬗; + #𰬘; + #𰬙; + #𰬚; + #𰬛; + #𰬜; + #𰬝; + #𰬞; + #𰬟; + #𰬠; + #𰬡; + #𰬢; + #𰬣; + #𰬤; + #𰬥; + #𰬦; + #𰬧; + #𰬨; + #𰬩; + #𰬪; + #𰬫; + #𰬬; + #𰬭; + #𰬮; + #𰬯; + #𰬰; + #𰬱; + #𰬲; + #𰬳; + #𰬴; + #𰬵; + #𰬶; + #𰬷; + #𰬸; + #𰬹; + #𰬺; + #𰬻; + #𰬼; + #𰬽; + #𰬾; + #𰬿; + #𰭀; + #𰭁; + #𰭂; + #𰭃; + #𰭄; + #𰭅; + #𰭆; + #𰭇; + #𰭈; + #𰭉; + #𰭊; + #𰭋; + #𰭌; + #𰭍; + #𰭎; + #𰭏; + #𰭐; + #𰭑; + #𰭒; + #𰭓; + #𰭔; + #𰭕; + #𰭖; + #𰭗; + #𰭘; + #𰭙; + #𰭚; + #𰭛; + #𰭜; + #𰭝; + #𰭞; + #𰭟; + #𰭠; + #𰭡; + #𰭢; + #𰭣; + #𰭤; + #𰭥; + #𰭦; + #𰭧; + #𰭨; + #𰭩; + #𰭪; + #𰭫; + #𰭬; + #𰭭; + #𰭮; + #𰭯; + #𰭰; + #𰭱; + #𰭲; + #𰭳; + #𰭴; + #𰭵; + #𰭶; + #𰭷; + #𰭸; + #𰭹; + #𰭺; + #𰭻; + #𰭼; + #𰭽; + #𰭾; + #𰭿; + #𰮀; + #𰮁; + #𰮂; + #𰮃; + #𰮄; + #𰮅; + #𰮆; + #𰮇; + #𰮈; + #𰮉; + #𰮊; + #𰮋; + #𰮌; + #𰮍; + #𰮎; + #𰮏; + #𰮐; + #𰮑; + #𰮒; + #𰮓; + #𰮔; + #𰮕; + #𰮖; + #𰮗; + #𰮘; + #𰮙; + #𰮚; + #𰮛; + #𰮜; + #𰮝; + #𰮞; + #𰮟; + #𰮠; + #𰮡; + #𰮢; + #𰮣; + #𰮤; + #𰮥; + #𰮦; + #𰮧; + #𰮨; + #𰮩; + #𰮪; + #𰮫; + #𰮬; + #𰮭; + #𰮮; + #𰮯; + #𰮰; + #𰮱; + #𰮲; + #𰮳; + #𰮴; + #𰮵; + #𰮶; + #𰮷; + #𰮸; + #𰮹; + #𰮺; + #𰮻; + #𰮼; + #𰮽; + #𰮾; + #𰮿; + #𰯀; + #𰯁; + #𰯂; + #𰯃; + #𰯄; + #𰯅; + #𰯆; + #𰯇; + #𰯈; + #𰯉; + #𰯊; + #𰯋; + #𰯌; + #𰯍; + #𰯎; + #𰯏; + #𰯐; + #𰯑; + #𰯒; + #𰯓; + #𰯔; + #𰯕; + #𰯖; + #𰯗; + #𰯘; + #𰯙; + #𰯚; + #𰯛; + #𰯜; + #𰯝; + #𰯞; + #𰯟; + #𰯠; + #𰯡; + #𰯢; + #𰯣; + #𰯤; + #𰯥; + #𰯦; + #𰯧; + #𰯨; + #𰯩; + #𰯪; + #𰯫; + #𰯬; + #𰯭; + #𰯮; + #𰯯; + #𰯰; + #𰯱; + #𰯲; + #𰯳; + #𰯴; + #𰯵; + #𰯶; + #𰯷; + #𰯸; + #𰯹; + #𰯺; + #𰯻; + #𰯼; + #𰯽; + #𰯾; + #𰯿; + #𰰀; + #𰰁; + #𰰂; + #𰰃; + #𰰄; + #𰰅; + #𰰆; + #𰰇; + #𰰈; + #𰰉; + #𰰊; + #𰰋; + #𰰌; + #𰰍; + #𰰎; + #𰰏; + #𰰐; + #𰰑; + #𰰒; + #𰰓; + #𰰔; + #𰰕; + #𰰖; + #𰰗; + #𰰘; + #𰰙; + #𰰚; + #𰰛; + #𰰜; + #𰰝; + #𰰞; + #𰰟; + #𰰠; + #𰰡; + #𰰢; + #𰰣; + #𰰤; + #𰰥; + #𰰦; + #𰰧; + #𰰨; + #𰰩; + #𰰪; + #𰰫; + #𰰬; + #𰰭; + #𰰮; + #𰰯; + #𰰰; + #𰰱; + #𰰲; + #𰰳; + #𰰴; + #𰰵; + #𰰶; + #𰰷; + #𰰸; + #𰰹; + #𰰺; + #𰰻; + #𰰼; + #𰰽; + #𰰾; + #𰰿; + #𰱀; + #𰱁; + #𰱂; + #𰱃; + #𰱄; + #𰱅; + #𰱆; + #𰱇; + #𰱈; + #𰱉; + #𰱊; + #𰱋; + #𰱌; + #𰱍; + #𰱎; + #𰱏; + #𰱐; + #𰱑; + #𰱒; + #𰱓; + #𰱔; + #𰱕; + #𰱖; + #𰱗; + #𰱘; + #𰱙; + #𰱚; + #𰱛; + #𰱜; + #𰱝; + #𰱞; + #𰱟; + #𰱠; + #𰱡; + #𰱢; + #𰱣; + #𰱤; + #𰱥; + #𰱦; + #𰱧; + #𰱨; + #𰱩; + #𰱪; + #𰱫; + #𰱬; + #𰱭; + #𰱮; + #𰱯; + #𰱰; + #𰱱; + #𰱲; + #𰱳; + #𰱴; + #𰱵; + #𰱶; + #𰱷; + #𰱸; + #𰱹; + #𰱺; + #𰱻; + #𰱼; + #𰱽; + #𰱾; + #𰱿; + #𰲀; + #𰲁; + #𰲂; + #𰲃; + #𰲄; + #𰲅; + #𰲆; + #𰲇; + #𰲈; + #𰲉; + #𰲊; + #𰲋; + #𰲌; + #𰲍; + #𰲎; + #𰲏; + #𰲐; + #𰲑; + #𰲒; + #𰲓; + #𰲔; + #𰲕; + #𰲖; + #𰲗; + #𰲘; + #𰲙; + #𰲚; + #𰲛; + #𰲜; + #𰲝; + #𰲞; + #𰲟; + #𰲠; + #𰲡; + #𰲢; + #𰲣; + #𰲤; + #𰲥; + #𰲦; + #𰲧; + #𰲨; + #𰲩; + #𰲪; + #𰲫; + #𰲬; + #𰲭; + #𰲮; + #𰲯; + #𰲰; + #𰲱; + #𰲲; + #𰲳; + #𰲴; + #𰲵; + #𰲶; + #𰲷; + #𰲸; + #𰲹; + #𰲺; + #𰲻; + #𰲼; + #𰲽; + #𰲾; + #𰲿; + #𰳀; + #𰳁; + #𰳂; + #𰳃; + #𰳄; + #𰳅; + #𰳆; + #𰳇; + #𰳈; + #𰳉; + #𰳊; + #𰳋; + #𰳌; + #𰳍; + #𰳎; + #𰳏; + #𰳐; + #𰳑; + #𰳒; + #𰳓; + #𰳔; + #𰳕; + #𰳖; + #𰳗; + #𰳘; + #𰳙; + #𰳚; + #𰳛; + #𰳜; + #𰳝; + #𰳞; + #𰳟; + #𰳠; + #𰳡; + #𰳢; + #𰳣; + #𰳤; + #𰳥; + #𰳦; + #𰳧; + #𰳨; + #𰳩; + #𰳪; + #𰳫; + #𰳬; + #𰳭; + #𰳮; + #𰳯; + #𰳰; + #𰳱; + #𰳲; + #𰳳; + #𰳴; + #𰳵; + #𰳶; + #𰳷; + #𰳸; + #𰳹; + #𰳺; + #𰳻; + #𰳼; + #𰳽; + #𰳾; + #𰳿; + #𰴀; + #𰴁; + #𰴂; + #𰴃; + #𰴄; + #𰴅; + #𰴆; + #𰴇; + #𰴈; + #𰴉; + #𰴊; + #𰴋; + #𰴌; + #𰴍; + #𰴎; + #𰴏; + #𰴐; + #𰴑; + #𰴒; + #𰴓; + #𰴔; + #𰴕; + #𰴖; + #𰴗; + #𰴘; + #𰴙; + #𰴚; + #𰴛; + #𰴜; + #𰴝; + #𰴞; + #𰴟; + #𰴠; + #𰴡; + #𰴢; + #𰴣; + #𰴤; + #𰴥; + #𰴦; + #𰴧; + #𰴨; + #𰴩; + #𰴪; + #𰴫; + #𰴬; + #𰴭; + #𰴮; + #𰴯; + #𰴰; + #𰴱; + #𰴲; + #𰴳; + #𰴴; + #𰴵; + #𰴶; + #𰴷; + #𰴸; + #𰴹; + #𰴺; + #𰴻; + #𰴼; + #𰴽; + #𰴾; + #𰴿; + #𰵀; + #𰵁; + #𰵂; + #𰵃; + #𰵄; + #𰵅; + #𰵆; + #𰵇; + #𰵈; + #𰵉; + #𰵊; + #𰵋; + #𰵌; + #𰵍; + #𰵎; + #𰵏; + #𰵐; + #𰵑; + #𰵒; + #𰵓; + #𰵔; + #𰵕; + #𰵖; + #𰵗; + #𰵘; + #𰵙; + #𰵚; + #𰵛; + #𰵜; + #𰵝; + #𰵞; + #𰵟; + #𰵠; + #𰵡; + #𰵢; + #𰵣; + #𰵤; + #𰵥; + #𰵦; + #𰵧; + #𰵨; + #𰵩; + #𰵪; + #𰵫; + #𰵬; + #𰵭; + #𰵮; + #𰵯; + #𰵰; + #𰵱; + #𰵲; + #𰵳; + #𰵴; + #𰵵; + #𰵶; + #𰵷; + #𰵸; + #𰵹; + #𰵺; + #𰵻; + #𰵼; + #𰵽; + #𰵾; + #𰵿; + #𰶀; + #𰶁; + #𰶂; + #𰶃; + #𰶄; + #𰶅; + #𰶆; + #𰶇; + #𰶈; + #𰶉; + #𰶊; + #𰶋; + #𰶌; + #𰶍; + #𰶎; + #𰶏; + #𰶐; + #𰶑; + #𰶒; + #𰶓; + #𰶔; + #𰶕; + #𰶖; + #𰶗; + #𰶘; + #𰶙; + #𰶚; + #𰶛; + #𰶜; + #𰶝; + #𰶞; + #𰶟; + #𰶠; + #𰶡; + #𰶢; + #𰶣; + #𰶤; + #𰶥; + #𰶦; + #𰶧; + #𰶨; + #𰶩; + #𰶪; + #𰶫; + #𰶬; + #𰶭; + #𰶮; + #𰶯; + #𰶰; + #𰶱; + #𰶲; + #𰶳; + #𰶴; + #𰶵; + #𰶶; + #𰶷; + #𰶸; + #𰶹; + #𰶺; + #𰶻; + #𰶼; + #𰶽; + #𰶾; + #𰶿; + #𰷀; + #𰷁; + #𰷂; + #𰷃; + #𰷄; + #𰷅; + #𰷆; + #𰷇; + #𰷈; + #𰷉; + #𰷊; + #𰷋; + #𰷌; + #𰷍; + #𰷎; + #𰷏; + #𰷐; + #𰷑; + #𰷒; + #𰷓; + #𰷔; + #𰷕; + #𰷖; + #𰷗; + #𰷘; + #𰷙; + #𰷚; + #𰷛; + #𰷜; + #𰷝; + #𰷞; + #𰷟; + #𰷠; + #𰷡; + #𰷢; + #𰷣; + #𰷤; + #𰷥; + #𰷦; + #𰷧; + #𰷨; + #𰷩; + #𰷪; + #𰷫; + #𰷬; + #𰷭; + #𰷮; + #𰷯; + #𰷰; + #𰷱; + #𰷲; + #𰷳; + #𰷴; + #𰷵; + #𰷶; + #𰷷; + #𰷸; + #𰷹; + #𰷺; + #𰷻; + #𰷼; + #𰷽; + #𰷾; + #𰷿; + #𰸀; + #𰸁; + #𰸂; + #𰸃; + #𰸄; + #𰸅; + #𰸆; + #𰸇; + #𰸈; + #𰸉; + #𰸊; + #𰸋; + #𰸌; + #𰸍; + #𰸎; + #𰸏; + #𰸐; + #𰸑; + #𰸒; + #𰸓; + #𰸔; + #𰸕; + #𰸖; + #𰸗; + #𰸘; + #𰸙; + #𰸚; + #𰸛; + #𰸜; + #𰸝; + #𰸞; + #𰸟; + #𰸠; + #𰸡; + #𰸢; + #𰸣; + #𰸤; + #𰸥; + #𰸦; + #𰸧; + #𰸨; + #𰸩; + #𰸪; + #𰸫; + #𰸬; + #𰸭; + #𰸮; + #𰸯; + #𰸰; + #𰸱; + #𰸲; + #𰸳; + #𰸴; + #𰸵; + #𰸶; + #𰸷; + #𰸸; + #𰸹; + #𰸺; + #𰸻; + #𰸼; + #𰸽; + #𰸾; + #𰸿; + #𰹀; + #𰹁; + #𰹂; + #𰹃; + #𰹄; + #𰹅; + #𰹆; + #𰹇; + #𰹈; + #𰹉; + #𰹊; + #𰹋; + #𰹌; + #𰹍; + #𰹎; + #𰹏; + #𰹐; + #𰹑; + #𰹒; + #𰹓; + #𰹔; + #𰹕; + #𰹖; + #𰹗; + #𰹘; + #𰹙; + #𰹚; + #𰹛; + #𰹜; + #𰹝; + #𰹞; + #𰹟; + #𰹠; + #𰹡; + #𰹢; + #𰹣; + #𰹤; + #𰹥; + #𰹦; + #𰹧; + #𰹨; + #𰹩; + #𰹪; + #𰹫; + #𰹬; + #𰹭; + #𰹮; + #𰹯; + #𰹰; + #𰹱; + #𰹲; + #𰹳; + #𰹴; + #𰹵; + #𰹶; + #𰹷; + #𰹸; + #𰹹; + #𰹺; + #𰹻; + #𰹼; + #𰹽; + #𰹾; + #𰹿; + #𰺀; + #𰺁; + #𰺂; + #𰺃; + #𰺄; + #𰺅; + #𰺆; + #𰺇; + #𰺈; + #𰺉; + #𰺊; + #𰺋; + #𰺌; + #𰺍; + #𰺎; + #𰺏; + #𰺐; + #𰺑; + #𰺒; + #𰺓; + #𰺔; + #𰺕; + #𰺖; + #𰺗; + #𰺘; + #𰺙; + #𰺚; + #𰺛; + #𰺜; + #𰺝; + #𰺞; + #𰺟; + #𰺠; + #𰺡; + #𰺢; + #𰺣; + #𰺤; + #𰺥; + #𰺦; + #𰺧; + #𰺨; + #𰺩; + #𰺪; + #𰺫; + #𰺬; + #𰺭; + #𰺮; + #𰺯; + #𰺰; + #𰺱; + #𰺲; + #𰺳; + #𰺴; + #𰺵; + #𰺶; + #𰺷; + #𰺸; + #𰺹; + #𰺺; + #𰺻; + #𰺼; + #𰺽; + #𰺾; + #𰺿; + #𰻀; + #𰻁; + #𰻂; + #𰻃; + #𰻄; + #𰻅; + #𰻆; + #𰻇; + #𰻈; + #𰻉; + #𰻊; + #𰻋; + #𰻌; + #𰻍; + #𰻎; + #𰻏; + #𰻐; + #𰻑; + #𰻒; + #𰻓; + #𰻔; + #𰻕; + #𰻖; + #𰻗; + #𰻘; + #𰻙; + #𰻚; + #𰻛; + #𰻜; + #𰻝; + #𰻞; + #𰻟; + #𰻠; + #𰻡; + #𰻢; + #𰻣; + #𰻤; + #𰻥; + #𰻦; + #𰻧; + #𰻨; + #𰻩; + #𰻪; + #𰻫; + #𰻬; + #𰻭; + #𰻮; + #𰻯; + #𰻰; + #𰻱; + #𰻲; + #𰻳; + #𰻴; + #𰻵; + #𰻶; + #𰻷; + #𰻸; + #𰻹; + #𰻺; + #𰻻; + #𰻼; + #𰻽; + #𰻾; + #𰻿; + #𰼀; + #𰼁; + #𰼂; + #𰼃; + #𰼄; + #𰼅; + #𰼆; + #𰼇; + #𰼈; + #𰼉; + #𰼊; + #𰼋; + #𰼌; + #𰼍; + #𰼎; + #𰼏; + #𰼐; + #𰼑; + #𰼒; + #𰼓; + #𰼔; + #𰼕; + #𰼖; + #𰼗; + #𰼘; + #𰼙; + #𰼚; + #𰼛; + #𰼜; + #𰼝; + #𰼞; + #𰼟; + #𰼠; + #𰼡; + #𰼢; + #𰼣; + #𰼤; + #𰼥; + #𰼦; + #𰼧; + #𰼨; + #𰼩; + #𰼪; + #𰼫; + #𰼬; + #𰼭; + #𰼮; + #𰼯; + #𰼰; + #𰼱; + #𰼲; + #𰼳; + #𰼴; + #𰼵; + #𰼶; + #𰼷; + #𰼸; + #𰼹; + #𰼺; + #𰼻; + #𰼼; + #𰼽; + #𰼾; + #𰼿; + #𰽀; + #𰽁; + #𰽂; + #𰽃; + #𰽄; + #𰽅; + #𰽆; + #𰽇; + #𰽈; + #𰽉; + #𰽊; + #𰽋; + #𰽌; + #𰽍; + #𰽎; + #𰽏; + #𰽐; + #𰽑; + #𰽒; + #𰽓; + #𰽔; + #𰽕; + #𰽖; + #𰽗; + #𰽘; + #𰽙; + #𰽚; + #𰽛; + #𰽜; + #𰽝; + #𰽞; + #𰽟; + #𰽠; + #𰽡; + #𰽢; + #𰽣; + #𰽤; + #𰽥; + #𰽦; + #𰽧; + #𰽨; + #𰽩; + #𰽪; + #𰽫; + #𰽬; + #𰽭; + #𰽮; + #𰽯; + #𰽰; + #𰽱; + #𰽲; + #𰽳; + #𰽴; + #𰽵; + #𰽶; + #𰽷; + #𰽸; + #𰽹; + #𰽺; + #𰽻; + #𰽼; + #𰽽; + #𰽾; + #𰽿; + #𰾀; + #𰾁; + #𰾂; + #𰾃; + #𰾄; + #𰾅; + #𰾆; + #𰾇; + #𰾈; + #𰾉; + #𰾊; + #𰾋; + #𰾌; + #𰾍; + #𰾎; + #𰾏; + #𰾐; + #𰾑; + #𰾒; + #𰾓; + #𰾔; + #𰾕; + #𰾖; + #𰾗; + #𰾘; + #𰾙; + #𰾚; + #𰾛; + #𰾜; + #𰾝; + #𰾞; + #𰾟; + #𰾠; + #𰾡; + #𰾢; + #𰾣; + #𰾤; + #𰾥; + #𰾦; + #𰾧; + #𰾨; + #𰾩; + #𰾪; + #𰾫; + #𰾬; + #𰾭; + #𰾮; + #𰾯; + #𰾰; + #𰾱; + #𰾲; + #𰾳; + #𰾴; + #𰾵; + #𰾶; + #𰾷; + #𰾸; + #𰾹; + #𰾺; + #𰾻; + #𰾼; + #𰾽; + #𰾾; + #𰾿; + #𰿀; + #𰿁; + #𰿂; + #𰿃; + #𰿄; + #𰿅; + #𰿆; + #𰿇; + #𰿈; + #𰿉; + #𰿊; + #𰿋; + #𰿌; + #𰿍; + #𰿎; + #𰿏; + #𰿐; + #𰿑; + #𰿒; + #𰿓; + #𰿔; + #𰿕; + #𰿖; + #𰿗; + #𰿘; + #𰿙; + #𰿚; + #𰿛; + #𰿜; + #𰿝; + #𰿞; + #𰿟; + #𰿠; + #𰿡; + #𰿢; + #𰿣; + #𰿤; + #𰿥; + #𰿦; + #𰿧; + #𰿨; + #𰿩; + #𰿪; + #𰿫; + #𰿬; + #𰿭; + #𰿮; + #𰿯; + #𰿰; + #𰿱; + #𰿲; + #𰿳; + #𰿴; + #𰿵; + #𰿶; + #𰿷; + #𰿸; + #𰿹; + #𰿺; + #𰿻; + #𰿼; + #𰿽; + #𰿾; + #𰿿; + #𱀀; + #𱀁; + #𱀂; + #𱀃; + #𱀄; + #𱀅; + #𱀆; + #𱀇; + #𱀈; + #𱀉; + #𱀊; + #𱀋; + #𱀌; + #𱀍; + #𱀎; + #𱀏; + #𱀐; + #𱀑; + #𱀒; + #𱀓; + #𱀔; + #𱀕; + #𱀖; + #𱀗; + #𱀘; + #𱀙; + #𱀚; + #𱀛; + #𱀜; + #𱀝; + #𱀞; + #𱀟; + #𱀠; + #𱀡; + #𱀢; + #𱀣; + #𱀤; + #𱀥; + #𱀦; + #𱀧; + #𱀨; + #𱀩; + #𱀪; + #𱀫; + #𱀬; + #𱀭; + #𱀮; + #𱀯; + #𱀰; + #𱀱; + #𱀲; + #𱀳; + #𱀴; + #𱀵; + #𱀶; + #𱀷; + #𱀸; + #𱀹; + #𱀺; + #𱀻; + #𱀼; + #𱀽; + #𱀾; + #𱀿; + #𱁀; + #𱁁; + #𱁂; + #𱁃; + #𱁄; + #𱁅; + #𱁆; + #𱁇; + #𱁈; + #𱁉; + #𱁊; + #𱁋; + #𱁌; + #𱁍; + #𱁎; + #𱁏; + #𱁐; + #𱁑; + #𱁒; + #𱁓; + #𱁔; + #𱁕; + #𱁖; + #𱁗; + #𱁘; + #𱁙; + #𱁚; + #𱁛; + #𱁜; + #𱁝; + #𱁞; + #𱁟; + #𱁠; + #𱁡; + #𱁢; + #𱁣; + #𱁤; + #𱁥; + #𱁦; + #𱁧; + #𱁨; + #𱁩; + #𱁪; + #𱁫; + #𱁬; + #𱁭; + #𱁮; + #𱁯; + #𱁰; + #𱁱; + #𱁲; + #𱁳; + #𱁴; + #𱁵; + #𱁶; + #𱁷; + #𱁸; + #𱁹; + #𱁺; + #𱁻; + #𱁼; + #𱁽; + #𱁾; + #𱁿; + #𱂀; + #𱂁; + #𱂂; + #𱂃; + #𱂄; + #𱂅; + #𱂆; + #𱂇; + #𱂈; + #𱂉; + #𱂊; + #𱂋; + #𱂌; + #𱂍; + #𱂎; + #𱂏; + #𱂐; + #𱂑; + #𱂒; + #𱂓; + #𱂔; + #𱂕; + #𱂖; + #𱂗; + #𱂘; + #𱂙; + #𱂚; + #𱂛; + #𱂜; + #𱂝; + #𱂞; + #𱂟; + #𱂠; + #𱂡; + #𱂢; + #𱂣; + #𱂤; + #𱂥; + #𱂦; + #𱂧; + #𱂨; + #𱂩; + #𱂪; + #𱂫; + #𱂬; + #𱂭; + #𱂮; + #𱂯; + #𱂰; + #𱂱; + #𱂲; + #𱂳; + #𱂴; + #𱂵; + #𱂶; + #𱂷; + #𱂸; + #𱂹; + #𱂺; + #𱂻; + #𱂼; + #𱂽; + #𱂾; + #𱂿; + #𱃀; + #𱃁; + #𱃂; + #𱃃; + #𱃄; + #𱃅; + #𱃆; + #𱃇; + #𱃈; + #𱃉; + #𱃊; + #𱃋; + #𱃌; + #𱃍; + #𱃎; + #𱃏; + #𱃐; + #𱃑; + #𱃒; + #𱃓; + #𱃔; + #𱃕; + #𱃖; + #𱃗; + #𱃘; + #𱃙; + #𱃚; + #𱃛; + #𱃜; + #𱃝; + #𱃞; + #𱃟; + #𱃠; + #𱃡; + #𱃢; + #𱃣; + #𱃤; + #𱃥; + #𱃦; + #𱃧; + #𱃨; + #𱃩; + #𱃪; + #𱃫; + #𱃬; + #𱃭; + #𱃮; + #𱃯; + #𱃰; + #𱃱; + #𱃲; + #𱃳; + #𱃴; + #𱃵; + #𱃶; + #𱃷; + #𱃸; + #𱃹; + #𱃺; + #𱃻; + #𱃼; + #𱃽; + #𱃾; + #𱃿; + #𱄀; + #𱄁; + #𱄂; + #𱄃; + #𱄄; + #𱄅; + #𱄆; + #𱄇; + #𱄈; + #𱄉; + #𱄊; + #𱄋; + #𱄌; + #𱄍; + #𱄎; + #𱄏; + #𱄐; + #𱄑; + #𱄒; + #𱄓; + #𱄔; + #𱄕; + #𱄖; + #𱄗; + #𱄘; + #𱄙; + #𱄚; + #𱄛; + #𱄜; + #𱄝; + #𱄞; + #𱄟; + #𱄠; + #𱄡; + #𱄢; + #𱄣; + #𱄤; + #𱄥; + #𱄦; + #𱄧; + #𱄨; + #𱄩; + #𱄪; + #𱄫; + #𱄬; + #𱄭; + #𱄮; + #𱄯; + #𱄰; + #𱄱; + #𱄲; + #𱄳; + #𱄴; + #𱄵; + #𱄶; + #𱄷; + #𱄸; + #𱄹; + #𱄺; + #𱄻; + #𱄼; + #𱄽; + #𱄾; + #𱄿; + #𱅀; + #𱅁; + #𱅂; + #𱅃; + #𱅄; + #𱅅; + #𱅆; + #𱅇; + #𱅈; + #𱅉; + #𱅊; + #𱅋; + #𱅌; + #𱅍; + #𱅎; + #𱅏; + #𱅐; + #𱅑; + #𱅒; + #𱅓; + #𱅔; + #𱅕; + #𱅖; + #𱅗; + #𱅘; + #𱅙; + #𱅚; + #𱅛; + #𱅜; + #𱅝; + #𱅞; + #𱅟; + #𱅠; + #𱅡; + #𱅢; + #𱅣; + #𱅤; + #𱅥; + #𱅦; + #𱅧; + #𱅨; + #𱅩; + #𱅪; + #𱅫; + #𱅬; + #𱅭; + #𱅮; + #𱅯; + #𱅰; + #𱅱; + #𱅲; + #𱅳; + #𱅴; + #𱅵; + #𱅶; + #𱅷; + #𱅸; + #𱅹; + #𱅺; + #𱅻; + #𱅼; + #𱅽; + #𱅾; + #𱅿; + #𱆀; + #𱆁; + #𱆂; + #𱆃; + #𱆄; + #𱆅; + #𱆆; + #𱆇; + #𱆈; + #𱆉; + #𱆊; + #𱆋; + #𱆌; + #𱆍; + #𱆎; + #𱆏; + #𱆐; + #𱆑; + #𱆒; + #𱆓; + #𱆔; + #𱆕; + #𱆖; + #𱆗; + #𱆘; + #𱆙; + #𱆚; + #𱆛; + #𱆜; + #𱆝; + #𱆞; + #𱆟; + #𱆠; + #𱆡; + #𱆢; + #𱆣; + #𱆤; + #𱆥; + #𱆦; + #𱆧; + #𱆨; + #𱆩; + #𱆪; + #𱆫; + #𱆬; + #𱆭; + #𱆮; + #𱆯; + #𱆰; + #𱆱; + #𱆲; + #𱆳; + #𱆴; + #𱆵; + #𱆶; + #𱆷; + #𱆸; + #𱆹; + #𱆺; + #𱆻; + #𱆼; + #𱆽; + #𱆾; + #𱆿; + #𱇀; + #𱇁; + #𱇂; + #𱇃; + #𱇄; + #𱇅; + #𱇆; + #𱇇; + #𱇈; + #𱇉; + #𱇊; + #𱇋; + #𱇌; + #𱇍; + #𱇎; + #𱇏; + #𱇐; + #𱇑; + #𱇒; + #𱇓; + #𱇔; + #𱇕; + #𱇖; + #𱇗; + #𱇘; + #𱇙; + #𱇚; + #𱇛; + #𱇜; + #𱇝; + #𱇞; + #𱇟; + #𱇠; + #𱇡; + #𱇢; + #𱇣; + #𱇤; + #𱇥; + #𱇦; + #𱇧; + #𱇨; + #𱇩; + #𱇪; + #𱇫; + #𱇬; + #𱇭; + #𱇮; + #𱇯; + #𱇰; + #𱇱; + #𱇲; + #𱇳; + #𱇴; + #𱇵; + #𱇶; + #𱇷; + #𱇸; + #𱇹; + #𱇺; + #𱇻; + #𱇼; + #𱇽; + #𱇾; + #𱇿; + #𱈀; + #𱈁; + #𱈂; + #𱈃; + #𱈄; + #𱈅; + #𱈆; + #𱈇; + #𱈈; + #𱈉; + #𱈊; + #𱈋; + #𱈌; + #𱈍; + #𱈎; + #𱈏; + #𱈐; + #𱈑; + #𱈒; + #𱈓; + #𱈔; + #𱈕; + #𱈖; + #𱈗; + #𱈘; + #𱈙; + #𱈚; + #𱈛; + #𱈜; + #𱈝; + #𱈞; + #𱈟; + #𱈠; + #𱈡; + #𱈢; + #𱈣; + #𱈤; + #𱈥; + #𱈦; + #𱈧; + #𱈨; + #𱈩; + #𱈪; + #𱈫; + #𱈬; + #𱈭; + #𱈮; + #𱈯; + #𱈰; + #𱈱; + #𱈲; + #𱈳; + #𱈴; + #𱈵; + #𱈶; + #𱈷; + #𱈸; + #𱈹; + #𱈺; + #𱈻; + #𱈼; + #𱈽; + #𱈾; + #𱈿; + #𱉀; + #𱉁; + #𱉂; + #𱉃; + #𱉄; + #𱉅; + #𱉆; + #𱉇; + #𱉈; + #𱉉; + #𱉊; + #𱉋; + #𱉌; + #𱉍; + #𱉎; + #𱉏; + #𱉐; + #𱉑; + #𱉒; + #𱉓; + #𱉔; + #𱉕; + #𱉖; + #𱉗; + #𱉘; + #𱉙; + #𱉚; + #𱉛; + #𱉜; + #𱉝; + #𱉞; + #𱉟; + #𱉠; + #𱉡; + #𱉢; + #𱉣; + #𱉤; + #𱉥; + #𱉦; + #𱉧; + #𱉨; + #𱉩; + #𱉪; + #𱉫; + #𱉬; + #𱉭; + #𱉮; + #𱉯; + #𱉰; + #𱉱; + #𱉲; + #𱉳; + #𱉴; + #𱉵; + #𱉶; + #𱉷; + #𱉸; + #𱉹; + #𱉺; + #𱉻; + #𱉼; + #𱉽; + #𱉾; + #𱉿; + #𱊀; + #𱊁; + #𱊂; + #𱊃; + #𱊄; + #𱊅; + #𱊆; + #𱊇; + #𱊈; + #𱊉; + #𱊊; + #𱊋; + #𱊌; + #𱊍; + #𱊎; + #𱊏; + #𱊐; + #𱊑; + #𱊒; + #𱊓; + #𱊔; + #𱊕; + #𱊖; + #𱊗; + #𱊘; + #𱊙; + #𱊚; + #𱊛; + #𱊜; + #𱊝; + #𱊞; + #𱊟; + #𱊠; + #𱊡; + #𱊢; + #𱊣; + #𱊤; + #𱊥; + #𱊦; + #𱊧; + #𱊨; + #𱊩; + #𱊪; + #𱊫; + #𱊬; + #𱊭; + #𱊮; + #𱊯; + #𱊰; + #𱊱; + #𱊲; + #𱊳; + #𱊴; + #𱊵; + #𱊶; + #𱊷; + #𱊸; + #𱊹; + #𱊺; + #𱊻; + #𱊼; + #𱊽; + #𱊾; + #𱊿; + #𱋀; + #𱋁; + #𱋂; + #𱋃; + #𱋄; + #𱋅; + #𱋆; + #𱋇; + #𱋈; + #𱋉; + #𱋊; + #𱋋; + #𱋌; + #𱋍; + #𱋎; + #𱋏; + #𱋐; + #𱋑; + #𱋒; + #𱋓; + #𱋔; + #𱋕; + #𱋖; + #𱋗; + #𱋘; + #𱋙; + #𱋚; + #𱋛; + #𱋜; + #𱋝; + #𱋞; + #𱋟; + #𱋠; + #𱋡; + #𱋢; + #𱋣; + #𱋤; + #𱋥; + #𱋦; + #𱋧; + #𱋨; + #𱋩; + #𱋪; + #𱋫; + #𱋬; + #𱋭; + #𱋮; + #𱋯; + #𱋰; + #𱋱; + #𱋲; + #𱋳; + #𱋴; + #𱋵; + #𱋶; + #𱋷; + #𱋸; + #𱋹; + #𱋺; + #𱋻; + #𱋼; + #𱋽; + #𱋾; + #𱋿; + #𱌀; + #𱌁; + #𱌂; + #𱌃; + #𱌄; + #𱌅; + #𱌆; + #𱌇; + #𱌈; + #𱌉; + #𱌊; + #𱌋; + #𱌌; + #𱌍; + #𱌎; + #𱌏; + #𱌐; + #𱌑; + #𱌒; + #𱌓; + #𱌔; + #𱌕; + #𱌖; + #𱌗; + #𱌘; + #𱌙; + #𱌚; + #𱌛; + #𱌜; + #𱌝; + #𱌞; + #𱌟; + #𱌠; + #𱌡; + #𱌢; + #𱌣; + #𱌤; + #𱌥; + #𱌦; + #𱌧; + #𱌨; + #𱌩; + #𱌪; + #𱌫; + #𱌬; + #𱌭; + #𱌮; + #𱌯; + #𱌰; + #𱌱; + #𱌲; + #𱌳; + #𱌴; + #𱌵; + #𱌶; + #𱌷; + #𱌸; + #𱌹; + #𱌺; + #𱌻; + #𱌼; + #𱌽; + #𱌾; + #𱌿; + #𱍀; + #𱍁; + #𱍂; + #𱍃; + #𱍄; + #𱍅; + #𱍆; + #𱍇; + #𱍈; + #𱍉; + #𱍊; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0-escaped.js new file mode 100644 index 000000000..60968e648 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0-escaped.js @@ -0,0 +1,5613 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v13.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u08BE; +var \u08BF; +var \u08C0; +var \u08C1; +var \u08C2; +var \u08C3; +var \u08C4; +var \u08C5; +var \u08C6; +var \u08C7; +var \u0D04; +var \u31BB; +var \u31BC; +var \u31BD; +var \u31BE; +var \u31BF; +var \u4DB6; +var \u4DB7; +var \u4DB8; +var \u4DB9; +var \u4DBA; +var \u4DBB; +var \u4DBC; +var \u4DBD; +var \u4DBE; +var \u4DBF; +var \u9FF0; +var \u9FF1; +var \u9FF2; +var \u9FF3; +var \u9FF4; +var \u9FF5; +var \u9FF6; +var \u9FF7; +var \u9FF8; +var \u9FF9; +var \u9FFA; +var \u9FFB; +var \u9FFC; +var \uA7C7; +var \uA7C8; +var \uA7C9; +var \uA7CA; +var \uA7F5; +var \uA7F6; +var \uAB68; +var \uAB69; +var \u{10E80}; +var \u{10E81}; +var \u{10E82}; +var \u{10E83}; +var \u{10E84}; +var \u{10E85}; +var \u{10E86}; +var \u{10E87}; +var \u{10E88}; +var \u{10E89}; +var \u{10E8A}; +var \u{10E8B}; +var \u{10E8C}; +var \u{10E8D}; +var \u{10E8E}; +var \u{10E8F}; +var \u{10E90}; +var \u{10E91}; +var \u{10E92}; +var \u{10E93}; +var \u{10E94}; +var \u{10E95}; +var \u{10E96}; +var \u{10E97}; +var \u{10E98}; +var \u{10E99}; +var \u{10E9A}; +var \u{10E9B}; +var \u{10E9C}; +var \u{10E9D}; +var \u{10E9E}; +var \u{10E9F}; +var \u{10EA0}; +var \u{10EA1}; +var \u{10EA2}; +var \u{10EA3}; +var \u{10EA4}; +var \u{10EA5}; +var \u{10EA6}; +var \u{10EA7}; +var \u{10EA8}; +var \u{10EA9}; +var \u{10EB0}; +var \u{10EB1}; +var \u{10FB0}; +var \u{10FB1}; +var \u{10FB2}; +var \u{10FB3}; +var \u{10FB4}; +var \u{10FB5}; +var \u{10FB6}; +var \u{10FB7}; +var \u{10FB8}; +var \u{10FB9}; +var \u{10FBA}; +var \u{10FBB}; +var \u{10FBC}; +var \u{10FBD}; +var \u{10FBE}; +var \u{10FBF}; +var \u{10FC0}; +var \u{10FC1}; +var \u{10FC2}; +var \u{10FC3}; +var \u{10FC4}; +var \u{11147}; +var \u{11460}; +var \u{11461}; +var \u{11900}; +var \u{11901}; +var \u{11902}; +var \u{11903}; +var \u{11904}; +var \u{11905}; +var \u{11906}; +var \u{11909}; +var \u{1190C}; +var \u{1190D}; +var \u{1190E}; +var \u{1190F}; +var \u{11910}; +var \u{11911}; +var \u{11912}; +var \u{11913}; +var \u{11915}; +var \u{11916}; +var \u{11918}; +var \u{11919}; +var \u{1191A}; +var \u{1191B}; +var \u{1191C}; +var \u{1191D}; +var \u{1191E}; +var \u{1191F}; +var \u{11920}; +var \u{11921}; +var \u{11922}; +var \u{11923}; +var \u{11924}; +var \u{11925}; +var \u{11926}; +var \u{11927}; +var \u{11928}; +var \u{11929}; +var \u{1192A}; +var \u{1192B}; +var \u{1192C}; +var \u{1192D}; +var \u{1192E}; +var \u{1192F}; +var \u{1193F}; +var \u{11941}; +var \u{11FB0}; +var \u{18AF3}; +var \u{18AF4}; +var \u{18AF5}; +var \u{18AF6}; +var \u{18AF7}; +var \u{18AF8}; +var \u{18AF9}; +var \u{18AFA}; +var \u{18AFB}; +var \u{18AFC}; +var \u{18AFD}; +var \u{18AFE}; +var \u{18AFF}; +var \u{18B00}; +var \u{18B01}; +var \u{18B02}; +var \u{18B03}; +var \u{18B04}; +var \u{18B05}; +var \u{18B06}; +var \u{18B07}; +var \u{18B08}; +var \u{18B09}; +var \u{18B0A}; +var \u{18B0B}; +var \u{18B0C}; +var \u{18B0D}; +var \u{18B0E}; +var \u{18B0F}; +var \u{18B10}; +var \u{18B11}; +var \u{18B12}; +var \u{18B13}; +var \u{18B14}; +var \u{18B15}; +var \u{18B16}; +var \u{18B17}; +var \u{18B18}; +var \u{18B19}; +var \u{18B1A}; +var \u{18B1B}; +var \u{18B1C}; +var \u{18B1D}; +var \u{18B1E}; +var \u{18B1F}; +var \u{18B20}; +var \u{18B21}; +var \u{18B22}; +var \u{18B23}; +var \u{18B24}; +var \u{18B25}; +var \u{18B26}; +var \u{18B27}; +var \u{18B28}; +var \u{18B29}; +var \u{18B2A}; +var \u{18B2B}; +var \u{18B2C}; +var \u{18B2D}; +var \u{18B2E}; +var \u{18B2F}; +var \u{18B30}; +var \u{18B31}; +var \u{18B32}; +var \u{18B33}; +var \u{18B34}; +var \u{18B35}; +var \u{18B36}; +var \u{18B37}; +var \u{18B38}; +var \u{18B39}; +var \u{18B3A}; +var \u{18B3B}; +var \u{18B3C}; +var \u{18B3D}; +var \u{18B3E}; +var \u{18B3F}; +var \u{18B40}; +var \u{18B41}; +var \u{18B42}; +var \u{18B43}; +var \u{18B44}; +var \u{18B45}; +var \u{18B46}; +var \u{18B47}; +var \u{18B48}; +var \u{18B49}; +var \u{18B4A}; +var \u{18B4B}; +var \u{18B4C}; +var \u{18B4D}; +var \u{18B4E}; +var \u{18B4F}; +var \u{18B50}; +var \u{18B51}; +var \u{18B52}; +var \u{18B53}; +var \u{18B54}; +var \u{18B55}; +var \u{18B56}; +var \u{18B57}; +var \u{18B58}; +var \u{18B59}; +var \u{18B5A}; +var \u{18B5B}; +var \u{18B5C}; +var \u{18B5D}; +var \u{18B5E}; +var \u{18B5F}; +var \u{18B60}; +var \u{18B61}; +var \u{18B62}; +var \u{18B63}; +var \u{18B64}; +var \u{18B65}; +var \u{18B66}; +var \u{18B67}; +var \u{18B68}; +var \u{18B69}; +var \u{18B6A}; +var \u{18B6B}; +var \u{18B6C}; +var \u{18B6D}; +var \u{18B6E}; +var \u{18B6F}; +var \u{18B70}; +var \u{18B71}; +var \u{18B72}; +var \u{18B73}; +var \u{18B74}; +var \u{18B75}; +var \u{18B76}; +var \u{18B77}; +var \u{18B78}; +var \u{18B79}; +var \u{18B7A}; +var \u{18B7B}; +var \u{18B7C}; +var \u{18B7D}; +var \u{18B7E}; +var \u{18B7F}; +var \u{18B80}; +var \u{18B81}; +var \u{18B82}; +var \u{18B83}; +var \u{18B84}; +var \u{18B85}; +var \u{18B86}; +var \u{18B87}; +var \u{18B88}; +var \u{18B89}; +var \u{18B8A}; +var \u{18B8B}; +var \u{18B8C}; +var \u{18B8D}; +var \u{18B8E}; +var \u{18B8F}; +var \u{18B90}; +var \u{18B91}; +var \u{18B92}; +var \u{18B93}; +var \u{18B94}; +var \u{18B95}; +var \u{18B96}; +var \u{18B97}; +var \u{18B98}; +var \u{18B99}; +var \u{18B9A}; +var \u{18B9B}; +var \u{18B9C}; +var \u{18B9D}; +var \u{18B9E}; +var \u{18B9F}; +var \u{18BA0}; +var \u{18BA1}; +var \u{18BA2}; +var \u{18BA3}; +var \u{18BA4}; +var \u{18BA5}; +var \u{18BA6}; +var \u{18BA7}; +var \u{18BA8}; +var \u{18BA9}; +var \u{18BAA}; +var \u{18BAB}; +var \u{18BAC}; +var \u{18BAD}; +var \u{18BAE}; +var \u{18BAF}; +var \u{18BB0}; +var \u{18BB1}; +var \u{18BB2}; +var \u{18BB3}; +var \u{18BB4}; +var \u{18BB5}; +var \u{18BB6}; +var \u{18BB7}; +var \u{18BB8}; +var \u{18BB9}; +var \u{18BBA}; +var \u{18BBB}; +var \u{18BBC}; +var \u{18BBD}; +var \u{18BBE}; +var \u{18BBF}; +var \u{18BC0}; +var \u{18BC1}; +var \u{18BC2}; +var \u{18BC3}; +var \u{18BC4}; +var \u{18BC5}; +var \u{18BC6}; +var \u{18BC7}; +var \u{18BC8}; +var \u{18BC9}; +var \u{18BCA}; +var \u{18BCB}; +var \u{18BCC}; +var \u{18BCD}; +var \u{18BCE}; +var \u{18BCF}; +var \u{18BD0}; +var \u{18BD1}; +var \u{18BD2}; +var \u{18BD3}; +var \u{18BD4}; +var \u{18BD5}; +var \u{18BD6}; +var \u{18BD7}; +var \u{18BD8}; +var \u{18BD9}; +var \u{18BDA}; +var \u{18BDB}; +var \u{18BDC}; +var \u{18BDD}; +var \u{18BDE}; +var \u{18BDF}; +var \u{18BE0}; +var \u{18BE1}; +var \u{18BE2}; +var \u{18BE3}; +var \u{18BE4}; +var \u{18BE5}; +var \u{18BE6}; +var \u{18BE7}; +var \u{18BE8}; +var \u{18BE9}; +var \u{18BEA}; +var \u{18BEB}; +var \u{18BEC}; +var \u{18BED}; +var \u{18BEE}; +var \u{18BEF}; +var \u{18BF0}; +var \u{18BF1}; +var \u{18BF2}; +var \u{18BF3}; +var \u{18BF4}; +var \u{18BF5}; +var \u{18BF6}; +var \u{18BF7}; +var \u{18BF8}; +var \u{18BF9}; +var \u{18BFA}; +var \u{18BFB}; +var \u{18BFC}; +var \u{18BFD}; +var \u{18BFE}; +var \u{18BFF}; +var \u{18C00}; +var \u{18C01}; +var \u{18C02}; +var \u{18C03}; +var \u{18C04}; +var \u{18C05}; +var \u{18C06}; +var \u{18C07}; +var \u{18C08}; +var \u{18C09}; +var \u{18C0A}; +var \u{18C0B}; +var \u{18C0C}; +var \u{18C0D}; +var \u{18C0E}; +var \u{18C0F}; +var \u{18C10}; +var \u{18C11}; +var \u{18C12}; +var \u{18C13}; +var \u{18C14}; +var \u{18C15}; +var \u{18C16}; +var \u{18C17}; +var \u{18C18}; +var \u{18C19}; +var \u{18C1A}; +var \u{18C1B}; +var \u{18C1C}; +var \u{18C1D}; +var \u{18C1E}; +var \u{18C1F}; +var \u{18C20}; +var \u{18C21}; +var \u{18C22}; +var \u{18C23}; +var \u{18C24}; +var \u{18C25}; +var \u{18C26}; +var \u{18C27}; +var \u{18C28}; +var \u{18C29}; +var \u{18C2A}; +var \u{18C2B}; +var \u{18C2C}; +var \u{18C2D}; +var \u{18C2E}; +var \u{18C2F}; +var \u{18C30}; +var \u{18C31}; +var \u{18C32}; +var \u{18C33}; +var \u{18C34}; +var \u{18C35}; +var \u{18C36}; +var \u{18C37}; +var \u{18C38}; +var \u{18C39}; +var \u{18C3A}; +var \u{18C3B}; +var \u{18C3C}; +var \u{18C3D}; +var \u{18C3E}; +var \u{18C3F}; +var \u{18C40}; +var \u{18C41}; +var \u{18C42}; +var \u{18C43}; +var \u{18C44}; +var \u{18C45}; +var \u{18C46}; +var \u{18C47}; +var \u{18C48}; +var \u{18C49}; +var \u{18C4A}; +var \u{18C4B}; +var \u{18C4C}; +var \u{18C4D}; +var \u{18C4E}; +var \u{18C4F}; +var \u{18C50}; +var \u{18C51}; +var \u{18C52}; +var \u{18C53}; +var \u{18C54}; +var \u{18C55}; +var \u{18C56}; +var \u{18C57}; +var \u{18C58}; +var \u{18C59}; +var \u{18C5A}; +var \u{18C5B}; +var \u{18C5C}; +var \u{18C5D}; +var \u{18C5E}; +var \u{18C5F}; +var \u{18C60}; +var \u{18C61}; +var \u{18C62}; +var \u{18C63}; +var \u{18C64}; +var \u{18C65}; +var \u{18C66}; +var \u{18C67}; +var \u{18C68}; +var \u{18C69}; +var \u{18C6A}; +var \u{18C6B}; +var \u{18C6C}; +var \u{18C6D}; +var \u{18C6E}; +var \u{18C6F}; +var \u{18C70}; +var \u{18C71}; +var \u{18C72}; +var \u{18C73}; +var \u{18C74}; +var \u{18C75}; +var \u{18C76}; +var \u{18C77}; +var \u{18C78}; +var \u{18C79}; +var \u{18C7A}; +var \u{18C7B}; +var \u{18C7C}; +var \u{18C7D}; +var \u{18C7E}; +var \u{18C7F}; +var \u{18C80}; +var \u{18C81}; +var \u{18C82}; +var \u{18C83}; +var \u{18C84}; +var \u{18C85}; +var \u{18C86}; +var \u{18C87}; +var \u{18C88}; +var \u{18C89}; +var \u{18C8A}; +var \u{18C8B}; +var \u{18C8C}; +var \u{18C8D}; +var \u{18C8E}; +var \u{18C8F}; +var \u{18C90}; +var \u{18C91}; +var \u{18C92}; +var \u{18C93}; +var \u{18C94}; +var \u{18C95}; +var \u{18C96}; +var \u{18C97}; +var \u{18C98}; +var \u{18C99}; +var \u{18C9A}; +var \u{18C9B}; +var \u{18C9C}; +var \u{18C9D}; +var \u{18C9E}; +var \u{18C9F}; +var \u{18CA0}; +var \u{18CA1}; +var \u{18CA2}; +var \u{18CA3}; +var \u{18CA4}; +var \u{18CA5}; +var \u{18CA6}; +var \u{18CA7}; +var \u{18CA8}; +var \u{18CA9}; +var \u{18CAA}; +var \u{18CAB}; +var \u{18CAC}; +var \u{18CAD}; +var \u{18CAE}; +var \u{18CAF}; +var \u{18CB0}; +var \u{18CB1}; +var \u{18CB2}; +var \u{18CB3}; +var \u{18CB4}; +var \u{18CB5}; +var \u{18CB6}; +var \u{18CB7}; +var \u{18CB8}; +var \u{18CB9}; +var \u{18CBA}; +var \u{18CBB}; +var \u{18CBC}; +var \u{18CBD}; +var \u{18CBE}; +var \u{18CBF}; +var \u{18CC0}; +var \u{18CC1}; +var \u{18CC2}; +var \u{18CC3}; +var \u{18CC4}; +var \u{18CC5}; +var \u{18CC6}; +var \u{18CC7}; +var \u{18CC8}; +var \u{18CC9}; +var \u{18CCA}; +var \u{18CCB}; +var \u{18CCC}; +var \u{18CCD}; +var \u{18CCE}; +var \u{18CCF}; +var \u{18CD0}; +var \u{18CD1}; +var \u{18CD2}; +var \u{18CD3}; +var \u{18CD4}; +var \u{18CD5}; +var \u{18D00}; +var \u{18D01}; +var \u{18D02}; +var \u{18D03}; +var \u{18D04}; +var \u{18D05}; +var \u{18D06}; +var \u{18D07}; +var \u{18D08}; +var \u{2A6D7}; +var \u{2A6D8}; +var \u{2A6D9}; +var \u{2A6DA}; +var \u{2A6DB}; +var \u{2A6DC}; +var \u{2A6DD}; +var \u{30000}; +var \u{30001}; +var \u{30002}; +var \u{30003}; +var \u{30004}; +var \u{30005}; +var \u{30006}; +var \u{30007}; +var \u{30008}; +var \u{30009}; +var \u{3000A}; +var \u{3000B}; +var \u{3000C}; +var \u{3000D}; +var \u{3000E}; +var \u{3000F}; +var \u{30010}; +var \u{30011}; +var \u{30012}; +var \u{30013}; +var \u{30014}; +var \u{30015}; +var \u{30016}; +var \u{30017}; +var \u{30018}; +var \u{30019}; +var \u{3001A}; +var \u{3001B}; +var \u{3001C}; +var \u{3001D}; +var \u{3001E}; +var \u{3001F}; +var \u{30020}; +var \u{30021}; +var \u{30022}; +var \u{30023}; +var \u{30024}; +var \u{30025}; +var \u{30026}; +var \u{30027}; +var \u{30028}; +var \u{30029}; +var \u{3002A}; +var \u{3002B}; +var \u{3002C}; +var \u{3002D}; +var \u{3002E}; +var \u{3002F}; +var \u{30030}; +var \u{30031}; +var \u{30032}; +var \u{30033}; +var \u{30034}; +var \u{30035}; +var \u{30036}; +var \u{30037}; +var \u{30038}; +var \u{30039}; +var \u{3003A}; +var \u{3003B}; +var \u{3003C}; +var \u{3003D}; +var \u{3003E}; +var \u{3003F}; +var \u{30040}; +var \u{30041}; +var \u{30042}; +var \u{30043}; +var \u{30044}; +var \u{30045}; +var \u{30046}; +var \u{30047}; +var \u{30048}; +var \u{30049}; +var \u{3004A}; +var \u{3004B}; +var \u{3004C}; +var \u{3004D}; +var \u{3004E}; +var \u{3004F}; +var \u{30050}; +var \u{30051}; +var \u{30052}; +var \u{30053}; +var \u{30054}; +var \u{30055}; +var \u{30056}; +var \u{30057}; +var \u{30058}; +var \u{30059}; +var \u{3005A}; +var \u{3005B}; +var \u{3005C}; +var \u{3005D}; +var \u{3005E}; +var \u{3005F}; +var \u{30060}; +var \u{30061}; +var \u{30062}; +var \u{30063}; +var \u{30064}; +var \u{30065}; +var \u{30066}; +var \u{30067}; +var \u{30068}; +var \u{30069}; +var \u{3006A}; +var \u{3006B}; +var \u{3006C}; +var \u{3006D}; +var \u{3006E}; +var \u{3006F}; +var \u{30070}; +var \u{30071}; +var \u{30072}; +var \u{30073}; +var \u{30074}; +var \u{30075}; +var \u{30076}; +var \u{30077}; +var \u{30078}; +var \u{30079}; +var \u{3007A}; +var \u{3007B}; +var \u{3007C}; +var \u{3007D}; +var \u{3007E}; +var \u{3007F}; +var \u{30080}; +var \u{30081}; +var \u{30082}; +var \u{30083}; +var \u{30084}; +var \u{30085}; +var \u{30086}; +var \u{30087}; +var \u{30088}; +var \u{30089}; +var \u{3008A}; +var \u{3008B}; +var \u{3008C}; +var \u{3008D}; +var \u{3008E}; +var \u{3008F}; +var \u{30090}; +var \u{30091}; +var \u{30092}; +var \u{30093}; +var \u{30094}; +var \u{30095}; +var \u{30096}; +var \u{30097}; +var \u{30098}; +var \u{30099}; +var \u{3009A}; +var \u{3009B}; +var \u{3009C}; +var \u{3009D}; +var \u{3009E}; +var \u{3009F}; +var \u{300A0}; +var \u{300A1}; +var \u{300A2}; +var \u{300A3}; +var \u{300A4}; +var \u{300A5}; +var \u{300A6}; +var \u{300A7}; +var \u{300A8}; +var \u{300A9}; +var \u{300AA}; +var \u{300AB}; +var \u{300AC}; +var \u{300AD}; +var \u{300AE}; +var \u{300AF}; +var \u{300B0}; +var \u{300B1}; +var \u{300B2}; +var \u{300B3}; +var \u{300B4}; +var \u{300B5}; +var \u{300B6}; +var \u{300B7}; +var \u{300B8}; +var \u{300B9}; +var \u{300BA}; +var \u{300BB}; +var \u{300BC}; +var \u{300BD}; +var \u{300BE}; +var \u{300BF}; +var \u{300C0}; +var \u{300C1}; +var \u{300C2}; +var \u{300C3}; +var \u{300C4}; +var \u{300C5}; +var \u{300C6}; +var \u{300C7}; +var \u{300C8}; +var \u{300C9}; +var \u{300CA}; +var \u{300CB}; +var \u{300CC}; +var \u{300CD}; +var \u{300CE}; +var \u{300CF}; +var \u{300D0}; +var \u{300D1}; +var \u{300D2}; +var \u{300D3}; +var \u{300D4}; +var \u{300D5}; +var \u{300D6}; +var \u{300D7}; +var \u{300D8}; +var \u{300D9}; +var \u{300DA}; +var \u{300DB}; +var \u{300DC}; +var \u{300DD}; +var \u{300DE}; +var \u{300DF}; +var \u{300E0}; +var \u{300E1}; +var \u{300E2}; +var \u{300E3}; +var \u{300E4}; +var \u{300E5}; +var \u{300E6}; +var \u{300E7}; +var \u{300E8}; +var \u{300E9}; +var \u{300EA}; +var \u{300EB}; +var \u{300EC}; +var \u{300ED}; +var \u{300EE}; +var \u{300EF}; +var \u{300F0}; +var \u{300F1}; +var \u{300F2}; +var \u{300F3}; +var \u{300F4}; +var \u{300F5}; +var \u{300F6}; +var \u{300F7}; +var \u{300F8}; +var \u{300F9}; +var \u{300FA}; +var \u{300FB}; +var \u{300FC}; +var \u{300FD}; +var \u{300FE}; +var \u{300FF}; +var \u{30100}; +var \u{30101}; +var \u{30102}; +var \u{30103}; +var \u{30104}; +var \u{30105}; +var \u{30106}; +var \u{30107}; +var \u{30108}; +var \u{30109}; +var \u{3010A}; +var \u{3010B}; +var \u{3010C}; +var \u{3010D}; +var \u{3010E}; +var \u{3010F}; +var \u{30110}; +var \u{30111}; +var \u{30112}; +var \u{30113}; +var \u{30114}; +var \u{30115}; +var \u{30116}; +var \u{30117}; +var \u{30118}; +var \u{30119}; +var \u{3011A}; +var \u{3011B}; +var \u{3011C}; +var \u{3011D}; +var \u{3011E}; +var \u{3011F}; +var \u{30120}; +var \u{30121}; +var \u{30122}; +var \u{30123}; +var \u{30124}; +var \u{30125}; +var \u{30126}; +var \u{30127}; +var \u{30128}; +var \u{30129}; +var \u{3012A}; +var \u{3012B}; +var \u{3012C}; +var \u{3012D}; +var \u{3012E}; +var \u{3012F}; +var \u{30130}; +var \u{30131}; +var \u{30132}; +var \u{30133}; +var \u{30134}; +var \u{30135}; +var \u{30136}; +var \u{30137}; +var \u{30138}; +var \u{30139}; +var \u{3013A}; +var \u{3013B}; +var \u{3013C}; +var \u{3013D}; +var \u{3013E}; +var \u{3013F}; +var \u{30140}; +var \u{30141}; +var \u{30142}; +var \u{30143}; +var \u{30144}; +var \u{30145}; +var \u{30146}; +var \u{30147}; +var \u{30148}; +var \u{30149}; +var \u{3014A}; +var \u{3014B}; +var \u{3014C}; +var \u{3014D}; +var \u{3014E}; +var \u{3014F}; +var \u{30150}; +var \u{30151}; +var \u{30152}; +var \u{30153}; +var \u{30154}; +var \u{30155}; +var \u{30156}; +var \u{30157}; +var \u{30158}; +var \u{30159}; +var \u{3015A}; +var \u{3015B}; +var \u{3015C}; +var \u{3015D}; +var \u{3015E}; +var \u{3015F}; +var \u{30160}; +var \u{30161}; +var \u{30162}; +var \u{30163}; +var \u{30164}; +var \u{30165}; +var \u{30166}; +var \u{30167}; +var \u{30168}; +var \u{30169}; +var \u{3016A}; +var \u{3016B}; +var \u{3016C}; +var \u{3016D}; +var \u{3016E}; +var \u{3016F}; +var \u{30170}; +var \u{30171}; +var \u{30172}; +var \u{30173}; +var \u{30174}; +var \u{30175}; +var \u{30176}; +var \u{30177}; +var \u{30178}; +var \u{30179}; +var \u{3017A}; +var \u{3017B}; +var \u{3017C}; +var \u{3017D}; +var \u{3017E}; +var \u{3017F}; +var \u{30180}; +var \u{30181}; +var \u{30182}; +var \u{30183}; +var \u{30184}; +var \u{30185}; +var \u{30186}; +var \u{30187}; +var \u{30188}; +var \u{30189}; +var \u{3018A}; +var \u{3018B}; +var \u{3018C}; +var \u{3018D}; +var \u{3018E}; +var \u{3018F}; +var \u{30190}; +var \u{30191}; +var \u{30192}; +var \u{30193}; +var \u{30194}; +var \u{30195}; +var \u{30196}; +var \u{30197}; +var \u{30198}; +var \u{30199}; +var \u{3019A}; +var \u{3019B}; +var \u{3019C}; +var \u{3019D}; +var \u{3019E}; +var \u{3019F}; +var \u{301A0}; +var \u{301A1}; +var \u{301A2}; +var \u{301A3}; +var \u{301A4}; +var \u{301A5}; +var \u{301A6}; +var \u{301A7}; +var \u{301A8}; +var \u{301A9}; +var \u{301AA}; +var \u{301AB}; +var \u{301AC}; +var \u{301AD}; +var \u{301AE}; +var \u{301AF}; +var \u{301B0}; +var \u{301B1}; +var \u{301B2}; +var \u{301B3}; +var \u{301B4}; +var \u{301B5}; +var \u{301B6}; +var \u{301B7}; +var \u{301B8}; +var \u{301B9}; +var \u{301BA}; +var \u{301BB}; +var \u{301BC}; +var \u{301BD}; +var \u{301BE}; +var \u{301BF}; +var \u{301C0}; +var \u{301C1}; +var \u{301C2}; +var \u{301C3}; +var \u{301C4}; +var \u{301C5}; +var \u{301C6}; +var \u{301C7}; +var \u{301C8}; +var \u{301C9}; +var \u{301CA}; +var \u{301CB}; +var \u{301CC}; +var \u{301CD}; +var \u{301CE}; +var \u{301CF}; +var \u{301D0}; +var \u{301D1}; +var \u{301D2}; +var \u{301D3}; +var \u{301D4}; +var \u{301D5}; +var \u{301D6}; +var \u{301D7}; +var \u{301D8}; +var \u{301D9}; +var \u{301DA}; +var \u{301DB}; +var \u{301DC}; +var \u{301DD}; +var \u{301DE}; +var \u{301DF}; +var \u{301E0}; +var \u{301E1}; +var \u{301E2}; +var \u{301E3}; +var \u{301E4}; +var \u{301E5}; +var \u{301E6}; +var \u{301E7}; +var \u{301E8}; +var \u{301E9}; +var \u{301EA}; +var \u{301EB}; +var \u{301EC}; +var \u{301ED}; +var \u{301EE}; +var \u{301EF}; +var \u{301F0}; +var \u{301F1}; +var \u{301F2}; +var \u{301F3}; +var \u{301F4}; +var \u{301F5}; +var \u{301F6}; +var \u{301F7}; +var \u{301F8}; +var \u{301F9}; +var \u{301FA}; +var \u{301FB}; +var \u{301FC}; +var \u{301FD}; +var \u{301FE}; +var \u{301FF}; +var \u{30200}; +var \u{30201}; +var \u{30202}; +var \u{30203}; +var \u{30204}; +var \u{30205}; +var \u{30206}; +var \u{30207}; +var \u{30208}; +var \u{30209}; +var \u{3020A}; +var \u{3020B}; +var \u{3020C}; +var \u{3020D}; +var \u{3020E}; +var \u{3020F}; +var \u{30210}; +var \u{30211}; +var \u{30212}; +var \u{30213}; +var \u{30214}; +var \u{30215}; +var \u{30216}; +var \u{30217}; +var \u{30218}; +var \u{30219}; +var \u{3021A}; +var \u{3021B}; +var \u{3021C}; +var \u{3021D}; +var \u{3021E}; +var \u{3021F}; +var \u{30220}; +var \u{30221}; +var \u{30222}; +var \u{30223}; +var \u{30224}; +var \u{30225}; +var \u{30226}; +var \u{30227}; +var \u{30228}; +var \u{30229}; +var \u{3022A}; +var \u{3022B}; +var \u{3022C}; +var \u{3022D}; +var \u{3022E}; +var \u{3022F}; +var \u{30230}; +var \u{30231}; +var \u{30232}; +var \u{30233}; +var \u{30234}; +var \u{30235}; +var \u{30236}; +var \u{30237}; +var \u{30238}; +var \u{30239}; +var \u{3023A}; +var \u{3023B}; +var \u{3023C}; +var \u{3023D}; +var \u{3023E}; +var \u{3023F}; +var \u{30240}; +var \u{30241}; +var \u{30242}; +var \u{30243}; +var \u{30244}; +var \u{30245}; +var \u{30246}; +var \u{30247}; +var \u{30248}; +var \u{30249}; +var \u{3024A}; +var \u{3024B}; +var \u{3024C}; +var \u{3024D}; +var \u{3024E}; +var \u{3024F}; +var \u{30250}; +var \u{30251}; +var \u{30252}; +var \u{30253}; +var \u{30254}; +var \u{30255}; +var \u{30256}; +var \u{30257}; +var \u{30258}; +var \u{30259}; +var \u{3025A}; +var \u{3025B}; +var \u{3025C}; +var \u{3025D}; +var \u{3025E}; +var \u{3025F}; +var \u{30260}; +var \u{30261}; +var \u{30262}; +var \u{30263}; +var \u{30264}; +var \u{30265}; +var \u{30266}; +var \u{30267}; +var \u{30268}; +var \u{30269}; +var \u{3026A}; +var \u{3026B}; +var \u{3026C}; +var \u{3026D}; +var \u{3026E}; +var \u{3026F}; +var \u{30270}; +var \u{30271}; +var \u{30272}; +var \u{30273}; +var \u{30274}; +var \u{30275}; +var \u{30276}; +var \u{30277}; +var \u{30278}; +var \u{30279}; +var \u{3027A}; +var \u{3027B}; +var \u{3027C}; +var \u{3027D}; +var \u{3027E}; +var \u{3027F}; +var \u{30280}; +var \u{30281}; +var \u{30282}; +var \u{30283}; +var \u{30284}; +var \u{30285}; +var \u{30286}; +var \u{30287}; +var \u{30288}; +var \u{30289}; +var \u{3028A}; +var \u{3028B}; +var \u{3028C}; +var \u{3028D}; +var \u{3028E}; +var \u{3028F}; +var \u{30290}; +var \u{30291}; +var \u{30292}; +var \u{30293}; +var \u{30294}; +var \u{30295}; +var \u{30296}; +var \u{30297}; +var \u{30298}; +var \u{30299}; +var \u{3029A}; +var \u{3029B}; +var \u{3029C}; +var \u{3029D}; +var \u{3029E}; +var \u{3029F}; +var \u{302A0}; +var \u{302A1}; +var \u{302A2}; +var \u{302A3}; +var \u{302A4}; +var \u{302A5}; +var \u{302A6}; +var \u{302A7}; +var \u{302A8}; +var \u{302A9}; +var \u{302AA}; +var \u{302AB}; +var \u{302AC}; +var \u{302AD}; +var \u{302AE}; +var \u{302AF}; +var \u{302B0}; +var \u{302B1}; +var \u{302B2}; +var \u{302B3}; +var \u{302B4}; +var \u{302B5}; +var \u{302B6}; +var \u{302B7}; +var \u{302B8}; +var \u{302B9}; +var \u{302BA}; +var \u{302BB}; +var \u{302BC}; +var \u{302BD}; +var \u{302BE}; +var \u{302BF}; +var \u{302C0}; +var \u{302C1}; +var \u{302C2}; +var \u{302C3}; +var \u{302C4}; +var \u{302C5}; +var \u{302C6}; +var \u{302C7}; +var \u{302C8}; +var \u{302C9}; +var \u{302CA}; +var \u{302CB}; +var \u{302CC}; +var \u{302CD}; +var \u{302CE}; +var \u{302CF}; +var \u{302D0}; +var \u{302D1}; +var \u{302D2}; +var \u{302D3}; +var \u{302D4}; +var \u{302D5}; +var \u{302D6}; +var \u{302D7}; +var \u{302D8}; +var \u{302D9}; +var \u{302DA}; +var \u{302DB}; +var \u{302DC}; +var \u{302DD}; +var \u{302DE}; +var \u{302DF}; +var \u{302E0}; +var \u{302E1}; +var \u{302E2}; +var \u{302E3}; +var \u{302E4}; +var \u{302E5}; +var \u{302E6}; +var \u{302E7}; +var \u{302E8}; +var \u{302E9}; +var \u{302EA}; +var \u{302EB}; +var \u{302EC}; +var \u{302ED}; +var \u{302EE}; +var \u{302EF}; +var \u{302F0}; +var \u{302F1}; +var \u{302F2}; +var \u{302F3}; +var \u{302F4}; +var \u{302F5}; +var \u{302F6}; +var \u{302F7}; +var \u{302F8}; +var \u{302F9}; +var \u{302FA}; +var \u{302FB}; +var \u{302FC}; +var \u{302FD}; +var \u{302FE}; +var \u{302FF}; +var \u{30300}; +var \u{30301}; +var \u{30302}; +var \u{30303}; +var \u{30304}; +var \u{30305}; +var \u{30306}; +var \u{30307}; +var \u{30308}; +var \u{30309}; +var \u{3030A}; +var \u{3030B}; +var \u{3030C}; +var \u{3030D}; +var \u{3030E}; +var \u{3030F}; +var \u{30310}; +var \u{30311}; +var \u{30312}; +var \u{30313}; +var \u{30314}; +var \u{30315}; +var \u{30316}; +var \u{30317}; +var \u{30318}; +var \u{30319}; +var \u{3031A}; +var \u{3031B}; +var \u{3031C}; +var \u{3031D}; +var \u{3031E}; +var \u{3031F}; +var \u{30320}; +var \u{30321}; +var \u{30322}; +var \u{30323}; +var \u{30324}; +var \u{30325}; +var \u{30326}; +var \u{30327}; +var \u{30328}; +var \u{30329}; +var \u{3032A}; +var \u{3032B}; +var \u{3032C}; +var \u{3032D}; +var \u{3032E}; +var \u{3032F}; +var \u{30330}; +var \u{30331}; +var \u{30332}; +var \u{30333}; +var \u{30334}; +var \u{30335}; +var \u{30336}; +var \u{30337}; +var \u{30338}; +var \u{30339}; +var \u{3033A}; +var \u{3033B}; +var \u{3033C}; +var \u{3033D}; +var \u{3033E}; +var \u{3033F}; +var \u{30340}; +var \u{30341}; +var \u{30342}; +var \u{30343}; +var \u{30344}; +var \u{30345}; +var \u{30346}; +var \u{30347}; +var \u{30348}; +var \u{30349}; +var \u{3034A}; +var \u{3034B}; +var \u{3034C}; +var \u{3034D}; +var \u{3034E}; +var \u{3034F}; +var \u{30350}; +var \u{30351}; +var \u{30352}; +var \u{30353}; +var \u{30354}; +var \u{30355}; +var \u{30356}; +var \u{30357}; +var \u{30358}; +var \u{30359}; +var \u{3035A}; +var \u{3035B}; +var \u{3035C}; +var \u{3035D}; +var \u{3035E}; +var \u{3035F}; +var \u{30360}; +var \u{30361}; +var \u{30362}; +var \u{30363}; +var \u{30364}; +var \u{30365}; +var \u{30366}; +var \u{30367}; +var \u{30368}; +var \u{30369}; +var \u{3036A}; +var \u{3036B}; +var \u{3036C}; +var \u{3036D}; +var \u{3036E}; +var \u{3036F}; +var \u{30370}; +var \u{30371}; +var \u{30372}; +var \u{30373}; +var \u{30374}; +var \u{30375}; +var \u{30376}; +var \u{30377}; +var \u{30378}; +var \u{30379}; +var \u{3037A}; +var \u{3037B}; +var \u{3037C}; +var \u{3037D}; +var \u{3037E}; +var \u{3037F}; +var \u{30380}; +var \u{30381}; +var \u{30382}; +var \u{30383}; +var \u{30384}; +var \u{30385}; +var \u{30386}; +var \u{30387}; +var \u{30388}; +var \u{30389}; +var \u{3038A}; +var \u{3038B}; +var \u{3038C}; +var \u{3038D}; +var \u{3038E}; +var \u{3038F}; +var \u{30390}; +var \u{30391}; +var \u{30392}; +var \u{30393}; +var \u{30394}; +var \u{30395}; +var \u{30396}; +var \u{30397}; +var \u{30398}; +var \u{30399}; +var \u{3039A}; +var \u{3039B}; +var \u{3039C}; +var \u{3039D}; +var \u{3039E}; +var \u{3039F}; +var \u{303A0}; +var \u{303A1}; +var \u{303A2}; +var \u{303A3}; +var \u{303A4}; +var \u{303A5}; +var \u{303A6}; +var \u{303A7}; +var \u{303A8}; +var \u{303A9}; +var \u{303AA}; +var \u{303AB}; +var \u{303AC}; +var \u{303AD}; +var \u{303AE}; +var \u{303AF}; +var \u{303B0}; +var \u{303B1}; +var \u{303B2}; +var \u{303B3}; +var \u{303B4}; +var \u{303B5}; +var \u{303B6}; +var \u{303B7}; +var \u{303B8}; +var \u{303B9}; +var \u{303BA}; +var \u{303BB}; +var \u{303BC}; +var \u{303BD}; +var \u{303BE}; +var \u{303BF}; +var \u{303C0}; +var \u{303C1}; +var \u{303C2}; +var \u{303C3}; +var \u{303C4}; +var \u{303C5}; +var \u{303C6}; +var \u{303C7}; +var \u{303C8}; +var \u{303C9}; +var \u{303CA}; +var \u{303CB}; +var \u{303CC}; +var \u{303CD}; +var \u{303CE}; +var \u{303CF}; +var \u{303D0}; +var \u{303D1}; +var \u{303D2}; +var \u{303D3}; +var \u{303D4}; +var \u{303D5}; +var \u{303D6}; +var \u{303D7}; +var \u{303D8}; +var \u{303D9}; +var \u{303DA}; +var \u{303DB}; +var \u{303DC}; +var \u{303DD}; +var \u{303DE}; +var \u{303DF}; +var \u{303E0}; +var \u{303E1}; +var \u{303E2}; +var \u{303E3}; +var \u{303E4}; +var \u{303E5}; +var \u{303E6}; +var \u{303E7}; +var \u{303E8}; +var \u{303E9}; +var \u{303EA}; +var \u{303EB}; +var \u{303EC}; +var \u{303ED}; +var \u{303EE}; +var \u{303EF}; +var \u{303F0}; +var \u{303F1}; +var \u{303F2}; +var \u{303F3}; +var \u{303F4}; +var \u{303F5}; +var \u{303F6}; +var \u{303F7}; +var \u{303F8}; +var \u{303F9}; +var \u{303FA}; +var \u{303FB}; +var \u{303FC}; +var \u{303FD}; +var \u{303FE}; +var \u{303FF}; +var \u{30400}; +var \u{30401}; +var \u{30402}; +var \u{30403}; +var \u{30404}; +var \u{30405}; +var \u{30406}; +var \u{30407}; +var \u{30408}; +var \u{30409}; +var \u{3040A}; +var \u{3040B}; +var \u{3040C}; +var \u{3040D}; +var \u{3040E}; +var \u{3040F}; +var \u{30410}; +var \u{30411}; +var \u{30412}; +var \u{30413}; +var \u{30414}; +var \u{30415}; +var \u{30416}; +var \u{30417}; +var \u{30418}; +var \u{30419}; +var \u{3041A}; +var \u{3041B}; +var \u{3041C}; +var \u{3041D}; +var \u{3041E}; +var \u{3041F}; +var \u{30420}; +var \u{30421}; +var \u{30422}; +var \u{30423}; +var \u{30424}; +var \u{30425}; +var \u{30426}; +var \u{30427}; +var \u{30428}; +var \u{30429}; +var \u{3042A}; +var \u{3042B}; +var \u{3042C}; +var \u{3042D}; +var \u{3042E}; +var \u{3042F}; +var \u{30430}; +var \u{30431}; +var \u{30432}; +var \u{30433}; +var \u{30434}; +var \u{30435}; +var \u{30436}; +var \u{30437}; +var \u{30438}; +var \u{30439}; +var \u{3043A}; +var \u{3043B}; +var \u{3043C}; +var \u{3043D}; +var \u{3043E}; +var \u{3043F}; +var \u{30440}; +var \u{30441}; +var \u{30442}; +var \u{30443}; +var \u{30444}; +var \u{30445}; +var \u{30446}; +var \u{30447}; +var \u{30448}; +var \u{30449}; +var \u{3044A}; +var \u{3044B}; +var \u{3044C}; +var \u{3044D}; +var \u{3044E}; +var \u{3044F}; +var \u{30450}; +var \u{30451}; +var \u{30452}; +var \u{30453}; +var \u{30454}; +var \u{30455}; +var \u{30456}; +var \u{30457}; +var \u{30458}; +var \u{30459}; +var \u{3045A}; +var \u{3045B}; +var \u{3045C}; +var \u{3045D}; +var \u{3045E}; +var \u{3045F}; +var \u{30460}; +var \u{30461}; +var \u{30462}; +var \u{30463}; +var \u{30464}; +var \u{30465}; +var \u{30466}; +var \u{30467}; +var \u{30468}; +var \u{30469}; +var \u{3046A}; +var \u{3046B}; +var \u{3046C}; +var \u{3046D}; +var \u{3046E}; +var \u{3046F}; +var \u{30470}; +var \u{30471}; +var \u{30472}; +var \u{30473}; +var \u{30474}; +var \u{30475}; +var \u{30476}; +var \u{30477}; +var \u{30478}; +var \u{30479}; +var \u{3047A}; +var \u{3047B}; +var \u{3047C}; +var \u{3047D}; +var \u{3047E}; +var \u{3047F}; +var \u{30480}; +var \u{30481}; +var \u{30482}; +var \u{30483}; +var \u{30484}; +var \u{30485}; +var \u{30486}; +var \u{30487}; +var \u{30488}; +var \u{30489}; +var \u{3048A}; +var \u{3048B}; +var \u{3048C}; +var \u{3048D}; +var \u{3048E}; +var \u{3048F}; +var \u{30490}; +var \u{30491}; +var \u{30492}; +var \u{30493}; +var \u{30494}; +var \u{30495}; +var \u{30496}; +var \u{30497}; +var \u{30498}; +var \u{30499}; +var \u{3049A}; +var \u{3049B}; +var \u{3049C}; +var \u{3049D}; +var \u{3049E}; +var \u{3049F}; +var \u{304A0}; +var \u{304A1}; +var \u{304A2}; +var \u{304A3}; +var \u{304A4}; +var \u{304A5}; +var \u{304A6}; +var \u{304A7}; +var \u{304A8}; +var \u{304A9}; +var \u{304AA}; +var \u{304AB}; +var \u{304AC}; +var \u{304AD}; +var \u{304AE}; +var \u{304AF}; +var \u{304B0}; +var \u{304B1}; +var \u{304B2}; +var \u{304B3}; +var \u{304B4}; +var \u{304B5}; +var \u{304B6}; +var \u{304B7}; +var \u{304B8}; +var \u{304B9}; +var \u{304BA}; +var \u{304BB}; +var \u{304BC}; +var \u{304BD}; +var \u{304BE}; +var \u{304BF}; +var \u{304C0}; +var \u{304C1}; +var \u{304C2}; +var \u{304C3}; +var \u{304C4}; +var \u{304C5}; +var \u{304C6}; +var \u{304C7}; +var \u{304C8}; +var \u{304C9}; +var \u{304CA}; +var \u{304CB}; +var \u{304CC}; +var \u{304CD}; +var \u{304CE}; +var \u{304CF}; +var \u{304D0}; +var \u{304D1}; +var \u{304D2}; +var \u{304D3}; +var \u{304D4}; +var \u{304D5}; +var \u{304D6}; +var \u{304D7}; +var \u{304D8}; +var \u{304D9}; +var \u{304DA}; +var \u{304DB}; +var \u{304DC}; +var \u{304DD}; +var \u{304DE}; +var \u{304DF}; +var \u{304E0}; +var \u{304E1}; +var \u{304E2}; +var \u{304E3}; +var \u{304E4}; +var \u{304E5}; +var \u{304E6}; +var \u{304E7}; +var \u{304E8}; +var \u{304E9}; +var \u{304EA}; +var \u{304EB}; +var \u{304EC}; +var \u{304ED}; +var \u{304EE}; +var \u{304EF}; +var \u{304F0}; +var \u{304F1}; +var \u{304F2}; +var \u{304F3}; +var \u{304F4}; +var \u{304F5}; +var \u{304F6}; +var \u{304F7}; +var \u{304F8}; +var \u{304F9}; +var \u{304FA}; +var \u{304FB}; +var \u{304FC}; +var \u{304FD}; +var \u{304FE}; +var \u{304FF}; +var \u{30500}; +var \u{30501}; +var \u{30502}; +var \u{30503}; +var \u{30504}; +var \u{30505}; +var \u{30506}; +var \u{30507}; +var \u{30508}; +var \u{30509}; +var \u{3050A}; +var \u{3050B}; +var \u{3050C}; +var \u{3050D}; +var \u{3050E}; +var \u{3050F}; +var \u{30510}; +var \u{30511}; +var \u{30512}; +var \u{30513}; +var \u{30514}; +var \u{30515}; +var \u{30516}; +var \u{30517}; +var \u{30518}; +var \u{30519}; +var \u{3051A}; +var \u{3051B}; +var \u{3051C}; +var \u{3051D}; +var \u{3051E}; +var \u{3051F}; +var \u{30520}; +var \u{30521}; +var \u{30522}; +var \u{30523}; +var \u{30524}; +var \u{30525}; +var \u{30526}; +var \u{30527}; +var \u{30528}; +var \u{30529}; +var \u{3052A}; +var \u{3052B}; +var \u{3052C}; +var \u{3052D}; +var \u{3052E}; +var \u{3052F}; +var \u{30530}; +var \u{30531}; +var \u{30532}; +var \u{30533}; +var \u{30534}; +var \u{30535}; +var \u{30536}; +var \u{30537}; +var \u{30538}; +var \u{30539}; +var \u{3053A}; +var \u{3053B}; +var \u{3053C}; +var \u{3053D}; +var \u{3053E}; +var \u{3053F}; +var \u{30540}; +var \u{30541}; +var \u{30542}; +var \u{30543}; +var \u{30544}; +var \u{30545}; +var \u{30546}; +var \u{30547}; +var \u{30548}; +var \u{30549}; +var \u{3054A}; +var \u{3054B}; +var \u{3054C}; +var \u{3054D}; +var \u{3054E}; +var \u{3054F}; +var \u{30550}; +var \u{30551}; +var \u{30552}; +var \u{30553}; +var \u{30554}; +var \u{30555}; +var \u{30556}; +var \u{30557}; +var \u{30558}; +var \u{30559}; +var \u{3055A}; +var \u{3055B}; +var \u{3055C}; +var \u{3055D}; +var \u{3055E}; +var \u{3055F}; +var \u{30560}; +var \u{30561}; +var \u{30562}; +var \u{30563}; +var \u{30564}; +var \u{30565}; +var \u{30566}; +var \u{30567}; +var \u{30568}; +var \u{30569}; +var \u{3056A}; +var \u{3056B}; +var \u{3056C}; +var \u{3056D}; +var \u{3056E}; +var \u{3056F}; +var \u{30570}; +var \u{30571}; +var \u{30572}; +var \u{30573}; +var \u{30574}; +var \u{30575}; +var \u{30576}; +var \u{30577}; +var \u{30578}; +var \u{30579}; +var \u{3057A}; +var \u{3057B}; +var \u{3057C}; +var \u{3057D}; +var \u{3057E}; +var \u{3057F}; +var \u{30580}; +var \u{30581}; +var \u{30582}; +var \u{30583}; +var \u{30584}; +var \u{30585}; +var \u{30586}; +var \u{30587}; +var \u{30588}; +var \u{30589}; +var \u{3058A}; +var \u{3058B}; +var \u{3058C}; +var \u{3058D}; +var \u{3058E}; +var \u{3058F}; +var \u{30590}; +var \u{30591}; +var \u{30592}; +var \u{30593}; +var \u{30594}; +var \u{30595}; +var \u{30596}; +var \u{30597}; +var \u{30598}; +var \u{30599}; +var \u{3059A}; +var \u{3059B}; +var \u{3059C}; +var \u{3059D}; +var \u{3059E}; +var \u{3059F}; +var \u{305A0}; +var \u{305A1}; +var \u{305A2}; +var \u{305A3}; +var \u{305A4}; +var \u{305A5}; +var \u{305A6}; +var \u{305A7}; +var \u{305A8}; +var \u{305A9}; +var \u{305AA}; +var \u{305AB}; +var \u{305AC}; +var \u{305AD}; +var \u{305AE}; +var \u{305AF}; +var \u{305B0}; +var \u{305B1}; +var \u{305B2}; +var \u{305B3}; +var \u{305B4}; +var \u{305B5}; +var \u{305B6}; +var \u{305B7}; +var \u{305B8}; +var \u{305B9}; +var \u{305BA}; +var \u{305BB}; +var \u{305BC}; +var \u{305BD}; +var \u{305BE}; +var \u{305BF}; +var \u{305C0}; +var \u{305C1}; +var \u{305C2}; +var \u{305C3}; +var \u{305C4}; +var \u{305C5}; +var \u{305C6}; +var \u{305C7}; +var \u{305C8}; +var \u{305C9}; +var \u{305CA}; +var \u{305CB}; +var \u{305CC}; +var \u{305CD}; +var \u{305CE}; +var \u{305CF}; +var \u{305D0}; +var \u{305D1}; +var \u{305D2}; +var \u{305D3}; +var \u{305D4}; +var \u{305D5}; +var \u{305D6}; +var \u{305D7}; +var \u{305D8}; +var \u{305D9}; +var \u{305DA}; +var \u{305DB}; +var \u{305DC}; +var \u{305DD}; +var \u{305DE}; +var \u{305DF}; +var \u{305E0}; +var \u{305E1}; +var \u{305E2}; +var \u{305E3}; +var \u{305E4}; +var \u{305E5}; +var \u{305E6}; +var \u{305E7}; +var \u{305E8}; +var \u{305E9}; +var \u{305EA}; +var \u{305EB}; +var \u{305EC}; +var \u{305ED}; +var \u{305EE}; +var \u{305EF}; +var \u{305F0}; +var \u{305F1}; +var \u{305F2}; +var \u{305F3}; +var \u{305F4}; +var \u{305F5}; +var \u{305F6}; +var \u{305F7}; +var \u{305F8}; +var \u{305F9}; +var \u{305FA}; +var \u{305FB}; +var \u{305FC}; +var \u{305FD}; +var \u{305FE}; +var \u{305FF}; +var \u{30600}; +var \u{30601}; +var \u{30602}; +var \u{30603}; +var \u{30604}; +var \u{30605}; +var \u{30606}; +var \u{30607}; +var \u{30608}; +var \u{30609}; +var \u{3060A}; +var \u{3060B}; +var \u{3060C}; +var \u{3060D}; +var \u{3060E}; +var \u{3060F}; +var \u{30610}; +var \u{30611}; +var \u{30612}; +var \u{30613}; +var \u{30614}; +var \u{30615}; +var \u{30616}; +var \u{30617}; +var \u{30618}; +var \u{30619}; +var \u{3061A}; +var \u{3061B}; +var \u{3061C}; +var \u{3061D}; +var \u{3061E}; +var \u{3061F}; +var \u{30620}; +var \u{30621}; +var \u{30622}; +var \u{30623}; +var \u{30624}; +var \u{30625}; +var \u{30626}; +var \u{30627}; +var \u{30628}; +var \u{30629}; +var \u{3062A}; +var \u{3062B}; +var \u{3062C}; +var \u{3062D}; +var \u{3062E}; +var \u{3062F}; +var \u{30630}; +var \u{30631}; +var \u{30632}; +var \u{30633}; +var \u{30634}; +var \u{30635}; +var \u{30636}; +var \u{30637}; +var \u{30638}; +var \u{30639}; +var \u{3063A}; +var \u{3063B}; +var \u{3063C}; +var \u{3063D}; +var \u{3063E}; +var \u{3063F}; +var \u{30640}; +var \u{30641}; +var \u{30642}; +var \u{30643}; +var \u{30644}; +var \u{30645}; +var \u{30646}; +var \u{30647}; +var \u{30648}; +var \u{30649}; +var \u{3064A}; +var \u{3064B}; +var \u{3064C}; +var \u{3064D}; +var \u{3064E}; +var \u{3064F}; +var \u{30650}; +var \u{30651}; +var \u{30652}; +var \u{30653}; +var \u{30654}; +var \u{30655}; +var \u{30656}; +var \u{30657}; +var \u{30658}; +var \u{30659}; +var \u{3065A}; +var \u{3065B}; +var \u{3065C}; +var \u{3065D}; +var \u{3065E}; +var \u{3065F}; +var \u{30660}; +var \u{30661}; +var \u{30662}; +var \u{30663}; +var \u{30664}; +var \u{30665}; +var \u{30666}; +var \u{30667}; +var \u{30668}; +var \u{30669}; +var \u{3066A}; +var \u{3066B}; +var \u{3066C}; +var \u{3066D}; +var \u{3066E}; +var \u{3066F}; +var \u{30670}; +var \u{30671}; +var \u{30672}; +var \u{30673}; +var \u{30674}; +var \u{30675}; +var \u{30676}; +var \u{30677}; +var \u{30678}; +var \u{30679}; +var \u{3067A}; +var \u{3067B}; +var \u{3067C}; +var \u{3067D}; +var \u{3067E}; +var \u{3067F}; +var \u{30680}; +var \u{30681}; +var \u{30682}; +var \u{30683}; +var \u{30684}; +var \u{30685}; +var \u{30686}; +var \u{30687}; +var \u{30688}; +var \u{30689}; +var \u{3068A}; +var \u{3068B}; +var \u{3068C}; +var \u{3068D}; +var \u{3068E}; +var \u{3068F}; +var \u{30690}; +var \u{30691}; +var \u{30692}; +var \u{30693}; +var \u{30694}; +var \u{30695}; +var \u{30696}; +var \u{30697}; +var \u{30698}; +var \u{30699}; +var \u{3069A}; +var \u{3069B}; +var \u{3069C}; +var \u{3069D}; +var \u{3069E}; +var \u{3069F}; +var \u{306A0}; +var \u{306A1}; +var \u{306A2}; +var \u{306A3}; +var \u{306A4}; +var \u{306A5}; +var \u{306A6}; +var \u{306A7}; +var \u{306A8}; +var \u{306A9}; +var \u{306AA}; +var \u{306AB}; +var \u{306AC}; +var \u{306AD}; +var \u{306AE}; +var \u{306AF}; +var \u{306B0}; +var \u{306B1}; +var \u{306B2}; +var \u{306B3}; +var \u{306B4}; +var \u{306B5}; +var \u{306B6}; +var \u{306B7}; +var \u{306B8}; +var \u{306B9}; +var \u{306BA}; +var \u{306BB}; +var \u{306BC}; +var \u{306BD}; +var \u{306BE}; +var \u{306BF}; +var \u{306C0}; +var \u{306C1}; +var \u{306C2}; +var \u{306C3}; +var \u{306C4}; +var \u{306C5}; +var \u{306C6}; +var \u{306C7}; +var \u{306C8}; +var \u{306C9}; +var \u{306CA}; +var \u{306CB}; +var \u{306CC}; +var \u{306CD}; +var \u{306CE}; +var \u{306CF}; +var \u{306D0}; +var \u{306D1}; +var \u{306D2}; +var \u{306D3}; +var \u{306D4}; +var \u{306D5}; +var \u{306D6}; +var \u{306D7}; +var \u{306D8}; +var \u{306D9}; +var \u{306DA}; +var \u{306DB}; +var \u{306DC}; +var \u{306DD}; +var \u{306DE}; +var \u{306DF}; +var \u{306E0}; +var \u{306E1}; +var \u{306E2}; +var \u{306E3}; +var \u{306E4}; +var \u{306E5}; +var \u{306E6}; +var \u{306E7}; +var \u{306E8}; +var \u{306E9}; +var \u{306EA}; +var \u{306EB}; +var \u{306EC}; +var \u{306ED}; +var \u{306EE}; +var \u{306EF}; +var \u{306F0}; +var \u{306F1}; +var \u{306F2}; +var \u{306F3}; +var \u{306F4}; +var \u{306F5}; +var \u{306F6}; +var \u{306F7}; +var \u{306F8}; +var \u{306F9}; +var \u{306FA}; +var \u{306FB}; +var \u{306FC}; +var \u{306FD}; +var \u{306FE}; +var \u{306FF}; +var \u{30700}; +var \u{30701}; +var \u{30702}; +var \u{30703}; +var \u{30704}; +var \u{30705}; +var \u{30706}; +var \u{30707}; +var \u{30708}; +var \u{30709}; +var \u{3070A}; +var \u{3070B}; +var \u{3070C}; +var \u{3070D}; +var \u{3070E}; +var \u{3070F}; +var \u{30710}; +var \u{30711}; +var \u{30712}; +var \u{30713}; +var \u{30714}; +var \u{30715}; +var \u{30716}; +var \u{30717}; +var \u{30718}; +var \u{30719}; +var \u{3071A}; +var \u{3071B}; +var \u{3071C}; +var \u{3071D}; +var \u{3071E}; +var \u{3071F}; +var \u{30720}; +var \u{30721}; +var \u{30722}; +var \u{30723}; +var \u{30724}; +var \u{30725}; +var \u{30726}; +var \u{30727}; +var \u{30728}; +var \u{30729}; +var \u{3072A}; +var \u{3072B}; +var \u{3072C}; +var \u{3072D}; +var \u{3072E}; +var \u{3072F}; +var \u{30730}; +var \u{30731}; +var \u{30732}; +var \u{30733}; +var \u{30734}; +var \u{30735}; +var \u{30736}; +var \u{30737}; +var \u{30738}; +var \u{30739}; +var \u{3073A}; +var \u{3073B}; +var \u{3073C}; +var \u{3073D}; +var \u{3073E}; +var \u{3073F}; +var \u{30740}; +var \u{30741}; +var \u{30742}; +var \u{30743}; +var \u{30744}; +var \u{30745}; +var \u{30746}; +var \u{30747}; +var \u{30748}; +var \u{30749}; +var \u{3074A}; +var \u{3074B}; +var \u{3074C}; +var \u{3074D}; +var \u{3074E}; +var \u{3074F}; +var \u{30750}; +var \u{30751}; +var \u{30752}; +var \u{30753}; +var \u{30754}; +var \u{30755}; +var \u{30756}; +var \u{30757}; +var \u{30758}; +var \u{30759}; +var \u{3075A}; +var \u{3075B}; +var \u{3075C}; +var \u{3075D}; +var \u{3075E}; +var \u{3075F}; +var \u{30760}; +var \u{30761}; +var \u{30762}; +var \u{30763}; +var \u{30764}; +var \u{30765}; +var \u{30766}; +var \u{30767}; +var \u{30768}; +var \u{30769}; +var \u{3076A}; +var \u{3076B}; +var \u{3076C}; +var \u{3076D}; +var \u{3076E}; +var \u{3076F}; +var \u{30770}; +var \u{30771}; +var \u{30772}; +var \u{30773}; +var \u{30774}; +var \u{30775}; +var \u{30776}; +var \u{30777}; +var \u{30778}; +var \u{30779}; +var \u{3077A}; +var \u{3077B}; +var \u{3077C}; +var \u{3077D}; +var \u{3077E}; +var \u{3077F}; +var \u{30780}; +var \u{30781}; +var \u{30782}; +var \u{30783}; +var \u{30784}; +var \u{30785}; +var \u{30786}; +var \u{30787}; +var \u{30788}; +var \u{30789}; +var \u{3078A}; +var \u{3078B}; +var \u{3078C}; +var \u{3078D}; +var \u{3078E}; +var \u{3078F}; +var \u{30790}; +var \u{30791}; +var \u{30792}; +var \u{30793}; +var \u{30794}; +var \u{30795}; +var \u{30796}; +var \u{30797}; +var \u{30798}; +var \u{30799}; +var \u{3079A}; +var \u{3079B}; +var \u{3079C}; +var \u{3079D}; +var \u{3079E}; +var \u{3079F}; +var \u{307A0}; +var \u{307A1}; +var \u{307A2}; +var \u{307A3}; +var \u{307A4}; +var \u{307A5}; +var \u{307A6}; +var \u{307A7}; +var \u{307A8}; +var \u{307A9}; +var \u{307AA}; +var \u{307AB}; +var \u{307AC}; +var \u{307AD}; +var \u{307AE}; +var \u{307AF}; +var \u{307B0}; +var \u{307B1}; +var \u{307B2}; +var \u{307B3}; +var \u{307B4}; +var \u{307B5}; +var \u{307B6}; +var \u{307B7}; +var \u{307B8}; +var \u{307B9}; +var \u{307BA}; +var \u{307BB}; +var \u{307BC}; +var \u{307BD}; +var \u{307BE}; +var \u{307BF}; +var \u{307C0}; +var \u{307C1}; +var \u{307C2}; +var \u{307C3}; +var \u{307C4}; +var \u{307C5}; +var \u{307C6}; +var \u{307C7}; +var \u{307C8}; +var \u{307C9}; +var \u{307CA}; +var \u{307CB}; +var \u{307CC}; +var \u{307CD}; +var \u{307CE}; +var \u{307CF}; +var \u{307D0}; +var \u{307D1}; +var \u{307D2}; +var \u{307D3}; +var \u{307D4}; +var \u{307D5}; +var \u{307D6}; +var \u{307D7}; +var \u{307D8}; +var \u{307D9}; +var \u{307DA}; +var \u{307DB}; +var \u{307DC}; +var \u{307DD}; +var \u{307DE}; +var \u{307DF}; +var \u{307E0}; +var \u{307E1}; +var \u{307E2}; +var \u{307E3}; +var \u{307E4}; +var \u{307E5}; +var \u{307E6}; +var \u{307E7}; +var \u{307E8}; +var \u{307E9}; +var \u{307EA}; +var \u{307EB}; +var \u{307EC}; +var \u{307ED}; +var \u{307EE}; +var \u{307EF}; +var \u{307F0}; +var \u{307F1}; +var \u{307F2}; +var \u{307F3}; +var \u{307F4}; +var \u{307F5}; +var \u{307F6}; +var \u{307F7}; +var \u{307F8}; +var \u{307F9}; +var \u{307FA}; +var \u{307FB}; +var \u{307FC}; +var \u{307FD}; +var \u{307FE}; +var \u{307FF}; +var \u{30800}; +var \u{30801}; +var \u{30802}; +var \u{30803}; +var \u{30804}; +var \u{30805}; +var \u{30806}; +var \u{30807}; +var \u{30808}; +var \u{30809}; +var \u{3080A}; +var \u{3080B}; +var \u{3080C}; +var \u{3080D}; +var \u{3080E}; +var \u{3080F}; +var \u{30810}; +var \u{30811}; +var \u{30812}; +var \u{30813}; +var \u{30814}; +var \u{30815}; +var \u{30816}; +var \u{30817}; +var \u{30818}; +var \u{30819}; +var \u{3081A}; +var \u{3081B}; +var \u{3081C}; +var \u{3081D}; +var \u{3081E}; +var \u{3081F}; +var \u{30820}; +var \u{30821}; +var \u{30822}; +var \u{30823}; +var \u{30824}; +var \u{30825}; +var \u{30826}; +var \u{30827}; +var \u{30828}; +var \u{30829}; +var \u{3082A}; +var \u{3082B}; +var \u{3082C}; +var \u{3082D}; +var \u{3082E}; +var \u{3082F}; +var \u{30830}; +var \u{30831}; +var \u{30832}; +var \u{30833}; +var \u{30834}; +var \u{30835}; +var \u{30836}; +var \u{30837}; +var \u{30838}; +var \u{30839}; +var \u{3083A}; +var \u{3083B}; +var \u{3083C}; +var \u{3083D}; +var \u{3083E}; +var \u{3083F}; +var \u{30840}; +var \u{30841}; +var \u{30842}; +var \u{30843}; +var \u{30844}; +var \u{30845}; +var \u{30846}; +var \u{30847}; +var \u{30848}; +var \u{30849}; +var \u{3084A}; +var \u{3084B}; +var \u{3084C}; +var \u{3084D}; +var \u{3084E}; +var \u{3084F}; +var \u{30850}; +var \u{30851}; +var \u{30852}; +var \u{30853}; +var \u{30854}; +var \u{30855}; +var \u{30856}; +var \u{30857}; +var \u{30858}; +var \u{30859}; +var \u{3085A}; +var \u{3085B}; +var \u{3085C}; +var \u{3085D}; +var \u{3085E}; +var \u{3085F}; +var \u{30860}; +var \u{30861}; +var \u{30862}; +var \u{30863}; +var \u{30864}; +var \u{30865}; +var \u{30866}; +var \u{30867}; +var \u{30868}; +var \u{30869}; +var \u{3086A}; +var \u{3086B}; +var \u{3086C}; +var \u{3086D}; +var \u{3086E}; +var \u{3086F}; +var \u{30870}; +var \u{30871}; +var \u{30872}; +var \u{30873}; +var \u{30874}; +var \u{30875}; +var \u{30876}; +var \u{30877}; +var \u{30878}; +var \u{30879}; +var \u{3087A}; +var \u{3087B}; +var \u{3087C}; +var \u{3087D}; +var \u{3087E}; +var \u{3087F}; +var \u{30880}; +var \u{30881}; +var \u{30882}; +var \u{30883}; +var \u{30884}; +var \u{30885}; +var \u{30886}; +var \u{30887}; +var \u{30888}; +var \u{30889}; +var \u{3088A}; +var \u{3088B}; +var \u{3088C}; +var \u{3088D}; +var \u{3088E}; +var \u{3088F}; +var \u{30890}; +var \u{30891}; +var \u{30892}; +var \u{30893}; +var \u{30894}; +var \u{30895}; +var \u{30896}; +var \u{30897}; +var \u{30898}; +var \u{30899}; +var \u{3089A}; +var \u{3089B}; +var \u{3089C}; +var \u{3089D}; +var \u{3089E}; +var \u{3089F}; +var \u{308A0}; +var \u{308A1}; +var \u{308A2}; +var \u{308A3}; +var \u{308A4}; +var \u{308A5}; +var \u{308A6}; +var \u{308A7}; +var \u{308A8}; +var \u{308A9}; +var \u{308AA}; +var \u{308AB}; +var \u{308AC}; +var \u{308AD}; +var \u{308AE}; +var \u{308AF}; +var \u{308B0}; +var \u{308B1}; +var \u{308B2}; +var \u{308B3}; +var \u{308B4}; +var \u{308B5}; +var \u{308B6}; +var \u{308B7}; +var \u{308B8}; +var \u{308B9}; +var \u{308BA}; +var \u{308BB}; +var \u{308BC}; +var \u{308BD}; +var \u{308BE}; +var \u{308BF}; +var \u{308C0}; +var \u{308C1}; +var \u{308C2}; +var \u{308C3}; +var \u{308C4}; +var \u{308C5}; +var \u{308C6}; +var \u{308C7}; +var \u{308C8}; +var \u{308C9}; +var \u{308CA}; +var \u{308CB}; +var \u{308CC}; +var \u{308CD}; +var \u{308CE}; +var \u{308CF}; +var \u{308D0}; +var \u{308D1}; +var \u{308D2}; +var \u{308D3}; +var \u{308D4}; +var \u{308D5}; +var \u{308D6}; +var \u{308D7}; +var \u{308D8}; +var \u{308D9}; +var \u{308DA}; +var \u{308DB}; +var \u{308DC}; +var \u{308DD}; +var \u{308DE}; +var \u{308DF}; +var \u{308E0}; +var \u{308E1}; +var \u{308E2}; +var \u{308E3}; +var \u{308E4}; +var \u{308E5}; +var \u{308E6}; +var \u{308E7}; +var \u{308E8}; +var \u{308E9}; +var \u{308EA}; +var \u{308EB}; +var \u{308EC}; +var \u{308ED}; +var \u{308EE}; +var \u{308EF}; +var \u{308F0}; +var \u{308F1}; +var \u{308F2}; +var \u{308F3}; +var \u{308F4}; +var \u{308F5}; +var \u{308F6}; +var \u{308F7}; +var \u{308F8}; +var \u{308F9}; +var \u{308FA}; +var \u{308FB}; +var \u{308FC}; +var \u{308FD}; +var \u{308FE}; +var \u{308FF}; +var \u{30900}; +var \u{30901}; +var \u{30902}; +var \u{30903}; +var \u{30904}; +var \u{30905}; +var \u{30906}; +var \u{30907}; +var \u{30908}; +var \u{30909}; +var \u{3090A}; +var \u{3090B}; +var \u{3090C}; +var \u{3090D}; +var \u{3090E}; +var \u{3090F}; +var \u{30910}; +var \u{30911}; +var \u{30912}; +var \u{30913}; +var \u{30914}; +var \u{30915}; +var \u{30916}; +var \u{30917}; +var \u{30918}; +var \u{30919}; +var \u{3091A}; +var \u{3091B}; +var \u{3091C}; +var \u{3091D}; +var \u{3091E}; +var \u{3091F}; +var \u{30920}; +var \u{30921}; +var \u{30922}; +var \u{30923}; +var \u{30924}; +var \u{30925}; +var \u{30926}; +var \u{30927}; +var \u{30928}; +var \u{30929}; +var \u{3092A}; +var \u{3092B}; +var \u{3092C}; +var \u{3092D}; +var \u{3092E}; +var \u{3092F}; +var \u{30930}; +var \u{30931}; +var \u{30932}; +var \u{30933}; +var \u{30934}; +var \u{30935}; +var \u{30936}; +var \u{30937}; +var \u{30938}; +var \u{30939}; +var \u{3093A}; +var \u{3093B}; +var \u{3093C}; +var \u{3093D}; +var \u{3093E}; +var \u{3093F}; +var \u{30940}; +var \u{30941}; +var \u{30942}; +var \u{30943}; +var \u{30944}; +var \u{30945}; +var \u{30946}; +var \u{30947}; +var \u{30948}; +var \u{30949}; +var \u{3094A}; +var \u{3094B}; +var \u{3094C}; +var \u{3094D}; +var \u{3094E}; +var \u{3094F}; +var \u{30950}; +var \u{30951}; +var \u{30952}; +var \u{30953}; +var \u{30954}; +var \u{30955}; +var \u{30956}; +var \u{30957}; +var \u{30958}; +var \u{30959}; +var \u{3095A}; +var \u{3095B}; +var \u{3095C}; +var \u{3095D}; +var \u{3095E}; +var \u{3095F}; +var \u{30960}; +var \u{30961}; +var \u{30962}; +var \u{30963}; +var \u{30964}; +var \u{30965}; +var \u{30966}; +var \u{30967}; +var \u{30968}; +var \u{30969}; +var \u{3096A}; +var \u{3096B}; +var \u{3096C}; +var \u{3096D}; +var \u{3096E}; +var \u{3096F}; +var \u{30970}; +var \u{30971}; +var \u{30972}; +var \u{30973}; +var \u{30974}; +var \u{30975}; +var \u{30976}; +var \u{30977}; +var \u{30978}; +var \u{30979}; +var \u{3097A}; +var \u{3097B}; +var \u{3097C}; +var \u{3097D}; +var \u{3097E}; +var \u{3097F}; +var \u{30980}; +var \u{30981}; +var \u{30982}; +var \u{30983}; +var \u{30984}; +var \u{30985}; +var \u{30986}; +var \u{30987}; +var \u{30988}; +var \u{30989}; +var \u{3098A}; +var \u{3098B}; +var \u{3098C}; +var \u{3098D}; +var \u{3098E}; +var \u{3098F}; +var \u{30990}; +var \u{30991}; +var \u{30992}; +var \u{30993}; +var \u{30994}; +var \u{30995}; +var \u{30996}; +var \u{30997}; +var \u{30998}; +var \u{30999}; +var \u{3099A}; +var \u{3099B}; +var \u{3099C}; +var \u{3099D}; +var \u{3099E}; +var \u{3099F}; +var \u{309A0}; +var \u{309A1}; +var \u{309A2}; +var \u{309A3}; +var \u{309A4}; +var \u{309A5}; +var \u{309A6}; +var \u{309A7}; +var \u{309A8}; +var \u{309A9}; +var \u{309AA}; +var \u{309AB}; +var \u{309AC}; +var \u{309AD}; +var \u{309AE}; +var \u{309AF}; +var \u{309B0}; +var \u{309B1}; +var \u{309B2}; +var \u{309B3}; +var \u{309B4}; +var \u{309B5}; +var \u{309B6}; +var \u{309B7}; +var \u{309B8}; +var \u{309B9}; +var \u{309BA}; +var \u{309BB}; +var \u{309BC}; +var \u{309BD}; +var \u{309BE}; +var \u{309BF}; +var \u{309C0}; +var \u{309C1}; +var \u{309C2}; +var \u{309C3}; +var \u{309C4}; +var \u{309C5}; +var \u{309C6}; +var \u{309C7}; +var \u{309C8}; +var \u{309C9}; +var \u{309CA}; +var \u{309CB}; +var \u{309CC}; +var \u{309CD}; +var \u{309CE}; +var \u{309CF}; +var \u{309D0}; +var \u{309D1}; +var \u{309D2}; +var \u{309D3}; +var \u{309D4}; +var \u{309D5}; +var \u{309D6}; +var \u{309D7}; +var \u{309D8}; +var \u{309D9}; +var \u{309DA}; +var \u{309DB}; +var \u{309DC}; +var \u{309DD}; +var \u{309DE}; +var \u{309DF}; +var \u{309E0}; +var \u{309E1}; +var \u{309E2}; +var \u{309E3}; +var \u{309E4}; +var \u{309E5}; +var \u{309E6}; +var \u{309E7}; +var \u{309E8}; +var \u{309E9}; +var \u{309EA}; +var \u{309EB}; +var \u{309EC}; +var \u{309ED}; +var \u{309EE}; +var \u{309EF}; +var \u{309F0}; +var \u{309F1}; +var \u{309F2}; +var \u{309F3}; +var \u{309F4}; +var \u{309F5}; +var \u{309F6}; +var \u{309F7}; +var \u{309F8}; +var \u{309F9}; +var \u{309FA}; +var \u{309FB}; +var \u{309FC}; +var \u{309FD}; +var \u{309FE}; +var \u{309FF}; +var \u{30A00}; +var \u{30A01}; +var \u{30A02}; +var \u{30A03}; +var \u{30A04}; +var \u{30A05}; +var \u{30A06}; +var \u{30A07}; +var \u{30A08}; +var \u{30A09}; +var \u{30A0A}; +var \u{30A0B}; +var \u{30A0C}; +var \u{30A0D}; +var \u{30A0E}; +var \u{30A0F}; +var \u{30A10}; +var \u{30A11}; +var \u{30A12}; +var \u{30A13}; +var \u{30A14}; +var \u{30A15}; +var \u{30A16}; +var \u{30A17}; +var \u{30A18}; +var \u{30A19}; +var \u{30A1A}; +var \u{30A1B}; +var \u{30A1C}; +var \u{30A1D}; +var \u{30A1E}; +var \u{30A1F}; +var \u{30A20}; +var \u{30A21}; +var \u{30A22}; +var \u{30A23}; +var \u{30A24}; +var \u{30A25}; +var \u{30A26}; +var \u{30A27}; +var \u{30A28}; +var \u{30A29}; +var \u{30A2A}; +var \u{30A2B}; +var \u{30A2C}; +var \u{30A2D}; +var \u{30A2E}; +var \u{30A2F}; +var \u{30A30}; +var \u{30A31}; +var \u{30A32}; +var \u{30A33}; +var \u{30A34}; +var \u{30A35}; +var \u{30A36}; +var \u{30A37}; +var \u{30A38}; +var \u{30A39}; +var \u{30A3A}; +var \u{30A3B}; +var \u{30A3C}; +var \u{30A3D}; +var \u{30A3E}; +var \u{30A3F}; +var \u{30A40}; +var \u{30A41}; +var \u{30A42}; +var \u{30A43}; +var \u{30A44}; +var \u{30A45}; +var \u{30A46}; +var \u{30A47}; +var \u{30A48}; +var \u{30A49}; +var \u{30A4A}; +var \u{30A4B}; +var \u{30A4C}; +var \u{30A4D}; +var \u{30A4E}; +var \u{30A4F}; +var \u{30A50}; +var \u{30A51}; +var \u{30A52}; +var \u{30A53}; +var \u{30A54}; +var \u{30A55}; +var \u{30A56}; +var \u{30A57}; +var \u{30A58}; +var \u{30A59}; +var \u{30A5A}; +var \u{30A5B}; +var \u{30A5C}; +var \u{30A5D}; +var \u{30A5E}; +var \u{30A5F}; +var \u{30A60}; +var \u{30A61}; +var \u{30A62}; +var \u{30A63}; +var \u{30A64}; +var \u{30A65}; +var \u{30A66}; +var \u{30A67}; +var \u{30A68}; +var \u{30A69}; +var \u{30A6A}; +var \u{30A6B}; +var \u{30A6C}; +var \u{30A6D}; +var \u{30A6E}; +var \u{30A6F}; +var \u{30A70}; +var \u{30A71}; +var \u{30A72}; +var \u{30A73}; +var \u{30A74}; +var \u{30A75}; +var \u{30A76}; +var \u{30A77}; +var \u{30A78}; +var \u{30A79}; +var \u{30A7A}; +var \u{30A7B}; +var \u{30A7C}; +var \u{30A7D}; +var \u{30A7E}; +var \u{30A7F}; +var \u{30A80}; +var \u{30A81}; +var \u{30A82}; +var \u{30A83}; +var \u{30A84}; +var \u{30A85}; +var \u{30A86}; +var \u{30A87}; +var \u{30A88}; +var \u{30A89}; +var \u{30A8A}; +var \u{30A8B}; +var \u{30A8C}; +var \u{30A8D}; +var \u{30A8E}; +var \u{30A8F}; +var \u{30A90}; +var \u{30A91}; +var \u{30A92}; +var \u{30A93}; +var \u{30A94}; +var \u{30A95}; +var \u{30A96}; +var \u{30A97}; +var \u{30A98}; +var \u{30A99}; +var \u{30A9A}; +var \u{30A9B}; +var \u{30A9C}; +var \u{30A9D}; +var \u{30A9E}; +var \u{30A9F}; +var \u{30AA0}; +var \u{30AA1}; +var \u{30AA2}; +var \u{30AA3}; +var \u{30AA4}; +var \u{30AA5}; +var \u{30AA6}; +var \u{30AA7}; +var \u{30AA8}; +var \u{30AA9}; +var \u{30AAA}; +var \u{30AAB}; +var \u{30AAC}; +var \u{30AAD}; +var \u{30AAE}; +var \u{30AAF}; +var \u{30AB0}; +var \u{30AB1}; +var \u{30AB2}; +var \u{30AB3}; +var \u{30AB4}; +var \u{30AB5}; +var \u{30AB6}; +var \u{30AB7}; +var \u{30AB8}; +var \u{30AB9}; +var \u{30ABA}; +var \u{30ABB}; +var \u{30ABC}; +var \u{30ABD}; +var \u{30ABE}; +var \u{30ABF}; +var \u{30AC0}; +var \u{30AC1}; +var \u{30AC2}; +var \u{30AC3}; +var \u{30AC4}; +var \u{30AC5}; +var \u{30AC6}; +var \u{30AC7}; +var \u{30AC8}; +var \u{30AC9}; +var \u{30ACA}; +var \u{30ACB}; +var \u{30ACC}; +var \u{30ACD}; +var \u{30ACE}; +var \u{30ACF}; +var \u{30AD0}; +var \u{30AD1}; +var \u{30AD2}; +var \u{30AD3}; +var \u{30AD4}; +var \u{30AD5}; +var \u{30AD6}; +var \u{30AD7}; +var \u{30AD8}; +var \u{30AD9}; +var \u{30ADA}; +var \u{30ADB}; +var \u{30ADC}; +var \u{30ADD}; +var \u{30ADE}; +var \u{30ADF}; +var \u{30AE0}; +var \u{30AE1}; +var \u{30AE2}; +var \u{30AE3}; +var \u{30AE4}; +var \u{30AE5}; +var \u{30AE6}; +var \u{30AE7}; +var \u{30AE8}; +var \u{30AE9}; +var \u{30AEA}; +var \u{30AEB}; +var \u{30AEC}; +var \u{30AED}; +var \u{30AEE}; +var \u{30AEF}; +var \u{30AF0}; +var \u{30AF1}; +var \u{30AF2}; +var \u{30AF3}; +var \u{30AF4}; +var \u{30AF5}; +var \u{30AF6}; +var \u{30AF7}; +var \u{30AF8}; +var \u{30AF9}; +var \u{30AFA}; +var \u{30AFB}; +var \u{30AFC}; +var \u{30AFD}; +var \u{30AFE}; +var \u{30AFF}; +var \u{30B00}; +var \u{30B01}; +var \u{30B02}; +var \u{30B03}; +var \u{30B04}; +var \u{30B05}; +var \u{30B06}; +var \u{30B07}; +var \u{30B08}; +var \u{30B09}; +var \u{30B0A}; +var \u{30B0B}; +var \u{30B0C}; +var \u{30B0D}; +var \u{30B0E}; +var \u{30B0F}; +var \u{30B10}; +var \u{30B11}; +var \u{30B12}; +var \u{30B13}; +var \u{30B14}; +var \u{30B15}; +var \u{30B16}; +var \u{30B17}; +var \u{30B18}; +var \u{30B19}; +var \u{30B1A}; +var \u{30B1B}; +var \u{30B1C}; +var \u{30B1D}; +var \u{30B1E}; +var \u{30B1F}; +var \u{30B20}; +var \u{30B21}; +var \u{30B22}; +var \u{30B23}; +var \u{30B24}; +var \u{30B25}; +var \u{30B26}; +var \u{30B27}; +var \u{30B28}; +var \u{30B29}; +var \u{30B2A}; +var \u{30B2B}; +var \u{30B2C}; +var \u{30B2D}; +var \u{30B2E}; +var \u{30B2F}; +var \u{30B30}; +var \u{30B31}; +var \u{30B32}; +var \u{30B33}; +var \u{30B34}; +var \u{30B35}; +var \u{30B36}; +var \u{30B37}; +var \u{30B38}; +var \u{30B39}; +var \u{30B3A}; +var \u{30B3B}; +var \u{30B3C}; +var \u{30B3D}; +var \u{30B3E}; +var \u{30B3F}; +var \u{30B40}; +var \u{30B41}; +var \u{30B42}; +var \u{30B43}; +var \u{30B44}; +var \u{30B45}; +var \u{30B46}; +var \u{30B47}; +var \u{30B48}; +var \u{30B49}; +var \u{30B4A}; +var \u{30B4B}; +var \u{30B4C}; +var \u{30B4D}; +var \u{30B4E}; +var \u{30B4F}; +var \u{30B50}; +var \u{30B51}; +var \u{30B52}; +var \u{30B53}; +var \u{30B54}; +var \u{30B55}; +var \u{30B56}; +var \u{30B57}; +var \u{30B58}; +var \u{30B59}; +var \u{30B5A}; +var \u{30B5B}; +var \u{30B5C}; +var \u{30B5D}; +var \u{30B5E}; +var \u{30B5F}; +var \u{30B60}; +var \u{30B61}; +var \u{30B62}; +var \u{30B63}; +var \u{30B64}; +var \u{30B65}; +var \u{30B66}; +var \u{30B67}; +var \u{30B68}; +var \u{30B69}; +var \u{30B6A}; +var \u{30B6B}; +var \u{30B6C}; +var \u{30B6D}; +var \u{30B6E}; +var \u{30B6F}; +var \u{30B70}; +var \u{30B71}; +var \u{30B72}; +var \u{30B73}; +var \u{30B74}; +var \u{30B75}; +var \u{30B76}; +var \u{30B77}; +var \u{30B78}; +var \u{30B79}; +var \u{30B7A}; +var \u{30B7B}; +var \u{30B7C}; +var \u{30B7D}; +var \u{30B7E}; +var \u{30B7F}; +var \u{30B80}; +var \u{30B81}; +var \u{30B82}; +var \u{30B83}; +var \u{30B84}; +var \u{30B85}; +var \u{30B86}; +var \u{30B87}; +var \u{30B88}; +var \u{30B89}; +var \u{30B8A}; +var \u{30B8B}; +var \u{30B8C}; +var \u{30B8D}; +var \u{30B8E}; +var \u{30B8F}; +var \u{30B90}; +var \u{30B91}; +var \u{30B92}; +var \u{30B93}; +var \u{30B94}; +var \u{30B95}; +var \u{30B96}; +var \u{30B97}; +var \u{30B98}; +var \u{30B99}; +var \u{30B9A}; +var \u{30B9B}; +var \u{30B9C}; +var \u{30B9D}; +var \u{30B9E}; +var \u{30B9F}; +var \u{30BA0}; +var \u{30BA1}; +var \u{30BA2}; +var \u{30BA3}; +var \u{30BA4}; +var \u{30BA5}; +var \u{30BA6}; +var \u{30BA7}; +var \u{30BA8}; +var \u{30BA9}; +var \u{30BAA}; +var \u{30BAB}; +var \u{30BAC}; +var \u{30BAD}; +var \u{30BAE}; +var \u{30BAF}; +var \u{30BB0}; +var \u{30BB1}; +var \u{30BB2}; +var \u{30BB3}; +var \u{30BB4}; +var \u{30BB5}; +var \u{30BB6}; +var \u{30BB7}; +var \u{30BB8}; +var \u{30BB9}; +var \u{30BBA}; +var \u{30BBB}; +var \u{30BBC}; +var \u{30BBD}; +var \u{30BBE}; +var \u{30BBF}; +var \u{30BC0}; +var \u{30BC1}; +var \u{30BC2}; +var \u{30BC3}; +var \u{30BC4}; +var \u{30BC5}; +var \u{30BC6}; +var \u{30BC7}; +var \u{30BC8}; +var \u{30BC9}; +var \u{30BCA}; +var \u{30BCB}; +var \u{30BCC}; +var \u{30BCD}; +var \u{30BCE}; +var \u{30BCF}; +var \u{30BD0}; +var \u{30BD1}; +var \u{30BD2}; +var \u{30BD3}; +var \u{30BD4}; +var \u{30BD5}; +var \u{30BD6}; +var \u{30BD7}; +var \u{30BD8}; +var \u{30BD9}; +var \u{30BDA}; +var \u{30BDB}; +var \u{30BDC}; +var \u{30BDD}; +var \u{30BDE}; +var \u{30BDF}; +var \u{30BE0}; +var \u{30BE1}; +var \u{30BE2}; +var \u{30BE3}; +var \u{30BE4}; +var \u{30BE5}; +var \u{30BE6}; +var \u{30BE7}; +var \u{30BE8}; +var \u{30BE9}; +var \u{30BEA}; +var \u{30BEB}; +var \u{30BEC}; +var \u{30BED}; +var \u{30BEE}; +var \u{30BEF}; +var \u{30BF0}; +var \u{30BF1}; +var \u{30BF2}; +var \u{30BF3}; +var \u{30BF4}; +var \u{30BF5}; +var \u{30BF6}; +var \u{30BF7}; +var \u{30BF8}; +var \u{30BF9}; +var \u{30BFA}; +var \u{30BFB}; +var \u{30BFC}; +var \u{30BFD}; +var \u{30BFE}; +var \u{30BFF}; +var \u{30C00}; +var \u{30C01}; +var \u{30C02}; +var \u{30C03}; +var \u{30C04}; +var \u{30C05}; +var \u{30C06}; +var \u{30C07}; +var \u{30C08}; +var \u{30C09}; +var \u{30C0A}; +var \u{30C0B}; +var \u{30C0C}; +var \u{30C0D}; +var \u{30C0E}; +var \u{30C0F}; +var \u{30C10}; +var \u{30C11}; +var \u{30C12}; +var \u{30C13}; +var \u{30C14}; +var \u{30C15}; +var \u{30C16}; +var \u{30C17}; +var \u{30C18}; +var \u{30C19}; +var \u{30C1A}; +var \u{30C1B}; +var \u{30C1C}; +var \u{30C1D}; +var \u{30C1E}; +var \u{30C1F}; +var \u{30C20}; +var \u{30C21}; +var \u{30C22}; +var \u{30C23}; +var \u{30C24}; +var \u{30C25}; +var \u{30C26}; +var \u{30C27}; +var \u{30C28}; +var \u{30C29}; +var \u{30C2A}; +var \u{30C2B}; +var \u{30C2C}; +var \u{30C2D}; +var \u{30C2E}; +var \u{30C2F}; +var \u{30C30}; +var \u{30C31}; +var \u{30C32}; +var \u{30C33}; +var \u{30C34}; +var \u{30C35}; +var \u{30C36}; +var \u{30C37}; +var \u{30C38}; +var \u{30C39}; +var \u{30C3A}; +var \u{30C3B}; +var \u{30C3C}; +var \u{30C3D}; +var \u{30C3E}; +var \u{30C3F}; +var \u{30C40}; +var \u{30C41}; +var \u{30C42}; +var \u{30C43}; +var \u{30C44}; +var \u{30C45}; +var \u{30C46}; +var \u{30C47}; +var \u{30C48}; +var \u{30C49}; +var \u{30C4A}; +var \u{30C4B}; +var \u{30C4C}; +var \u{30C4D}; +var \u{30C4E}; +var \u{30C4F}; +var \u{30C50}; +var \u{30C51}; +var \u{30C52}; +var \u{30C53}; +var \u{30C54}; +var \u{30C55}; +var \u{30C56}; +var \u{30C57}; +var \u{30C58}; +var \u{30C59}; +var \u{30C5A}; +var \u{30C5B}; +var \u{30C5C}; +var \u{30C5D}; +var \u{30C5E}; +var \u{30C5F}; +var \u{30C60}; +var \u{30C61}; +var \u{30C62}; +var \u{30C63}; +var \u{30C64}; +var \u{30C65}; +var \u{30C66}; +var \u{30C67}; +var \u{30C68}; +var \u{30C69}; +var \u{30C6A}; +var \u{30C6B}; +var \u{30C6C}; +var \u{30C6D}; +var \u{30C6E}; +var \u{30C6F}; +var \u{30C70}; +var \u{30C71}; +var \u{30C72}; +var \u{30C73}; +var \u{30C74}; +var \u{30C75}; +var \u{30C76}; +var \u{30C77}; +var \u{30C78}; +var \u{30C79}; +var \u{30C7A}; +var \u{30C7B}; +var \u{30C7C}; +var \u{30C7D}; +var \u{30C7E}; +var \u{30C7F}; +var \u{30C80}; +var \u{30C81}; +var \u{30C82}; +var \u{30C83}; +var \u{30C84}; +var \u{30C85}; +var \u{30C86}; +var \u{30C87}; +var \u{30C88}; +var \u{30C89}; +var \u{30C8A}; +var \u{30C8B}; +var \u{30C8C}; +var \u{30C8D}; +var \u{30C8E}; +var \u{30C8F}; +var \u{30C90}; +var \u{30C91}; +var \u{30C92}; +var \u{30C93}; +var \u{30C94}; +var \u{30C95}; +var \u{30C96}; +var \u{30C97}; +var \u{30C98}; +var \u{30C99}; +var \u{30C9A}; +var \u{30C9B}; +var \u{30C9C}; +var \u{30C9D}; +var \u{30C9E}; +var \u{30C9F}; +var \u{30CA0}; +var \u{30CA1}; +var \u{30CA2}; +var \u{30CA3}; +var \u{30CA4}; +var \u{30CA5}; +var \u{30CA6}; +var \u{30CA7}; +var \u{30CA8}; +var \u{30CA9}; +var \u{30CAA}; +var \u{30CAB}; +var \u{30CAC}; +var \u{30CAD}; +var \u{30CAE}; +var \u{30CAF}; +var \u{30CB0}; +var \u{30CB1}; +var \u{30CB2}; +var \u{30CB3}; +var \u{30CB4}; +var \u{30CB5}; +var \u{30CB6}; +var \u{30CB7}; +var \u{30CB8}; +var \u{30CB9}; +var \u{30CBA}; +var \u{30CBB}; +var \u{30CBC}; +var \u{30CBD}; +var \u{30CBE}; +var \u{30CBF}; +var \u{30CC0}; +var \u{30CC1}; +var \u{30CC2}; +var \u{30CC3}; +var \u{30CC4}; +var \u{30CC5}; +var \u{30CC6}; +var \u{30CC7}; +var \u{30CC8}; +var \u{30CC9}; +var \u{30CCA}; +var \u{30CCB}; +var \u{30CCC}; +var \u{30CCD}; +var \u{30CCE}; +var \u{30CCF}; +var \u{30CD0}; +var \u{30CD1}; +var \u{30CD2}; +var \u{30CD3}; +var \u{30CD4}; +var \u{30CD5}; +var \u{30CD6}; +var \u{30CD7}; +var \u{30CD8}; +var \u{30CD9}; +var \u{30CDA}; +var \u{30CDB}; +var \u{30CDC}; +var \u{30CDD}; +var \u{30CDE}; +var \u{30CDF}; +var \u{30CE0}; +var \u{30CE1}; +var \u{30CE2}; +var \u{30CE3}; +var \u{30CE4}; +var \u{30CE5}; +var \u{30CE6}; +var \u{30CE7}; +var \u{30CE8}; +var \u{30CE9}; +var \u{30CEA}; +var \u{30CEB}; +var \u{30CEC}; +var \u{30CED}; +var \u{30CEE}; +var \u{30CEF}; +var \u{30CF0}; +var \u{30CF1}; +var \u{30CF2}; +var \u{30CF3}; +var \u{30CF4}; +var \u{30CF5}; +var \u{30CF6}; +var \u{30CF7}; +var \u{30CF8}; +var \u{30CF9}; +var \u{30CFA}; +var \u{30CFB}; +var \u{30CFC}; +var \u{30CFD}; +var \u{30CFE}; +var \u{30CFF}; +var \u{30D00}; +var \u{30D01}; +var \u{30D02}; +var \u{30D03}; +var \u{30D04}; +var \u{30D05}; +var \u{30D06}; +var \u{30D07}; +var \u{30D08}; +var \u{30D09}; +var \u{30D0A}; +var \u{30D0B}; +var \u{30D0C}; +var \u{30D0D}; +var \u{30D0E}; +var \u{30D0F}; +var \u{30D10}; +var \u{30D11}; +var \u{30D12}; +var \u{30D13}; +var \u{30D14}; +var \u{30D15}; +var \u{30D16}; +var \u{30D17}; +var \u{30D18}; +var \u{30D19}; +var \u{30D1A}; +var \u{30D1B}; +var \u{30D1C}; +var \u{30D1D}; +var \u{30D1E}; +var \u{30D1F}; +var \u{30D20}; +var \u{30D21}; +var \u{30D22}; +var \u{30D23}; +var \u{30D24}; +var \u{30D25}; +var \u{30D26}; +var \u{30D27}; +var \u{30D28}; +var \u{30D29}; +var \u{30D2A}; +var \u{30D2B}; +var \u{30D2C}; +var \u{30D2D}; +var \u{30D2E}; +var \u{30D2F}; +var \u{30D30}; +var \u{30D31}; +var \u{30D32}; +var \u{30D33}; +var \u{30D34}; +var \u{30D35}; +var \u{30D36}; +var \u{30D37}; +var \u{30D38}; +var \u{30D39}; +var \u{30D3A}; +var \u{30D3B}; +var \u{30D3C}; +var \u{30D3D}; +var \u{30D3E}; +var \u{30D3F}; +var \u{30D40}; +var \u{30D41}; +var \u{30D42}; +var \u{30D43}; +var \u{30D44}; +var \u{30D45}; +var \u{30D46}; +var \u{30D47}; +var \u{30D48}; +var \u{30D49}; +var \u{30D4A}; +var \u{30D4B}; +var \u{30D4C}; +var \u{30D4D}; +var \u{30D4E}; +var \u{30D4F}; +var \u{30D50}; +var \u{30D51}; +var \u{30D52}; +var \u{30D53}; +var \u{30D54}; +var \u{30D55}; +var \u{30D56}; +var \u{30D57}; +var \u{30D58}; +var \u{30D59}; +var \u{30D5A}; +var \u{30D5B}; +var \u{30D5C}; +var \u{30D5D}; +var \u{30D5E}; +var \u{30D5F}; +var \u{30D60}; +var \u{30D61}; +var \u{30D62}; +var \u{30D63}; +var \u{30D64}; +var \u{30D65}; +var \u{30D66}; +var \u{30D67}; +var \u{30D68}; +var \u{30D69}; +var \u{30D6A}; +var \u{30D6B}; +var \u{30D6C}; +var \u{30D6D}; +var \u{30D6E}; +var \u{30D6F}; +var \u{30D70}; +var \u{30D71}; +var \u{30D72}; +var \u{30D73}; +var \u{30D74}; +var \u{30D75}; +var \u{30D76}; +var \u{30D77}; +var \u{30D78}; +var \u{30D79}; +var \u{30D7A}; +var \u{30D7B}; +var \u{30D7C}; +var \u{30D7D}; +var \u{30D7E}; +var \u{30D7F}; +var \u{30D80}; +var \u{30D81}; +var \u{30D82}; +var \u{30D83}; +var \u{30D84}; +var \u{30D85}; +var \u{30D86}; +var \u{30D87}; +var \u{30D88}; +var \u{30D89}; +var \u{30D8A}; +var \u{30D8B}; +var \u{30D8C}; +var \u{30D8D}; +var \u{30D8E}; +var \u{30D8F}; +var \u{30D90}; +var \u{30D91}; +var \u{30D92}; +var \u{30D93}; +var \u{30D94}; +var \u{30D95}; +var \u{30D96}; +var \u{30D97}; +var \u{30D98}; +var \u{30D99}; +var \u{30D9A}; +var \u{30D9B}; +var \u{30D9C}; +var \u{30D9D}; +var \u{30D9E}; +var \u{30D9F}; +var \u{30DA0}; +var \u{30DA1}; +var \u{30DA2}; +var \u{30DA3}; +var \u{30DA4}; +var \u{30DA5}; +var \u{30DA6}; +var \u{30DA7}; +var \u{30DA8}; +var \u{30DA9}; +var \u{30DAA}; +var \u{30DAB}; +var \u{30DAC}; +var \u{30DAD}; +var \u{30DAE}; +var \u{30DAF}; +var \u{30DB0}; +var \u{30DB1}; +var \u{30DB2}; +var \u{30DB3}; +var \u{30DB4}; +var \u{30DB5}; +var \u{30DB6}; +var \u{30DB7}; +var \u{30DB8}; +var \u{30DB9}; +var \u{30DBA}; +var \u{30DBB}; +var \u{30DBC}; +var \u{30DBD}; +var \u{30DBE}; +var \u{30DBF}; +var \u{30DC0}; +var \u{30DC1}; +var \u{30DC2}; +var \u{30DC3}; +var \u{30DC4}; +var \u{30DC5}; +var \u{30DC6}; +var \u{30DC7}; +var \u{30DC8}; +var \u{30DC9}; +var \u{30DCA}; +var \u{30DCB}; +var \u{30DCC}; +var \u{30DCD}; +var \u{30DCE}; +var \u{30DCF}; +var \u{30DD0}; +var \u{30DD1}; +var \u{30DD2}; +var \u{30DD3}; +var \u{30DD4}; +var \u{30DD5}; +var \u{30DD6}; +var \u{30DD7}; +var \u{30DD8}; +var \u{30DD9}; +var \u{30DDA}; +var \u{30DDB}; +var \u{30DDC}; +var \u{30DDD}; +var \u{30DDE}; +var \u{30DDF}; +var \u{30DE0}; +var \u{30DE1}; +var \u{30DE2}; +var \u{30DE3}; +var \u{30DE4}; +var \u{30DE5}; +var \u{30DE6}; +var \u{30DE7}; +var \u{30DE8}; +var \u{30DE9}; +var \u{30DEA}; +var \u{30DEB}; +var \u{30DEC}; +var \u{30DED}; +var \u{30DEE}; +var \u{30DEF}; +var \u{30DF0}; +var \u{30DF1}; +var \u{30DF2}; +var \u{30DF3}; +var \u{30DF4}; +var \u{30DF5}; +var \u{30DF6}; +var \u{30DF7}; +var \u{30DF8}; +var \u{30DF9}; +var \u{30DFA}; +var \u{30DFB}; +var \u{30DFC}; +var \u{30DFD}; +var \u{30DFE}; +var \u{30DFF}; +var \u{30E00}; +var \u{30E01}; +var \u{30E02}; +var \u{30E03}; +var \u{30E04}; +var \u{30E05}; +var \u{30E06}; +var \u{30E07}; +var \u{30E08}; +var \u{30E09}; +var \u{30E0A}; +var \u{30E0B}; +var \u{30E0C}; +var \u{30E0D}; +var \u{30E0E}; +var \u{30E0F}; +var \u{30E10}; +var \u{30E11}; +var \u{30E12}; +var \u{30E13}; +var \u{30E14}; +var \u{30E15}; +var \u{30E16}; +var \u{30E17}; +var \u{30E18}; +var \u{30E19}; +var \u{30E1A}; +var \u{30E1B}; +var \u{30E1C}; +var \u{30E1D}; +var \u{30E1E}; +var \u{30E1F}; +var \u{30E20}; +var \u{30E21}; +var \u{30E22}; +var \u{30E23}; +var \u{30E24}; +var \u{30E25}; +var \u{30E26}; +var \u{30E27}; +var \u{30E28}; +var \u{30E29}; +var \u{30E2A}; +var \u{30E2B}; +var \u{30E2C}; +var \u{30E2D}; +var \u{30E2E}; +var \u{30E2F}; +var \u{30E30}; +var \u{30E31}; +var \u{30E32}; +var \u{30E33}; +var \u{30E34}; +var \u{30E35}; +var \u{30E36}; +var \u{30E37}; +var \u{30E38}; +var \u{30E39}; +var \u{30E3A}; +var \u{30E3B}; +var \u{30E3C}; +var \u{30E3D}; +var \u{30E3E}; +var \u{30E3F}; +var \u{30E40}; +var \u{30E41}; +var \u{30E42}; +var \u{30E43}; +var \u{30E44}; +var \u{30E45}; +var \u{30E46}; +var \u{30E47}; +var \u{30E48}; +var \u{30E49}; +var \u{30E4A}; +var \u{30E4B}; +var \u{30E4C}; +var \u{30E4D}; +var \u{30E4E}; +var \u{30E4F}; +var \u{30E50}; +var \u{30E51}; +var \u{30E52}; +var \u{30E53}; +var \u{30E54}; +var \u{30E55}; +var \u{30E56}; +var \u{30E57}; +var \u{30E58}; +var \u{30E59}; +var \u{30E5A}; +var \u{30E5B}; +var \u{30E5C}; +var \u{30E5D}; +var \u{30E5E}; +var \u{30E5F}; +var \u{30E60}; +var \u{30E61}; +var \u{30E62}; +var \u{30E63}; +var \u{30E64}; +var \u{30E65}; +var \u{30E66}; +var \u{30E67}; +var \u{30E68}; +var \u{30E69}; +var \u{30E6A}; +var \u{30E6B}; +var \u{30E6C}; +var \u{30E6D}; +var \u{30E6E}; +var \u{30E6F}; +var \u{30E70}; +var \u{30E71}; +var \u{30E72}; +var \u{30E73}; +var \u{30E74}; +var \u{30E75}; +var \u{30E76}; +var \u{30E77}; +var \u{30E78}; +var \u{30E79}; +var \u{30E7A}; +var \u{30E7B}; +var \u{30E7C}; +var \u{30E7D}; +var \u{30E7E}; +var \u{30E7F}; +var \u{30E80}; +var \u{30E81}; +var \u{30E82}; +var \u{30E83}; +var \u{30E84}; +var \u{30E85}; +var \u{30E86}; +var \u{30E87}; +var \u{30E88}; +var \u{30E89}; +var \u{30E8A}; +var \u{30E8B}; +var \u{30E8C}; +var \u{30E8D}; +var \u{30E8E}; +var \u{30E8F}; +var \u{30E90}; +var \u{30E91}; +var \u{30E92}; +var \u{30E93}; +var \u{30E94}; +var \u{30E95}; +var \u{30E96}; +var \u{30E97}; +var \u{30E98}; +var \u{30E99}; +var \u{30E9A}; +var \u{30E9B}; +var \u{30E9C}; +var \u{30E9D}; +var \u{30E9E}; +var \u{30E9F}; +var \u{30EA0}; +var \u{30EA1}; +var \u{30EA2}; +var \u{30EA3}; +var \u{30EA4}; +var \u{30EA5}; +var \u{30EA6}; +var \u{30EA7}; +var \u{30EA8}; +var \u{30EA9}; +var \u{30EAA}; +var \u{30EAB}; +var \u{30EAC}; +var \u{30EAD}; +var \u{30EAE}; +var \u{30EAF}; +var \u{30EB0}; +var \u{30EB1}; +var \u{30EB2}; +var \u{30EB3}; +var \u{30EB4}; +var \u{30EB5}; +var \u{30EB6}; +var \u{30EB7}; +var \u{30EB8}; +var \u{30EB9}; +var \u{30EBA}; +var \u{30EBB}; +var \u{30EBC}; +var \u{30EBD}; +var \u{30EBE}; +var \u{30EBF}; +var \u{30EC0}; +var \u{30EC1}; +var \u{30EC2}; +var \u{30EC3}; +var \u{30EC4}; +var \u{30EC5}; +var \u{30EC6}; +var \u{30EC7}; +var \u{30EC8}; +var \u{30EC9}; +var \u{30ECA}; +var \u{30ECB}; +var \u{30ECC}; +var \u{30ECD}; +var \u{30ECE}; +var \u{30ECF}; +var \u{30ED0}; +var \u{30ED1}; +var \u{30ED2}; +var \u{30ED3}; +var \u{30ED4}; +var \u{30ED5}; +var \u{30ED6}; +var \u{30ED7}; +var \u{30ED8}; +var \u{30ED9}; +var \u{30EDA}; +var \u{30EDB}; +var \u{30EDC}; +var \u{30EDD}; +var \u{30EDE}; +var \u{30EDF}; +var \u{30EE0}; +var \u{30EE1}; +var \u{30EE2}; +var \u{30EE3}; +var \u{30EE4}; +var \u{30EE5}; +var \u{30EE6}; +var \u{30EE7}; +var \u{30EE8}; +var \u{30EE9}; +var \u{30EEA}; +var \u{30EEB}; +var \u{30EEC}; +var \u{30EED}; +var \u{30EEE}; +var \u{30EEF}; +var \u{30EF0}; +var \u{30EF1}; +var \u{30EF2}; +var \u{30EF3}; +var \u{30EF4}; +var \u{30EF5}; +var \u{30EF6}; +var \u{30EF7}; +var \u{30EF8}; +var \u{30EF9}; +var \u{30EFA}; +var \u{30EFB}; +var \u{30EFC}; +var \u{30EFD}; +var \u{30EFE}; +var \u{30EFF}; +var \u{30F00}; +var \u{30F01}; +var \u{30F02}; +var \u{30F03}; +var \u{30F04}; +var \u{30F05}; +var \u{30F06}; +var \u{30F07}; +var \u{30F08}; +var \u{30F09}; +var \u{30F0A}; +var \u{30F0B}; +var \u{30F0C}; +var \u{30F0D}; +var \u{30F0E}; +var \u{30F0F}; +var \u{30F10}; +var \u{30F11}; +var \u{30F12}; +var \u{30F13}; +var \u{30F14}; +var \u{30F15}; +var \u{30F16}; +var \u{30F17}; +var \u{30F18}; +var \u{30F19}; +var \u{30F1A}; +var \u{30F1B}; +var \u{30F1C}; +var \u{30F1D}; +var \u{30F1E}; +var \u{30F1F}; +var \u{30F20}; +var \u{30F21}; +var \u{30F22}; +var \u{30F23}; +var \u{30F24}; +var \u{30F25}; +var \u{30F26}; +var \u{30F27}; +var \u{30F28}; +var \u{30F29}; +var \u{30F2A}; +var \u{30F2B}; +var \u{30F2C}; +var \u{30F2D}; +var \u{30F2E}; +var \u{30F2F}; +var \u{30F30}; +var \u{30F31}; +var \u{30F32}; +var \u{30F33}; +var \u{30F34}; +var \u{30F35}; +var \u{30F36}; +var \u{30F37}; +var \u{30F38}; +var \u{30F39}; +var \u{30F3A}; +var \u{30F3B}; +var \u{30F3C}; +var \u{30F3D}; +var \u{30F3E}; +var \u{30F3F}; +var \u{30F40}; +var \u{30F41}; +var \u{30F42}; +var \u{30F43}; +var \u{30F44}; +var \u{30F45}; +var \u{30F46}; +var \u{30F47}; +var \u{30F48}; +var \u{30F49}; +var \u{30F4A}; +var \u{30F4B}; +var \u{30F4C}; +var \u{30F4D}; +var \u{30F4E}; +var \u{30F4F}; +var \u{30F50}; +var \u{30F51}; +var \u{30F52}; +var \u{30F53}; +var \u{30F54}; +var \u{30F55}; +var \u{30F56}; +var \u{30F57}; +var \u{30F58}; +var \u{30F59}; +var \u{30F5A}; +var \u{30F5B}; +var \u{30F5C}; +var \u{30F5D}; +var \u{30F5E}; +var \u{30F5F}; +var \u{30F60}; +var \u{30F61}; +var \u{30F62}; +var \u{30F63}; +var \u{30F64}; +var \u{30F65}; +var \u{30F66}; +var \u{30F67}; +var \u{30F68}; +var \u{30F69}; +var \u{30F6A}; +var \u{30F6B}; +var \u{30F6C}; +var \u{30F6D}; +var \u{30F6E}; +var \u{30F6F}; +var \u{30F70}; +var \u{30F71}; +var \u{30F72}; +var \u{30F73}; +var \u{30F74}; +var \u{30F75}; +var \u{30F76}; +var \u{30F77}; +var \u{30F78}; +var \u{30F79}; +var \u{30F7A}; +var \u{30F7B}; +var \u{30F7C}; +var \u{30F7D}; +var \u{30F7E}; +var \u{30F7F}; +var \u{30F80}; +var \u{30F81}; +var \u{30F82}; +var \u{30F83}; +var \u{30F84}; +var \u{30F85}; +var \u{30F86}; +var \u{30F87}; +var \u{30F88}; +var \u{30F89}; +var \u{30F8A}; +var \u{30F8B}; +var \u{30F8C}; +var \u{30F8D}; +var \u{30F8E}; +var \u{30F8F}; +var \u{30F90}; +var \u{30F91}; +var \u{30F92}; +var \u{30F93}; +var \u{30F94}; +var \u{30F95}; +var \u{30F96}; +var \u{30F97}; +var \u{30F98}; +var \u{30F99}; +var \u{30F9A}; +var \u{30F9B}; +var \u{30F9C}; +var \u{30F9D}; +var \u{30F9E}; +var \u{30F9F}; +var \u{30FA0}; +var \u{30FA1}; +var \u{30FA2}; +var \u{30FA3}; +var \u{30FA4}; +var \u{30FA5}; +var \u{30FA6}; +var \u{30FA7}; +var \u{30FA8}; +var \u{30FA9}; +var \u{30FAA}; +var \u{30FAB}; +var \u{30FAC}; +var \u{30FAD}; +var \u{30FAE}; +var \u{30FAF}; +var \u{30FB0}; +var \u{30FB1}; +var \u{30FB2}; +var \u{30FB3}; +var \u{30FB4}; +var \u{30FB5}; +var \u{30FB6}; +var \u{30FB7}; +var \u{30FB8}; +var \u{30FB9}; +var \u{30FBA}; +var \u{30FBB}; +var \u{30FBC}; +var \u{30FBD}; +var \u{30FBE}; +var \u{30FBF}; +var \u{30FC0}; +var \u{30FC1}; +var \u{30FC2}; +var \u{30FC3}; +var \u{30FC4}; +var \u{30FC5}; +var \u{30FC6}; +var \u{30FC7}; +var \u{30FC8}; +var \u{30FC9}; +var \u{30FCA}; +var \u{30FCB}; +var \u{30FCC}; +var \u{30FCD}; +var \u{30FCE}; +var \u{30FCF}; +var \u{30FD0}; +var \u{30FD1}; +var \u{30FD2}; +var \u{30FD3}; +var \u{30FD4}; +var \u{30FD5}; +var \u{30FD6}; +var \u{30FD7}; +var \u{30FD8}; +var \u{30FD9}; +var \u{30FDA}; +var \u{30FDB}; +var \u{30FDC}; +var \u{30FDD}; +var \u{30FDE}; +var \u{30FDF}; +var \u{30FE0}; +var \u{30FE1}; +var \u{30FE2}; +var \u{30FE3}; +var \u{30FE4}; +var \u{30FE5}; +var \u{30FE6}; +var \u{30FE7}; +var \u{30FE8}; +var \u{30FE9}; +var \u{30FEA}; +var \u{30FEB}; +var \u{30FEC}; +var \u{30FED}; +var \u{30FEE}; +var \u{30FEF}; +var \u{30FF0}; +var \u{30FF1}; +var \u{30FF2}; +var \u{30FF3}; +var \u{30FF4}; +var \u{30FF5}; +var \u{30FF6}; +var \u{30FF7}; +var \u{30FF8}; +var \u{30FF9}; +var \u{30FFA}; +var \u{30FFB}; +var \u{30FFC}; +var \u{30FFD}; +var \u{30FFE}; +var \u{30FFF}; +var \u{31000}; +var \u{31001}; +var \u{31002}; +var \u{31003}; +var \u{31004}; +var \u{31005}; +var \u{31006}; +var \u{31007}; +var \u{31008}; +var \u{31009}; +var \u{3100A}; +var \u{3100B}; +var \u{3100C}; +var \u{3100D}; +var \u{3100E}; +var \u{3100F}; +var \u{31010}; +var \u{31011}; +var \u{31012}; +var \u{31013}; +var \u{31014}; +var \u{31015}; +var \u{31016}; +var \u{31017}; +var \u{31018}; +var \u{31019}; +var \u{3101A}; +var \u{3101B}; +var \u{3101C}; +var \u{3101D}; +var \u{3101E}; +var \u{3101F}; +var \u{31020}; +var \u{31021}; +var \u{31022}; +var \u{31023}; +var \u{31024}; +var \u{31025}; +var \u{31026}; +var \u{31027}; +var \u{31028}; +var \u{31029}; +var \u{3102A}; +var \u{3102B}; +var \u{3102C}; +var \u{3102D}; +var \u{3102E}; +var \u{3102F}; +var \u{31030}; +var \u{31031}; +var \u{31032}; +var \u{31033}; +var \u{31034}; +var \u{31035}; +var \u{31036}; +var \u{31037}; +var \u{31038}; +var \u{31039}; +var \u{3103A}; +var \u{3103B}; +var \u{3103C}; +var \u{3103D}; +var \u{3103E}; +var \u{3103F}; +var \u{31040}; +var \u{31041}; +var \u{31042}; +var \u{31043}; +var \u{31044}; +var \u{31045}; +var \u{31046}; +var \u{31047}; +var \u{31048}; +var \u{31049}; +var \u{3104A}; +var \u{3104B}; +var \u{3104C}; +var \u{3104D}; +var \u{3104E}; +var \u{3104F}; +var \u{31050}; +var \u{31051}; +var \u{31052}; +var \u{31053}; +var \u{31054}; +var \u{31055}; +var \u{31056}; +var \u{31057}; +var \u{31058}; +var \u{31059}; +var \u{3105A}; +var \u{3105B}; +var \u{3105C}; +var \u{3105D}; +var \u{3105E}; +var \u{3105F}; +var \u{31060}; +var \u{31061}; +var \u{31062}; +var \u{31063}; +var \u{31064}; +var \u{31065}; +var \u{31066}; +var \u{31067}; +var \u{31068}; +var \u{31069}; +var \u{3106A}; +var \u{3106B}; +var \u{3106C}; +var \u{3106D}; +var \u{3106E}; +var \u{3106F}; +var \u{31070}; +var \u{31071}; +var \u{31072}; +var \u{31073}; +var \u{31074}; +var \u{31075}; +var \u{31076}; +var \u{31077}; +var \u{31078}; +var \u{31079}; +var \u{3107A}; +var \u{3107B}; +var \u{3107C}; +var \u{3107D}; +var \u{3107E}; +var \u{3107F}; +var \u{31080}; +var \u{31081}; +var \u{31082}; +var \u{31083}; +var \u{31084}; +var \u{31085}; +var \u{31086}; +var \u{31087}; +var \u{31088}; +var \u{31089}; +var \u{3108A}; +var \u{3108B}; +var \u{3108C}; +var \u{3108D}; +var \u{3108E}; +var \u{3108F}; +var \u{31090}; +var \u{31091}; +var \u{31092}; +var \u{31093}; +var \u{31094}; +var \u{31095}; +var \u{31096}; +var \u{31097}; +var \u{31098}; +var \u{31099}; +var \u{3109A}; +var \u{3109B}; +var \u{3109C}; +var \u{3109D}; +var \u{3109E}; +var \u{3109F}; +var \u{310A0}; +var \u{310A1}; +var \u{310A2}; +var \u{310A3}; +var \u{310A4}; +var \u{310A5}; +var \u{310A6}; +var \u{310A7}; +var \u{310A8}; +var \u{310A9}; +var \u{310AA}; +var \u{310AB}; +var \u{310AC}; +var \u{310AD}; +var \u{310AE}; +var \u{310AF}; +var \u{310B0}; +var \u{310B1}; +var \u{310B2}; +var \u{310B3}; +var \u{310B4}; +var \u{310B5}; +var \u{310B6}; +var \u{310B7}; +var \u{310B8}; +var \u{310B9}; +var \u{310BA}; +var \u{310BB}; +var \u{310BC}; +var \u{310BD}; +var \u{310BE}; +var \u{310BF}; +var \u{310C0}; +var \u{310C1}; +var \u{310C2}; +var \u{310C3}; +var \u{310C4}; +var \u{310C5}; +var \u{310C6}; +var \u{310C7}; +var \u{310C8}; +var \u{310C9}; +var \u{310CA}; +var \u{310CB}; +var \u{310CC}; +var \u{310CD}; +var \u{310CE}; +var \u{310CF}; +var \u{310D0}; +var \u{310D1}; +var \u{310D2}; +var \u{310D3}; +var \u{310D4}; +var \u{310D5}; +var \u{310D6}; +var \u{310D7}; +var \u{310D8}; +var \u{310D9}; +var \u{310DA}; +var \u{310DB}; +var \u{310DC}; +var \u{310DD}; +var \u{310DE}; +var \u{310DF}; +var \u{310E0}; +var \u{310E1}; +var \u{310E2}; +var \u{310E3}; +var \u{310E4}; +var \u{310E5}; +var \u{310E6}; +var \u{310E7}; +var \u{310E8}; +var \u{310E9}; +var \u{310EA}; +var \u{310EB}; +var \u{310EC}; +var \u{310ED}; +var \u{310EE}; +var \u{310EF}; +var \u{310F0}; +var \u{310F1}; +var \u{310F2}; +var \u{310F3}; +var \u{310F4}; +var \u{310F5}; +var \u{310F6}; +var \u{310F7}; +var \u{310F8}; +var \u{310F9}; +var \u{310FA}; +var \u{310FB}; +var \u{310FC}; +var \u{310FD}; +var \u{310FE}; +var \u{310FF}; +var \u{31100}; +var \u{31101}; +var \u{31102}; +var \u{31103}; +var \u{31104}; +var \u{31105}; +var \u{31106}; +var \u{31107}; +var \u{31108}; +var \u{31109}; +var \u{3110A}; +var \u{3110B}; +var \u{3110C}; +var \u{3110D}; +var \u{3110E}; +var \u{3110F}; +var \u{31110}; +var \u{31111}; +var \u{31112}; +var \u{31113}; +var \u{31114}; +var \u{31115}; +var \u{31116}; +var \u{31117}; +var \u{31118}; +var \u{31119}; +var \u{3111A}; +var \u{3111B}; +var \u{3111C}; +var \u{3111D}; +var \u{3111E}; +var \u{3111F}; +var \u{31120}; +var \u{31121}; +var \u{31122}; +var \u{31123}; +var \u{31124}; +var \u{31125}; +var \u{31126}; +var \u{31127}; +var \u{31128}; +var \u{31129}; +var \u{3112A}; +var \u{3112B}; +var \u{3112C}; +var \u{3112D}; +var \u{3112E}; +var \u{3112F}; +var \u{31130}; +var \u{31131}; +var \u{31132}; +var \u{31133}; +var \u{31134}; +var \u{31135}; +var \u{31136}; +var \u{31137}; +var \u{31138}; +var \u{31139}; +var \u{3113A}; +var \u{3113B}; +var \u{3113C}; +var \u{3113D}; +var \u{3113E}; +var \u{3113F}; +var \u{31140}; +var \u{31141}; +var \u{31142}; +var \u{31143}; +var \u{31144}; +var \u{31145}; +var \u{31146}; +var \u{31147}; +var \u{31148}; +var \u{31149}; +var \u{3114A}; +var \u{3114B}; +var \u{3114C}; +var \u{3114D}; +var \u{3114E}; +var \u{3114F}; +var \u{31150}; +var \u{31151}; +var \u{31152}; +var \u{31153}; +var \u{31154}; +var \u{31155}; +var \u{31156}; +var \u{31157}; +var \u{31158}; +var \u{31159}; +var \u{3115A}; +var \u{3115B}; +var \u{3115C}; +var \u{3115D}; +var \u{3115E}; +var \u{3115F}; +var \u{31160}; +var \u{31161}; +var \u{31162}; +var \u{31163}; +var \u{31164}; +var \u{31165}; +var \u{31166}; +var \u{31167}; +var \u{31168}; +var \u{31169}; +var \u{3116A}; +var \u{3116B}; +var \u{3116C}; +var \u{3116D}; +var \u{3116E}; +var \u{3116F}; +var \u{31170}; +var \u{31171}; +var \u{31172}; +var \u{31173}; +var \u{31174}; +var \u{31175}; +var \u{31176}; +var \u{31177}; +var \u{31178}; +var \u{31179}; +var \u{3117A}; +var \u{3117B}; +var \u{3117C}; +var \u{3117D}; +var \u{3117E}; +var \u{3117F}; +var \u{31180}; +var \u{31181}; +var \u{31182}; +var \u{31183}; +var \u{31184}; +var \u{31185}; +var \u{31186}; +var \u{31187}; +var \u{31188}; +var \u{31189}; +var \u{3118A}; +var \u{3118B}; +var \u{3118C}; +var \u{3118D}; +var \u{3118E}; +var \u{3118F}; +var \u{31190}; +var \u{31191}; +var \u{31192}; +var \u{31193}; +var \u{31194}; +var \u{31195}; +var \u{31196}; +var \u{31197}; +var \u{31198}; +var \u{31199}; +var \u{3119A}; +var \u{3119B}; +var \u{3119C}; +var \u{3119D}; +var \u{3119E}; +var \u{3119F}; +var \u{311A0}; +var \u{311A1}; +var \u{311A2}; +var \u{311A3}; +var \u{311A4}; +var \u{311A5}; +var \u{311A6}; +var \u{311A7}; +var \u{311A8}; +var \u{311A9}; +var \u{311AA}; +var \u{311AB}; +var \u{311AC}; +var \u{311AD}; +var \u{311AE}; +var \u{311AF}; +var \u{311B0}; +var \u{311B1}; +var \u{311B2}; +var \u{311B3}; +var \u{311B4}; +var \u{311B5}; +var \u{311B6}; +var \u{311B7}; +var \u{311B8}; +var \u{311B9}; +var \u{311BA}; +var \u{311BB}; +var \u{311BC}; +var \u{311BD}; +var \u{311BE}; +var \u{311BF}; +var \u{311C0}; +var \u{311C1}; +var \u{311C2}; +var \u{311C3}; +var \u{311C4}; +var \u{311C5}; +var \u{311C6}; +var \u{311C7}; +var \u{311C8}; +var \u{311C9}; +var \u{311CA}; +var \u{311CB}; +var \u{311CC}; +var \u{311CD}; +var \u{311CE}; +var \u{311CF}; +var \u{311D0}; +var \u{311D1}; +var \u{311D2}; +var \u{311D3}; +var \u{311D4}; +var \u{311D5}; +var \u{311D6}; +var \u{311D7}; +var \u{311D8}; +var \u{311D9}; +var \u{311DA}; +var \u{311DB}; +var \u{311DC}; +var \u{311DD}; +var \u{311DE}; +var \u{311DF}; +var \u{311E0}; +var \u{311E1}; +var \u{311E2}; +var \u{311E3}; +var \u{311E4}; +var \u{311E5}; +var \u{311E6}; +var \u{311E7}; +var \u{311E8}; +var \u{311E9}; +var \u{311EA}; +var \u{311EB}; +var \u{311EC}; +var \u{311ED}; +var \u{311EE}; +var \u{311EF}; +var \u{311F0}; +var \u{311F1}; +var \u{311F2}; +var \u{311F3}; +var \u{311F4}; +var \u{311F5}; +var \u{311F6}; +var \u{311F7}; +var \u{311F8}; +var \u{311F9}; +var \u{311FA}; +var \u{311FB}; +var \u{311FC}; +var \u{311FD}; +var \u{311FE}; +var \u{311FF}; +var \u{31200}; +var \u{31201}; +var \u{31202}; +var \u{31203}; +var \u{31204}; +var \u{31205}; +var \u{31206}; +var \u{31207}; +var \u{31208}; +var \u{31209}; +var \u{3120A}; +var \u{3120B}; +var \u{3120C}; +var \u{3120D}; +var \u{3120E}; +var \u{3120F}; +var \u{31210}; +var \u{31211}; +var \u{31212}; +var \u{31213}; +var \u{31214}; +var \u{31215}; +var \u{31216}; +var \u{31217}; +var \u{31218}; +var \u{31219}; +var \u{3121A}; +var \u{3121B}; +var \u{3121C}; +var \u{3121D}; +var \u{3121E}; +var \u{3121F}; +var \u{31220}; +var \u{31221}; +var \u{31222}; +var \u{31223}; +var \u{31224}; +var \u{31225}; +var \u{31226}; +var \u{31227}; +var \u{31228}; +var \u{31229}; +var \u{3122A}; +var \u{3122B}; +var \u{3122C}; +var \u{3122D}; +var \u{3122E}; +var \u{3122F}; +var \u{31230}; +var \u{31231}; +var \u{31232}; +var \u{31233}; +var \u{31234}; +var \u{31235}; +var \u{31236}; +var \u{31237}; +var \u{31238}; +var \u{31239}; +var \u{3123A}; +var \u{3123B}; +var \u{3123C}; +var \u{3123D}; +var \u{3123E}; +var \u{3123F}; +var \u{31240}; +var \u{31241}; +var \u{31242}; +var \u{31243}; +var \u{31244}; +var \u{31245}; +var \u{31246}; +var \u{31247}; +var \u{31248}; +var \u{31249}; +var \u{3124A}; +var \u{3124B}; +var \u{3124C}; +var \u{3124D}; +var \u{3124E}; +var \u{3124F}; +var \u{31250}; +var \u{31251}; +var \u{31252}; +var \u{31253}; +var \u{31254}; +var \u{31255}; +var \u{31256}; +var \u{31257}; +var \u{31258}; +var \u{31259}; +var \u{3125A}; +var \u{3125B}; +var \u{3125C}; +var \u{3125D}; +var \u{3125E}; +var \u{3125F}; +var \u{31260}; +var \u{31261}; +var \u{31262}; +var \u{31263}; +var \u{31264}; +var \u{31265}; +var \u{31266}; +var \u{31267}; +var \u{31268}; +var \u{31269}; +var \u{3126A}; +var \u{3126B}; +var \u{3126C}; +var \u{3126D}; +var \u{3126E}; +var \u{3126F}; +var \u{31270}; +var \u{31271}; +var \u{31272}; +var \u{31273}; +var \u{31274}; +var \u{31275}; +var \u{31276}; +var \u{31277}; +var \u{31278}; +var \u{31279}; +var \u{3127A}; +var \u{3127B}; +var \u{3127C}; +var \u{3127D}; +var \u{3127E}; +var \u{3127F}; +var \u{31280}; +var \u{31281}; +var \u{31282}; +var \u{31283}; +var \u{31284}; +var \u{31285}; +var \u{31286}; +var \u{31287}; +var \u{31288}; +var \u{31289}; +var \u{3128A}; +var \u{3128B}; +var \u{3128C}; +var \u{3128D}; +var \u{3128E}; +var \u{3128F}; +var \u{31290}; +var \u{31291}; +var \u{31292}; +var \u{31293}; +var \u{31294}; +var \u{31295}; +var \u{31296}; +var \u{31297}; +var \u{31298}; +var \u{31299}; +var \u{3129A}; +var \u{3129B}; +var \u{3129C}; +var \u{3129D}; +var \u{3129E}; +var \u{3129F}; +var \u{312A0}; +var \u{312A1}; +var \u{312A2}; +var \u{312A3}; +var \u{312A4}; +var \u{312A5}; +var \u{312A6}; +var \u{312A7}; +var \u{312A8}; +var \u{312A9}; +var \u{312AA}; +var \u{312AB}; +var \u{312AC}; +var \u{312AD}; +var \u{312AE}; +var \u{312AF}; +var \u{312B0}; +var \u{312B1}; +var \u{312B2}; +var \u{312B3}; +var \u{312B4}; +var \u{312B5}; +var \u{312B6}; +var \u{312B7}; +var \u{312B8}; +var \u{312B9}; +var \u{312BA}; +var \u{312BB}; +var \u{312BC}; +var \u{312BD}; +var \u{312BE}; +var \u{312BF}; +var \u{312C0}; +var \u{312C1}; +var \u{312C2}; +var \u{312C3}; +var \u{312C4}; +var \u{312C5}; +var \u{312C6}; +var \u{312C7}; +var \u{312C8}; +var \u{312C9}; +var \u{312CA}; +var \u{312CB}; +var \u{312CC}; +var \u{312CD}; +var \u{312CE}; +var \u{312CF}; +var \u{312D0}; +var \u{312D1}; +var \u{312D2}; +var \u{312D3}; +var \u{312D4}; +var \u{312D5}; +var \u{312D6}; +var \u{312D7}; +var \u{312D8}; +var \u{312D9}; +var \u{312DA}; +var \u{312DB}; +var \u{312DC}; +var \u{312DD}; +var \u{312DE}; +var \u{312DF}; +var \u{312E0}; +var \u{312E1}; +var \u{312E2}; +var \u{312E3}; +var \u{312E4}; +var \u{312E5}; +var \u{312E6}; +var \u{312E7}; +var \u{312E8}; +var \u{312E9}; +var \u{312EA}; +var \u{312EB}; +var \u{312EC}; +var \u{312ED}; +var \u{312EE}; +var \u{312EF}; +var \u{312F0}; +var \u{312F1}; +var \u{312F2}; +var \u{312F3}; +var \u{312F4}; +var \u{312F5}; +var \u{312F6}; +var \u{312F7}; +var \u{312F8}; +var \u{312F9}; +var \u{312FA}; +var \u{312FB}; +var \u{312FC}; +var \u{312FD}; +var \u{312FE}; +var \u{312FF}; +var \u{31300}; +var \u{31301}; +var \u{31302}; +var \u{31303}; +var \u{31304}; +var \u{31305}; +var \u{31306}; +var \u{31307}; +var \u{31308}; +var \u{31309}; +var \u{3130A}; +var \u{3130B}; +var \u{3130C}; +var \u{3130D}; +var \u{3130E}; +var \u{3130F}; +var \u{31310}; +var \u{31311}; +var \u{31312}; +var \u{31313}; +var \u{31314}; +var \u{31315}; +var \u{31316}; +var \u{31317}; +var \u{31318}; +var \u{31319}; +var \u{3131A}; +var \u{3131B}; +var \u{3131C}; +var \u{3131D}; +var \u{3131E}; +var \u{3131F}; +var \u{31320}; +var \u{31321}; +var \u{31322}; +var \u{31323}; +var \u{31324}; +var \u{31325}; +var \u{31326}; +var \u{31327}; +var \u{31328}; +var \u{31329}; +var \u{3132A}; +var \u{3132B}; +var \u{3132C}; +var \u{3132D}; +var \u{3132E}; +var \u{3132F}; +var \u{31330}; +var \u{31331}; +var \u{31332}; +var \u{31333}; +var \u{31334}; +var \u{31335}; +var \u{31336}; +var \u{31337}; +var \u{31338}; +var \u{31339}; +var \u{3133A}; +var \u{3133B}; +var \u{3133C}; +var \u{3133D}; +var \u{3133E}; +var \u{3133F}; +var \u{31340}; +var \u{31341}; +var \u{31342}; +var \u{31343}; +var \u{31344}; +var \u{31345}; +var \u{31346}; +var \u{31347}; +var \u{31348}; +var \u{31349}; +var \u{3134A}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0.js new file mode 100644 index 000000000..6d0576a73 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-13.0.0.js @@ -0,0 +1,5611 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v13.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var ࢾ; +var ࢿ; +var ࣀ; +var ࣁ; +var ࣂ; +var ࣃ; +var ࣄ; +var ࣅ; +var ࣆ; +var ࣇ; +var ഄ; +var ㆻ; +var ㆼ; +var ㆽ; +var ㆾ; +var ㆿ; +var 䶶; +var 䶷; +var 䶸; +var 䶹; +var 䶺; +var 䶻; +var 䶼; +var 䶽; +var 䶾; +var 䶿; +var 鿰; +var 鿱; +var 鿲; +var 鿳; +var 鿴; +var 鿵; +var 鿶; +var 鿷; +var 鿸; +var 鿹; +var 鿺; +var 鿻; +var 鿼; +var Ꟈ; +var ꟈ; +var Ꟊ; +var ꟊ; +var Ꟶ; +var ꟶ; +var ꭨ; +var ꭩ; +var 𐺀; +var 𐺁; +var 𐺂; +var 𐺃; +var 𐺄; +var 𐺅; +var 𐺆; +var 𐺇; +var 𐺈; +var 𐺉; +var 𐺊; +var 𐺋; +var 𐺌; +var 𐺍; +var 𐺎; +var 𐺏; +var 𐺐; +var 𐺑; +var 𐺒; +var 𐺓; +var 𐺔; +var 𐺕; +var 𐺖; +var 𐺗; +var 𐺘; +var 𐺙; +var 𐺚; +var 𐺛; +var 𐺜; +var 𐺝; +var 𐺞; +var 𐺟; +var 𐺠; +var 𐺡; +var 𐺢; +var 𐺣; +var 𐺤; +var 𐺥; +var 𐺦; +var 𐺧; +var 𐺨; +var 𐺩; +var 𐺰; +var 𐺱; +var 𐾰; +var 𐾱; +var 𐾲; +var 𐾳; +var 𐾴; +var 𐾵; +var 𐾶; +var 𐾷; +var 𐾸; +var 𐾹; +var 𐾺; +var 𐾻; +var 𐾼; +var 𐾽; +var 𐾾; +var 𐾿; +var 𐿀; +var 𐿁; +var 𐿂; +var 𐿃; +var 𐿄; +var 𑅇; +var 𑑠; +var 𑑡; +var 𑤀; +var 𑤁; +var 𑤂; +var 𑤃; +var 𑤄; +var 𑤅; +var 𑤆; +var 𑤉; +var 𑤌; +var 𑤍; +var 𑤎; +var 𑤏; +var 𑤐; +var 𑤑; +var 𑤒; +var 𑤓; +var 𑤕; +var 𑤖; +var 𑤘; +var 𑤙; +var 𑤚; +var 𑤛; +var 𑤜; +var 𑤝; +var 𑤞; +var 𑤟; +var 𑤠; +var 𑤡; +var 𑤢; +var 𑤣; +var 𑤤; +var 𑤥; +var 𑤦; +var 𑤧; +var 𑤨; +var 𑤩; +var 𑤪; +var 𑤫; +var 𑤬; +var 𑤭; +var 𑤮; +var 𑤯; +var 𑤿; +var 𑥁; +var 𑾰; +var 𘫳; +var 𘫴; +var 𘫵; +var 𘫶; +var 𘫷; +var 𘫸; +var 𘫹; +var 𘫺; +var 𘫻; +var 𘫼; +var 𘫽; +var 𘫾; +var 𘫿; +var 𘬀; +var 𘬁; +var 𘬂; +var 𘬃; +var 𘬄; +var 𘬅; +var 𘬆; +var 𘬇; +var 𘬈; +var 𘬉; +var 𘬊; +var 𘬋; +var 𘬌; +var 𘬍; +var 𘬎; +var 𘬏; +var 𘬐; +var 𘬑; +var 𘬒; +var 𘬓; +var 𘬔; +var 𘬕; +var 𘬖; +var 𘬗; +var 𘬘; +var 𘬙; +var 𘬚; +var 𘬛; +var 𘬜; +var 𘬝; +var 𘬞; +var 𘬟; +var 𘬠; +var 𘬡; +var 𘬢; +var 𘬣; +var 𘬤; +var 𘬥; +var 𘬦; +var 𘬧; +var 𘬨; +var 𘬩; +var 𘬪; +var 𘬫; +var 𘬬; +var 𘬭; +var 𘬮; +var 𘬯; +var 𘬰; +var 𘬱; +var 𘬲; +var 𘬳; +var 𘬴; +var 𘬵; +var 𘬶; +var 𘬷; +var 𘬸; +var 𘬹; +var 𘬺; +var 𘬻; +var 𘬼; +var 𘬽; +var 𘬾; +var 𘬿; +var 𘭀; +var 𘭁; +var 𘭂; +var 𘭃; +var 𘭄; +var 𘭅; +var 𘭆; +var 𘭇; +var 𘭈; +var 𘭉; +var 𘭊; +var 𘭋; +var 𘭌; +var 𘭍; +var 𘭎; +var 𘭏; +var 𘭐; +var 𘭑; +var 𘭒; +var 𘭓; +var 𘭔; +var 𘭕; +var 𘭖; +var 𘭗; +var 𘭘; +var 𘭙; +var 𘭚; +var 𘭛; +var 𘭜; +var 𘭝; +var 𘭞; +var 𘭟; +var 𘭠; +var 𘭡; +var 𘭢; +var 𘭣; +var 𘭤; +var 𘭥; +var 𘭦; +var 𘭧; +var 𘭨; +var 𘭩; +var 𘭪; +var 𘭫; +var 𘭬; +var 𘭭; +var 𘭮; +var 𘭯; +var 𘭰; +var 𘭱; +var 𘭲; +var 𘭳; +var 𘭴; +var 𘭵; +var 𘭶; +var 𘭷; +var 𘭸; +var 𘭹; +var 𘭺; +var 𘭻; +var 𘭼; +var 𘭽; +var 𘭾; +var 𘭿; +var 𘮀; +var 𘮁; +var 𘮂; +var 𘮃; +var 𘮄; +var 𘮅; +var 𘮆; +var 𘮇; +var 𘮈; +var 𘮉; +var 𘮊; +var 𘮋; +var 𘮌; +var 𘮍; +var 𘮎; +var 𘮏; +var 𘮐; +var 𘮑; +var 𘮒; +var 𘮓; +var 𘮔; +var 𘮕; +var 𘮖; +var 𘮗; +var 𘮘; +var 𘮙; +var 𘮚; +var 𘮛; +var 𘮜; +var 𘮝; +var 𘮞; +var 𘮟; +var 𘮠; +var 𘮡; +var 𘮢; +var 𘮣; +var 𘮤; +var 𘮥; +var 𘮦; +var 𘮧; +var 𘮨; +var 𘮩; +var 𘮪; +var 𘮫; +var 𘮬; +var 𘮭; +var 𘮮; +var 𘮯; +var 𘮰; +var 𘮱; +var 𘮲; +var 𘮳; +var 𘮴; +var 𘮵; +var 𘮶; +var 𘮷; +var 𘮸; +var 𘮹; +var 𘮺; +var 𘮻; +var 𘮼; +var 𘮽; +var 𘮾; +var 𘮿; +var 𘯀; +var 𘯁; +var 𘯂; +var 𘯃; +var 𘯄; +var 𘯅; +var 𘯆; +var 𘯇; +var 𘯈; +var 𘯉; +var 𘯊; +var 𘯋; +var 𘯌; +var 𘯍; +var 𘯎; +var 𘯏; +var 𘯐; +var 𘯑; +var 𘯒; +var 𘯓; +var 𘯔; +var 𘯕; +var 𘯖; +var 𘯗; +var 𘯘; +var 𘯙; +var 𘯚; +var 𘯛; +var 𘯜; +var 𘯝; +var 𘯞; +var 𘯟; +var 𘯠; +var 𘯡; +var 𘯢; +var 𘯣; +var 𘯤; +var 𘯥; +var 𘯦; +var 𘯧; +var 𘯨; +var 𘯩; +var 𘯪; +var 𘯫; +var 𘯬; +var 𘯭; +var 𘯮; +var 𘯯; +var 𘯰; +var 𘯱; +var 𘯲; +var 𘯳; +var 𘯴; +var 𘯵; +var 𘯶; +var 𘯷; +var 𘯸; +var 𘯹; +var 𘯺; +var 𘯻; +var 𘯼; +var 𘯽; +var 𘯾; +var 𘯿; +var 𘰀; +var 𘰁; +var 𘰂; +var 𘰃; +var 𘰄; +var 𘰅; +var 𘰆; +var 𘰇; +var 𘰈; +var 𘰉; +var 𘰊; +var 𘰋; +var 𘰌; +var 𘰍; +var 𘰎; +var 𘰏; +var 𘰐; +var 𘰑; +var 𘰒; +var 𘰓; +var 𘰔; +var 𘰕; +var 𘰖; +var 𘰗; +var 𘰘; +var 𘰙; +var 𘰚; +var 𘰛; +var 𘰜; +var 𘰝; +var 𘰞; +var 𘰟; +var 𘰠; +var 𘰡; +var 𘰢; +var 𘰣; +var 𘰤; +var 𘰥; +var 𘰦; +var 𘰧; +var 𘰨; +var 𘰩; +var 𘰪; +var 𘰫; +var 𘰬; +var 𘰭; +var 𘰮; +var 𘰯; +var 𘰰; +var 𘰱; +var 𘰲; +var 𘰳; +var 𘰴; +var 𘰵; +var 𘰶; +var 𘰷; +var 𘰸; +var 𘰹; +var 𘰺; +var 𘰻; +var 𘰼; +var 𘰽; +var 𘰾; +var 𘰿; +var 𘱀; +var 𘱁; +var 𘱂; +var 𘱃; +var 𘱄; +var 𘱅; +var 𘱆; +var 𘱇; +var 𘱈; +var 𘱉; +var 𘱊; +var 𘱋; +var 𘱌; +var 𘱍; +var 𘱎; +var 𘱏; +var 𘱐; +var 𘱑; +var 𘱒; +var 𘱓; +var 𘱔; +var 𘱕; +var 𘱖; +var 𘱗; +var 𘱘; +var 𘱙; +var 𘱚; +var 𘱛; +var 𘱜; +var 𘱝; +var 𘱞; +var 𘱟; +var 𘱠; +var 𘱡; +var 𘱢; +var 𘱣; +var 𘱤; +var 𘱥; +var 𘱦; +var 𘱧; +var 𘱨; +var 𘱩; +var 𘱪; +var 𘱫; +var 𘱬; +var 𘱭; +var 𘱮; +var 𘱯; +var 𘱰; +var 𘱱; +var 𘱲; +var 𘱳; +var 𘱴; +var 𘱵; +var 𘱶; +var 𘱷; +var 𘱸; +var 𘱹; +var 𘱺; +var 𘱻; +var 𘱼; +var 𘱽; +var 𘱾; +var 𘱿; +var 𘲀; +var 𘲁; +var 𘲂; +var 𘲃; +var 𘲄; +var 𘲅; +var 𘲆; +var 𘲇; +var 𘲈; +var 𘲉; +var 𘲊; +var 𘲋; +var 𘲌; +var 𘲍; +var 𘲎; +var 𘲏; +var 𘲐; +var 𘲑; +var 𘲒; +var 𘲓; +var 𘲔; +var 𘲕; +var 𘲖; +var 𘲗; +var 𘲘; +var 𘲙; +var 𘲚; +var 𘲛; +var 𘲜; +var 𘲝; +var 𘲞; +var 𘲟; +var 𘲠; +var 𘲡; +var 𘲢; +var 𘲣; +var 𘲤; +var 𘲥; +var 𘲦; +var 𘲧; +var 𘲨; +var 𘲩; +var 𘲪; +var 𘲫; +var 𘲬; +var 𘲭; +var 𘲮; +var 𘲯; +var 𘲰; +var 𘲱; +var 𘲲; +var 𘲳; +var 𘲴; +var 𘲵; +var 𘲶; +var 𘲷; +var 𘲸; +var 𘲹; +var 𘲺; +var 𘲻; +var 𘲼; +var 𘲽; +var 𘲾; +var 𘲿; +var 𘳀; +var 𘳁; +var 𘳂; +var 𘳃; +var 𘳄; +var 𘳅; +var 𘳆; +var 𘳇; +var 𘳈; +var 𘳉; +var 𘳊; +var 𘳋; +var 𘳌; +var 𘳍; +var 𘳎; +var 𘳏; +var 𘳐; +var 𘳑; +var 𘳒; +var 𘳓; +var 𘳔; +var 𘳕; +var 𘴀; +var 𘴁; +var 𘴂; +var 𘴃; +var 𘴄; +var 𘴅; +var 𘴆; +var 𘴇; +var 𘴈; +var 𪛗; +var 𪛘; +var 𪛙; +var 𪛚; +var 𪛛; +var 𪛜; +var 𪛝; +var 𰀀; +var 𰀁; +var 𰀂; +var 𰀃; +var 𰀄; +var 𰀅; +var 𰀆; +var 𰀇; +var 𰀈; +var 𰀉; +var 𰀊; +var 𰀋; +var 𰀌; +var 𰀍; +var 𰀎; +var 𰀏; +var 𰀐; +var 𰀑; +var 𰀒; +var 𰀓; +var 𰀔; +var 𰀕; +var 𰀖; +var 𰀗; +var 𰀘; +var 𰀙; +var 𰀚; +var 𰀛; +var 𰀜; +var 𰀝; +var 𰀞; +var 𰀟; +var 𰀠; +var 𰀡; +var 𰀢; +var 𰀣; +var 𰀤; +var 𰀥; +var 𰀦; +var 𰀧; +var 𰀨; +var 𰀩; +var 𰀪; +var 𰀫; +var 𰀬; +var 𰀭; +var 𰀮; +var 𰀯; +var 𰀰; +var 𰀱; +var 𰀲; +var 𰀳; +var 𰀴; +var 𰀵; +var 𰀶; +var 𰀷; +var 𰀸; +var 𰀹; +var 𰀺; +var 𰀻; +var 𰀼; +var 𰀽; +var 𰀾; +var 𰀿; +var 𰁀; +var 𰁁; +var 𰁂; +var 𰁃; +var 𰁄; +var 𰁅; +var 𰁆; +var 𰁇; +var 𰁈; +var 𰁉; +var 𰁊; +var 𰁋; +var 𰁌; +var 𰁍; +var 𰁎; +var 𰁏; +var 𰁐; +var 𰁑; +var 𰁒; +var 𰁓; +var 𰁔; +var 𰁕; +var 𰁖; +var 𰁗; +var 𰁘; +var 𰁙; +var 𰁚; +var 𰁛; +var 𰁜; +var 𰁝; +var 𰁞; +var 𰁟; +var 𰁠; +var 𰁡; +var 𰁢; +var 𰁣; +var 𰁤; +var 𰁥; +var 𰁦; +var 𰁧; +var 𰁨; +var 𰁩; +var 𰁪; +var 𰁫; +var 𰁬; +var 𰁭; +var 𰁮; +var 𰁯; +var 𰁰; +var 𰁱; +var 𰁲; +var 𰁳; +var 𰁴; +var 𰁵; +var 𰁶; +var 𰁷; +var 𰁸; +var 𰁹; +var 𰁺; +var 𰁻; +var 𰁼; +var 𰁽; +var 𰁾; +var 𰁿; +var 𰂀; +var 𰂁; +var 𰂂; +var 𰂃; +var 𰂄; +var 𰂅; +var 𰂆; +var 𰂇; +var 𰂈; +var 𰂉; +var 𰂊; +var 𰂋; +var 𰂌; +var 𰂍; +var 𰂎; +var 𰂏; +var 𰂐; +var 𰂑; +var 𰂒; +var 𰂓; +var 𰂔; +var 𰂕; +var 𰂖; +var 𰂗; +var 𰂘; +var 𰂙; +var 𰂚; +var 𰂛; +var 𰂜; +var 𰂝; +var 𰂞; +var 𰂟; +var 𰂠; +var 𰂡; +var 𰂢; +var 𰂣; +var 𰂤; +var 𰂥; +var 𰂦; +var 𰂧; +var 𰂨; +var 𰂩; +var 𰂪; +var 𰂫; +var 𰂬; +var 𰂭; +var 𰂮; +var 𰂯; +var 𰂰; +var 𰂱; +var 𰂲; +var 𰂳; +var 𰂴; +var 𰂵; +var 𰂶; +var 𰂷; +var 𰂸; +var 𰂹; +var 𰂺; +var 𰂻; +var 𰂼; +var 𰂽; +var 𰂾; +var 𰂿; +var 𰃀; +var 𰃁; +var 𰃂; +var 𰃃; +var 𰃄; +var 𰃅; +var 𰃆; +var 𰃇; +var 𰃈; +var 𰃉; +var 𰃊; +var 𰃋; +var 𰃌; +var 𰃍; +var 𰃎; +var 𰃏; +var 𰃐; +var 𰃑; +var 𰃒; +var 𰃓; +var 𰃔; +var 𰃕; +var 𰃖; +var 𰃗; +var 𰃘; +var 𰃙; +var 𰃚; +var 𰃛; +var 𰃜; +var 𰃝; +var 𰃞; +var 𰃟; +var 𰃠; +var 𰃡; +var 𰃢; +var 𰃣; +var 𰃤; +var 𰃥; +var 𰃦; +var 𰃧; +var 𰃨; +var 𰃩; +var 𰃪; +var 𰃫; +var 𰃬; +var 𰃭; +var 𰃮; +var 𰃯; +var 𰃰; +var 𰃱; +var 𰃲; +var 𰃳; +var 𰃴; +var 𰃵; +var 𰃶; +var 𰃷; +var 𰃸; +var 𰃹; +var 𰃺; +var 𰃻; +var 𰃼; +var 𰃽; +var 𰃾; +var 𰃿; +var 𰄀; +var 𰄁; +var 𰄂; +var 𰄃; +var 𰄄; +var 𰄅; +var 𰄆; +var 𰄇; +var 𰄈; +var 𰄉; +var 𰄊; +var 𰄋; +var 𰄌; +var 𰄍; +var 𰄎; +var 𰄏; +var 𰄐; +var 𰄑; +var 𰄒; +var 𰄓; +var 𰄔; +var 𰄕; +var 𰄖; +var 𰄗; +var 𰄘; +var 𰄙; +var 𰄚; +var 𰄛; +var 𰄜; +var 𰄝; +var 𰄞; +var 𰄟; +var 𰄠; +var 𰄡; +var 𰄢; +var 𰄣; +var 𰄤; +var 𰄥; +var 𰄦; +var 𰄧; +var 𰄨; +var 𰄩; +var 𰄪; +var 𰄫; +var 𰄬; +var 𰄭; +var 𰄮; +var 𰄯; +var 𰄰; +var 𰄱; +var 𰄲; +var 𰄳; +var 𰄴; +var 𰄵; +var 𰄶; +var 𰄷; +var 𰄸; +var 𰄹; +var 𰄺; +var 𰄻; +var 𰄼; +var 𰄽; +var 𰄾; +var 𰄿; +var 𰅀; +var 𰅁; +var 𰅂; +var 𰅃; +var 𰅄; +var 𰅅; +var 𰅆; +var 𰅇; +var 𰅈; +var 𰅉; +var 𰅊; +var 𰅋; +var 𰅌; +var 𰅍; +var 𰅎; +var 𰅏; +var 𰅐; +var 𰅑; +var 𰅒; +var 𰅓; +var 𰅔; +var 𰅕; +var 𰅖; +var 𰅗; +var 𰅘; +var 𰅙; +var 𰅚; +var 𰅛; +var 𰅜; +var 𰅝; +var 𰅞; +var 𰅟; +var 𰅠; +var 𰅡; +var 𰅢; +var 𰅣; +var 𰅤; +var 𰅥; +var 𰅦; +var 𰅧; +var 𰅨; +var 𰅩; +var 𰅪; +var 𰅫; +var 𰅬; +var 𰅭; +var 𰅮; +var 𰅯; +var 𰅰; +var 𰅱; +var 𰅲; +var 𰅳; +var 𰅴; +var 𰅵; +var 𰅶; +var 𰅷; +var 𰅸; +var 𰅹; +var 𰅺; +var 𰅻; +var 𰅼; +var 𰅽; +var 𰅾; +var 𰅿; +var 𰆀; +var 𰆁; +var 𰆂; +var 𰆃; +var 𰆄; +var 𰆅; +var 𰆆; +var 𰆇; +var 𰆈; +var 𰆉; +var 𰆊; +var 𰆋; +var 𰆌; +var 𰆍; +var 𰆎; +var 𰆏; +var 𰆐; +var 𰆑; +var 𰆒; +var 𰆓; +var 𰆔; +var 𰆕; +var 𰆖; +var 𰆗; +var 𰆘; +var 𰆙; +var 𰆚; +var 𰆛; +var 𰆜; +var 𰆝; +var 𰆞; +var 𰆟; +var 𰆠; +var 𰆡; +var 𰆢; +var 𰆣; +var 𰆤; +var 𰆥; +var 𰆦; +var 𰆧; +var 𰆨; +var 𰆩; +var 𰆪; +var 𰆫; +var 𰆬; +var 𰆭; +var 𰆮; +var 𰆯; +var 𰆰; +var 𰆱; +var 𰆲; +var 𰆳; +var 𰆴; +var 𰆵; +var 𰆶; +var 𰆷; +var 𰆸; +var 𰆹; +var 𰆺; +var 𰆻; +var 𰆼; +var 𰆽; +var 𰆾; +var 𰆿; +var 𰇀; +var 𰇁; +var 𰇂; +var 𰇃; +var 𰇄; +var 𰇅; +var 𰇆; +var 𰇇; +var 𰇈; +var 𰇉; +var 𰇊; +var 𰇋; +var 𰇌; +var 𰇍; +var 𰇎; +var 𰇏; +var 𰇐; +var 𰇑; +var 𰇒; +var 𰇓; +var 𰇔; +var 𰇕; +var 𰇖; +var 𰇗; +var 𰇘; +var 𰇙; +var 𰇚; +var 𰇛; +var 𰇜; +var 𰇝; +var 𰇞; +var 𰇟; +var 𰇠; +var 𰇡; +var 𰇢; +var 𰇣; +var 𰇤; +var 𰇥; +var 𰇦; +var 𰇧; +var 𰇨; +var 𰇩; +var 𰇪; +var 𰇫; +var 𰇬; +var 𰇭; +var 𰇮; +var 𰇯; +var 𰇰; +var 𰇱; +var 𰇲; +var 𰇳; +var 𰇴; +var 𰇵; +var 𰇶; +var 𰇷; +var 𰇸; +var 𰇹; +var 𰇺; +var 𰇻; +var 𰇼; +var 𰇽; +var 𰇾; +var 𰇿; +var 𰈀; +var 𰈁; +var 𰈂; +var 𰈃; +var 𰈄; +var 𰈅; +var 𰈆; +var 𰈇; +var 𰈈; +var 𰈉; +var 𰈊; +var 𰈋; +var 𰈌; +var 𰈍; +var 𰈎; +var 𰈏; +var 𰈐; +var 𰈑; +var 𰈒; +var 𰈓; +var 𰈔; +var 𰈕; +var 𰈖; +var 𰈗; +var 𰈘; +var 𰈙; +var 𰈚; +var 𰈛; +var 𰈜; +var 𰈝; +var 𰈞; +var 𰈟; +var 𰈠; +var 𰈡; +var 𰈢; +var 𰈣; +var 𰈤; +var 𰈥; +var 𰈦; +var 𰈧; +var 𰈨; +var 𰈩; +var 𰈪; +var 𰈫; +var 𰈬; +var 𰈭; +var 𰈮; +var 𰈯; +var 𰈰; +var 𰈱; +var 𰈲; +var 𰈳; +var 𰈴; +var 𰈵; +var 𰈶; +var 𰈷; +var 𰈸; +var 𰈹; +var 𰈺; +var 𰈻; +var 𰈼; +var 𰈽; +var 𰈾; +var 𰈿; +var 𰉀; +var 𰉁; +var 𰉂; +var 𰉃; +var 𰉄; +var 𰉅; +var 𰉆; +var 𰉇; +var 𰉈; +var 𰉉; +var 𰉊; +var 𰉋; +var 𰉌; +var 𰉍; +var 𰉎; +var 𰉏; +var 𰉐; +var 𰉑; +var 𰉒; +var 𰉓; +var 𰉔; +var 𰉕; +var 𰉖; +var 𰉗; +var 𰉘; +var 𰉙; +var 𰉚; +var 𰉛; +var 𰉜; +var 𰉝; +var 𰉞; +var 𰉟; +var 𰉠; +var 𰉡; +var 𰉢; +var 𰉣; +var 𰉤; +var 𰉥; +var 𰉦; +var 𰉧; +var 𰉨; +var 𰉩; +var 𰉪; +var 𰉫; +var 𰉬; +var 𰉭; +var 𰉮; +var 𰉯; +var 𰉰; +var 𰉱; +var 𰉲; +var 𰉳; +var 𰉴; +var 𰉵; +var 𰉶; +var 𰉷; +var 𰉸; +var 𰉹; +var 𰉺; +var 𰉻; +var 𰉼; +var 𰉽; +var 𰉾; +var 𰉿; +var 𰊀; +var 𰊁; +var 𰊂; +var 𰊃; +var 𰊄; +var 𰊅; +var 𰊆; +var 𰊇; +var 𰊈; +var 𰊉; +var 𰊊; +var 𰊋; +var 𰊌; +var 𰊍; +var 𰊎; +var 𰊏; +var 𰊐; +var 𰊑; +var 𰊒; +var 𰊓; +var 𰊔; +var 𰊕; +var 𰊖; +var 𰊗; +var 𰊘; +var 𰊙; +var 𰊚; +var 𰊛; +var 𰊜; +var 𰊝; +var 𰊞; +var 𰊟; +var 𰊠; +var 𰊡; +var 𰊢; +var 𰊣; +var 𰊤; +var 𰊥; +var 𰊦; +var 𰊧; +var 𰊨; +var 𰊩; +var 𰊪; +var 𰊫; +var 𰊬; +var 𰊭; +var 𰊮; +var 𰊯; +var 𰊰; +var 𰊱; +var 𰊲; +var 𰊳; +var 𰊴; +var 𰊵; +var 𰊶; +var 𰊷; +var 𰊸; +var 𰊹; +var 𰊺; +var 𰊻; +var 𰊼; +var 𰊽; +var 𰊾; +var 𰊿; +var 𰋀; +var 𰋁; +var 𰋂; +var 𰋃; +var 𰋄; +var 𰋅; +var 𰋆; +var 𰋇; +var 𰋈; +var 𰋉; +var 𰋊; +var 𰋋; +var 𰋌; +var 𰋍; +var 𰋎; +var 𰋏; +var 𰋐; +var 𰋑; +var 𰋒; +var 𰋓; +var 𰋔; +var 𰋕; +var 𰋖; +var 𰋗; +var 𰋘; +var 𰋙; +var 𰋚; +var 𰋛; +var 𰋜; +var 𰋝; +var 𰋞; +var 𰋟; +var 𰋠; +var 𰋡; +var 𰋢; +var 𰋣; +var 𰋤; +var 𰋥; +var 𰋦; +var 𰋧; +var 𰋨; +var 𰋩; +var 𰋪; +var 𰋫; +var 𰋬; +var 𰋭; +var 𰋮; +var 𰋯; +var 𰋰; +var 𰋱; +var 𰋲; +var 𰋳; +var 𰋴; +var 𰋵; +var 𰋶; +var 𰋷; +var 𰋸; +var 𰋹; +var 𰋺; +var 𰋻; +var 𰋼; +var 𰋽; +var 𰋾; +var 𰋿; +var 𰌀; +var 𰌁; +var 𰌂; +var 𰌃; +var 𰌄; +var 𰌅; +var 𰌆; +var 𰌇; +var 𰌈; +var 𰌉; +var 𰌊; +var 𰌋; +var 𰌌; +var 𰌍; +var 𰌎; +var 𰌏; +var 𰌐; +var 𰌑; +var 𰌒; +var 𰌓; +var 𰌔; +var 𰌕; +var 𰌖; +var 𰌗; +var 𰌘; +var 𰌙; +var 𰌚; +var 𰌛; +var 𰌜; +var 𰌝; +var 𰌞; +var 𰌟; +var 𰌠; +var 𰌡; +var 𰌢; +var 𰌣; +var 𰌤; +var 𰌥; +var 𰌦; +var 𰌧; +var 𰌨; +var 𰌩; +var 𰌪; +var 𰌫; +var 𰌬; +var 𰌭; +var 𰌮; +var 𰌯; +var 𰌰; +var 𰌱; +var 𰌲; +var 𰌳; +var 𰌴; +var 𰌵; +var 𰌶; +var 𰌷; +var 𰌸; +var 𰌹; +var 𰌺; +var 𰌻; +var 𰌼; +var 𰌽; +var 𰌾; +var 𰌿; +var 𰍀; +var 𰍁; +var 𰍂; +var 𰍃; +var 𰍄; +var 𰍅; +var 𰍆; +var 𰍇; +var 𰍈; +var 𰍉; +var 𰍊; +var 𰍋; +var 𰍌; +var 𰍍; +var 𰍎; +var 𰍏; +var 𰍐; +var 𰍑; +var 𰍒; +var 𰍓; +var 𰍔; +var 𰍕; +var 𰍖; +var 𰍗; +var 𰍘; +var 𰍙; +var 𰍚; +var 𰍛; +var 𰍜; +var 𰍝; +var 𰍞; +var 𰍟; +var 𰍠; +var 𰍡; +var 𰍢; +var 𰍣; +var 𰍤; +var 𰍥; +var 𰍦; +var 𰍧; +var 𰍨; +var 𰍩; +var 𰍪; +var 𰍫; +var 𰍬; +var 𰍭; +var 𰍮; +var 𰍯; +var 𰍰; +var 𰍱; +var 𰍲; +var 𰍳; +var 𰍴; +var 𰍵; +var 𰍶; +var 𰍷; +var 𰍸; +var 𰍹; +var 𰍺; +var 𰍻; +var 𰍼; +var 𰍽; +var 𰍾; +var 𰍿; +var 𰎀; +var 𰎁; +var 𰎂; +var 𰎃; +var 𰎄; +var 𰎅; +var 𰎆; +var 𰎇; +var 𰎈; +var 𰎉; +var 𰎊; +var 𰎋; +var 𰎌; +var 𰎍; +var 𰎎; +var 𰎏; +var 𰎐; +var 𰎑; +var 𰎒; +var 𰎓; +var 𰎔; +var 𰎕; +var 𰎖; +var 𰎗; +var 𰎘; +var 𰎙; +var 𰎚; +var 𰎛; +var 𰎜; +var 𰎝; +var 𰎞; +var 𰎟; +var 𰎠; +var 𰎡; +var 𰎢; +var 𰎣; +var 𰎤; +var 𰎥; +var 𰎦; +var 𰎧; +var 𰎨; +var 𰎩; +var 𰎪; +var 𰎫; +var 𰎬; +var 𰎭; +var 𰎮; +var 𰎯; +var 𰎰; +var 𰎱; +var 𰎲; +var 𰎳; +var 𰎴; +var 𰎵; +var 𰎶; +var 𰎷; +var 𰎸; +var 𰎹; +var 𰎺; +var 𰎻; +var 𰎼; +var 𰎽; +var 𰎾; +var 𰎿; +var 𰏀; +var 𰏁; +var 𰏂; +var 𰏃; +var 𰏄; +var 𰏅; +var 𰏆; +var 𰏇; +var 𰏈; +var 𰏉; +var 𰏊; +var 𰏋; +var 𰏌; +var 𰏍; +var 𰏎; +var 𰏏; +var 𰏐; +var 𰏑; +var 𰏒; +var 𰏓; +var 𰏔; +var 𰏕; +var 𰏖; +var 𰏗; +var 𰏘; +var 𰏙; +var 𰏚; +var 𰏛; +var 𰏜; +var 𰏝; +var 𰏞; +var 𰏟; +var 𰏠; +var 𰏡; +var 𰏢; +var 𰏣; +var 𰏤; +var 𰏥; +var 𰏦; +var 𰏧; +var 𰏨; +var 𰏩; +var 𰏪; +var 𰏫; +var 𰏬; +var 𰏭; +var 𰏮; +var 𰏯; +var 𰏰; +var 𰏱; +var 𰏲; +var 𰏳; +var 𰏴; +var 𰏵; +var 𰏶; +var 𰏷; +var 𰏸; +var 𰏹; +var 𰏺; +var 𰏻; +var 𰏼; +var 𰏽; +var 𰏾; +var 𰏿; +var 𰐀; +var 𰐁; +var 𰐂; +var 𰐃; +var 𰐄; +var 𰐅; +var 𰐆; +var 𰐇; +var 𰐈; +var 𰐉; +var 𰐊; +var 𰐋; +var 𰐌; +var 𰐍; +var 𰐎; +var 𰐏; +var 𰐐; +var 𰐑; +var 𰐒; +var 𰐓; +var 𰐔; +var 𰐕; +var 𰐖; +var 𰐗; +var 𰐘; +var 𰐙; +var 𰐚; +var 𰐛; +var 𰐜; +var 𰐝; +var 𰐞; +var 𰐟; +var 𰐠; +var 𰐡; +var 𰐢; +var 𰐣; +var 𰐤; +var 𰐥; +var 𰐦; +var 𰐧; +var 𰐨; +var 𰐩; +var 𰐪; +var 𰐫; +var 𰐬; +var 𰐭; +var 𰐮; +var 𰐯; +var 𰐰; +var 𰐱; +var 𰐲; +var 𰐳; +var 𰐴; +var 𰐵; +var 𰐶; +var 𰐷; +var 𰐸; +var 𰐹; +var 𰐺; +var 𰐻; +var 𰐼; +var 𰐽; +var 𰐾; +var 𰐿; +var 𰑀; +var 𰑁; +var 𰑂; +var 𰑃; +var 𰑄; +var 𰑅; +var 𰑆; +var 𰑇; +var 𰑈; +var 𰑉; +var 𰑊; +var 𰑋; +var 𰑌; +var 𰑍; +var 𰑎; +var 𰑏; +var 𰑐; +var 𰑑; +var 𰑒; +var 𰑓; +var 𰑔; +var 𰑕; +var 𰑖; +var 𰑗; +var 𰑘; +var 𰑙; +var 𰑚; +var 𰑛; +var 𰑜; +var 𰑝; +var 𰑞; +var 𰑟; +var 𰑠; +var 𰑡; +var 𰑢; +var 𰑣; +var 𰑤; +var 𰑥; +var 𰑦; +var 𰑧; +var 𰑨; +var 𰑩; +var 𰑪; +var 𰑫; +var 𰑬; +var 𰑭; +var 𰑮; +var 𰑯; +var 𰑰; +var 𰑱; +var 𰑲; +var 𰑳; +var 𰑴; +var 𰑵; +var 𰑶; +var 𰑷; +var 𰑸; +var 𰑹; +var 𰑺; +var 𰑻; +var 𰑼; +var 𰑽; +var 𰑾; +var 𰑿; +var 𰒀; +var 𰒁; +var 𰒂; +var 𰒃; +var 𰒄; +var 𰒅; +var 𰒆; +var 𰒇; +var 𰒈; +var 𰒉; +var 𰒊; +var 𰒋; +var 𰒌; +var 𰒍; +var 𰒎; +var 𰒏; +var 𰒐; +var 𰒑; +var 𰒒; +var 𰒓; +var 𰒔; +var 𰒕; +var 𰒖; +var 𰒗; +var 𰒘; +var 𰒙; +var 𰒚; +var 𰒛; +var 𰒜; +var 𰒝; +var 𰒞; +var 𰒟; +var 𰒠; +var 𰒡; +var 𰒢; +var 𰒣; +var 𰒤; +var 𰒥; +var 𰒦; +var 𰒧; +var 𰒨; +var 𰒩; +var 𰒪; +var 𰒫; +var 𰒬; +var 𰒭; +var 𰒮; +var 𰒯; +var 𰒰; +var 𰒱; +var 𰒲; +var 𰒳; +var 𰒴; +var 𰒵; +var 𰒶; +var 𰒷; +var 𰒸; +var 𰒹; +var 𰒺; +var 𰒻; +var 𰒼; +var 𰒽; +var 𰒾; +var 𰒿; +var 𰓀; +var 𰓁; +var 𰓂; +var 𰓃; +var 𰓄; +var 𰓅; +var 𰓆; +var 𰓇; +var 𰓈; +var 𰓉; +var 𰓊; +var 𰓋; +var 𰓌; +var 𰓍; +var 𰓎; +var 𰓏; +var 𰓐; +var 𰓑; +var 𰓒; +var 𰓓; +var 𰓔; +var 𰓕; +var 𰓖; +var 𰓗; +var 𰓘; +var 𰓙; +var 𰓚; +var 𰓛; +var 𰓜; +var 𰓝; +var 𰓞; +var 𰓟; +var 𰓠; +var 𰓡; +var 𰓢; +var 𰓣; +var 𰓤; +var 𰓥; +var 𰓦; +var 𰓧; +var 𰓨; +var 𰓩; +var 𰓪; +var 𰓫; +var 𰓬; +var 𰓭; +var 𰓮; +var 𰓯; +var 𰓰; +var 𰓱; +var 𰓲; +var 𰓳; +var 𰓴; +var 𰓵; +var 𰓶; +var 𰓷; +var 𰓸; +var 𰓹; +var 𰓺; +var 𰓻; +var 𰓼; +var 𰓽; +var 𰓾; +var 𰓿; +var 𰔀; +var 𰔁; +var 𰔂; +var 𰔃; +var 𰔄; +var 𰔅; +var 𰔆; +var 𰔇; +var 𰔈; +var 𰔉; +var 𰔊; +var 𰔋; +var 𰔌; +var 𰔍; +var 𰔎; +var 𰔏; +var 𰔐; +var 𰔑; +var 𰔒; +var 𰔓; +var 𰔔; +var 𰔕; +var 𰔖; +var 𰔗; +var 𰔘; +var 𰔙; +var 𰔚; +var 𰔛; +var 𰔜; +var 𰔝; +var 𰔞; +var 𰔟; +var 𰔠; +var 𰔡; +var 𰔢; +var 𰔣; +var 𰔤; +var 𰔥; +var 𰔦; +var 𰔧; +var 𰔨; +var 𰔩; +var 𰔪; +var 𰔫; +var 𰔬; +var 𰔭; +var 𰔮; +var 𰔯; +var 𰔰; +var 𰔱; +var 𰔲; +var 𰔳; +var 𰔴; +var 𰔵; +var 𰔶; +var 𰔷; +var 𰔸; +var 𰔹; +var 𰔺; +var 𰔻; +var 𰔼; +var 𰔽; +var 𰔾; +var 𰔿; +var 𰕀; +var 𰕁; +var 𰕂; +var 𰕃; +var 𰕄; +var 𰕅; +var 𰕆; +var 𰕇; +var 𰕈; +var 𰕉; +var 𰕊; +var 𰕋; +var 𰕌; +var 𰕍; +var 𰕎; +var 𰕏; +var 𰕐; +var 𰕑; +var 𰕒; +var 𰕓; +var 𰕔; +var 𰕕; +var 𰕖; +var 𰕗; +var 𰕘; +var 𰕙; +var 𰕚; +var 𰕛; +var 𰕜; +var 𰕝; +var 𰕞; +var 𰕟; +var 𰕠; +var 𰕡; +var 𰕢; +var 𰕣; +var 𰕤; +var 𰕥; +var 𰕦; +var 𰕧; +var 𰕨; +var 𰕩; +var 𰕪; +var 𰕫; +var 𰕬; +var 𰕭; +var 𰕮; +var 𰕯; +var 𰕰; +var 𰕱; +var 𰕲; +var 𰕳; +var 𰕴; +var 𰕵; +var 𰕶; +var 𰕷; +var 𰕸; +var 𰕹; +var 𰕺; +var 𰕻; +var 𰕼; +var 𰕽; +var 𰕾; +var 𰕿; +var 𰖀; +var 𰖁; +var 𰖂; +var 𰖃; +var 𰖄; +var 𰖅; +var 𰖆; +var 𰖇; +var 𰖈; +var 𰖉; +var 𰖊; +var 𰖋; +var 𰖌; +var 𰖍; +var 𰖎; +var 𰖏; +var 𰖐; +var 𰖑; +var 𰖒; +var 𰖓; +var 𰖔; +var 𰖕; +var 𰖖; +var 𰖗; +var 𰖘; +var 𰖙; +var 𰖚; +var 𰖛; +var 𰖜; +var 𰖝; +var 𰖞; +var 𰖟; +var 𰖠; +var 𰖡; +var 𰖢; +var 𰖣; +var 𰖤; +var 𰖥; +var 𰖦; +var 𰖧; +var 𰖨; +var 𰖩; +var 𰖪; +var 𰖫; +var 𰖬; +var 𰖭; +var 𰖮; +var 𰖯; +var 𰖰; +var 𰖱; +var 𰖲; +var 𰖳; +var 𰖴; +var 𰖵; +var 𰖶; +var 𰖷; +var 𰖸; +var 𰖹; +var 𰖺; +var 𰖻; +var 𰖼; +var 𰖽; +var 𰖾; +var 𰖿; +var 𰗀; +var 𰗁; +var 𰗂; +var 𰗃; +var 𰗄; +var 𰗅; +var 𰗆; +var 𰗇; +var 𰗈; +var 𰗉; +var 𰗊; +var 𰗋; +var 𰗌; +var 𰗍; +var 𰗎; +var 𰗏; +var 𰗐; +var 𰗑; +var 𰗒; +var 𰗓; +var 𰗔; +var 𰗕; +var 𰗖; +var 𰗗; +var 𰗘; +var 𰗙; +var 𰗚; +var 𰗛; +var 𰗜; +var 𰗝; +var 𰗞; +var 𰗟; +var 𰗠; +var 𰗡; +var 𰗢; +var 𰗣; +var 𰗤; +var 𰗥; +var 𰗦; +var 𰗧; +var 𰗨; +var 𰗩; +var 𰗪; +var 𰗫; +var 𰗬; +var 𰗭; +var 𰗮; +var 𰗯; +var 𰗰; +var 𰗱; +var 𰗲; +var 𰗳; +var 𰗴; +var 𰗵; +var 𰗶; +var 𰗷; +var 𰗸; +var 𰗹; +var 𰗺; +var 𰗻; +var 𰗼; +var 𰗽; +var 𰗾; +var 𰗿; +var 𰘀; +var 𰘁; +var 𰘂; +var 𰘃; +var 𰘄; +var 𰘅; +var 𰘆; +var 𰘇; +var 𰘈; +var 𰘉; +var 𰘊; +var 𰘋; +var 𰘌; +var 𰘍; +var 𰘎; +var 𰘏; +var 𰘐; +var 𰘑; +var 𰘒; +var 𰘓; +var 𰘔; +var 𰘕; +var 𰘖; +var 𰘗; +var 𰘘; +var 𰘙; +var 𰘚; +var 𰘛; +var 𰘜; +var 𰘝; +var 𰘞; +var 𰘟; +var 𰘠; +var 𰘡; +var 𰘢; +var 𰘣; +var 𰘤; +var 𰘥; +var 𰘦; +var 𰘧; +var 𰘨; +var 𰘩; +var 𰘪; +var 𰘫; +var 𰘬; +var 𰘭; +var 𰘮; +var 𰘯; +var 𰘰; +var 𰘱; +var 𰘲; +var 𰘳; +var 𰘴; +var 𰘵; +var 𰘶; +var 𰘷; +var 𰘸; +var 𰘹; +var 𰘺; +var 𰘻; +var 𰘼; +var 𰘽; +var 𰘾; +var 𰘿; +var 𰙀; +var 𰙁; +var 𰙂; +var 𰙃; +var 𰙄; +var 𰙅; +var 𰙆; +var 𰙇; +var 𰙈; +var 𰙉; +var 𰙊; +var 𰙋; +var 𰙌; +var 𰙍; +var 𰙎; +var 𰙏; +var 𰙐; +var 𰙑; +var 𰙒; +var 𰙓; +var 𰙔; +var 𰙕; +var 𰙖; +var 𰙗; +var 𰙘; +var 𰙙; +var 𰙚; +var 𰙛; +var 𰙜; +var 𰙝; +var 𰙞; +var 𰙟; +var 𰙠; +var 𰙡; +var 𰙢; +var 𰙣; +var 𰙤; +var 𰙥; +var 𰙦; +var 𰙧; +var 𰙨; +var 𰙩; +var 𰙪; +var 𰙫; +var 𰙬; +var 𰙭; +var 𰙮; +var 𰙯; +var 𰙰; +var 𰙱; +var 𰙲; +var 𰙳; +var 𰙴; +var 𰙵; +var 𰙶; +var 𰙷; +var 𰙸; +var 𰙹; +var 𰙺; +var 𰙻; +var 𰙼; +var 𰙽; +var 𰙾; +var 𰙿; +var 𰚀; +var 𰚁; +var 𰚂; +var 𰚃; +var 𰚄; +var 𰚅; +var 𰚆; +var 𰚇; +var 𰚈; +var 𰚉; +var 𰚊; +var 𰚋; +var 𰚌; +var 𰚍; +var 𰚎; +var 𰚏; +var 𰚐; +var 𰚑; +var 𰚒; +var 𰚓; +var 𰚔; +var 𰚕; +var 𰚖; +var 𰚗; +var 𰚘; +var 𰚙; +var 𰚚; +var 𰚛; +var 𰚜; +var 𰚝; +var 𰚞; +var 𰚟; +var 𰚠; +var 𰚡; +var 𰚢; +var 𰚣; +var 𰚤; +var 𰚥; +var 𰚦; +var 𰚧; +var 𰚨; +var 𰚩; +var 𰚪; +var 𰚫; +var 𰚬; +var 𰚭; +var 𰚮; +var 𰚯; +var 𰚰; +var 𰚱; +var 𰚲; +var 𰚳; +var 𰚴; +var 𰚵; +var 𰚶; +var 𰚷; +var 𰚸; +var 𰚹; +var 𰚺; +var 𰚻; +var 𰚼; +var 𰚽; +var 𰚾; +var 𰚿; +var 𰛀; +var 𰛁; +var 𰛂; +var 𰛃; +var 𰛄; +var 𰛅; +var 𰛆; +var 𰛇; +var 𰛈; +var 𰛉; +var 𰛊; +var 𰛋; +var 𰛌; +var 𰛍; +var 𰛎; +var 𰛏; +var 𰛐; +var 𰛑; +var 𰛒; +var 𰛓; +var 𰛔; +var 𰛕; +var 𰛖; +var 𰛗; +var 𰛘; +var 𰛙; +var 𰛚; +var 𰛛; +var 𰛜; +var 𰛝; +var 𰛞; +var 𰛟; +var 𰛠; +var 𰛡; +var 𰛢; +var 𰛣; +var 𰛤; +var 𰛥; +var 𰛦; +var 𰛧; +var 𰛨; +var 𰛩; +var 𰛪; +var 𰛫; +var 𰛬; +var 𰛭; +var 𰛮; +var 𰛯; +var 𰛰; +var 𰛱; +var 𰛲; +var 𰛳; +var 𰛴; +var 𰛵; +var 𰛶; +var 𰛷; +var 𰛸; +var 𰛹; +var 𰛺; +var 𰛻; +var 𰛼; +var 𰛽; +var 𰛾; +var 𰛿; +var 𰜀; +var 𰜁; +var 𰜂; +var 𰜃; +var 𰜄; +var 𰜅; +var 𰜆; +var 𰜇; +var 𰜈; +var 𰜉; +var 𰜊; +var 𰜋; +var 𰜌; +var 𰜍; +var 𰜎; +var 𰜏; +var 𰜐; +var 𰜑; +var 𰜒; +var 𰜓; +var 𰜔; +var 𰜕; +var 𰜖; +var 𰜗; +var 𰜘; +var 𰜙; +var 𰜚; +var 𰜛; +var 𰜜; +var 𰜝; +var 𰜞; +var 𰜟; +var 𰜠; +var 𰜡; +var 𰜢; +var 𰜣; +var 𰜤; +var 𰜥; +var 𰜦; +var 𰜧; +var 𰜨; +var 𰜩; +var 𰜪; +var 𰜫; +var 𰜬; +var 𰜭; +var 𰜮; +var 𰜯; +var 𰜰; +var 𰜱; +var 𰜲; +var 𰜳; +var 𰜴; +var 𰜵; +var 𰜶; +var 𰜷; +var 𰜸; +var 𰜹; +var 𰜺; +var 𰜻; +var 𰜼; +var 𰜽; +var 𰜾; +var 𰜿; +var 𰝀; +var 𰝁; +var 𰝂; +var 𰝃; +var 𰝄; +var 𰝅; +var 𰝆; +var 𰝇; +var 𰝈; +var 𰝉; +var 𰝊; +var 𰝋; +var 𰝌; +var 𰝍; +var 𰝎; +var 𰝏; +var 𰝐; +var 𰝑; +var 𰝒; +var 𰝓; +var 𰝔; +var 𰝕; +var 𰝖; +var 𰝗; +var 𰝘; +var 𰝙; +var 𰝚; +var 𰝛; +var 𰝜; +var 𰝝; +var 𰝞; +var 𰝟; +var 𰝠; +var 𰝡; +var 𰝢; +var 𰝣; +var 𰝤; +var 𰝥; +var 𰝦; +var 𰝧; +var 𰝨; +var 𰝩; +var 𰝪; +var 𰝫; +var 𰝬; +var 𰝭; +var 𰝮; +var 𰝯; +var 𰝰; +var 𰝱; +var 𰝲; +var 𰝳; +var 𰝴; +var 𰝵; +var 𰝶; +var 𰝷; +var 𰝸; +var 𰝹; +var 𰝺; +var 𰝻; +var 𰝼; +var 𰝽; +var 𰝾; +var 𰝿; +var 𰞀; +var 𰞁; +var 𰞂; +var 𰞃; +var 𰞄; +var 𰞅; +var 𰞆; +var 𰞇; +var 𰞈; +var 𰞉; +var 𰞊; +var 𰞋; +var 𰞌; +var 𰞍; +var 𰞎; +var 𰞏; +var 𰞐; +var 𰞑; +var 𰞒; +var 𰞓; +var 𰞔; +var 𰞕; +var 𰞖; +var 𰞗; +var 𰞘; +var 𰞙; +var 𰞚; +var 𰞛; +var 𰞜; +var 𰞝; +var 𰞞; +var 𰞟; +var 𰞠; +var 𰞡; +var 𰞢; +var 𰞣; +var 𰞤; +var 𰞥; +var 𰞦; +var 𰞧; +var 𰞨; +var 𰞩; +var 𰞪; +var 𰞫; +var 𰞬; +var 𰞭; +var 𰞮; +var 𰞯; +var 𰞰; +var 𰞱; +var 𰞲; +var 𰞳; +var 𰞴; +var 𰞵; +var 𰞶; +var 𰞷; +var 𰞸; +var 𰞹; +var 𰞺; +var 𰞻; +var 𰞼; +var 𰞽; +var 𰞾; +var 𰞿; +var 𰟀; +var 𰟁; +var 𰟂; +var 𰟃; +var 𰟄; +var 𰟅; +var 𰟆; +var 𰟇; +var 𰟈; +var 𰟉; +var 𰟊; +var 𰟋; +var 𰟌; +var 𰟍; +var 𰟎; +var 𰟏; +var 𰟐; +var 𰟑; +var 𰟒; +var 𰟓; +var 𰟔; +var 𰟕; +var 𰟖; +var 𰟗; +var 𰟘; +var 𰟙; +var 𰟚; +var 𰟛; +var 𰟜; +var 𰟝; +var 𰟞; +var 𰟟; +var 𰟠; +var 𰟡; +var 𰟢; +var 𰟣; +var 𰟤; +var 𰟥; +var 𰟦; +var 𰟧; +var 𰟨; +var 𰟩; +var 𰟪; +var 𰟫; +var 𰟬; +var 𰟭; +var 𰟮; +var 𰟯; +var 𰟰; +var 𰟱; +var 𰟲; +var 𰟳; +var 𰟴; +var 𰟵; +var 𰟶; +var 𰟷; +var 𰟸; +var 𰟹; +var 𰟺; +var 𰟻; +var 𰟼; +var 𰟽; +var 𰟾; +var 𰟿; +var 𰠀; +var 𰠁; +var 𰠂; +var 𰠃; +var 𰠄; +var 𰠅; +var 𰠆; +var 𰠇; +var 𰠈; +var 𰠉; +var 𰠊; +var 𰠋; +var 𰠌; +var 𰠍; +var 𰠎; +var 𰠏; +var 𰠐; +var 𰠑; +var 𰠒; +var 𰠓; +var 𰠔; +var 𰠕; +var 𰠖; +var 𰠗; +var 𰠘; +var 𰠙; +var 𰠚; +var 𰠛; +var 𰠜; +var 𰠝; +var 𰠞; +var 𰠟; +var 𰠠; +var 𰠡; +var 𰠢; +var 𰠣; +var 𰠤; +var 𰠥; +var 𰠦; +var 𰠧; +var 𰠨; +var 𰠩; +var 𰠪; +var 𰠫; +var 𰠬; +var 𰠭; +var 𰠮; +var 𰠯; +var 𰠰; +var 𰠱; +var 𰠲; +var 𰠳; +var 𰠴; +var 𰠵; +var 𰠶; +var 𰠷; +var 𰠸; +var 𰠹; +var 𰠺; +var 𰠻; +var 𰠼; +var 𰠽; +var 𰠾; +var 𰠿; +var 𰡀; +var 𰡁; +var 𰡂; +var 𰡃; +var 𰡄; +var 𰡅; +var 𰡆; +var 𰡇; +var 𰡈; +var 𰡉; +var 𰡊; +var 𰡋; +var 𰡌; +var 𰡍; +var 𰡎; +var 𰡏; +var 𰡐; +var 𰡑; +var 𰡒; +var 𰡓; +var 𰡔; +var 𰡕; +var 𰡖; +var 𰡗; +var 𰡘; +var 𰡙; +var 𰡚; +var 𰡛; +var 𰡜; +var 𰡝; +var 𰡞; +var 𰡟; +var 𰡠; +var 𰡡; +var 𰡢; +var 𰡣; +var 𰡤; +var 𰡥; +var 𰡦; +var 𰡧; +var 𰡨; +var 𰡩; +var 𰡪; +var 𰡫; +var 𰡬; +var 𰡭; +var 𰡮; +var 𰡯; +var 𰡰; +var 𰡱; +var 𰡲; +var 𰡳; +var 𰡴; +var 𰡵; +var 𰡶; +var 𰡷; +var 𰡸; +var 𰡹; +var 𰡺; +var 𰡻; +var 𰡼; +var 𰡽; +var 𰡾; +var 𰡿; +var 𰢀; +var 𰢁; +var 𰢂; +var 𰢃; +var 𰢄; +var 𰢅; +var 𰢆; +var 𰢇; +var 𰢈; +var 𰢉; +var 𰢊; +var 𰢋; +var 𰢌; +var 𰢍; +var 𰢎; +var 𰢏; +var 𰢐; +var 𰢑; +var 𰢒; +var 𰢓; +var 𰢔; +var 𰢕; +var 𰢖; +var 𰢗; +var 𰢘; +var 𰢙; +var 𰢚; +var 𰢛; +var 𰢜; +var 𰢝; +var 𰢞; +var 𰢟; +var 𰢠; +var 𰢡; +var 𰢢; +var 𰢣; +var 𰢤; +var 𰢥; +var 𰢦; +var 𰢧; +var 𰢨; +var 𰢩; +var 𰢪; +var 𰢫; +var 𰢬; +var 𰢭; +var 𰢮; +var 𰢯; +var 𰢰; +var 𰢱; +var 𰢲; +var 𰢳; +var 𰢴; +var 𰢵; +var 𰢶; +var 𰢷; +var 𰢸; +var 𰢹; +var 𰢺; +var 𰢻; +var 𰢼; +var 𰢽; +var 𰢾; +var 𰢿; +var 𰣀; +var 𰣁; +var 𰣂; +var 𰣃; +var 𰣄; +var 𰣅; +var 𰣆; +var 𰣇; +var 𰣈; +var 𰣉; +var 𰣊; +var 𰣋; +var 𰣌; +var 𰣍; +var 𰣎; +var 𰣏; +var 𰣐; +var 𰣑; +var 𰣒; +var 𰣓; +var 𰣔; +var 𰣕; +var 𰣖; +var 𰣗; +var 𰣘; +var 𰣙; +var 𰣚; +var 𰣛; +var 𰣜; +var 𰣝; +var 𰣞; +var 𰣟; +var 𰣠; +var 𰣡; +var 𰣢; +var 𰣣; +var 𰣤; +var 𰣥; +var 𰣦; +var 𰣧; +var 𰣨; +var 𰣩; +var 𰣪; +var 𰣫; +var 𰣬; +var 𰣭; +var 𰣮; +var 𰣯; +var 𰣰; +var 𰣱; +var 𰣲; +var 𰣳; +var 𰣴; +var 𰣵; +var 𰣶; +var 𰣷; +var 𰣸; +var 𰣹; +var 𰣺; +var 𰣻; +var 𰣼; +var 𰣽; +var 𰣾; +var 𰣿; +var 𰤀; +var 𰤁; +var 𰤂; +var 𰤃; +var 𰤄; +var 𰤅; +var 𰤆; +var 𰤇; +var 𰤈; +var 𰤉; +var 𰤊; +var 𰤋; +var 𰤌; +var 𰤍; +var 𰤎; +var 𰤏; +var 𰤐; +var 𰤑; +var 𰤒; +var 𰤓; +var 𰤔; +var 𰤕; +var 𰤖; +var 𰤗; +var 𰤘; +var 𰤙; +var 𰤚; +var 𰤛; +var 𰤜; +var 𰤝; +var 𰤞; +var 𰤟; +var 𰤠; +var 𰤡; +var 𰤢; +var 𰤣; +var 𰤤; +var 𰤥; +var 𰤦; +var 𰤧; +var 𰤨; +var 𰤩; +var 𰤪; +var 𰤫; +var 𰤬; +var 𰤭; +var 𰤮; +var 𰤯; +var 𰤰; +var 𰤱; +var 𰤲; +var 𰤳; +var 𰤴; +var 𰤵; +var 𰤶; +var 𰤷; +var 𰤸; +var 𰤹; +var 𰤺; +var 𰤻; +var 𰤼; +var 𰤽; +var 𰤾; +var 𰤿; +var 𰥀; +var 𰥁; +var 𰥂; +var 𰥃; +var 𰥄; +var 𰥅; +var 𰥆; +var 𰥇; +var 𰥈; +var 𰥉; +var 𰥊; +var 𰥋; +var 𰥌; +var 𰥍; +var 𰥎; +var 𰥏; +var 𰥐; +var 𰥑; +var 𰥒; +var 𰥓; +var 𰥔; +var 𰥕; +var 𰥖; +var 𰥗; +var 𰥘; +var 𰥙; +var 𰥚; +var 𰥛; +var 𰥜; +var 𰥝; +var 𰥞; +var 𰥟; +var 𰥠; +var 𰥡; +var 𰥢; +var 𰥣; +var 𰥤; +var 𰥥; +var 𰥦; +var 𰥧; +var 𰥨; +var 𰥩; +var 𰥪; +var 𰥫; +var 𰥬; +var 𰥭; +var 𰥮; +var 𰥯; +var 𰥰; +var 𰥱; +var 𰥲; +var 𰥳; +var 𰥴; +var 𰥵; +var 𰥶; +var 𰥷; +var 𰥸; +var 𰥹; +var 𰥺; +var 𰥻; +var 𰥼; +var 𰥽; +var 𰥾; +var 𰥿; +var 𰦀; +var 𰦁; +var 𰦂; +var 𰦃; +var 𰦄; +var 𰦅; +var 𰦆; +var 𰦇; +var 𰦈; +var 𰦉; +var 𰦊; +var 𰦋; +var 𰦌; +var 𰦍; +var 𰦎; +var 𰦏; +var 𰦐; +var 𰦑; +var 𰦒; +var 𰦓; +var 𰦔; +var 𰦕; +var 𰦖; +var 𰦗; +var 𰦘; +var 𰦙; +var 𰦚; +var 𰦛; +var 𰦜; +var 𰦝; +var 𰦞; +var 𰦟; +var 𰦠; +var 𰦡; +var 𰦢; +var 𰦣; +var 𰦤; +var 𰦥; +var 𰦦; +var 𰦧; +var 𰦨; +var 𰦩; +var 𰦪; +var 𰦫; +var 𰦬; +var 𰦭; +var 𰦮; +var 𰦯; +var 𰦰; +var 𰦱; +var 𰦲; +var 𰦳; +var 𰦴; +var 𰦵; +var 𰦶; +var 𰦷; +var 𰦸; +var 𰦹; +var 𰦺; +var 𰦻; +var 𰦼; +var 𰦽; +var 𰦾; +var 𰦿; +var 𰧀; +var 𰧁; +var 𰧂; +var 𰧃; +var 𰧄; +var 𰧅; +var 𰧆; +var 𰧇; +var 𰧈; +var 𰧉; +var 𰧊; +var 𰧋; +var 𰧌; +var 𰧍; +var 𰧎; +var 𰧏; +var 𰧐; +var 𰧑; +var 𰧒; +var 𰧓; +var 𰧔; +var 𰧕; +var 𰧖; +var 𰧗; +var 𰧘; +var 𰧙; +var 𰧚; +var 𰧛; +var 𰧜; +var 𰧝; +var 𰧞; +var 𰧟; +var 𰧠; +var 𰧡; +var 𰧢; +var 𰧣; +var 𰧤; +var 𰧥; +var 𰧦; +var 𰧧; +var 𰧨; +var 𰧩; +var 𰧪; +var 𰧫; +var 𰧬; +var 𰧭; +var 𰧮; +var 𰧯; +var 𰧰; +var 𰧱; +var 𰧲; +var 𰧳; +var 𰧴; +var 𰧵; +var 𰧶; +var 𰧷; +var 𰧸; +var 𰧹; +var 𰧺; +var 𰧻; +var 𰧼; +var 𰧽; +var 𰧾; +var 𰧿; +var 𰨀; +var 𰨁; +var 𰨂; +var 𰨃; +var 𰨄; +var 𰨅; +var 𰨆; +var 𰨇; +var 𰨈; +var 𰨉; +var 𰨊; +var 𰨋; +var 𰨌; +var 𰨍; +var 𰨎; +var 𰨏; +var 𰨐; +var 𰨑; +var 𰨒; +var 𰨓; +var 𰨔; +var 𰨕; +var 𰨖; +var 𰨗; +var 𰨘; +var 𰨙; +var 𰨚; +var 𰨛; +var 𰨜; +var 𰨝; +var 𰨞; +var 𰨟; +var 𰨠; +var 𰨡; +var 𰨢; +var 𰨣; +var 𰨤; +var 𰨥; +var 𰨦; +var 𰨧; +var 𰨨; +var 𰨩; +var 𰨪; +var 𰨫; +var 𰨬; +var 𰨭; +var 𰨮; +var 𰨯; +var 𰨰; +var 𰨱; +var 𰨲; +var 𰨳; +var 𰨴; +var 𰨵; +var 𰨶; +var 𰨷; +var 𰨸; +var 𰨹; +var 𰨺; +var 𰨻; +var 𰨼; +var 𰨽; +var 𰨾; +var 𰨿; +var 𰩀; +var 𰩁; +var 𰩂; +var 𰩃; +var 𰩄; +var 𰩅; +var 𰩆; +var 𰩇; +var 𰩈; +var 𰩉; +var 𰩊; +var 𰩋; +var 𰩌; +var 𰩍; +var 𰩎; +var 𰩏; +var 𰩐; +var 𰩑; +var 𰩒; +var 𰩓; +var 𰩔; +var 𰩕; +var 𰩖; +var 𰩗; +var 𰩘; +var 𰩙; +var 𰩚; +var 𰩛; +var 𰩜; +var 𰩝; +var 𰩞; +var 𰩟; +var 𰩠; +var 𰩡; +var 𰩢; +var 𰩣; +var 𰩤; +var 𰩥; +var 𰩦; +var 𰩧; +var 𰩨; +var 𰩩; +var 𰩪; +var 𰩫; +var 𰩬; +var 𰩭; +var 𰩮; +var 𰩯; +var 𰩰; +var 𰩱; +var 𰩲; +var 𰩳; +var 𰩴; +var 𰩵; +var 𰩶; +var 𰩷; +var 𰩸; +var 𰩹; +var 𰩺; +var 𰩻; +var 𰩼; +var 𰩽; +var 𰩾; +var 𰩿; +var 𰪀; +var 𰪁; +var 𰪂; +var 𰪃; +var 𰪄; +var 𰪅; +var 𰪆; +var 𰪇; +var 𰪈; +var 𰪉; +var 𰪊; +var 𰪋; +var 𰪌; +var 𰪍; +var 𰪎; +var 𰪏; +var 𰪐; +var 𰪑; +var 𰪒; +var 𰪓; +var 𰪔; +var 𰪕; +var 𰪖; +var 𰪗; +var 𰪘; +var 𰪙; +var 𰪚; +var 𰪛; +var 𰪜; +var 𰪝; +var 𰪞; +var 𰪟; +var 𰪠; +var 𰪡; +var 𰪢; +var 𰪣; +var 𰪤; +var 𰪥; +var 𰪦; +var 𰪧; +var 𰪨; +var 𰪩; +var 𰪪; +var 𰪫; +var 𰪬; +var 𰪭; +var 𰪮; +var 𰪯; +var 𰪰; +var 𰪱; +var 𰪲; +var 𰪳; +var 𰪴; +var 𰪵; +var 𰪶; +var 𰪷; +var 𰪸; +var 𰪹; +var 𰪺; +var 𰪻; +var 𰪼; +var 𰪽; +var 𰪾; +var 𰪿; +var 𰫀; +var 𰫁; +var 𰫂; +var 𰫃; +var 𰫄; +var 𰫅; +var 𰫆; +var 𰫇; +var 𰫈; +var 𰫉; +var 𰫊; +var 𰫋; +var 𰫌; +var 𰫍; +var 𰫎; +var 𰫏; +var 𰫐; +var 𰫑; +var 𰫒; +var 𰫓; +var 𰫔; +var 𰫕; +var 𰫖; +var 𰫗; +var 𰫘; +var 𰫙; +var 𰫚; +var 𰫛; +var 𰫜; +var 𰫝; +var 𰫞; +var 𰫟; +var 𰫠; +var 𰫡; +var 𰫢; +var 𰫣; +var 𰫤; +var 𰫥; +var 𰫦; +var 𰫧; +var 𰫨; +var 𰫩; +var 𰫪; +var 𰫫; +var 𰫬; +var 𰫭; +var 𰫮; +var 𰫯; +var 𰫰; +var 𰫱; +var 𰫲; +var 𰫳; +var 𰫴; +var 𰫵; +var 𰫶; +var 𰫷; +var 𰫸; +var 𰫹; +var 𰫺; +var 𰫻; +var 𰫼; +var 𰫽; +var 𰫾; +var 𰫿; +var 𰬀; +var 𰬁; +var 𰬂; +var 𰬃; +var 𰬄; +var 𰬅; +var 𰬆; +var 𰬇; +var 𰬈; +var 𰬉; +var 𰬊; +var 𰬋; +var 𰬌; +var 𰬍; +var 𰬎; +var 𰬏; +var 𰬐; +var 𰬑; +var 𰬒; +var 𰬓; +var 𰬔; +var 𰬕; +var 𰬖; +var 𰬗; +var 𰬘; +var 𰬙; +var 𰬚; +var 𰬛; +var 𰬜; +var 𰬝; +var 𰬞; +var 𰬟; +var 𰬠; +var 𰬡; +var 𰬢; +var 𰬣; +var 𰬤; +var 𰬥; +var 𰬦; +var 𰬧; +var 𰬨; +var 𰬩; +var 𰬪; +var 𰬫; +var 𰬬; +var 𰬭; +var 𰬮; +var 𰬯; +var 𰬰; +var 𰬱; +var 𰬲; +var 𰬳; +var 𰬴; +var 𰬵; +var 𰬶; +var 𰬷; +var 𰬸; +var 𰬹; +var 𰬺; +var 𰬻; +var 𰬼; +var 𰬽; +var 𰬾; +var 𰬿; +var 𰭀; +var 𰭁; +var 𰭂; +var 𰭃; +var 𰭄; +var 𰭅; +var 𰭆; +var 𰭇; +var 𰭈; +var 𰭉; +var 𰭊; +var 𰭋; +var 𰭌; +var 𰭍; +var 𰭎; +var 𰭏; +var 𰭐; +var 𰭑; +var 𰭒; +var 𰭓; +var 𰭔; +var 𰭕; +var 𰭖; +var 𰭗; +var 𰭘; +var 𰭙; +var 𰭚; +var 𰭛; +var 𰭜; +var 𰭝; +var 𰭞; +var 𰭟; +var 𰭠; +var 𰭡; +var 𰭢; +var 𰭣; +var 𰭤; +var 𰭥; +var 𰭦; +var 𰭧; +var 𰭨; +var 𰭩; +var 𰭪; +var 𰭫; +var 𰭬; +var 𰭭; +var 𰭮; +var 𰭯; +var 𰭰; +var 𰭱; +var 𰭲; +var 𰭳; +var 𰭴; +var 𰭵; +var 𰭶; +var 𰭷; +var 𰭸; +var 𰭹; +var 𰭺; +var 𰭻; +var 𰭼; +var 𰭽; +var 𰭾; +var 𰭿; +var 𰮀; +var 𰮁; +var 𰮂; +var 𰮃; +var 𰮄; +var 𰮅; +var 𰮆; +var 𰮇; +var 𰮈; +var 𰮉; +var 𰮊; +var 𰮋; +var 𰮌; +var 𰮍; +var 𰮎; +var 𰮏; +var 𰮐; +var 𰮑; +var 𰮒; +var 𰮓; +var 𰮔; +var 𰮕; +var 𰮖; +var 𰮗; +var 𰮘; +var 𰮙; +var 𰮚; +var 𰮛; +var 𰮜; +var 𰮝; +var 𰮞; +var 𰮟; +var 𰮠; +var 𰮡; +var 𰮢; +var 𰮣; +var 𰮤; +var 𰮥; +var 𰮦; +var 𰮧; +var 𰮨; +var 𰮩; +var 𰮪; +var 𰮫; +var 𰮬; +var 𰮭; +var 𰮮; +var 𰮯; +var 𰮰; +var 𰮱; +var 𰮲; +var 𰮳; +var 𰮴; +var 𰮵; +var 𰮶; +var 𰮷; +var 𰮸; +var 𰮹; +var 𰮺; +var 𰮻; +var 𰮼; +var 𰮽; +var 𰮾; +var 𰮿; +var 𰯀; +var 𰯁; +var 𰯂; +var 𰯃; +var 𰯄; +var 𰯅; +var 𰯆; +var 𰯇; +var 𰯈; +var 𰯉; +var 𰯊; +var 𰯋; +var 𰯌; +var 𰯍; +var 𰯎; +var 𰯏; +var 𰯐; +var 𰯑; +var 𰯒; +var 𰯓; +var 𰯔; +var 𰯕; +var 𰯖; +var 𰯗; +var 𰯘; +var 𰯙; +var 𰯚; +var 𰯛; +var 𰯜; +var 𰯝; +var 𰯞; +var 𰯟; +var 𰯠; +var 𰯡; +var 𰯢; +var 𰯣; +var 𰯤; +var 𰯥; +var 𰯦; +var 𰯧; +var 𰯨; +var 𰯩; +var 𰯪; +var 𰯫; +var 𰯬; +var 𰯭; +var 𰯮; +var 𰯯; +var 𰯰; +var 𰯱; +var 𰯲; +var 𰯳; +var 𰯴; +var 𰯵; +var 𰯶; +var 𰯷; +var 𰯸; +var 𰯹; +var 𰯺; +var 𰯻; +var 𰯼; +var 𰯽; +var 𰯾; +var 𰯿; +var 𰰀; +var 𰰁; +var 𰰂; +var 𰰃; +var 𰰄; +var 𰰅; +var 𰰆; +var 𰰇; +var 𰰈; +var 𰰉; +var 𰰊; +var 𰰋; +var 𰰌; +var 𰰍; +var 𰰎; +var 𰰏; +var 𰰐; +var 𰰑; +var 𰰒; +var 𰰓; +var 𰰔; +var 𰰕; +var 𰰖; +var 𰰗; +var 𰰘; +var 𰰙; +var 𰰚; +var 𰰛; +var 𰰜; +var 𰰝; +var 𰰞; +var 𰰟; +var 𰰠; +var 𰰡; +var 𰰢; +var 𰰣; +var 𰰤; +var 𰰥; +var 𰰦; +var 𰰧; +var 𰰨; +var 𰰩; +var 𰰪; +var 𰰫; +var 𰰬; +var 𰰭; +var 𰰮; +var 𰰯; +var 𰰰; +var 𰰱; +var 𰰲; +var 𰰳; +var 𰰴; +var 𰰵; +var 𰰶; +var 𰰷; +var 𰰸; +var 𰰹; +var 𰰺; +var 𰰻; +var 𰰼; +var 𰰽; +var 𰰾; +var 𰰿; +var 𰱀; +var 𰱁; +var 𰱂; +var 𰱃; +var 𰱄; +var 𰱅; +var 𰱆; +var 𰱇; +var 𰱈; +var 𰱉; +var 𰱊; +var 𰱋; +var 𰱌; +var 𰱍; +var 𰱎; +var 𰱏; +var 𰱐; +var 𰱑; +var 𰱒; +var 𰱓; +var 𰱔; +var 𰱕; +var 𰱖; +var 𰱗; +var 𰱘; +var 𰱙; +var 𰱚; +var 𰱛; +var 𰱜; +var 𰱝; +var 𰱞; +var 𰱟; +var 𰱠; +var 𰱡; +var 𰱢; +var 𰱣; +var 𰱤; +var 𰱥; +var 𰱦; +var 𰱧; +var 𰱨; +var 𰱩; +var 𰱪; +var 𰱫; +var 𰱬; +var 𰱭; +var 𰱮; +var 𰱯; +var 𰱰; +var 𰱱; +var 𰱲; +var 𰱳; +var 𰱴; +var 𰱵; +var 𰱶; +var 𰱷; +var 𰱸; +var 𰱹; +var 𰱺; +var 𰱻; +var 𰱼; +var 𰱽; +var 𰱾; +var 𰱿; +var 𰲀; +var 𰲁; +var 𰲂; +var 𰲃; +var 𰲄; +var 𰲅; +var 𰲆; +var 𰲇; +var 𰲈; +var 𰲉; +var 𰲊; +var 𰲋; +var 𰲌; +var 𰲍; +var 𰲎; +var 𰲏; +var 𰲐; +var 𰲑; +var 𰲒; +var 𰲓; +var 𰲔; +var 𰲕; +var 𰲖; +var 𰲗; +var 𰲘; +var 𰲙; +var 𰲚; +var 𰲛; +var 𰲜; +var 𰲝; +var 𰲞; +var 𰲟; +var 𰲠; +var 𰲡; +var 𰲢; +var 𰲣; +var 𰲤; +var 𰲥; +var 𰲦; +var 𰲧; +var 𰲨; +var 𰲩; +var 𰲪; +var 𰲫; +var 𰲬; +var 𰲭; +var 𰲮; +var 𰲯; +var 𰲰; +var 𰲱; +var 𰲲; +var 𰲳; +var 𰲴; +var 𰲵; +var 𰲶; +var 𰲷; +var 𰲸; +var 𰲹; +var 𰲺; +var 𰲻; +var 𰲼; +var 𰲽; +var 𰲾; +var 𰲿; +var 𰳀; +var 𰳁; +var 𰳂; +var 𰳃; +var 𰳄; +var 𰳅; +var 𰳆; +var 𰳇; +var 𰳈; +var 𰳉; +var 𰳊; +var 𰳋; +var 𰳌; +var 𰳍; +var 𰳎; +var 𰳏; +var 𰳐; +var 𰳑; +var 𰳒; +var 𰳓; +var 𰳔; +var 𰳕; +var 𰳖; +var 𰳗; +var 𰳘; +var 𰳙; +var 𰳚; +var 𰳛; +var 𰳜; +var 𰳝; +var 𰳞; +var 𰳟; +var 𰳠; +var 𰳡; +var 𰳢; +var 𰳣; +var 𰳤; +var 𰳥; +var 𰳦; +var 𰳧; +var 𰳨; +var 𰳩; +var 𰳪; +var 𰳫; +var 𰳬; +var 𰳭; +var 𰳮; +var 𰳯; +var 𰳰; +var 𰳱; +var 𰳲; +var 𰳳; +var 𰳴; +var 𰳵; +var 𰳶; +var 𰳷; +var 𰳸; +var 𰳹; +var 𰳺; +var 𰳻; +var 𰳼; +var 𰳽; +var 𰳾; +var 𰳿; +var 𰴀; +var 𰴁; +var 𰴂; +var 𰴃; +var 𰴄; +var 𰴅; +var 𰴆; +var 𰴇; +var 𰴈; +var 𰴉; +var 𰴊; +var 𰴋; +var 𰴌; +var 𰴍; +var 𰴎; +var 𰴏; +var 𰴐; +var 𰴑; +var 𰴒; +var 𰴓; +var 𰴔; +var 𰴕; +var 𰴖; +var 𰴗; +var 𰴘; +var 𰴙; +var 𰴚; +var 𰴛; +var 𰴜; +var 𰴝; +var 𰴞; +var 𰴟; +var 𰴠; +var 𰴡; +var 𰴢; +var 𰴣; +var 𰴤; +var 𰴥; +var 𰴦; +var 𰴧; +var 𰴨; +var 𰴩; +var 𰴪; +var 𰴫; +var 𰴬; +var 𰴭; +var 𰴮; +var 𰴯; +var 𰴰; +var 𰴱; +var 𰴲; +var 𰴳; +var 𰴴; +var 𰴵; +var 𰴶; +var 𰴷; +var 𰴸; +var 𰴹; +var 𰴺; +var 𰴻; +var 𰴼; +var 𰴽; +var 𰴾; +var 𰴿; +var 𰵀; +var 𰵁; +var 𰵂; +var 𰵃; +var 𰵄; +var 𰵅; +var 𰵆; +var 𰵇; +var 𰵈; +var 𰵉; +var 𰵊; +var 𰵋; +var 𰵌; +var 𰵍; +var 𰵎; +var 𰵏; +var 𰵐; +var 𰵑; +var 𰵒; +var 𰵓; +var 𰵔; +var 𰵕; +var 𰵖; +var 𰵗; +var 𰵘; +var 𰵙; +var 𰵚; +var 𰵛; +var 𰵜; +var 𰵝; +var 𰵞; +var 𰵟; +var 𰵠; +var 𰵡; +var 𰵢; +var 𰵣; +var 𰵤; +var 𰵥; +var 𰵦; +var 𰵧; +var 𰵨; +var 𰵩; +var 𰵪; +var 𰵫; +var 𰵬; +var 𰵭; +var 𰵮; +var 𰵯; +var 𰵰; +var 𰵱; +var 𰵲; +var 𰵳; +var 𰵴; +var 𰵵; +var 𰵶; +var 𰵷; +var 𰵸; +var 𰵹; +var 𰵺; +var 𰵻; +var 𰵼; +var 𰵽; +var 𰵾; +var 𰵿; +var 𰶀; +var 𰶁; +var 𰶂; +var 𰶃; +var 𰶄; +var 𰶅; +var 𰶆; +var 𰶇; +var 𰶈; +var 𰶉; +var 𰶊; +var 𰶋; +var 𰶌; +var 𰶍; +var 𰶎; +var 𰶏; +var 𰶐; +var 𰶑; +var 𰶒; +var 𰶓; +var 𰶔; +var 𰶕; +var 𰶖; +var 𰶗; +var 𰶘; +var 𰶙; +var 𰶚; +var 𰶛; +var 𰶜; +var 𰶝; +var 𰶞; +var 𰶟; +var 𰶠; +var 𰶡; +var 𰶢; +var 𰶣; +var 𰶤; +var 𰶥; +var 𰶦; +var 𰶧; +var 𰶨; +var 𰶩; +var 𰶪; +var 𰶫; +var 𰶬; +var 𰶭; +var 𰶮; +var 𰶯; +var 𰶰; +var 𰶱; +var 𰶲; +var 𰶳; +var 𰶴; +var 𰶵; +var 𰶶; +var 𰶷; +var 𰶸; +var 𰶹; +var 𰶺; +var 𰶻; +var 𰶼; +var 𰶽; +var 𰶾; +var 𰶿; +var 𰷀; +var 𰷁; +var 𰷂; +var 𰷃; +var 𰷄; +var 𰷅; +var 𰷆; +var 𰷇; +var 𰷈; +var 𰷉; +var 𰷊; +var 𰷋; +var 𰷌; +var 𰷍; +var 𰷎; +var 𰷏; +var 𰷐; +var 𰷑; +var 𰷒; +var 𰷓; +var 𰷔; +var 𰷕; +var 𰷖; +var 𰷗; +var 𰷘; +var 𰷙; +var 𰷚; +var 𰷛; +var 𰷜; +var 𰷝; +var 𰷞; +var 𰷟; +var 𰷠; +var 𰷡; +var 𰷢; +var 𰷣; +var 𰷤; +var 𰷥; +var 𰷦; +var 𰷧; +var 𰷨; +var 𰷩; +var 𰷪; +var 𰷫; +var 𰷬; +var 𰷭; +var 𰷮; +var 𰷯; +var 𰷰; +var 𰷱; +var 𰷲; +var 𰷳; +var 𰷴; +var 𰷵; +var 𰷶; +var 𰷷; +var 𰷸; +var 𰷹; +var 𰷺; +var 𰷻; +var 𰷼; +var 𰷽; +var 𰷾; +var 𰷿; +var 𰸀; +var 𰸁; +var 𰸂; +var 𰸃; +var 𰸄; +var 𰸅; +var 𰸆; +var 𰸇; +var 𰸈; +var 𰸉; +var 𰸊; +var 𰸋; +var 𰸌; +var 𰸍; +var 𰸎; +var 𰸏; +var 𰸐; +var 𰸑; +var 𰸒; +var 𰸓; +var 𰸔; +var 𰸕; +var 𰸖; +var 𰸗; +var 𰸘; +var 𰸙; +var 𰸚; +var 𰸛; +var 𰸜; +var 𰸝; +var 𰸞; +var 𰸟; +var 𰸠; +var 𰸡; +var 𰸢; +var 𰸣; +var 𰸤; +var 𰸥; +var 𰸦; +var 𰸧; +var 𰸨; +var 𰸩; +var 𰸪; +var 𰸫; +var 𰸬; +var 𰸭; +var 𰸮; +var 𰸯; +var 𰸰; +var 𰸱; +var 𰸲; +var 𰸳; +var 𰸴; +var 𰸵; +var 𰸶; +var 𰸷; +var 𰸸; +var 𰸹; +var 𰸺; +var 𰸻; +var 𰸼; +var 𰸽; +var 𰸾; +var 𰸿; +var 𰹀; +var 𰹁; +var 𰹂; +var 𰹃; +var 𰹄; +var 𰹅; +var 𰹆; +var 𰹇; +var 𰹈; +var 𰹉; +var 𰹊; +var 𰹋; +var 𰹌; +var 𰹍; +var 𰹎; +var 𰹏; +var 𰹐; +var 𰹑; +var 𰹒; +var 𰹓; +var 𰹔; +var 𰹕; +var 𰹖; +var 𰹗; +var 𰹘; +var 𰹙; +var 𰹚; +var 𰹛; +var 𰹜; +var 𰹝; +var 𰹞; +var 𰹟; +var 𰹠; +var 𰹡; +var 𰹢; +var 𰹣; +var 𰹤; +var 𰹥; +var 𰹦; +var 𰹧; +var 𰹨; +var 𰹩; +var 𰹪; +var 𰹫; +var 𰹬; +var 𰹭; +var 𰹮; +var 𰹯; +var 𰹰; +var 𰹱; +var 𰹲; +var 𰹳; +var 𰹴; +var 𰹵; +var 𰹶; +var 𰹷; +var 𰹸; +var 𰹹; +var 𰹺; +var 𰹻; +var 𰹼; +var 𰹽; +var 𰹾; +var 𰹿; +var 𰺀; +var 𰺁; +var 𰺂; +var 𰺃; +var 𰺄; +var 𰺅; +var 𰺆; +var 𰺇; +var 𰺈; +var 𰺉; +var 𰺊; +var 𰺋; +var 𰺌; +var 𰺍; +var 𰺎; +var 𰺏; +var 𰺐; +var 𰺑; +var 𰺒; +var 𰺓; +var 𰺔; +var 𰺕; +var 𰺖; +var 𰺗; +var 𰺘; +var 𰺙; +var 𰺚; +var 𰺛; +var 𰺜; +var 𰺝; +var 𰺞; +var 𰺟; +var 𰺠; +var 𰺡; +var 𰺢; +var 𰺣; +var 𰺤; +var 𰺥; +var 𰺦; +var 𰺧; +var 𰺨; +var 𰺩; +var 𰺪; +var 𰺫; +var 𰺬; +var 𰺭; +var 𰺮; +var 𰺯; +var 𰺰; +var 𰺱; +var 𰺲; +var 𰺳; +var 𰺴; +var 𰺵; +var 𰺶; +var 𰺷; +var 𰺸; +var 𰺹; +var 𰺺; +var 𰺻; +var 𰺼; +var 𰺽; +var 𰺾; +var 𰺿; +var 𰻀; +var 𰻁; +var 𰻂; +var 𰻃; +var 𰻄; +var 𰻅; +var 𰻆; +var 𰻇; +var 𰻈; +var 𰻉; +var 𰻊; +var 𰻋; +var 𰻌; +var 𰻍; +var 𰻎; +var 𰻏; +var 𰻐; +var 𰻑; +var 𰻒; +var 𰻓; +var 𰻔; +var 𰻕; +var 𰻖; +var 𰻗; +var 𰻘; +var 𰻙; +var 𰻚; +var 𰻛; +var 𰻜; +var 𰻝; +var 𰻞; +var 𰻟; +var 𰻠; +var 𰻡; +var 𰻢; +var 𰻣; +var 𰻤; +var 𰻥; +var 𰻦; +var 𰻧; +var 𰻨; +var 𰻩; +var 𰻪; +var 𰻫; +var 𰻬; +var 𰻭; +var 𰻮; +var 𰻯; +var 𰻰; +var 𰻱; +var 𰻲; +var 𰻳; +var 𰻴; +var 𰻵; +var 𰻶; +var 𰻷; +var 𰻸; +var 𰻹; +var 𰻺; +var 𰻻; +var 𰻼; +var 𰻽; +var 𰻾; +var 𰻿; +var 𰼀; +var 𰼁; +var 𰼂; +var 𰼃; +var 𰼄; +var 𰼅; +var 𰼆; +var 𰼇; +var 𰼈; +var 𰼉; +var 𰼊; +var 𰼋; +var 𰼌; +var 𰼍; +var 𰼎; +var 𰼏; +var 𰼐; +var 𰼑; +var 𰼒; +var 𰼓; +var 𰼔; +var 𰼕; +var 𰼖; +var 𰼗; +var 𰼘; +var 𰼙; +var 𰼚; +var 𰼛; +var 𰼜; +var 𰼝; +var 𰼞; +var 𰼟; +var 𰼠; +var 𰼡; +var 𰼢; +var 𰼣; +var 𰼤; +var 𰼥; +var 𰼦; +var 𰼧; +var 𰼨; +var 𰼩; +var 𰼪; +var 𰼫; +var 𰼬; +var 𰼭; +var 𰼮; +var 𰼯; +var 𰼰; +var 𰼱; +var 𰼲; +var 𰼳; +var 𰼴; +var 𰼵; +var 𰼶; +var 𰼷; +var 𰼸; +var 𰼹; +var 𰼺; +var 𰼻; +var 𰼼; +var 𰼽; +var 𰼾; +var 𰼿; +var 𰽀; +var 𰽁; +var 𰽂; +var 𰽃; +var 𰽄; +var 𰽅; +var 𰽆; +var 𰽇; +var 𰽈; +var 𰽉; +var 𰽊; +var 𰽋; +var 𰽌; +var 𰽍; +var 𰽎; +var 𰽏; +var 𰽐; +var 𰽑; +var 𰽒; +var 𰽓; +var 𰽔; +var 𰽕; +var 𰽖; +var 𰽗; +var 𰽘; +var 𰽙; +var 𰽚; +var 𰽛; +var 𰽜; +var 𰽝; +var 𰽞; +var 𰽟; +var 𰽠; +var 𰽡; +var 𰽢; +var 𰽣; +var 𰽤; +var 𰽥; +var 𰽦; +var 𰽧; +var 𰽨; +var 𰽩; +var 𰽪; +var 𰽫; +var 𰽬; +var 𰽭; +var 𰽮; +var 𰽯; +var 𰽰; +var 𰽱; +var 𰽲; +var 𰽳; +var 𰽴; +var 𰽵; +var 𰽶; +var 𰽷; +var 𰽸; +var 𰽹; +var 𰽺; +var 𰽻; +var 𰽼; +var 𰽽; +var 𰽾; +var 𰽿; +var 𰾀; +var 𰾁; +var 𰾂; +var 𰾃; +var 𰾄; +var 𰾅; +var 𰾆; +var 𰾇; +var 𰾈; +var 𰾉; +var 𰾊; +var 𰾋; +var 𰾌; +var 𰾍; +var 𰾎; +var 𰾏; +var 𰾐; +var 𰾑; +var 𰾒; +var 𰾓; +var 𰾔; +var 𰾕; +var 𰾖; +var 𰾗; +var 𰾘; +var 𰾙; +var 𰾚; +var 𰾛; +var 𰾜; +var 𰾝; +var 𰾞; +var 𰾟; +var 𰾠; +var 𰾡; +var 𰾢; +var 𰾣; +var 𰾤; +var 𰾥; +var 𰾦; +var 𰾧; +var 𰾨; +var 𰾩; +var 𰾪; +var 𰾫; +var 𰾬; +var 𰾭; +var 𰾮; +var 𰾯; +var 𰾰; +var 𰾱; +var 𰾲; +var 𰾳; +var 𰾴; +var 𰾵; +var 𰾶; +var 𰾷; +var 𰾸; +var 𰾹; +var 𰾺; +var 𰾻; +var 𰾼; +var 𰾽; +var 𰾾; +var 𰾿; +var 𰿀; +var 𰿁; +var 𰿂; +var 𰿃; +var 𰿄; +var 𰿅; +var 𰿆; +var 𰿇; +var 𰿈; +var 𰿉; +var 𰿊; +var 𰿋; +var 𰿌; +var 𰿍; +var 𰿎; +var 𰿏; +var 𰿐; +var 𰿑; +var 𰿒; +var 𰿓; +var 𰿔; +var 𰿕; +var 𰿖; +var 𰿗; +var 𰿘; +var 𰿙; +var 𰿚; +var 𰿛; +var 𰿜; +var 𰿝; +var 𰿞; +var 𰿟; +var 𰿠; +var 𰿡; +var 𰿢; +var 𰿣; +var 𰿤; +var 𰿥; +var 𰿦; +var 𰿧; +var 𰿨; +var 𰿩; +var 𰿪; +var 𰿫; +var 𰿬; +var 𰿭; +var 𰿮; +var 𰿯; +var 𰿰; +var 𰿱; +var 𰿲; +var 𰿳; +var 𰿴; +var 𰿵; +var 𰿶; +var 𰿷; +var 𰿸; +var 𰿹; +var 𰿺; +var 𰿻; +var 𰿼; +var 𰿽; +var 𰿾; +var 𰿿; +var 𱀀; +var 𱀁; +var 𱀂; +var 𱀃; +var 𱀄; +var 𱀅; +var 𱀆; +var 𱀇; +var 𱀈; +var 𱀉; +var 𱀊; +var 𱀋; +var 𱀌; +var 𱀍; +var 𱀎; +var 𱀏; +var 𱀐; +var 𱀑; +var 𱀒; +var 𱀓; +var 𱀔; +var 𱀕; +var 𱀖; +var 𱀗; +var 𱀘; +var 𱀙; +var 𱀚; +var 𱀛; +var 𱀜; +var 𱀝; +var 𱀞; +var 𱀟; +var 𱀠; +var 𱀡; +var 𱀢; +var 𱀣; +var 𱀤; +var 𱀥; +var 𱀦; +var 𱀧; +var 𱀨; +var 𱀩; +var 𱀪; +var 𱀫; +var 𱀬; +var 𱀭; +var 𱀮; +var 𱀯; +var 𱀰; +var 𱀱; +var 𱀲; +var 𱀳; +var 𱀴; +var 𱀵; +var 𱀶; +var 𱀷; +var 𱀸; +var 𱀹; +var 𱀺; +var 𱀻; +var 𱀼; +var 𱀽; +var 𱀾; +var 𱀿; +var 𱁀; +var 𱁁; +var 𱁂; +var 𱁃; +var 𱁄; +var 𱁅; +var 𱁆; +var 𱁇; +var 𱁈; +var 𱁉; +var 𱁊; +var 𱁋; +var 𱁌; +var 𱁍; +var 𱁎; +var 𱁏; +var 𱁐; +var 𱁑; +var 𱁒; +var 𱁓; +var 𱁔; +var 𱁕; +var 𱁖; +var 𱁗; +var 𱁘; +var 𱁙; +var 𱁚; +var 𱁛; +var 𱁜; +var 𱁝; +var 𱁞; +var 𱁟; +var 𱁠; +var 𱁡; +var 𱁢; +var 𱁣; +var 𱁤; +var 𱁥; +var 𱁦; +var 𱁧; +var 𱁨; +var 𱁩; +var 𱁪; +var 𱁫; +var 𱁬; +var 𱁭; +var 𱁮; +var 𱁯; +var 𱁰; +var 𱁱; +var 𱁲; +var 𱁳; +var 𱁴; +var 𱁵; +var 𱁶; +var 𱁷; +var 𱁸; +var 𱁹; +var 𱁺; +var 𱁻; +var 𱁼; +var 𱁽; +var 𱁾; +var 𱁿; +var 𱂀; +var 𱂁; +var 𱂂; +var 𱂃; +var 𱂄; +var 𱂅; +var 𱂆; +var 𱂇; +var 𱂈; +var 𱂉; +var 𱂊; +var 𱂋; +var 𱂌; +var 𱂍; +var 𱂎; +var 𱂏; +var 𱂐; +var 𱂑; +var 𱂒; +var 𱂓; +var 𱂔; +var 𱂕; +var 𱂖; +var 𱂗; +var 𱂘; +var 𱂙; +var 𱂚; +var 𱂛; +var 𱂜; +var 𱂝; +var 𱂞; +var 𱂟; +var 𱂠; +var 𱂡; +var 𱂢; +var 𱂣; +var 𱂤; +var 𱂥; +var 𱂦; +var 𱂧; +var 𱂨; +var 𱂩; +var 𱂪; +var 𱂫; +var 𱂬; +var 𱂭; +var 𱂮; +var 𱂯; +var 𱂰; +var 𱂱; +var 𱂲; +var 𱂳; +var 𱂴; +var 𱂵; +var 𱂶; +var 𱂷; +var 𱂸; +var 𱂹; +var 𱂺; +var 𱂻; +var 𱂼; +var 𱂽; +var 𱂾; +var 𱂿; +var 𱃀; +var 𱃁; +var 𱃂; +var 𱃃; +var 𱃄; +var 𱃅; +var 𱃆; +var 𱃇; +var 𱃈; +var 𱃉; +var 𱃊; +var 𱃋; +var 𱃌; +var 𱃍; +var 𱃎; +var 𱃏; +var 𱃐; +var 𱃑; +var 𱃒; +var 𱃓; +var 𱃔; +var 𱃕; +var 𱃖; +var 𱃗; +var 𱃘; +var 𱃙; +var 𱃚; +var 𱃛; +var 𱃜; +var 𱃝; +var 𱃞; +var 𱃟; +var 𱃠; +var 𱃡; +var 𱃢; +var 𱃣; +var 𱃤; +var 𱃥; +var 𱃦; +var 𱃧; +var 𱃨; +var 𱃩; +var 𱃪; +var 𱃫; +var 𱃬; +var 𱃭; +var 𱃮; +var 𱃯; +var 𱃰; +var 𱃱; +var 𱃲; +var 𱃳; +var 𱃴; +var 𱃵; +var 𱃶; +var 𱃷; +var 𱃸; +var 𱃹; +var 𱃺; +var 𱃻; +var 𱃼; +var 𱃽; +var 𱃾; +var 𱃿; +var 𱄀; +var 𱄁; +var 𱄂; +var 𱄃; +var 𱄄; +var 𱄅; +var 𱄆; +var 𱄇; +var 𱄈; +var 𱄉; +var 𱄊; +var 𱄋; +var 𱄌; +var 𱄍; +var 𱄎; +var 𱄏; +var 𱄐; +var 𱄑; +var 𱄒; +var 𱄓; +var 𱄔; +var 𱄕; +var 𱄖; +var 𱄗; +var 𱄘; +var 𱄙; +var 𱄚; +var 𱄛; +var 𱄜; +var 𱄝; +var 𱄞; +var 𱄟; +var 𱄠; +var 𱄡; +var 𱄢; +var 𱄣; +var 𱄤; +var 𱄥; +var 𱄦; +var 𱄧; +var 𱄨; +var 𱄩; +var 𱄪; +var 𱄫; +var 𱄬; +var 𱄭; +var 𱄮; +var 𱄯; +var 𱄰; +var 𱄱; +var 𱄲; +var 𱄳; +var 𱄴; +var 𱄵; +var 𱄶; +var 𱄷; +var 𱄸; +var 𱄹; +var 𱄺; +var 𱄻; +var 𱄼; +var 𱄽; +var 𱄾; +var 𱄿; +var 𱅀; +var 𱅁; +var 𱅂; +var 𱅃; +var 𱅄; +var 𱅅; +var 𱅆; +var 𱅇; +var 𱅈; +var 𱅉; +var 𱅊; +var 𱅋; +var 𱅌; +var 𱅍; +var 𱅎; +var 𱅏; +var 𱅐; +var 𱅑; +var 𱅒; +var 𱅓; +var 𱅔; +var 𱅕; +var 𱅖; +var 𱅗; +var 𱅘; +var 𱅙; +var 𱅚; +var 𱅛; +var 𱅜; +var 𱅝; +var 𱅞; +var 𱅟; +var 𱅠; +var 𱅡; +var 𱅢; +var 𱅣; +var 𱅤; +var 𱅥; +var 𱅦; +var 𱅧; +var 𱅨; +var 𱅩; +var 𱅪; +var 𱅫; +var 𱅬; +var 𱅭; +var 𱅮; +var 𱅯; +var 𱅰; +var 𱅱; +var 𱅲; +var 𱅳; +var 𱅴; +var 𱅵; +var 𱅶; +var 𱅷; +var 𱅸; +var 𱅹; +var 𱅺; +var 𱅻; +var 𱅼; +var 𱅽; +var 𱅾; +var 𱅿; +var 𱆀; +var 𱆁; +var 𱆂; +var 𱆃; +var 𱆄; +var 𱆅; +var 𱆆; +var 𱆇; +var 𱆈; +var 𱆉; +var 𱆊; +var 𱆋; +var 𱆌; +var 𱆍; +var 𱆎; +var 𱆏; +var 𱆐; +var 𱆑; +var 𱆒; +var 𱆓; +var 𱆔; +var 𱆕; +var 𱆖; +var 𱆗; +var 𱆘; +var 𱆙; +var 𱆚; +var 𱆛; +var 𱆜; +var 𱆝; +var 𱆞; +var 𱆟; +var 𱆠; +var 𱆡; +var 𱆢; +var 𱆣; +var 𱆤; +var 𱆥; +var 𱆦; +var 𱆧; +var 𱆨; +var 𱆩; +var 𱆪; +var 𱆫; +var 𱆬; +var 𱆭; +var 𱆮; +var 𱆯; +var 𱆰; +var 𱆱; +var 𱆲; +var 𱆳; +var 𱆴; +var 𱆵; +var 𱆶; +var 𱆷; +var 𱆸; +var 𱆹; +var 𱆺; +var 𱆻; +var 𱆼; +var 𱆽; +var 𱆾; +var 𱆿; +var 𱇀; +var 𱇁; +var 𱇂; +var 𱇃; +var 𱇄; +var 𱇅; +var 𱇆; +var 𱇇; +var 𱇈; +var 𱇉; +var 𱇊; +var 𱇋; +var 𱇌; +var 𱇍; +var 𱇎; +var 𱇏; +var 𱇐; +var 𱇑; +var 𱇒; +var 𱇓; +var 𱇔; +var 𱇕; +var 𱇖; +var 𱇗; +var 𱇘; +var 𱇙; +var 𱇚; +var 𱇛; +var 𱇜; +var 𱇝; +var 𱇞; +var 𱇟; +var 𱇠; +var 𱇡; +var 𱇢; +var 𱇣; +var 𱇤; +var 𱇥; +var 𱇦; +var 𱇧; +var 𱇨; +var 𱇩; +var 𱇪; +var 𱇫; +var 𱇬; +var 𱇭; +var 𱇮; +var 𱇯; +var 𱇰; +var 𱇱; +var 𱇲; +var 𱇳; +var 𱇴; +var 𱇵; +var 𱇶; +var 𱇷; +var 𱇸; +var 𱇹; +var 𱇺; +var 𱇻; +var 𱇼; +var 𱇽; +var 𱇾; +var 𱇿; +var 𱈀; +var 𱈁; +var 𱈂; +var 𱈃; +var 𱈄; +var 𱈅; +var 𱈆; +var 𱈇; +var 𱈈; +var 𱈉; +var 𱈊; +var 𱈋; +var 𱈌; +var 𱈍; +var 𱈎; +var 𱈏; +var 𱈐; +var 𱈑; +var 𱈒; +var 𱈓; +var 𱈔; +var 𱈕; +var 𱈖; +var 𱈗; +var 𱈘; +var 𱈙; +var 𱈚; +var 𱈛; +var 𱈜; +var 𱈝; +var 𱈞; +var 𱈟; +var 𱈠; +var 𱈡; +var 𱈢; +var 𱈣; +var 𱈤; +var 𱈥; +var 𱈦; +var 𱈧; +var 𱈨; +var 𱈩; +var 𱈪; +var 𱈫; +var 𱈬; +var 𱈭; +var 𱈮; +var 𱈯; +var 𱈰; +var 𱈱; +var 𱈲; +var 𱈳; +var 𱈴; +var 𱈵; +var 𱈶; +var 𱈷; +var 𱈸; +var 𱈹; +var 𱈺; +var 𱈻; +var 𱈼; +var 𱈽; +var 𱈾; +var 𱈿; +var 𱉀; +var 𱉁; +var 𱉂; +var 𱉃; +var 𱉄; +var 𱉅; +var 𱉆; +var 𱉇; +var 𱉈; +var 𱉉; +var 𱉊; +var 𱉋; +var 𱉌; +var 𱉍; +var 𱉎; +var 𱉏; +var 𱉐; +var 𱉑; +var 𱉒; +var 𱉓; +var 𱉔; +var 𱉕; +var 𱉖; +var 𱉗; +var 𱉘; +var 𱉙; +var 𱉚; +var 𱉛; +var 𱉜; +var 𱉝; +var 𱉞; +var 𱉟; +var 𱉠; +var 𱉡; +var 𱉢; +var 𱉣; +var 𱉤; +var 𱉥; +var 𱉦; +var 𱉧; +var 𱉨; +var 𱉩; +var 𱉪; +var 𱉫; +var 𱉬; +var 𱉭; +var 𱉮; +var 𱉯; +var 𱉰; +var 𱉱; +var 𱉲; +var 𱉳; +var 𱉴; +var 𱉵; +var 𱉶; +var 𱉷; +var 𱉸; +var 𱉹; +var 𱉺; +var 𱉻; +var 𱉼; +var 𱉽; +var 𱉾; +var 𱉿; +var 𱊀; +var 𱊁; +var 𱊂; +var 𱊃; +var 𱊄; +var 𱊅; +var 𱊆; +var 𱊇; +var 𱊈; +var 𱊉; +var 𱊊; +var 𱊋; +var 𱊌; +var 𱊍; +var 𱊎; +var 𱊏; +var 𱊐; +var 𱊑; +var 𱊒; +var 𱊓; +var 𱊔; +var 𱊕; +var 𱊖; +var 𱊗; +var 𱊘; +var 𱊙; +var 𱊚; +var 𱊛; +var 𱊜; +var 𱊝; +var 𱊞; +var 𱊟; +var 𱊠; +var 𱊡; +var 𱊢; +var 𱊣; +var 𱊤; +var 𱊥; +var 𱊦; +var 𱊧; +var 𱊨; +var 𱊩; +var 𱊪; +var 𱊫; +var 𱊬; +var 𱊭; +var 𱊮; +var 𱊯; +var 𱊰; +var 𱊱; +var 𱊲; +var 𱊳; +var 𱊴; +var 𱊵; +var 𱊶; +var 𱊷; +var 𱊸; +var 𱊹; +var 𱊺; +var 𱊻; +var 𱊼; +var 𱊽; +var 𱊾; +var 𱊿; +var 𱋀; +var 𱋁; +var 𱋂; +var 𱋃; +var 𱋄; +var 𱋅; +var 𱋆; +var 𱋇; +var 𱋈; +var 𱋉; +var 𱋊; +var 𱋋; +var 𱋌; +var 𱋍; +var 𱋎; +var 𱋏; +var 𱋐; +var 𱋑; +var 𱋒; +var 𱋓; +var 𱋔; +var 𱋕; +var 𱋖; +var 𱋗; +var 𱋘; +var 𱋙; +var 𱋚; +var 𱋛; +var 𱋜; +var 𱋝; +var 𱋞; +var 𱋟; +var 𱋠; +var 𱋡; +var 𱋢; +var 𱋣; +var 𱋤; +var 𱋥; +var 𱋦; +var 𱋧; +var 𱋨; +var 𱋩; +var 𱋪; +var 𱋫; +var 𱋬; +var 𱋭; +var 𱋮; +var 𱋯; +var 𱋰; +var 𱋱; +var 𱋲; +var 𱋳; +var 𱋴; +var 𱋵; +var 𱋶; +var 𱋷; +var 𱋸; +var 𱋹; +var 𱋺; +var 𱋻; +var 𱋼; +var 𱋽; +var 𱋾; +var 𱋿; +var 𱌀; +var 𱌁; +var 𱌂; +var 𱌃; +var 𱌄; +var 𱌅; +var 𱌆; +var 𱌇; +var 𱌈; +var 𱌉; +var 𱌊; +var 𱌋; +var 𱌌; +var 𱌍; +var 𱌎; +var 𱌏; +var 𱌐; +var 𱌑; +var 𱌒; +var 𱌓; +var 𱌔; +var 𱌕; +var 𱌖; +var 𱌗; +var 𱌘; +var 𱌙; +var 𱌚; +var 𱌛; +var 𱌜; +var 𱌝; +var 𱌞; +var 𱌟; +var 𱌠; +var 𱌡; +var 𱌢; +var 𱌣; +var 𱌤; +var 𱌥; +var 𱌦; +var 𱌧; +var 𱌨; +var 𱌩; +var 𱌪; +var 𱌫; +var 𱌬; +var 𱌭; +var 𱌮; +var 𱌯; +var 𱌰; +var 𱌱; +var 𱌲; +var 𱌳; +var 𱌴; +var 𱌵; +var 𱌶; +var 𱌷; +var 𱌸; +var 𱌹; +var 𱌺; +var 𱌻; +var 𱌼; +var 𱌽; +var 𱌾; +var 𱌿; +var 𱍀; +var 𱍁; +var 𱍂; +var 𱍃; +var 𱍄; +var 𱍅; +var 𱍆; +var 𱍇; +var 𱍈; +var 𱍉; +var 𱍊; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0-class-escaped.js new file mode 100644 index 000000000..b2306b35f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0-class-escaped.js @@ -0,0 +1,534 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v14.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u0870; + #\u0871; + #\u0872; + #\u0873; + #\u0874; + #\u0875; + #\u0876; + #\u0877; + #\u0878; + #\u0879; + #\u087A; + #\u087B; + #\u087C; + #\u087D; + #\u087E; + #\u087F; + #\u0880; + #\u0881; + #\u0882; + #\u0883; + #\u0884; + #\u0885; + #\u0886; + #\u0887; + #\u0889; + #\u088A; + #\u088B; + #\u088C; + #\u088D; + #\u088E; + #\u08B5; + #\u08C8; + #\u08C9; + #\u0C5D; + #\u0CDD; + #\u170D; + #\u171F; + #\u1B4C; + #\u2C2F; + #\u2C5F; + #\u9FFD; + #\u9FFE; + #\u9FFF; + #\uA7C0; + #\uA7C1; + #\uA7D0; + #\uA7D1; + #\uA7D3; + #\uA7D5; + #\uA7D6; + #\uA7D7; + #\uA7D8; + #\uA7D9; + #\uA7F2; + #\uA7F3; + #\uA7F4; + #\u{10570}; + #\u{10571}; + #\u{10572}; + #\u{10573}; + #\u{10574}; + #\u{10575}; + #\u{10576}; + #\u{10577}; + #\u{10578}; + #\u{10579}; + #\u{1057A}; + #\u{1057C}; + #\u{1057D}; + #\u{1057E}; + #\u{1057F}; + #\u{10580}; + #\u{10581}; + #\u{10582}; + #\u{10583}; + #\u{10584}; + #\u{10585}; + #\u{10586}; + #\u{10587}; + #\u{10588}; + #\u{10589}; + #\u{1058A}; + #\u{1058C}; + #\u{1058D}; + #\u{1058E}; + #\u{1058F}; + #\u{10590}; + #\u{10591}; + #\u{10592}; + #\u{10594}; + #\u{10595}; + #\u{10597}; + #\u{10598}; + #\u{10599}; + #\u{1059A}; + #\u{1059B}; + #\u{1059C}; + #\u{1059D}; + #\u{1059E}; + #\u{1059F}; + #\u{105A0}; + #\u{105A1}; + #\u{105A3}; + #\u{105A4}; + #\u{105A5}; + #\u{105A6}; + #\u{105A7}; + #\u{105A8}; + #\u{105A9}; + #\u{105AA}; + #\u{105AB}; + #\u{105AC}; + #\u{105AD}; + #\u{105AE}; + #\u{105AF}; + #\u{105B0}; + #\u{105B1}; + #\u{105B3}; + #\u{105B4}; + #\u{105B5}; + #\u{105B6}; + #\u{105B7}; + #\u{105B8}; + #\u{105B9}; + #\u{105BB}; + #\u{105BC}; + #\u{10780}; + #\u{10781}; + #\u{10782}; + #\u{10783}; + #\u{10784}; + #\u{10785}; + #\u{10787}; + #\u{10788}; + #\u{10789}; + #\u{1078A}; + #\u{1078B}; + #\u{1078C}; + #\u{1078D}; + #\u{1078E}; + #\u{1078F}; + #\u{10790}; + #\u{10791}; + #\u{10792}; + #\u{10793}; + #\u{10794}; + #\u{10795}; + #\u{10796}; + #\u{10797}; + #\u{10798}; + #\u{10799}; + #\u{1079A}; + #\u{1079B}; + #\u{1079C}; + #\u{1079D}; + #\u{1079E}; + #\u{1079F}; + #\u{107A0}; + #\u{107A1}; + #\u{107A2}; + #\u{107A3}; + #\u{107A4}; + #\u{107A5}; + #\u{107A6}; + #\u{107A7}; + #\u{107A8}; + #\u{107A9}; + #\u{107AA}; + #\u{107AB}; + #\u{107AC}; + #\u{107AD}; + #\u{107AE}; + #\u{107AF}; + #\u{107B0}; + #\u{107B2}; + #\u{107B3}; + #\u{107B4}; + #\u{107B5}; + #\u{107B6}; + #\u{107B7}; + #\u{107B8}; + #\u{107B9}; + #\u{107BA}; + #\u{10F70}; + #\u{10F71}; + #\u{10F72}; + #\u{10F73}; + #\u{10F74}; + #\u{10F75}; + #\u{10F76}; + #\u{10F77}; + #\u{10F78}; + #\u{10F79}; + #\u{10F7A}; + #\u{10F7B}; + #\u{10F7C}; + #\u{10F7D}; + #\u{10F7E}; + #\u{10F7F}; + #\u{10F80}; + #\u{10F81}; + #\u{11071}; + #\u{11072}; + #\u{11075}; + #\u{11740}; + #\u{11741}; + #\u{11742}; + #\u{11743}; + #\u{11744}; + #\u{11745}; + #\u{11746}; + #\u{11AB0}; + #\u{11AB1}; + #\u{11AB2}; + #\u{11AB3}; + #\u{11AB4}; + #\u{11AB5}; + #\u{11AB6}; + #\u{11AB7}; + #\u{11AB8}; + #\u{11AB9}; + #\u{11ABA}; + #\u{11ABB}; + #\u{11ABC}; + #\u{11ABD}; + #\u{11ABE}; + #\u{11ABF}; + #\u{12F90}; + #\u{12F91}; + #\u{12F92}; + #\u{12F93}; + #\u{12F94}; + #\u{12F95}; + #\u{12F96}; + #\u{12F97}; + #\u{12F98}; + #\u{12F99}; + #\u{12F9A}; + #\u{12F9B}; + #\u{12F9C}; + #\u{12F9D}; + #\u{12F9E}; + #\u{12F9F}; + #\u{12FA0}; + #\u{12FA1}; + #\u{12FA2}; + #\u{12FA3}; + #\u{12FA4}; + #\u{12FA5}; + #\u{12FA6}; + #\u{12FA7}; + #\u{12FA8}; + #\u{12FA9}; + #\u{12FAA}; + #\u{12FAB}; + #\u{12FAC}; + #\u{12FAD}; + #\u{12FAE}; + #\u{12FAF}; + #\u{12FB0}; + #\u{12FB1}; + #\u{12FB2}; + #\u{12FB3}; + #\u{12FB4}; + #\u{12FB5}; + #\u{12FB6}; + #\u{12FB7}; + #\u{12FB8}; + #\u{12FB9}; + #\u{12FBA}; + #\u{12FBB}; + #\u{12FBC}; + #\u{12FBD}; + #\u{12FBE}; + #\u{12FBF}; + #\u{12FC0}; + #\u{12FC1}; + #\u{12FC2}; + #\u{12FC3}; + #\u{12FC4}; + #\u{12FC5}; + #\u{12FC6}; + #\u{12FC7}; + #\u{12FC8}; + #\u{12FC9}; + #\u{12FCA}; + #\u{12FCB}; + #\u{12FCC}; + #\u{12FCD}; + #\u{12FCE}; + #\u{12FCF}; + #\u{12FD0}; + #\u{12FD1}; + #\u{12FD2}; + #\u{12FD3}; + #\u{12FD4}; + #\u{12FD5}; + #\u{12FD6}; + #\u{12FD7}; + #\u{12FD8}; + #\u{12FD9}; + #\u{12FDA}; + #\u{12FDB}; + #\u{12FDC}; + #\u{12FDD}; + #\u{12FDE}; + #\u{12FDF}; + #\u{12FE0}; + #\u{12FE1}; + #\u{12FE2}; + #\u{12FE3}; + #\u{12FE4}; + #\u{12FE5}; + #\u{12FE6}; + #\u{12FE7}; + #\u{12FE8}; + #\u{12FE9}; + #\u{12FEA}; + #\u{12FEB}; + #\u{12FEC}; + #\u{12FED}; + #\u{12FEE}; + #\u{12FEF}; + #\u{12FF0}; + #\u{16A70}; + #\u{16A71}; + #\u{16A72}; + #\u{16A73}; + #\u{16A74}; + #\u{16A75}; + #\u{16A76}; + #\u{16A77}; + #\u{16A78}; + #\u{16A79}; + #\u{16A7A}; + #\u{16A7B}; + #\u{16A7C}; + #\u{16A7D}; + #\u{16A7E}; + #\u{16A7F}; + #\u{16A80}; + #\u{16A81}; + #\u{16A82}; + #\u{16A83}; + #\u{16A84}; + #\u{16A85}; + #\u{16A86}; + #\u{16A87}; + #\u{16A88}; + #\u{16A89}; + #\u{16A8A}; + #\u{16A8B}; + #\u{16A8C}; + #\u{16A8D}; + #\u{16A8E}; + #\u{16A8F}; + #\u{16A90}; + #\u{16A91}; + #\u{16A92}; + #\u{16A93}; + #\u{16A94}; + #\u{16A95}; + #\u{16A96}; + #\u{16A97}; + #\u{16A98}; + #\u{16A99}; + #\u{16A9A}; + #\u{16A9B}; + #\u{16A9C}; + #\u{16A9D}; + #\u{16A9E}; + #\u{16A9F}; + #\u{16AA0}; + #\u{16AA1}; + #\u{16AA2}; + #\u{16AA3}; + #\u{16AA4}; + #\u{16AA5}; + #\u{16AA6}; + #\u{16AA7}; + #\u{16AA8}; + #\u{16AA9}; + #\u{16AAA}; + #\u{16AAB}; + #\u{16AAC}; + #\u{16AAD}; + #\u{16AAE}; + #\u{16AAF}; + #\u{16AB0}; + #\u{16AB1}; + #\u{16AB2}; + #\u{16AB3}; + #\u{16AB4}; + #\u{16AB5}; + #\u{16AB6}; + #\u{16AB7}; + #\u{16AB8}; + #\u{16AB9}; + #\u{16ABA}; + #\u{16ABB}; + #\u{16ABC}; + #\u{16ABD}; + #\u{16ABE}; + #\u{1AFF0}; + #\u{1AFF1}; + #\u{1AFF2}; + #\u{1AFF3}; + #\u{1AFF5}; + #\u{1AFF6}; + #\u{1AFF7}; + #\u{1AFF8}; + #\u{1AFF9}; + #\u{1AFFA}; + #\u{1AFFB}; + #\u{1AFFD}; + #\u{1AFFE}; + #\u{1B11F}; + #\u{1B120}; + #\u{1B121}; + #\u{1B122}; + #\u{1DF00}; + #\u{1DF01}; + #\u{1DF02}; + #\u{1DF03}; + #\u{1DF04}; + #\u{1DF05}; + #\u{1DF06}; + #\u{1DF07}; + #\u{1DF08}; + #\u{1DF09}; + #\u{1DF0A}; + #\u{1DF0B}; + #\u{1DF0C}; + #\u{1DF0D}; + #\u{1DF0E}; + #\u{1DF0F}; + #\u{1DF10}; + #\u{1DF11}; + #\u{1DF12}; + #\u{1DF13}; + #\u{1DF14}; + #\u{1DF15}; + #\u{1DF16}; + #\u{1DF17}; + #\u{1DF18}; + #\u{1DF19}; + #\u{1DF1A}; + #\u{1DF1B}; + #\u{1DF1C}; + #\u{1DF1D}; + #\u{1DF1E}; + #\u{1E290}; + #\u{1E291}; + #\u{1E292}; + #\u{1E293}; + #\u{1E294}; + #\u{1E295}; + #\u{1E296}; + #\u{1E297}; + #\u{1E298}; + #\u{1E299}; + #\u{1E29A}; + #\u{1E29B}; + #\u{1E29C}; + #\u{1E29D}; + #\u{1E29E}; + #\u{1E29F}; + #\u{1E2A0}; + #\u{1E2A1}; + #\u{1E2A2}; + #\u{1E2A3}; + #\u{1E2A4}; + #\u{1E2A5}; + #\u{1E2A6}; + #\u{1E2A7}; + #\u{1E2A8}; + #\u{1E2A9}; + #\u{1E2AA}; + #\u{1E2AB}; + #\u{1E2AC}; + #\u{1E2AD}; + #\u{1E7E0}; + #\u{1E7E1}; + #\u{1E7E2}; + #\u{1E7E3}; + #\u{1E7E4}; + #\u{1E7E5}; + #\u{1E7E6}; + #\u{1E7E8}; + #\u{1E7E9}; + #\u{1E7EA}; + #\u{1E7EB}; + #\u{1E7ED}; + #\u{1E7EE}; + #\u{1E7F0}; + #\u{1E7F1}; + #\u{1E7F2}; + #\u{1E7F3}; + #\u{1E7F4}; + #\u{1E7F5}; + #\u{1E7F6}; + #\u{1E7F7}; + #\u{1E7F8}; + #\u{1E7F9}; + #\u{1E7FA}; + #\u{1E7FB}; + #\u{1E7FC}; + #\u{1E7FD}; + #\u{1E7FE}; + #\u{2A6DE}; + #\u{2A6DF}; + #\u{2B735}; + #\u{2B736}; + #\u{2B737}; + #\u{2B738}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0-class.js new file mode 100644 index 000000000..3ae1ab831 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0-class.js @@ -0,0 +1,531 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v14.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #ࡰ; + #ࡱ; + #ࡲ; + #ࡳ; + #ࡴ; + #ࡵ; + #ࡶ; + #ࡷ; + #ࡸ; + #ࡹ; + #ࡺ; + #ࡻ; + #ࡼ; + #ࡽ; + #ࡾ; + #ࡿ; + #ࢀ; + #ࢁ; + #ࢂ; + #ࢃ; + #ࢄ; + #ࢅ; + #ࢆ; + #ࢇ; + #ࢉ; + #ࢊ; + #ࢋ; + #ࢌ; + #ࢍ; + #ࢎ; + #ࢵ; + #ࣈ; + #ࣉ; + #ౝ; + #ೝ; + #ᜍ; + #ᜟ; + #ᭌ; + #Ⱟ; + #ⱟ; + #鿽; + #鿾; + #鿿; + #Ꟁ; + #ꟁ; + #Ꟑ; + #ꟑ; + #ꟓ; + #ꟕ; + #Ꟗ; + #ꟗ; + #Ꟙ; + #ꟙ; + #ꟲ; + #ꟳ; + #ꟴ; + #𐕰; + #𐕱; + #𐕲; + #𐕳; + #𐕴; + #𐕵; + #𐕶; + #𐕷; + #𐕸; + #𐕹; + #𐕺; + #𐕼; + #𐕽; + #𐕾; + #𐕿; + #𐖀; + #𐖁; + #𐖂; + #𐖃; + #𐖄; + #𐖅; + #𐖆; + #𐖇; + #𐖈; + #𐖉; + #𐖊; + #𐖌; + #𐖍; + #𐖎; + #𐖏; + #𐖐; + #𐖑; + #𐖒; + #𐖔; + #𐖕; + #𐖗; + #𐖘; + #𐖙; + #𐖚; + #𐖛; + #𐖜; + #𐖝; + #𐖞; + #𐖟; + #𐖠; + #𐖡; + #𐖣; + #𐖤; + #𐖥; + #𐖦; + #𐖧; + #𐖨; + #𐖩; + #𐖪; + #𐖫; + #𐖬; + #𐖭; + #𐖮; + #𐖯; + #𐖰; + #𐖱; + #𐖳; + #𐖴; + #𐖵; + #𐖶; + #𐖷; + #𐖸; + #𐖹; + #𐖻; + #𐖼; + #𐞀; + #𐞁; + #𐞂; + #𐞃; + #𐞄; + #𐞅; + #𐞇; + #𐞈; + #𐞉; + #𐞊; + #𐞋; + #𐞌; + #𐞍; + #𐞎; + #𐞏; + #𐞐; + #𐞑; + #𐞒; + #𐞓; + #𐞔; + #𐞕; + #𐞖; + #𐞗; + #𐞘; + #𐞙; + #𐞚; + #𐞛; + #𐞜; + #𐞝; + #𐞞; + #𐞟; + #𐞠; + #𐞡; + #𐞢; + #𐞣; + #𐞤; + #𐞥; + #𐞦; + #𐞧; + #𐞨; + #𐞩; + #𐞪; + #𐞫; + #𐞬; + #𐞭; + #𐞮; + #𐞯; + #𐞰; + #𐞲; + #𐞳; + #𐞴; + #𐞵; + #𐞶; + #𐞷; + #𐞸; + #𐞹; + #𐞺; + #𐽰; + #𐽱; + #𐽲; + #𐽳; + #𐽴; + #𐽵; + #𐽶; + #𐽷; + #𐽸; + #𐽹; + #𐽺; + #𐽻; + #𐽼; + #𐽽; + #𐽾; + #𐽿; + #𐾀; + #𐾁; + #𑁱; + #𑁲; + #𑁵; + #𑝀; + #𑝁; + #𑝂; + #𑝃; + #𑝄; + #𑝅; + #𑝆; + #𑪰; + #𑪱; + #𑪲; + #𑪳; + #𑪴; + #𑪵; + #𑪶; + #𑪷; + #𑪸; + #𑪹; + #𑪺; + #𑪻; + #𑪼; + #𑪽; + #𑪾; + #𑪿; + #𒾐; + #𒾑; + #𒾒; + #𒾓; + #𒾔; + #𒾕; + #𒾖; + #𒾗; + #𒾘; + #𒾙; + #𒾚; + #𒾛; + #𒾜; + #𒾝; + #𒾞; + #𒾟; + #𒾠; + #𒾡; + #𒾢; + #𒾣; + #𒾤; + #𒾥; + #𒾦; + #𒾧; + #𒾨; + #𒾩; + #𒾪; + #𒾫; + #𒾬; + #𒾭; + #𒾮; + #𒾯; + #𒾰; + #𒾱; + #𒾲; + #𒾳; + #𒾴; + #𒾵; + #𒾶; + #𒾷; + #𒾸; + #𒾹; + #𒾺; + #𒾻; + #𒾼; + #𒾽; + #𒾾; + #𒾿; + #𒿀; + #𒿁; + #𒿂; + #𒿃; + #𒿄; + #𒿅; + #𒿆; + #𒿇; + #𒿈; + #𒿉; + #𒿊; + #𒿋; + #𒿌; + #𒿍; + #𒿎; + #𒿏; + #𒿐; + #𒿑; + #𒿒; + #𒿓; + #𒿔; + #𒿕; + #𒿖; + #𒿗; + #𒿘; + #𒿙; + #𒿚; + #𒿛; + #𒿜; + #𒿝; + #𒿞; + #𒿟; + #𒿠; + #𒿡; + #𒿢; + #𒿣; + #𒿤; + #𒿥; + #𒿦; + #𒿧; + #𒿨; + #𒿩; + #𒿪; + #𒿫; + #𒿬; + #𒿭; + #𒿮; + #𒿯; + #𒿰; + #𖩰; + #𖩱; + #𖩲; + #𖩳; + #𖩴; + #𖩵; + #𖩶; + #𖩷; + #𖩸; + #𖩹; + #𖩺; + #𖩻; + #𖩼; + #𖩽; + #𖩾; + #𖩿; + #𖪀; + #𖪁; + #𖪂; + #𖪃; + #𖪄; + #𖪅; + #𖪆; + #𖪇; + #𖪈; + #𖪉; + #𖪊; + #𖪋; + #𖪌; + #𖪍; + #𖪎; + #𖪏; + #𖪐; + #𖪑; + #𖪒; + #𖪓; + #𖪔; + #𖪕; + #𖪖; + #𖪗; + #𖪘; + #𖪙; + #𖪚; + #𖪛; + #𖪜; + #𖪝; + #𖪞; + #𖪟; + #𖪠; + #𖪡; + #𖪢; + #𖪣; + #𖪤; + #𖪥; + #𖪦; + #𖪧; + #𖪨; + #𖪩; + #𖪪; + #𖪫; + #𖪬; + #𖪭; + #𖪮; + #𖪯; + #𖪰; + #𖪱; + #𖪲; + #𖪳; + #𖪴; + #𖪵; + #𖪶; + #𖪷; + #𖪸; + #𖪹; + #𖪺; + #𖪻; + #𖪼; + #𖪽; + #𖪾; + #𚿰; + #𚿱; + #𚿲; + #𚿳; + #𚿵; + #𚿶; + #𚿷; + #𚿸; + #𚿹; + #𚿺; + #𚿻; + #𚿽; + #𚿾; + #𛄟; + #𛄠; + #𛄡; + #𛄢; + #𝼀; + #𝼁; + #𝼂; + #𝼃; + #𝼄; + #𝼅; + #𝼆; + #𝼇; + #𝼈; + #𝼉; + #𝼊; + #𝼋; + #𝼌; + #𝼍; + #𝼎; + #𝼏; + #𝼐; + #𝼑; + #𝼒; + #𝼓; + #𝼔; + #𝼕; + #𝼖; + #𝼗; + #𝼘; + #𝼙; + #𝼚; + #𝼛; + #𝼜; + #𝼝; + #𝼞; + #𞊐; + #𞊑; + #𞊒; + #𞊓; + #𞊔; + #𞊕; + #𞊖; + #𞊗; + #𞊘; + #𞊙; + #𞊚; + #𞊛; + #𞊜; + #𞊝; + #𞊞; + #𞊟; + #𞊠; + #𞊡; + #𞊢; + #𞊣; + #𞊤; + #𞊥; + #𞊦; + #𞊧; + #𞊨; + #𞊩; + #𞊪; + #𞊫; + #𞊬; + #𞊭; + #𞟠; + #𞟡; + #𞟢; + #𞟣; + #𞟤; + #𞟥; + #𞟦; + #𞟨; + #𞟩; + #𞟪; + #𞟫; + #𞟭; + #𞟮; + #𞟰; + #𞟱; + #𞟲; + #𞟳; + #𞟴; + #𞟵; + #𞟶; + #𞟷; + #𞟸; + #𞟹; + #𞟺; + #𞟻; + #𞟼; + #𞟽; + #𞟾; + #𪛞; + #𪛟; + #𫜵; + #𫜶; + #𫜷; + #𫜸; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0-escaped.js new file mode 100644 index 000000000..0447510aa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0-escaped.js @@ -0,0 +1,530 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v14.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u0870; +var \u0871; +var \u0872; +var \u0873; +var \u0874; +var \u0875; +var \u0876; +var \u0877; +var \u0878; +var \u0879; +var \u087A; +var \u087B; +var \u087C; +var \u087D; +var \u087E; +var \u087F; +var \u0880; +var \u0881; +var \u0882; +var \u0883; +var \u0884; +var \u0885; +var \u0886; +var \u0887; +var \u0889; +var \u088A; +var \u088B; +var \u088C; +var \u088D; +var \u088E; +var \u08B5; +var \u08C8; +var \u08C9; +var \u0C5D; +var \u0CDD; +var \u170D; +var \u171F; +var \u1B4C; +var \u2C2F; +var \u2C5F; +var \u9FFD; +var \u9FFE; +var \u9FFF; +var \uA7C0; +var \uA7C1; +var \uA7D0; +var \uA7D1; +var \uA7D3; +var \uA7D5; +var \uA7D6; +var \uA7D7; +var \uA7D8; +var \uA7D9; +var \uA7F2; +var \uA7F3; +var \uA7F4; +var \u{10570}; +var \u{10571}; +var \u{10572}; +var \u{10573}; +var \u{10574}; +var \u{10575}; +var \u{10576}; +var \u{10577}; +var \u{10578}; +var \u{10579}; +var \u{1057A}; +var \u{1057C}; +var \u{1057D}; +var \u{1057E}; +var \u{1057F}; +var \u{10580}; +var \u{10581}; +var \u{10582}; +var \u{10583}; +var \u{10584}; +var \u{10585}; +var \u{10586}; +var \u{10587}; +var \u{10588}; +var \u{10589}; +var \u{1058A}; +var \u{1058C}; +var \u{1058D}; +var \u{1058E}; +var \u{1058F}; +var \u{10590}; +var \u{10591}; +var \u{10592}; +var \u{10594}; +var \u{10595}; +var \u{10597}; +var \u{10598}; +var \u{10599}; +var \u{1059A}; +var \u{1059B}; +var \u{1059C}; +var \u{1059D}; +var \u{1059E}; +var \u{1059F}; +var \u{105A0}; +var \u{105A1}; +var \u{105A3}; +var \u{105A4}; +var \u{105A5}; +var \u{105A6}; +var \u{105A7}; +var \u{105A8}; +var \u{105A9}; +var \u{105AA}; +var \u{105AB}; +var \u{105AC}; +var \u{105AD}; +var \u{105AE}; +var \u{105AF}; +var \u{105B0}; +var \u{105B1}; +var \u{105B3}; +var \u{105B4}; +var \u{105B5}; +var \u{105B6}; +var \u{105B7}; +var \u{105B8}; +var \u{105B9}; +var \u{105BB}; +var \u{105BC}; +var \u{10780}; +var \u{10781}; +var \u{10782}; +var \u{10783}; +var \u{10784}; +var \u{10785}; +var \u{10787}; +var \u{10788}; +var \u{10789}; +var \u{1078A}; +var \u{1078B}; +var \u{1078C}; +var \u{1078D}; +var \u{1078E}; +var \u{1078F}; +var \u{10790}; +var \u{10791}; +var \u{10792}; +var \u{10793}; +var \u{10794}; +var \u{10795}; +var \u{10796}; +var \u{10797}; +var \u{10798}; +var \u{10799}; +var \u{1079A}; +var \u{1079B}; +var \u{1079C}; +var \u{1079D}; +var \u{1079E}; +var \u{1079F}; +var \u{107A0}; +var \u{107A1}; +var \u{107A2}; +var \u{107A3}; +var \u{107A4}; +var \u{107A5}; +var \u{107A6}; +var \u{107A7}; +var \u{107A8}; +var \u{107A9}; +var \u{107AA}; +var \u{107AB}; +var \u{107AC}; +var \u{107AD}; +var \u{107AE}; +var \u{107AF}; +var \u{107B0}; +var \u{107B2}; +var \u{107B3}; +var \u{107B4}; +var \u{107B5}; +var \u{107B6}; +var \u{107B7}; +var \u{107B8}; +var \u{107B9}; +var \u{107BA}; +var \u{10F70}; +var \u{10F71}; +var \u{10F72}; +var \u{10F73}; +var \u{10F74}; +var \u{10F75}; +var \u{10F76}; +var \u{10F77}; +var \u{10F78}; +var \u{10F79}; +var \u{10F7A}; +var \u{10F7B}; +var \u{10F7C}; +var \u{10F7D}; +var \u{10F7E}; +var \u{10F7F}; +var \u{10F80}; +var \u{10F81}; +var \u{11071}; +var \u{11072}; +var \u{11075}; +var \u{11740}; +var \u{11741}; +var \u{11742}; +var \u{11743}; +var \u{11744}; +var \u{11745}; +var \u{11746}; +var \u{11AB0}; +var \u{11AB1}; +var \u{11AB2}; +var \u{11AB3}; +var \u{11AB4}; +var \u{11AB5}; +var \u{11AB6}; +var \u{11AB7}; +var \u{11AB8}; +var \u{11AB9}; +var \u{11ABA}; +var \u{11ABB}; +var \u{11ABC}; +var \u{11ABD}; +var \u{11ABE}; +var \u{11ABF}; +var \u{12F90}; +var \u{12F91}; +var \u{12F92}; +var \u{12F93}; +var \u{12F94}; +var \u{12F95}; +var \u{12F96}; +var \u{12F97}; +var \u{12F98}; +var \u{12F99}; +var \u{12F9A}; +var \u{12F9B}; +var \u{12F9C}; +var \u{12F9D}; +var \u{12F9E}; +var \u{12F9F}; +var \u{12FA0}; +var \u{12FA1}; +var \u{12FA2}; +var \u{12FA3}; +var \u{12FA4}; +var \u{12FA5}; +var \u{12FA6}; +var \u{12FA7}; +var \u{12FA8}; +var \u{12FA9}; +var \u{12FAA}; +var \u{12FAB}; +var \u{12FAC}; +var \u{12FAD}; +var \u{12FAE}; +var \u{12FAF}; +var \u{12FB0}; +var \u{12FB1}; +var \u{12FB2}; +var \u{12FB3}; +var \u{12FB4}; +var \u{12FB5}; +var \u{12FB6}; +var \u{12FB7}; +var \u{12FB8}; +var \u{12FB9}; +var \u{12FBA}; +var \u{12FBB}; +var \u{12FBC}; +var \u{12FBD}; +var \u{12FBE}; +var \u{12FBF}; +var \u{12FC0}; +var \u{12FC1}; +var \u{12FC2}; +var \u{12FC3}; +var \u{12FC4}; +var \u{12FC5}; +var \u{12FC6}; +var \u{12FC7}; +var \u{12FC8}; +var \u{12FC9}; +var \u{12FCA}; +var \u{12FCB}; +var \u{12FCC}; +var \u{12FCD}; +var \u{12FCE}; +var \u{12FCF}; +var \u{12FD0}; +var \u{12FD1}; +var \u{12FD2}; +var \u{12FD3}; +var \u{12FD4}; +var \u{12FD5}; +var \u{12FD6}; +var \u{12FD7}; +var \u{12FD8}; +var \u{12FD9}; +var \u{12FDA}; +var \u{12FDB}; +var \u{12FDC}; +var \u{12FDD}; +var \u{12FDE}; +var \u{12FDF}; +var \u{12FE0}; +var \u{12FE1}; +var \u{12FE2}; +var \u{12FE3}; +var \u{12FE4}; +var \u{12FE5}; +var \u{12FE6}; +var \u{12FE7}; +var \u{12FE8}; +var \u{12FE9}; +var \u{12FEA}; +var \u{12FEB}; +var \u{12FEC}; +var \u{12FED}; +var \u{12FEE}; +var \u{12FEF}; +var \u{12FF0}; +var \u{16A70}; +var \u{16A71}; +var \u{16A72}; +var \u{16A73}; +var \u{16A74}; +var \u{16A75}; +var \u{16A76}; +var \u{16A77}; +var \u{16A78}; +var \u{16A79}; +var \u{16A7A}; +var \u{16A7B}; +var \u{16A7C}; +var \u{16A7D}; +var \u{16A7E}; +var \u{16A7F}; +var \u{16A80}; +var \u{16A81}; +var \u{16A82}; +var \u{16A83}; +var \u{16A84}; +var \u{16A85}; +var \u{16A86}; +var \u{16A87}; +var \u{16A88}; +var \u{16A89}; +var \u{16A8A}; +var \u{16A8B}; +var \u{16A8C}; +var \u{16A8D}; +var \u{16A8E}; +var \u{16A8F}; +var \u{16A90}; +var \u{16A91}; +var \u{16A92}; +var \u{16A93}; +var \u{16A94}; +var \u{16A95}; +var \u{16A96}; +var \u{16A97}; +var \u{16A98}; +var \u{16A99}; +var \u{16A9A}; +var \u{16A9B}; +var \u{16A9C}; +var \u{16A9D}; +var \u{16A9E}; +var \u{16A9F}; +var \u{16AA0}; +var \u{16AA1}; +var \u{16AA2}; +var \u{16AA3}; +var \u{16AA4}; +var \u{16AA5}; +var \u{16AA6}; +var \u{16AA7}; +var \u{16AA8}; +var \u{16AA9}; +var \u{16AAA}; +var \u{16AAB}; +var \u{16AAC}; +var \u{16AAD}; +var \u{16AAE}; +var \u{16AAF}; +var \u{16AB0}; +var \u{16AB1}; +var \u{16AB2}; +var \u{16AB3}; +var \u{16AB4}; +var \u{16AB5}; +var \u{16AB6}; +var \u{16AB7}; +var \u{16AB8}; +var \u{16AB9}; +var \u{16ABA}; +var \u{16ABB}; +var \u{16ABC}; +var \u{16ABD}; +var \u{16ABE}; +var \u{1AFF0}; +var \u{1AFF1}; +var \u{1AFF2}; +var \u{1AFF3}; +var \u{1AFF5}; +var \u{1AFF6}; +var \u{1AFF7}; +var \u{1AFF8}; +var \u{1AFF9}; +var \u{1AFFA}; +var \u{1AFFB}; +var \u{1AFFD}; +var \u{1AFFE}; +var \u{1B11F}; +var \u{1B120}; +var \u{1B121}; +var \u{1B122}; +var \u{1DF00}; +var \u{1DF01}; +var \u{1DF02}; +var \u{1DF03}; +var \u{1DF04}; +var \u{1DF05}; +var \u{1DF06}; +var \u{1DF07}; +var \u{1DF08}; +var \u{1DF09}; +var \u{1DF0A}; +var \u{1DF0B}; +var \u{1DF0C}; +var \u{1DF0D}; +var \u{1DF0E}; +var \u{1DF0F}; +var \u{1DF10}; +var \u{1DF11}; +var \u{1DF12}; +var \u{1DF13}; +var \u{1DF14}; +var \u{1DF15}; +var \u{1DF16}; +var \u{1DF17}; +var \u{1DF18}; +var \u{1DF19}; +var \u{1DF1A}; +var \u{1DF1B}; +var \u{1DF1C}; +var \u{1DF1D}; +var \u{1DF1E}; +var \u{1E290}; +var \u{1E291}; +var \u{1E292}; +var \u{1E293}; +var \u{1E294}; +var \u{1E295}; +var \u{1E296}; +var \u{1E297}; +var \u{1E298}; +var \u{1E299}; +var \u{1E29A}; +var \u{1E29B}; +var \u{1E29C}; +var \u{1E29D}; +var \u{1E29E}; +var \u{1E29F}; +var \u{1E2A0}; +var \u{1E2A1}; +var \u{1E2A2}; +var \u{1E2A3}; +var \u{1E2A4}; +var \u{1E2A5}; +var \u{1E2A6}; +var \u{1E2A7}; +var \u{1E2A8}; +var \u{1E2A9}; +var \u{1E2AA}; +var \u{1E2AB}; +var \u{1E2AC}; +var \u{1E2AD}; +var \u{1E7E0}; +var \u{1E7E1}; +var \u{1E7E2}; +var \u{1E7E3}; +var \u{1E7E4}; +var \u{1E7E5}; +var \u{1E7E6}; +var \u{1E7E8}; +var \u{1E7E9}; +var \u{1E7EA}; +var \u{1E7EB}; +var \u{1E7ED}; +var \u{1E7EE}; +var \u{1E7F0}; +var \u{1E7F1}; +var \u{1E7F2}; +var \u{1E7F3}; +var \u{1E7F4}; +var \u{1E7F5}; +var \u{1E7F6}; +var \u{1E7F7}; +var \u{1E7F8}; +var \u{1E7F9}; +var \u{1E7FA}; +var \u{1E7FB}; +var \u{1E7FC}; +var \u{1E7FD}; +var \u{1E7FE}; +var \u{2A6DE}; +var \u{2A6DF}; +var \u{2B735}; +var \u{2B736}; +var \u{2B737}; +var \u{2B738}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0.js new file mode 100644 index 000000000..5b05be340 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-14.0.0.js @@ -0,0 +1,528 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v14.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var ࡰ; +var ࡱ; +var ࡲ; +var ࡳ; +var ࡴ; +var ࡵ; +var ࡶ; +var ࡷ; +var ࡸ; +var ࡹ; +var ࡺ; +var ࡻ; +var ࡼ; +var ࡽ; +var ࡾ; +var ࡿ; +var ࢀ; +var ࢁ; +var ࢂ; +var ࢃ; +var ࢄ; +var ࢅ; +var ࢆ; +var ࢇ; +var ࢉ; +var ࢊ; +var ࢋ; +var ࢌ; +var ࢍ; +var ࢎ; +var ࢵ; +var ࣈ; +var ࣉ; +var ౝ; +var ೝ; +var ᜍ; +var ᜟ; +var ᭌ; +var Ⱟ; +var ⱟ; +var 鿽; +var 鿾; +var 鿿; +var Ꟁ; +var ꟁ; +var Ꟑ; +var ꟑ; +var ꟓ; +var ꟕ; +var Ꟗ; +var ꟗ; +var Ꟙ; +var ꟙ; +var ꟲ; +var ꟳ; +var ꟴ; +var 𐕰; +var 𐕱; +var 𐕲; +var 𐕳; +var 𐕴; +var 𐕵; +var 𐕶; +var 𐕷; +var 𐕸; +var 𐕹; +var 𐕺; +var 𐕼; +var 𐕽; +var 𐕾; +var 𐕿; +var 𐖀; +var 𐖁; +var 𐖂; +var 𐖃; +var 𐖄; +var 𐖅; +var 𐖆; +var 𐖇; +var 𐖈; +var 𐖉; +var 𐖊; +var 𐖌; +var 𐖍; +var 𐖎; +var 𐖏; +var 𐖐; +var 𐖑; +var 𐖒; +var 𐖔; +var 𐖕; +var 𐖗; +var 𐖘; +var 𐖙; +var 𐖚; +var 𐖛; +var 𐖜; +var 𐖝; +var 𐖞; +var 𐖟; +var 𐖠; +var 𐖡; +var 𐖣; +var 𐖤; +var 𐖥; +var 𐖦; +var 𐖧; +var 𐖨; +var 𐖩; +var 𐖪; +var 𐖫; +var 𐖬; +var 𐖭; +var 𐖮; +var 𐖯; +var 𐖰; +var 𐖱; +var 𐖳; +var 𐖴; +var 𐖵; +var 𐖶; +var 𐖷; +var 𐖸; +var 𐖹; +var 𐖻; +var 𐖼; +var 𐞀; +var 𐞁; +var 𐞂; +var 𐞃; +var 𐞄; +var 𐞅; +var 𐞇; +var 𐞈; +var 𐞉; +var 𐞊; +var 𐞋; +var 𐞌; +var 𐞍; +var 𐞎; +var 𐞏; +var 𐞐; +var 𐞑; +var 𐞒; +var 𐞓; +var 𐞔; +var 𐞕; +var 𐞖; +var 𐞗; +var 𐞘; +var 𐞙; +var 𐞚; +var 𐞛; +var 𐞜; +var 𐞝; +var 𐞞; +var 𐞟; +var 𐞠; +var 𐞡; +var 𐞢; +var 𐞣; +var 𐞤; +var 𐞥; +var 𐞦; +var 𐞧; +var 𐞨; +var 𐞩; +var 𐞪; +var 𐞫; +var 𐞬; +var 𐞭; +var 𐞮; +var 𐞯; +var 𐞰; +var 𐞲; +var 𐞳; +var 𐞴; +var 𐞵; +var 𐞶; +var 𐞷; +var 𐞸; +var 𐞹; +var 𐞺; +var 𐽰; +var 𐽱; +var 𐽲; +var 𐽳; +var 𐽴; +var 𐽵; +var 𐽶; +var 𐽷; +var 𐽸; +var 𐽹; +var 𐽺; +var 𐽻; +var 𐽼; +var 𐽽; +var 𐽾; +var 𐽿; +var 𐾀; +var 𐾁; +var 𑁱; +var 𑁲; +var 𑁵; +var 𑝀; +var 𑝁; +var 𑝂; +var 𑝃; +var 𑝄; +var 𑝅; +var 𑝆; +var 𑪰; +var 𑪱; +var 𑪲; +var 𑪳; +var 𑪴; +var 𑪵; +var 𑪶; +var 𑪷; +var 𑪸; +var 𑪹; +var 𑪺; +var 𑪻; +var 𑪼; +var 𑪽; +var 𑪾; +var 𑪿; +var 𒾐; +var 𒾑; +var 𒾒; +var 𒾓; +var 𒾔; +var 𒾕; +var 𒾖; +var 𒾗; +var 𒾘; +var 𒾙; +var 𒾚; +var 𒾛; +var 𒾜; +var 𒾝; +var 𒾞; +var 𒾟; +var 𒾠; +var 𒾡; +var 𒾢; +var 𒾣; +var 𒾤; +var 𒾥; +var 𒾦; +var 𒾧; +var 𒾨; +var 𒾩; +var 𒾪; +var 𒾫; +var 𒾬; +var 𒾭; +var 𒾮; +var 𒾯; +var 𒾰; +var 𒾱; +var 𒾲; +var 𒾳; +var 𒾴; +var 𒾵; +var 𒾶; +var 𒾷; +var 𒾸; +var 𒾹; +var 𒾺; +var 𒾻; +var 𒾼; +var 𒾽; +var 𒾾; +var 𒾿; +var 𒿀; +var 𒿁; +var 𒿂; +var 𒿃; +var 𒿄; +var 𒿅; +var 𒿆; +var 𒿇; +var 𒿈; +var 𒿉; +var 𒿊; +var 𒿋; +var 𒿌; +var 𒿍; +var 𒿎; +var 𒿏; +var 𒿐; +var 𒿑; +var 𒿒; +var 𒿓; +var 𒿔; +var 𒿕; +var 𒿖; +var 𒿗; +var 𒿘; +var 𒿙; +var 𒿚; +var 𒿛; +var 𒿜; +var 𒿝; +var 𒿞; +var 𒿟; +var 𒿠; +var 𒿡; +var 𒿢; +var 𒿣; +var 𒿤; +var 𒿥; +var 𒿦; +var 𒿧; +var 𒿨; +var 𒿩; +var 𒿪; +var 𒿫; +var 𒿬; +var 𒿭; +var 𒿮; +var 𒿯; +var 𒿰; +var 𖩰; +var 𖩱; +var 𖩲; +var 𖩳; +var 𖩴; +var 𖩵; +var 𖩶; +var 𖩷; +var 𖩸; +var 𖩹; +var 𖩺; +var 𖩻; +var 𖩼; +var 𖩽; +var 𖩾; +var 𖩿; +var 𖪀; +var 𖪁; +var 𖪂; +var 𖪃; +var 𖪄; +var 𖪅; +var 𖪆; +var 𖪇; +var 𖪈; +var 𖪉; +var 𖪊; +var 𖪋; +var 𖪌; +var 𖪍; +var 𖪎; +var 𖪏; +var 𖪐; +var 𖪑; +var 𖪒; +var 𖪓; +var 𖪔; +var 𖪕; +var 𖪖; +var 𖪗; +var 𖪘; +var 𖪙; +var 𖪚; +var 𖪛; +var 𖪜; +var 𖪝; +var 𖪞; +var 𖪟; +var 𖪠; +var 𖪡; +var 𖪢; +var 𖪣; +var 𖪤; +var 𖪥; +var 𖪦; +var 𖪧; +var 𖪨; +var 𖪩; +var 𖪪; +var 𖪫; +var 𖪬; +var 𖪭; +var 𖪮; +var 𖪯; +var 𖪰; +var 𖪱; +var 𖪲; +var 𖪳; +var 𖪴; +var 𖪵; +var 𖪶; +var 𖪷; +var 𖪸; +var 𖪹; +var 𖪺; +var 𖪻; +var 𖪼; +var 𖪽; +var 𖪾; +var 𚿰; +var 𚿱; +var 𚿲; +var 𚿳; +var 𚿵; +var 𚿶; +var 𚿷; +var 𚿸; +var 𚿹; +var 𚿺; +var 𚿻; +var 𚿽; +var 𚿾; +var 𛄟; +var 𛄠; +var 𛄡; +var 𛄢; +var 𝼀; +var 𝼁; +var 𝼂; +var 𝼃; +var 𝼄; +var 𝼅; +var 𝼆; +var 𝼇; +var 𝼈; +var 𝼉; +var 𝼊; +var 𝼋; +var 𝼌; +var 𝼍; +var 𝼎; +var 𝼏; +var 𝼐; +var 𝼑; +var 𝼒; +var 𝼓; +var 𝼔; +var 𝼕; +var 𝼖; +var 𝼗; +var 𝼘; +var 𝼙; +var 𝼚; +var 𝼛; +var 𝼜; +var 𝼝; +var 𝼞; +var 𞊐; +var 𞊑; +var 𞊒; +var 𞊓; +var 𞊔; +var 𞊕; +var 𞊖; +var 𞊗; +var 𞊘; +var 𞊙; +var 𞊚; +var 𞊛; +var 𞊜; +var 𞊝; +var 𞊞; +var 𞊟; +var 𞊠; +var 𞊡; +var 𞊢; +var 𞊣; +var 𞊤; +var 𞊥; +var 𞊦; +var 𞊧; +var 𞊨; +var 𞊩; +var 𞊪; +var 𞊫; +var 𞊬; +var 𞊭; +var 𞟠; +var 𞟡; +var 𞟢; +var 𞟣; +var 𞟤; +var 𞟥; +var 𞟦; +var 𞟨; +var 𞟩; +var 𞟪; +var 𞟫; +var 𞟭; +var 𞟮; +var 𞟰; +var 𞟱; +var 𞟲; +var 𞟳; +var 𞟴; +var 𞟵; +var 𞟶; +var 𞟷; +var 𞟸; +var 𞟹; +var 𞟺; +var 𞟻; +var 𞟼; +var 𞟽; +var 𞟾; +var 𪛞; +var 𪛟; +var 𫜵; +var 𫜶; +var 𫜷; +var 𫜸; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0-class-escaped.js new file mode 100644 index 000000000..006ec272d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0-class-escaped.js @@ -0,0 +1,4367 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v15.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u{1123F}; + #\u{11240}; + #\u{11F02}; + #\u{11F04}; + #\u{11F05}; + #\u{11F06}; + #\u{11F07}; + #\u{11F08}; + #\u{11F09}; + #\u{11F0A}; + #\u{11F0B}; + #\u{11F0C}; + #\u{11F0D}; + #\u{11F0E}; + #\u{11F0F}; + #\u{11F10}; + #\u{11F12}; + #\u{11F13}; + #\u{11F14}; + #\u{11F15}; + #\u{11F16}; + #\u{11F17}; + #\u{11F18}; + #\u{11F19}; + #\u{11F1A}; + #\u{11F1B}; + #\u{11F1C}; + #\u{11F1D}; + #\u{11F1E}; + #\u{11F1F}; + #\u{11F20}; + #\u{11F21}; + #\u{11F22}; + #\u{11F23}; + #\u{11F24}; + #\u{11F25}; + #\u{11F26}; + #\u{11F27}; + #\u{11F28}; + #\u{11F29}; + #\u{11F2A}; + #\u{11F2B}; + #\u{11F2C}; + #\u{11F2D}; + #\u{11F2E}; + #\u{11F2F}; + #\u{11F30}; + #\u{11F31}; + #\u{11F32}; + #\u{11F33}; + #\u{1342F}; + #\u{13441}; + #\u{13442}; + #\u{13443}; + #\u{13444}; + #\u{13445}; + #\u{13446}; + #\u{1B132}; + #\u{1B155}; + #\u{1DF25}; + #\u{1DF26}; + #\u{1DF27}; + #\u{1DF28}; + #\u{1DF29}; + #\u{1DF2A}; + #\u{1E030}; + #\u{1E031}; + #\u{1E032}; + #\u{1E033}; + #\u{1E034}; + #\u{1E035}; + #\u{1E036}; + #\u{1E037}; + #\u{1E038}; + #\u{1E039}; + #\u{1E03A}; + #\u{1E03B}; + #\u{1E03C}; + #\u{1E03D}; + #\u{1E03E}; + #\u{1E03F}; + #\u{1E040}; + #\u{1E041}; + #\u{1E042}; + #\u{1E043}; + #\u{1E044}; + #\u{1E045}; + #\u{1E046}; + #\u{1E047}; + #\u{1E048}; + #\u{1E049}; + #\u{1E04A}; + #\u{1E04B}; + #\u{1E04C}; + #\u{1E04D}; + #\u{1E04E}; + #\u{1E04F}; + #\u{1E050}; + #\u{1E051}; + #\u{1E052}; + #\u{1E053}; + #\u{1E054}; + #\u{1E055}; + #\u{1E056}; + #\u{1E057}; + #\u{1E058}; + #\u{1E059}; + #\u{1E05A}; + #\u{1E05B}; + #\u{1E05C}; + #\u{1E05D}; + #\u{1E05E}; + #\u{1E05F}; + #\u{1E060}; + #\u{1E061}; + #\u{1E062}; + #\u{1E063}; + #\u{1E064}; + #\u{1E065}; + #\u{1E066}; + #\u{1E067}; + #\u{1E068}; + #\u{1E069}; + #\u{1E06A}; + #\u{1E06B}; + #\u{1E06C}; + #\u{1E06D}; + #\u{1E4D0}; + #\u{1E4D1}; + #\u{1E4D2}; + #\u{1E4D3}; + #\u{1E4D4}; + #\u{1E4D5}; + #\u{1E4D6}; + #\u{1E4D7}; + #\u{1E4D8}; + #\u{1E4D9}; + #\u{1E4DA}; + #\u{1E4DB}; + #\u{1E4DC}; + #\u{1E4DD}; + #\u{1E4DE}; + #\u{1E4DF}; + #\u{1E4E0}; + #\u{1E4E1}; + #\u{1E4E2}; + #\u{1E4E3}; + #\u{1E4E4}; + #\u{1E4E5}; + #\u{1E4E6}; + #\u{1E4E7}; + #\u{1E4E8}; + #\u{1E4E9}; + #\u{1E4EA}; + #\u{1E4EB}; + #\u{2B739}; + #\u{31350}; + #\u{31351}; + #\u{31352}; + #\u{31353}; + #\u{31354}; + #\u{31355}; + #\u{31356}; + #\u{31357}; + #\u{31358}; + #\u{31359}; + #\u{3135A}; + #\u{3135B}; + #\u{3135C}; + #\u{3135D}; + #\u{3135E}; + #\u{3135F}; + #\u{31360}; + #\u{31361}; + #\u{31362}; + #\u{31363}; + #\u{31364}; + #\u{31365}; + #\u{31366}; + #\u{31367}; + #\u{31368}; + #\u{31369}; + #\u{3136A}; + #\u{3136B}; + #\u{3136C}; + #\u{3136D}; + #\u{3136E}; + #\u{3136F}; + #\u{31370}; + #\u{31371}; + #\u{31372}; + #\u{31373}; + #\u{31374}; + #\u{31375}; + #\u{31376}; + #\u{31377}; + #\u{31378}; + #\u{31379}; + #\u{3137A}; + #\u{3137B}; + #\u{3137C}; + #\u{3137D}; + #\u{3137E}; + #\u{3137F}; + #\u{31380}; + #\u{31381}; + #\u{31382}; + #\u{31383}; + #\u{31384}; + #\u{31385}; + #\u{31386}; + #\u{31387}; + #\u{31388}; + #\u{31389}; + #\u{3138A}; + #\u{3138B}; + #\u{3138C}; + #\u{3138D}; + #\u{3138E}; + #\u{3138F}; + #\u{31390}; + #\u{31391}; + #\u{31392}; + #\u{31393}; + #\u{31394}; + #\u{31395}; + #\u{31396}; + #\u{31397}; + #\u{31398}; + #\u{31399}; + #\u{3139A}; + #\u{3139B}; + #\u{3139C}; + #\u{3139D}; + #\u{3139E}; + #\u{3139F}; + #\u{313A0}; + #\u{313A1}; + #\u{313A2}; + #\u{313A3}; + #\u{313A4}; + #\u{313A5}; + #\u{313A6}; + #\u{313A7}; + #\u{313A8}; + #\u{313A9}; + #\u{313AA}; + #\u{313AB}; + #\u{313AC}; + #\u{313AD}; + #\u{313AE}; + #\u{313AF}; + #\u{313B0}; + #\u{313B1}; + #\u{313B2}; + #\u{313B3}; + #\u{313B4}; + #\u{313B5}; + #\u{313B6}; + #\u{313B7}; + #\u{313B8}; + #\u{313B9}; + #\u{313BA}; + #\u{313BB}; + #\u{313BC}; + #\u{313BD}; + #\u{313BE}; + #\u{313BF}; + #\u{313C0}; + #\u{313C1}; + #\u{313C2}; + #\u{313C3}; + #\u{313C4}; + #\u{313C5}; + #\u{313C6}; + #\u{313C7}; + #\u{313C8}; + #\u{313C9}; + #\u{313CA}; + #\u{313CB}; + #\u{313CC}; + #\u{313CD}; + #\u{313CE}; + #\u{313CF}; + #\u{313D0}; + #\u{313D1}; + #\u{313D2}; + #\u{313D3}; + #\u{313D4}; + #\u{313D5}; + #\u{313D6}; + #\u{313D7}; + #\u{313D8}; + #\u{313D9}; + #\u{313DA}; + #\u{313DB}; + #\u{313DC}; + #\u{313DD}; + #\u{313DE}; + #\u{313DF}; + #\u{313E0}; + #\u{313E1}; + #\u{313E2}; + #\u{313E3}; + #\u{313E4}; + #\u{313E5}; + #\u{313E6}; + #\u{313E7}; + #\u{313E8}; + #\u{313E9}; + #\u{313EA}; + #\u{313EB}; + #\u{313EC}; + #\u{313ED}; + #\u{313EE}; + #\u{313EF}; + #\u{313F0}; + #\u{313F1}; + #\u{313F2}; + #\u{313F3}; + #\u{313F4}; + #\u{313F5}; + #\u{313F6}; + #\u{313F7}; + #\u{313F8}; + #\u{313F9}; + #\u{313FA}; + #\u{313FB}; + #\u{313FC}; + #\u{313FD}; + #\u{313FE}; + #\u{313FF}; + #\u{31400}; + #\u{31401}; + #\u{31402}; + #\u{31403}; + #\u{31404}; + #\u{31405}; + #\u{31406}; + #\u{31407}; + #\u{31408}; + #\u{31409}; + #\u{3140A}; + #\u{3140B}; + #\u{3140C}; + #\u{3140D}; + #\u{3140E}; + #\u{3140F}; + #\u{31410}; + #\u{31411}; + #\u{31412}; + #\u{31413}; + #\u{31414}; + #\u{31415}; + #\u{31416}; + #\u{31417}; + #\u{31418}; + #\u{31419}; + #\u{3141A}; + #\u{3141B}; + #\u{3141C}; + #\u{3141D}; + #\u{3141E}; + #\u{3141F}; + #\u{31420}; + #\u{31421}; + #\u{31422}; + #\u{31423}; + #\u{31424}; + #\u{31425}; + #\u{31426}; + #\u{31427}; + #\u{31428}; + #\u{31429}; + #\u{3142A}; + #\u{3142B}; + #\u{3142C}; + #\u{3142D}; + #\u{3142E}; + #\u{3142F}; + #\u{31430}; + #\u{31431}; + #\u{31432}; + #\u{31433}; + #\u{31434}; + #\u{31435}; + #\u{31436}; + #\u{31437}; + #\u{31438}; + #\u{31439}; + #\u{3143A}; + #\u{3143B}; + #\u{3143C}; + #\u{3143D}; + #\u{3143E}; + #\u{3143F}; + #\u{31440}; + #\u{31441}; + #\u{31442}; + #\u{31443}; + #\u{31444}; + #\u{31445}; + #\u{31446}; + #\u{31447}; + #\u{31448}; + #\u{31449}; + #\u{3144A}; + #\u{3144B}; + #\u{3144C}; + #\u{3144D}; + #\u{3144E}; + #\u{3144F}; + #\u{31450}; + #\u{31451}; + #\u{31452}; + #\u{31453}; + #\u{31454}; + #\u{31455}; + #\u{31456}; + #\u{31457}; + #\u{31458}; + #\u{31459}; + #\u{3145A}; + #\u{3145B}; + #\u{3145C}; + #\u{3145D}; + #\u{3145E}; + #\u{3145F}; + #\u{31460}; + #\u{31461}; + #\u{31462}; + #\u{31463}; + #\u{31464}; + #\u{31465}; + #\u{31466}; + #\u{31467}; + #\u{31468}; + #\u{31469}; + #\u{3146A}; + #\u{3146B}; + #\u{3146C}; + #\u{3146D}; + #\u{3146E}; + #\u{3146F}; + #\u{31470}; + #\u{31471}; + #\u{31472}; + #\u{31473}; + #\u{31474}; + #\u{31475}; + #\u{31476}; + #\u{31477}; + #\u{31478}; + #\u{31479}; + #\u{3147A}; + #\u{3147B}; + #\u{3147C}; + #\u{3147D}; + #\u{3147E}; + #\u{3147F}; + #\u{31480}; + #\u{31481}; + #\u{31482}; + #\u{31483}; + #\u{31484}; + #\u{31485}; + #\u{31486}; + #\u{31487}; + #\u{31488}; + #\u{31489}; + #\u{3148A}; + #\u{3148B}; + #\u{3148C}; + #\u{3148D}; + #\u{3148E}; + #\u{3148F}; + #\u{31490}; + #\u{31491}; + #\u{31492}; + #\u{31493}; + #\u{31494}; + #\u{31495}; + #\u{31496}; + #\u{31497}; + #\u{31498}; + #\u{31499}; + #\u{3149A}; + #\u{3149B}; + #\u{3149C}; + #\u{3149D}; + #\u{3149E}; + #\u{3149F}; + #\u{314A0}; + #\u{314A1}; + #\u{314A2}; + #\u{314A3}; + #\u{314A4}; + #\u{314A5}; + #\u{314A6}; + #\u{314A7}; + #\u{314A8}; + #\u{314A9}; + #\u{314AA}; + #\u{314AB}; + #\u{314AC}; + #\u{314AD}; + #\u{314AE}; + #\u{314AF}; + #\u{314B0}; + #\u{314B1}; + #\u{314B2}; + #\u{314B3}; + #\u{314B4}; + #\u{314B5}; + #\u{314B6}; + #\u{314B7}; + #\u{314B8}; + #\u{314B9}; + #\u{314BA}; + #\u{314BB}; + #\u{314BC}; + #\u{314BD}; + #\u{314BE}; + #\u{314BF}; + #\u{314C0}; + #\u{314C1}; + #\u{314C2}; + #\u{314C3}; + #\u{314C4}; + #\u{314C5}; + #\u{314C6}; + #\u{314C7}; + #\u{314C8}; + #\u{314C9}; + #\u{314CA}; + #\u{314CB}; + #\u{314CC}; + #\u{314CD}; + #\u{314CE}; + #\u{314CF}; + #\u{314D0}; + #\u{314D1}; + #\u{314D2}; + #\u{314D3}; + #\u{314D4}; + #\u{314D5}; + #\u{314D6}; + #\u{314D7}; + #\u{314D8}; + #\u{314D9}; + #\u{314DA}; + #\u{314DB}; + #\u{314DC}; + #\u{314DD}; + #\u{314DE}; + #\u{314DF}; + #\u{314E0}; + #\u{314E1}; + #\u{314E2}; + #\u{314E3}; + #\u{314E4}; + #\u{314E5}; + #\u{314E6}; + #\u{314E7}; + #\u{314E8}; + #\u{314E9}; + #\u{314EA}; + #\u{314EB}; + #\u{314EC}; + #\u{314ED}; + #\u{314EE}; + #\u{314EF}; + #\u{314F0}; + #\u{314F1}; + #\u{314F2}; + #\u{314F3}; + #\u{314F4}; + #\u{314F5}; + #\u{314F6}; + #\u{314F7}; + #\u{314F8}; + #\u{314F9}; + #\u{314FA}; + #\u{314FB}; + #\u{314FC}; + #\u{314FD}; + #\u{314FE}; + #\u{314FF}; + #\u{31500}; + #\u{31501}; + #\u{31502}; + #\u{31503}; + #\u{31504}; + #\u{31505}; + #\u{31506}; + #\u{31507}; + #\u{31508}; + #\u{31509}; + #\u{3150A}; + #\u{3150B}; + #\u{3150C}; + #\u{3150D}; + #\u{3150E}; + #\u{3150F}; + #\u{31510}; + #\u{31511}; + #\u{31512}; + #\u{31513}; + #\u{31514}; + #\u{31515}; + #\u{31516}; + #\u{31517}; + #\u{31518}; + #\u{31519}; + #\u{3151A}; + #\u{3151B}; + #\u{3151C}; + #\u{3151D}; + #\u{3151E}; + #\u{3151F}; + #\u{31520}; + #\u{31521}; + #\u{31522}; + #\u{31523}; + #\u{31524}; + #\u{31525}; + #\u{31526}; + #\u{31527}; + #\u{31528}; + #\u{31529}; + #\u{3152A}; + #\u{3152B}; + #\u{3152C}; + #\u{3152D}; + #\u{3152E}; + #\u{3152F}; + #\u{31530}; + #\u{31531}; + #\u{31532}; + #\u{31533}; + #\u{31534}; + #\u{31535}; + #\u{31536}; + #\u{31537}; + #\u{31538}; + #\u{31539}; + #\u{3153A}; + #\u{3153B}; + #\u{3153C}; + #\u{3153D}; + #\u{3153E}; + #\u{3153F}; + #\u{31540}; + #\u{31541}; + #\u{31542}; + #\u{31543}; + #\u{31544}; + #\u{31545}; + #\u{31546}; + #\u{31547}; + #\u{31548}; + #\u{31549}; + #\u{3154A}; + #\u{3154B}; + #\u{3154C}; + #\u{3154D}; + #\u{3154E}; + #\u{3154F}; + #\u{31550}; + #\u{31551}; + #\u{31552}; + #\u{31553}; + #\u{31554}; + #\u{31555}; + #\u{31556}; + #\u{31557}; + #\u{31558}; + #\u{31559}; + #\u{3155A}; + #\u{3155B}; + #\u{3155C}; + #\u{3155D}; + #\u{3155E}; + #\u{3155F}; + #\u{31560}; + #\u{31561}; + #\u{31562}; + #\u{31563}; + #\u{31564}; + #\u{31565}; + #\u{31566}; + #\u{31567}; + #\u{31568}; + #\u{31569}; + #\u{3156A}; + #\u{3156B}; + #\u{3156C}; + #\u{3156D}; + #\u{3156E}; + #\u{3156F}; + #\u{31570}; + #\u{31571}; + #\u{31572}; + #\u{31573}; + #\u{31574}; + #\u{31575}; + #\u{31576}; + #\u{31577}; + #\u{31578}; + #\u{31579}; + #\u{3157A}; + #\u{3157B}; + #\u{3157C}; + #\u{3157D}; + #\u{3157E}; + #\u{3157F}; + #\u{31580}; + #\u{31581}; + #\u{31582}; + #\u{31583}; + #\u{31584}; + #\u{31585}; + #\u{31586}; + #\u{31587}; + #\u{31588}; + #\u{31589}; + #\u{3158A}; + #\u{3158B}; + #\u{3158C}; + #\u{3158D}; + #\u{3158E}; + #\u{3158F}; + #\u{31590}; + #\u{31591}; + #\u{31592}; + #\u{31593}; + #\u{31594}; + #\u{31595}; + #\u{31596}; + #\u{31597}; + #\u{31598}; + #\u{31599}; + #\u{3159A}; + #\u{3159B}; + #\u{3159C}; + #\u{3159D}; + #\u{3159E}; + #\u{3159F}; + #\u{315A0}; + #\u{315A1}; + #\u{315A2}; + #\u{315A3}; + #\u{315A4}; + #\u{315A5}; + #\u{315A6}; + #\u{315A7}; + #\u{315A8}; + #\u{315A9}; + #\u{315AA}; + #\u{315AB}; + #\u{315AC}; + #\u{315AD}; + #\u{315AE}; + #\u{315AF}; + #\u{315B0}; + #\u{315B1}; + #\u{315B2}; + #\u{315B3}; + #\u{315B4}; + #\u{315B5}; + #\u{315B6}; + #\u{315B7}; + #\u{315B8}; + #\u{315B9}; + #\u{315BA}; + #\u{315BB}; + #\u{315BC}; + #\u{315BD}; + #\u{315BE}; + #\u{315BF}; + #\u{315C0}; + #\u{315C1}; + #\u{315C2}; + #\u{315C3}; + #\u{315C4}; + #\u{315C5}; + #\u{315C6}; + #\u{315C7}; + #\u{315C8}; + #\u{315C9}; + #\u{315CA}; + #\u{315CB}; + #\u{315CC}; + #\u{315CD}; + #\u{315CE}; + #\u{315CF}; + #\u{315D0}; + #\u{315D1}; + #\u{315D2}; + #\u{315D3}; + #\u{315D4}; + #\u{315D5}; + #\u{315D6}; + #\u{315D7}; + #\u{315D8}; + #\u{315D9}; + #\u{315DA}; + #\u{315DB}; + #\u{315DC}; + #\u{315DD}; + #\u{315DE}; + #\u{315DF}; + #\u{315E0}; + #\u{315E1}; + #\u{315E2}; + #\u{315E3}; + #\u{315E4}; + #\u{315E5}; + #\u{315E6}; + #\u{315E7}; + #\u{315E8}; + #\u{315E9}; + #\u{315EA}; + #\u{315EB}; + #\u{315EC}; + #\u{315ED}; + #\u{315EE}; + #\u{315EF}; + #\u{315F0}; + #\u{315F1}; + #\u{315F2}; + #\u{315F3}; + #\u{315F4}; + #\u{315F5}; + #\u{315F6}; + #\u{315F7}; + #\u{315F8}; + #\u{315F9}; + #\u{315FA}; + #\u{315FB}; + #\u{315FC}; + #\u{315FD}; + #\u{315FE}; + #\u{315FF}; + #\u{31600}; + #\u{31601}; + #\u{31602}; + #\u{31603}; + #\u{31604}; + #\u{31605}; + #\u{31606}; + #\u{31607}; + #\u{31608}; + #\u{31609}; + #\u{3160A}; + #\u{3160B}; + #\u{3160C}; + #\u{3160D}; + #\u{3160E}; + #\u{3160F}; + #\u{31610}; + #\u{31611}; + #\u{31612}; + #\u{31613}; + #\u{31614}; + #\u{31615}; + #\u{31616}; + #\u{31617}; + #\u{31618}; + #\u{31619}; + #\u{3161A}; + #\u{3161B}; + #\u{3161C}; + #\u{3161D}; + #\u{3161E}; + #\u{3161F}; + #\u{31620}; + #\u{31621}; + #\u{31622}; + #\u{31623}; + #\u{31624}; + #\u{31625}; + #\u{31626}; + #\u{31627}; + #\u{31628}; + #\u{31629}; + #\u{3162A}; + #\u{3162B}; + #\u{3162C}; + #\u{3162D}; + #\u{3162E}; + #\u{3162F}; + #\u{31630}; + #\u{31631}; + #\u{31632}; + #\u{31633}; + #\u{31634}; + #\u{31635}; + #\u{31636}; + #\u{31637}; + #\u{31638}; + #\u{31639}; + #\u{3163A}; + #\u{3163B}; + #\u{3163C}; + #\u{3163D}; + #\u{3163E}; + #\u{3163F}; + #\u{31640}; + #\u{31641}; + #\u{31642}; + #\u{31643}; + #\u{31644}; + #\u{31645}; + #\u{31646}; + #\u{31647}; + #\u{31648}; + #\u{31649}; + #\u{3164A}; + #\u{3164B}; + #\u{3164C}; + #\u{3164D}; + #\u{3164E}; + #\u{3164F}; + #\u{31650}; + #\u{31651}; + #\u{31652}; + #\u{31653}; + #\u{31654}; + #\u{31655}; + #\u{31656}; + #\u{31657}; + #\u{31658}; + #\u{31659}; + #\u{3165A}; + #\u{3165B}; + #\u{3165C}; + #\u{3165D}; + #\u{3165E}; + #\u{3165F}; + #\u{31660}; + #\u{31661}; + #\u{31662}; + #\u{31663}; + #\u{31664}; + #\u{31665}; + #\u{31666}; + #\u{31667}; + #\u{31668}; + #\u{31669}; + #\u{3166A}; + #\u{3166B}; + #\u{3166C}; + #\u{3166D}; + #\u{3166E}; + #\u{3166F}; + #\u{31670}; + #\u{31671}; + #\u{31672}; + #\u{31673}; + #\u{31674}; + #\u{31675}; + #\u{31676}; + #\u{31677}; + #\u{31678}; + #\u{31679}; + #\u{3167A}; + #\u{3167B}; + #\u{3167C}; + #\u{3167D}; + #\u{3167E}; + #\u{3167F}; + #\u{31680}; + #\u{31681}; + #\u{31682}; + #\u{31683}; + #\u{31684}; + #\u{31685}; + #\u{31686}; + #\u{31687}; + #\u{31688}; + #\u{31689}; + #\u{3168A}; + #\u{3168B}; + #\u{3168C}; + #\u{3168D}; + #\u{3168E}; + #\u{3168F}; + #\u{31690}; + #\u{31691}; + #\u{31692}; + #\u{31693}; + #\u{31694}; + #\u{31695}; + #\u{31696}; + #\u{31697}; + #\u{31698}; + #\u{31699}; + #\u{3169A}; + #\u{3169B}; + #\u{3169C}; + #\u{3169D}; + #\u{3169E}; + #\u{3169F}; + #\u{316A0}; + #\u{316A1}; + #\u{316A2}; + #\u{316A3}; + #\u{316A4}; + #\u{316A5}; + #\u{316A6}; + #\u{316A7}; + #\u{316A8}; + #\u{316A9}; + #\u{316AA}; + #\u{316AB}; + #\u{316AC}; + #\u{316AD}; + #\u{316AE}; + #\u{316AF}; + #\u{316B0}; + #\u{316B1}; + #\u{316B2}; + #\u{316B3}; + #\u{316B4}; + #\u{316B5}; + #\u{316B6}; + #\u{316B7}; + #\u{316B8}; + #\u{316B9}; + #\u{316BA}; + #\u{316BB}; + #\u{316BC}; + #\u{316BD}; + #\u{316BE}; + #\u{316BF}; + #\u{316C0}; + #\u{316C1}; + #\u{316C2}; + #\u{316C3}; + #\u{316C4}; + #\u{316C5}; + #\u{316C6}; + #\u{316C7}; + #\u{316C8}; + #\u{316C9}; + #\u{316CA}; + #\u{316CB}; + #\u{316CC}; + #\u{316CD}; + #\u{316CE}; + #\u{316CF}; + #\u{316D0}; + #\u{316D1}; + #\u{316D2}; + #\u{316D3}; + #\u{316D4}; + #\u{316D5}; + #\u{316D6}; + #\u{316D7}; + #\u{316D8}; + #\u{316D9}; + #\u{316DA}; + #\u{316DB}; + #\u{316DC}; + #\u{316DD}; + #\u{316DE}; + #\u{316DF}; + #\u{316E0}; + #\u{316E1}; + #\u{316E2}; + #\u{316E3}; + #\u{316E4}; + #\u{316E5}; + #\u{316E6}; + #\u{316E7}; + #\u{316E8}; + #\u{316E9}; + #\u{316EA}; + #\u{316EB}; + #\u{316EC}; + #\u{316ED}; + #\u{316EE}; + #\u{316EF}; + #\u{316F0}; + #\u{316F1}; + #\u{316F2}; + #\u{316F3}; + #\u{316F4}; + #\u{316F5}; + #\u{316F6}; + #\u{316F7}; + #\u{316F8}; + #\u{316F9}; + #\u{316FA}; + #\u{316FB}; + #\u{316FC}; + #\u{316FD}; + #\u{316FE}; + #\u{316FF}; + #\u{31700}; + #\u{31701}; + #\u{31702}; + #\u{31703}; + #\u{31704}; + #\u{31705}; + #\u{31706}; + #\u{31707}; + #\u{31708}; + #\u{31709}; + #\u{3170A}; + #\u{3170B}; + #\u{3170C}; + #\u{3170D}; + #\u{3170E}; + #\u{3170F}; + #\u{31710}; + #\u{31711}; + #\u{31712}; + #\u{31713}; + #\u{31714}; + #\u{31715}; + #\u{31716}; + #\u{31717}; + #\u{31718}; + #\u{31719}; + #\u{3171A}; + #\u{3171B}; + #\u{3171C}; + #\u{3171D}; + #\u{3171E}; + #\u{3171F}; + #\u{31720}; + #\u{31721}; + #\u{31722}; + #\u{31723}; + #\u{31724}; + #\u{31725}; + #\u{31726}; + #\u{31727}; + #\u{31728}; + #\u{31729}; + #\u{3172A}; + #\u{3172B}; + #\u{3172C}; + #\u{3172D}; + #\u{3172E}; + #\u{3172F}; + #\u{31730}; + #\u{31731}; + #\u{31732}; + #\u{31733}; + #\u{31734}; + #\u{31735}; + #\u{31736}; + #\u{31737}; + #\u{31738}; + #\u{31739}; + #\u{3173A}; + #\u{3173B}; + #\u{3173C}; + #\u{3173D}; + #\u{3173E}; + #\u{3173F}; + #\u{31740}; + #\u{31741}; + #\u{31742}; + #\u{31743}; + #\u{31744}; + #\u{31745}; + #\u{31746}; + #\u{31747}; + #\u{31748}; + #\u{31749}; + #\u{3174A}; + #\u{3174B}; + #\u{3174C}; + #\u{3174D}; + #\u{3174E}; + #\u{3174F}; + #\u{31750}; + #\u{31751}; + #\u{31752}; + #\u{31753}; + #\u{31754}; + #\u{31755}; + #\u{31756}; + #\u{31757}; + #\u{31758}; + #\u{31759}; + #\u{3175A}; + #\u{3175B}; + #\u{3175C}; + #\u{3175D}; + #\u{3175E}; + #\u{3175F}; + #\u{31760}; + #\u{31761}; + #\u{31762}; + #\u{31763}; + #\u{31764}; + #\u{31765}; + #\u{31766}; + #\u{31767}; + #\u{31768}; + #\u{31769}; + #\u{3176A}; + #\u{3176B}; + #\u{3176C}; + #\u{3176D}; + #\u{3176E}; + #\u{3176F}; + #\u{31770}; + #\u{31771}; + #\u{31772}; + #\u{31773}; + #\u{31774}; + #\u{31775}; + #\u{31776}; + #\u{31777}; + #\u{31778}; + #\u{31779}; + #\u{3177A}; + #\u{3177B}; + #\u{3177C}; + #\u{3177D}; + #\u{3177E}; + #\u{3177F}; + #\u{31780}; + #\u{31781}; + #\u{31782}; + #\u{31783}; + #\u{31784}; + #\u{31785}; + #\u{31786}; + #\u{31787}; + #\u{31788}; + #\u{31789}; + #\u{3178A}; + #\u{3178B}; + #\u{3178C}; + #\u{3178D}; + #\u{3178E}; + #\u{3178F}; + #\u{31790}; + #\u{31791}; + #\u{31792}; + #\u{31793}; + #\u{31794}; + #\u{31795}; + #\u{31796}; + #\u{31797}; + #\u{31798}; + #\u{31799}; + #\u{3179A}; + #\u{3179B}; + #\u{3179C}; + #\u{3179D}; + #\u{3179E}; + #\u{3179F}; + #\u{317A0}; + #\u{317A1}; + #\u{317A2}; + #\u{317A3}; + #\u{317A4}; + #\u{317A5}; + #\u{317A6}; + #\u{317A7}; + #\u{317A8}; + #\u{317A9}; + #\u{317AA}; + #\u{317AB}; + #\u{317AC}; + #\u{317AD}; + #\u{317AE}; + #\u{317AF}; + #\u{317B0}; + #\u{317B1}; + #\u{317B2}; + #\u{317B3}; + #\u{317B4}; + #\u{317B5}; + #\u{317B6}; + #\u{317B7}; + #\u{317B8}; + #\u{317B9}; + #\u{317BA}; + #\u{317BB}; + #\u{317BC}; + #\u{317BD}; + #\u{317BE}; + #\u{317BF}; + #\u{317C0}; + #\u{317C1}; + #\u{317C2}; + #\u{317C3}; + #\u{317C4}; + #\u{317C5}; + #\u{317C6}; + #\u{317C7}; + #\u{317C8}; + #\u{317C9}; + #\u{317CA}; + #\u{317CB}; + #\u{317CC}; + #\u{317CD}; + #\u{317CE}; + #\u{317CF}; + #\u{317D0}; + #\u{317D1}; + #\u{317D2}; + #\u{317D3}; + #\u{317D4}; + #\u{317D5}; + #\u{317D6}; + #\u{317D7}; + #\u{317D8}; + #\u{317D9}; + #\u{317DA}; + #\u{317DB}; + #\u{317DC}; + #\u{317DD}; + #\u{317DE}; + #\u{317DF}; + #\u{317E0}; + #\u{317E1}; + #\u{317E2}; + #\u{317E3}; + #\u{317E4}; + #\u{317E5}; + #\u{317E6}; + #\u{317E7}; + #\u{317E8}; + #\u{317E9}; + #\u{317EA}; + #\u{317EB}; + #\u{317EC}; + #\u{317ED}; + #\u{317EE}; + #\u{317EF}; + #\u{317F0}; + #\u{317F1}; + #\u{317F2}; + #\u{317F3}; + #\u{317F4}; + #\u{317F5}; + #\u{317F6}; + #\u{317F7}; + #\u{317F8}; + #\u{317F9}; + #\u{317FA}; + #\u{317FB}; + #\u{317FC}; + #\u{317FD}; + #\u{317FE}; + #\u{317FF}; + #\u{31800}; + #\u{31801}; + #\u{31802}; + #\u{31803}; + #\u{31804}; + #\u{31805}; + #\u{31806}; + #\u{31807}; + #\u{31808}; + #\u{31809}; + #\u{3180A}; + #\u{3180B}; + #\u{3180C}; + #\u{3180D}; + #\u{3180E}; + #\u{3180F}; + #\u{31810}; + #\u{31811}; + #\u{31812}; + #\u{31813}; + #\u{31814}; + #\u{31815}; + #\u{31816}; + #\u{31817}; + #\u{31818}; + #\u{31819}; + #\u{3181A}; + #\u{3181B}; + #\u{3181C}; + #\u{3181D}; + #\u{3181E}; + #\u{3181F}; + #\u{31820}; + #\u{31821}; + #\u{31822}; + #\u{31823}; + #\u{31824}; + #\u{31825}; + #\u{31826}; + #\u{31827}; + #\u{31828}; + #\u{31829}; + #\u{3182A}; + #\u{3182B}; + #\u{3182C}; + #\u{3182D}; + #\u{3182E}; + #\u{3182F}; + #\u{31830}; + #\u{31831}; + #\u{31832}; + #\u{31833}; + #\u{31834}; + #\u{31835}; + #\u{31836}; + #\u{31837}; + #\u{31838}; + #\u{31839}; + #\u{3183A}; + #\u{3183B}; + #\u{3183C}; + #\u{3183D}; + #\u{3183E}; + #\u{3183F}; + #\u{31840}; + #\u{31841}; + #\u{31842}; + #\u{31843}; + #\u{31844}; + #\u{31845}; + #\u{31846}; + #\u{31847}; + #\u{31848}; + #\u{31849}; + #\u{3184A}; + #\u{3184B}; + #\u{3184C}; + #\u{3184D}; + #\u{3184E}; + #\u{3184F}; + #\u{31850}; + #\u{31851}; + #\u{31852}; + #\u{31853}; + #\u{31854}; + #\u{31855}; + #\u{31856}; + #\u{31857}; + #\u{31858}; + #\u{31859}; + #\u{3185A}; + #\u{3185B}; + #\u{3185C}; + #\u{3185D}; + #\u{3185E}; + #\u{3185F}; + #\u{31860}; + #\u{31861}; + #\u{31862}; + #\u{31863}; + #\u{31864}; + #\u{31865}; + #\u{31866}; + #\u{31867}; + #\u{31868}; + #\u{31869}; + #\u{3186A}; + #\u{3186B}; + #\u{3186C}; + #\u{3186D}; + #\u{3186E}; + #\u{3186F}; + #\u{31870}; + #\u{31871}; + #\u{31872}; + #\u{31873}; + #\u{31874}; + #\u{31875}; + #\u{31876}; + #\u{31877}; + #\u{31878}; + #\u{31879}; + #\u{3187A}; + #\u{3187B}; + #\u{3187C}; + #\u{3187D}; + #\u{3187E}; + #\u{3187F}; + #\u{31880}; + #\u{31881}; + #\u{31882}; + #\u{31883}; + #\u{31884}; + #\u{31885}; + #\u{31886}; + #\u{31887}; + #\u{31888}; + #\u{31889}; + #\u{3188A}; + #\u{3188B}; + #\u{3188C}; + #\u{3188D}; + #\u{3188E}; + #\u{3188F}; + #\u{31890}; + #\u{31891}; + #\u{31892}; + #\u{31893}; + #\u{31894}; + #\u{31895}; + #\u{31896}; + #\u{31897}; + #\u{31898}; + #\u{31899}; + #\u{3189A}; + #\u{3189B}; + #\u{3189C}; + #\u{3189D}; + #\u{3189E}; + #\u{3189F}; + #\u{318A0}; + #\u{318A1}; + #\u{318A2}; + #\u{318A3}; + #\u{318A4}; + #\u{318A5}; + #\u{318A6}; + #\u{318A7}; + #\u{318A8}; + #\u{318A9}; + #\u{318AA}; + #\u{318AB}; + #\u{318AC}; + #\u{318AD}; + #\u{318AE}; + #\u{318AF}; + #\u{318B0}; + #\u{318B1}; + #\u{318B2}; + #\u{318B3}; + #\u{318B4}; + #\u{318B5}; + #\u{318B6}; + #\u{318B7}; + #\u{318B8}; + #\u{318B9}; + #\u{318BA}; + #\u{318BB}; + #\u{318BC}; + #\u{318BD}; + #\u{318BE}; + #\u{318BF}; + #\u{318C0}; + #\u{318C1}; + #\u{318C2}; + #\u{318C3}; + #\u{318C4}; + #\u{318C5}; + #\u{318C6}; + #\u{318C7}; + #\u{318C8}; + #\u{318C9}; + #\u{318CA}; + #\u{318CB}; + #\u{318CC}; + #\u{318CD}; + #\u{318CE}; + #\u{318CF}; + #\u{318D0}; + #\u{318D1}; + #\u{318D2}; + #\u{318D3}; + #\u{318D4}; + #\u{318D5}; + #\u{318D6}; + #\u{318D7}; + #\u{318D8}; + #\u{318D9}; + #\u{318DA}; + #\u{318DB}; + #\u{318DC}; + #\u{318DD}; + #\u{318DE}; + #\u{318DF}; + #\u{318E0}; + #\u{318E1}; + #\u{318E2}; + #\u{318E3}; + #\u{318E4}; + #\u{318E5}; + #\u{318E6}; + #\u{318E7}; + #\u{318E8}; + #\u{318E9}; + #\u{318EA}; + #\u{318EB}; + #\u{318EC}; + #\u{318ED}; + #\u{318EE}; + #\u{318EF}; + #\u{318F0}; + #\u{318F1}; + #\u{318F2}; + #\u{318F3}; + #\u{318F4}; + #\u{318F5}; + #\u{318F6}; + #\u{318F7}; + #\u{318F8}; + #\u{318F9}; + #\u{318FA}; + #\u{318FB}; + #\u{318FC}; + #\u{318FD}; + #\u{318FE}; + #\u{318FF}; + #\u{31900}; + #\u{31901}; + #\u{31902}; + #\u{31903}; + #\u{31904}; + #\u{31905}; + #\u{31906}; + #\u{31907}; + #\u{31908}; + #\u{31909}; + #\u{3190A}; + #\u{3190B}; + #\u{3190C}; + #\u{3190D}; + #\u{3190E}; + #\u{3190F}; + #\u{31910}; + #\u{31911}; + #\u{31912}; + #\u{31913}; + #\u{31914}; + #\u{31915}; + #\u{31916}; + #\u{31917}; + #\u{31918}; + #\u{31919}; + #\u{3191A}; + #\u{3191B}; + #\u{3191C}; + #\u{3191D}; + #\u{3191E}; + #\u{3191F}; + #\u{31920}; + #\u{31921}; + #\u{31922}; + #\u{31923}; + #\u{31924}; + #\u{31925}; + #\u{31926}; + #\u{31927}; + #\u{31928}; + #\u{31929}; + #\u{3192A}; + #\u{3192B}; + #\u{3192C}; + #\u{3192D}; + #\u{3192E}; + #\u{3192F}; + #\u{31930}; + #\u{31931}; + #\u{31932}; + #\u{31933}; + #\u{31934}; + #\u{31935}; + #\u{31936}; + #\u{31937}; + #\u{31938}; + #\u{31939}; + #\u{3193A}; + #\u{3193B}; + #\u{3193C}; + #\u{3193D}; + #\u{3193E}; + #\u{3193F}; + #\u{31940}; + #\u{31941}; + #\u{31942}; + #\u{31943}; + #\u{31944}; + #\u{31945}; + #\u{31946}; + #\u{31947}; + #\u{31948}; + #\u{31949}; + #\u{3194A}; + #\u{3194B}; + #\u{3194C}; + #\u{3194D}; + #\u{3194E}; + #\u{3194F}; + #\u{31950}; + #\u{31951}; + #\u{31952}; + #\u{31953}; + #\u{31954}; + #\u{31955}; + #\u{31956}; + #\u{31957}; + #\u{31958}; + #\u{31959}; + #\u{3195A}; + #\u{3195B}; + #\u{3195C}; + #\u{3195D}; + #\u{3195E}; + #\u{3195F}; + #\u{31960}; + #\u{31961}; + #\u{31962}; + #\u{31963}; + #\u{31964}; + #\u{31965}; + #\u{31966}; + #\u{31967}; + #\u{31968}; + #\u{31969}; + #\u{3196A}; + #\u{3196B}; + #\u{3196C}; + #\u{3196D}; + #\u{3196E}; + #\u{3196F}; + #\u{31970}; + #\u{31971}; + #\u{31972}; + #\u{31973}; + #\u{31974}; + #\u{31975}; + #\u{31976}; + #\u{31977}; + #\u{31978}; + #\u{31979}; + #\u{3197A}; + #\u{3197B}; + #\u{3197C}; + #\u{3197D}; + #\u{3197E}; + #\u{3197F}; + #\u{31980}; + #\u{31981}; + #\u{31982}; + #\u{31983}; + #\u{31984}; + #\u{31985}; + #\u{31986}; + #\u{31987}; + #\u{31988}; + #\u{31989}; + #\u{3198A}; + #\u{3198B}; + #\u{3198C}; + #\u{3198D}; + #\u{3198E}; + #\u{3198F}; + #\u{31990}; + #\u{31991}; + #\u{31992}; + #\u{31993}; + #\u{31994}; + #\u{31995}; + #\u{31996}; + #\u{31997}; + #\u{31998}; + #\u{31999}; + #\u{3199A}; + #\u{3199B}; + #\u{3199C}; + #\u{3199D}; + #\u{3199E}; + #\u{3199F}; + #\u{319A0}; + #\u{319A1}; + #\u{319A2}; + #\u{319A3}; + #\u{319A4}; + #\u{319A5}; + #\u{319A6}; + #\u{319A7}; + #\u{319A8}; + #\u{319A9}; + #\u{319AA}; + #\u{319AB}; + #\u{319AC}; + #\u{319AD}; + #\u{319AE}; + #\u{319AF}; + #\u{319B0}; + #\u{319B1}; + #\u{319B2}; + #\u{319B3}; + #\u{319B4}; + #\u{319B5}; + #\u{319B6}; + #\u{319B7}; + #\u{319B8}; + #\u{319B9}; + #\u{319BA}; + #\u{319BB}; + #\u{319BC}; + #\u{319BD}; + #\u{319BE}; + #\u{319BF}; + #\u{319C0}; + #\u{319C1}; + #\u{319C2}; + #\u{319C3}; + #\u{319C4}; + #\u{319C5}; + #\u{319C6}; + #\u{319C7}; + #\u{319C8}; + #\u{319C9}; + #\u{319CA}; + #\u{319CB}; + #\u{319CC}; + #\u{319CD}; + #\u{319CE}; + #\u{319CF}; + #\u{319D0}; + #\u{319D1}; + #\u{319D2}; + #\u{319D3}; + #\u{319D4}; + #\u{319D5}; + #\u{319D6}; + #\u{319D7}; + #\u{319D8}; + #\u{319D9}; + #\u{319DA}; + #\u{319DB}; + #\u{319DC}; + #\u{319DD}; + #\u{319DE}; + #\u{319DF}; + #\u{319E0}; + #\u{319E1}; + #\u{319E2}; + #\u{319E3}; + #\u{319E4}; + #\u{319E5}; + #\u{319E6}; + #\u{319E7}; + #\u{319E8}; + #\u{319E9}; + #\u{319EA}; + #\u{319EB}; + #\u{319EC}; + #\u{319ED}; + #\u{319EE}; + #\u{319EF}; + #\u{319F0}; + #\u{319F1}; + #\u{319F2}; + #\u{319F3}; + #\u{319F4}; + #\u{319F5}; + #\u{319F6}; + #\u{319F7}; + #\u{319F8}; + #\u{319F9}; + #\u{319FA}; + #\u{319FB}; + #\u{319FC}; + #\u{319FD}; + #\u{319FE}; + #\u{319FF}; + #\u{31A00}; + #\u{31A01}; + #\u{31A02}; + #\u{31A03}; + #\u{31A04}; + #\u{31A05}; + #\u{31A06}; + #\u{31A07}; + #\u{31A08}; + #\u{31A09}; + #\u{31A0A}; + #\u{31A0B}; + #\u{31A0C}; + #\u{31A0D}; + #\u{31A0E}; + #\u{31A0F}; + #\u{31A10}; + #\u{31A11}; + #\u{31A12}; + #\u{31A13}; + #\u{31A14}; + #\u{31A15}; + #\u{31A16}; + #\u{31A17}; + #\u{31A18}; + #\u{31A19}; + #\u{31A1A}; + #\u{31A1B}; + #\u{31A1C}; + #\u{31A1D}; + #\u{31A1E}; + #\u{31A1F}; + #\u{31A20}; + #\u{31A21}; + #\u{31A22}; + #\u{31A23}; + #\u{31A24}; + #\u{31A25}; + #\u{31A26}; + #\u{31A27}; + #\u{31A28}; + #\u{31A29}; + #\u{31A2A}; + #\u{31A2B}; + #\u{31A2C}; + #\u{31A2D}; + #\u{31A2E}; + #\u{31A2F}; + #\u{31A30}; + #\u{31A31}; + #\u{31A32}; + #\u{31A33}; + #\u{31A34}; + #\u{31A35}; + #\u{31A36}; + #\u{31A37}; + #\u{31A38}; + #\u{31A39}; + #\u{31A3A}; + #\u{31A3B}; + #\u{31A3C}; + #\u{31A3D}; + #\u{31A3E}; + #\u{31A3F}; + #\u{31A40}; + #\u{31A41}; + #\u{31A42}; + #\u{31A43}; + #\u{31A44}; + #\u{31A45}; + #\u{31A46}; + #\u{31A47}; + #\u{31A48}; + #\u{31A49}; + #\u{31A4A}; + #\u{31A4B}; + #\u{31A4C}; + #\u{31A4D}; + #\u{31A4E}; + #\u{31A4F}; + #\u{31A50}; + #\u{31A51}; + #\u{31A52}; + #\u{31A53}; + #\u{31A54}; + #\u{31A55}; + #\u{31A56}; + #\u{31A57}; + #\u{31A58}; + #\u{31A59}; + #\u{31A5A}; + #\u{31A5B}; + #\u{31A5C}; + #\u{31A5D}; + #\u{31A5E}; + #\u{31A5F}; + #\u{31A60}; + #\u{31A61}; + #\u{31A62}; + #\u{31A63}; + #\u{31A64}; + #\u{31A65}; + #\u{31A66}; + #\u{31A67}; + #\u{31A68}; + #\u{31A69}; + #\u{31A6A}; + #\u{31A6B}; + #\u{31A6C}; + #\u{31A6D}; + #\u{31A6E}; + #\u{31A6F}; + #\u{31A70}; + #\u{31A71}; + #\u{31A72}; + #\u{31A73}; + #\u{31A74}; + #\u{31A75}; + #\u{31A76}; + #\u{31A77}; + #\u{31A78}; + #\u{31A79}; + #\u{31A7A}; + #\u{31A7B}; + #\u{31A7C}; + #\u{31A7D}; + #\u{31A7E}; + #\u{31A7F}; + #\u{31A80}; + #\u{31A81}; + #\u{31A82}; + #\u{31A83}; + #\u{31A84}; + #\u{31A85}; + #\u{31A86}; + #\u{31A87}; + #\u{31A88}; + #\u{31A89}; + #\u{31A8A}; + #\u{31A8B}; + #\u{31A8C}; + #\u{31A8D}; + #\u{31A8E}; + #\u{31A8F}; + #\u{31A90}; + #\u{31A91}; + #\u{31A92}; + #\u{31A93}; + #\u{31A94}; + #\u{31A95}; + #\u{31A96}; + #\u{31A97}; + #\u{31A98}; + #\u{31A99}; + #\u{31A9A}; + #\u{31A9B}; + #\u{31A9C}; + #\u{31A9D}; + #\u{31A9E}; + #\u{31A9F}; + #\u{31AA0}; + #\u{31AA1}; + #\u{31AA2}; + #\u{31AA3}; + #\u{31AA4}; + #\u{31AA5}; + #\u{31AA6}; + #\u{31AA7}; + #\u{31AA8}; + #\u{31AA9}; + #\u{31AAA}; + #\u{31AAB}; + #\u{31AAC}; + #\u{31AAD}; + #\u{31AAE}; + #\u{31AAF}; + #\u{31AB0}; + #\u{31AB1}; + #\u{31AB2}; + #\u{31AB3}; + #\u{31AB4}; + #\u{31AB5}; + #\u{31AB6}; + #\u{31AB7}; + #\u{31AB8}; + #\u{31AB9}; + #\u{31ABA}; + #\u{31ABB}; + #\u{31ABC}; + #\u{31ABD}; + #\u{31ABE}; + #\u{31ABF}; + #\u{31AC0}; + #\u{31AC1}; + #\u{31AC2}; + #\u{31AC3}; + #\u{31AC4}; + #\u{31AC5}; + #\u{31AC6}; + #\u{31AC7}; + #\u{31AC8}; + #\u{31AC9}; + #\u{31ACA}; + #\u{31ACB}; + #\u{31ACC}; + #\u{31ACD}; + #\u{31ACE}; + #\u{31ACF}; + #\u{31AD0}; + #\u{31AD1}; + #\u{31AD2}; + #\u{31AD3}; + #\u{31AD4}; + #\u{31AD5}; + #\u{31AD6}; + #\u{31AD7}; + #\u{31AD8}; + #\u{31AD9}; + #\u{31ADA}; + #\u{31ADB}; + #\u{31ADC}; + #\u{31ADD}; + #\u{31ADE}; + #\u{31ADF}; + #\u{31AE0}; + #\u{31AE1}; + #\u{31AE2}; + #\u{31AE3}; + #\u{31AE4}; + #\u{31AE5}; + #\u{31AE6}; + #\u{31AE7}; + #\u{31AE8}; + #\u{31AE9}; + #\u{31AEA}; + #\u{31AEB}; + #\u{31AEC}; + #\u{31AED}; + #\u{31AEE}; + #\u{31AEF}; + #\u{31AF0}; + #\u{31AF1}; + #\u{31AF2}; + #\u{31AF3}; + #\u{31AF4}; + #\u{31AF5}; + #\u{31AF6}; + #\u{31AF7}; + #\u{31AF8}; + #\u{31AF9}; + #\u{31AFA}; + #\u{31AFB}; + #\u{31AFC}; + #\u{31AFD}; + #\u{31AFE}; + #\u{31AFF}; + #\u{31B00}; + #\u{31B01}; + #\u{31B02}; + #\u{31B03}; + #\u{31B04}; + #\u{31B05}; + #\u{31B06}; + #\u{31B07}; + #\u{31B08}; + #\u{31B09}; + #\u{31B0A}; + #\u{31B0B}; + #\u{31B0C}; + #\u{31B0D}; + #\u{31B0E}; + #\u{31B0F}; + #\u{31B10}; + #\u{31B11}; + #\u{31B12}; + #\u{31B13}; + #\u{31B14}; + #\u{31B15}; + #\u{31B16}; + #\u{31B17}; + #\u{31B18}; + #\u{31B19}; + #\u{31B1A}; + #\u{31B1B}; + #\u{31B1C}; + #\u{31B1D}; + #\u{31B1E}; + #\u{31B1F}; + #\u{31B20}; + #\u{31B21}; + #\u{31B22}; + #\u{31B23}; + #\u{31B24}; + #\u{31B25}; + #\u{31B26}; + #\u{31B27}; + #\u{31B28}; + #\u{31B29}; + #\u{31B2A}; + #\u{31B2B}; + #\u{31B2C}; + #\u{31B2D}; + #\u{31B2E}; + #\u{31B2F}; + #\u{31B30}; + #\u{31B31}; + #\u{31B32}; + #\u{31B33}; + #\u{31B34}; + #\u{31B35}; + #\u{31B36}; + #\u{31B37}; + #\u{31B38}; + #\u{31B39}; + #\u{31B3A}; + #\u{31B3B}; + #\u{31B3C}; + #\u{31B3D}; + #\u{31B3E}; + #\u{31B3F}; + #\u{31B40}; + #\u{31B41}; + #\u{31B42}; + #\u{31B43}; + #\u{31B44}; + #\u{31B45}; + #\u{31B46}; + #\u{31B47}; + #\u{31B48}; + #\u{31B49}; + #\u{31B4A}; + #\u{31B4B}; + #\u{31B4C}; + #\u{31B4D}; + #\u{31B4E}; + #\u{31B4F}; + #\u{31B50}; + #\u{31B51}; + #\u{31B52}; + #\u{31B53}; + #\u{31B54}; + #\u{31B55}; + #\u{31B56}; + #\u{31B57}; + #\u{31B58}; + #\u{31B59}; + #\u{31B5A}; + #\u{31B5B}; + #\u{31B5C}; + #\u{31B5D}; + #\u{31B5E}; + #\u{31B5F}; + #\u{31B60}; + #\u{31B61}; + #\u{31B62}; + #\u{31B63}; + #\u{31B64}; + #\u{31B65}; + #\u{31B66}; + #\u{31B67}; + #\u{31B68}; + #\u{31B69}; + #\u{31B6A}; + #\u{31B6B}; + #\u{31B6C}; + #\u{31B6D}; + #\u{31B6E}; + #\u{31B6F}; + #\u{31B70}; + #\u{31B71}; + #\u{31B72}; + #\u{31B73}; + #\u{31B74}; + #\u{31B75}; + #\u{31B76}; + #\u{31B77}; + #\u{31B78}; + #\u{31B79}; + #\u{31B7A}; + #\u{31B7B}; + #\u{31B7C}; + #\u{31B7D}; + #\u{31B7E}; + #\u{31B7F}; + #\u{31B80}; + #\u{31B81}; + #\u{31B82}; + #\u{31B83}; + #\u{31B84}; + #\u{31B85}; + #\u{31B86}; + #\u{31B87}; + #\u{31B88}; + #\u{31B89}; + #\u{31B8A}; + #\u{31B8B}; + #\u{31B8C}; + #\u{31B8D}; + #\u{31B8E}; + #\u{31B8F}; + #\u{31B90}; + #\u{31B91}; + #\u{31B92}; + #\u{31B93}; + #\u{31B94}; + #\u{31B95}; + #\u{31B96}; + #\u{31B97}; + #\u{31B98}; + #\u{31B99}; + #\u{31B9A}; + #\u{31B9B}; + #\u{31B9C}; + #\u{31B9D}; + #\u{31B9E}; + #\u{31B9F}; + #\u{31BA0}; + #\u{31BA1}; + #\u{31BA2}; + #\u{31BA3}; + #\u{31BA4}; + #\u{31BA5}; + #\u{31BA6}; + #\u{31BA7}; + #\u{31BA8}; + #\u{31BA9}; + #\u{31BAA}; + #\u{31BAB}; + #\u{31BAC}; + #\u{31BAD}; + #\u{31BAE}; + #\u{31BAF}; + #\u{31BB0}; + #\u{31BB1}; + #\u{31BB2}; + #\u{31BB3}; + #\u{31BB4}; + #\u{31BB5}; + #\u{31BB6}; + #\u{31BB7}; + #\u{31BB8}; + #\u{31BB9}; + #\u{31BBA}; + #\u{31BBB}; + #\u{31BBC}; + #\u{31BBD}; + #\u{31BBE}; + #\u{31BBF}; + #\u{31BC0}; + #\u{31BC1}; + #\u{31BC2}; + #\u{31BC3}; + #\u{31BC4}; + #\u{31BC5}; + #\u{31BC6}; + #\u{31BC7}; + #\u{31BC8}; + #\u{31BC9}; + #\u{31BCA}; + #\u{31BCB}; + #\u{31BCC}; + #\u{31BCD}; + #\u{31BCE}; + #\u{31BCF}; + #\u{31BD0}; + #\u{31BD1}; + #\u{31BD2}; + #\u{31BD3}; + #\u{31BD4}; + #\u{31BD5}; + #\u{31BD6}; + #\u{31BD7}; + #\u{31BD8}; + #\u{31BD9}; + #\u{31BDA}; + #\u{31BDB}; + #\u{31BDC}; + #\u{31BDD}; + #\u{31BDE}; + #\u{31BDF}; + #\u{31BE0}; + #\u{31BE1}; + #\u{31BE2}; + #\u{31BE3}; + #\u{31BE4}; + #\u{31BE5}; + #\u{31BE6}; + #\u{31BE7}; + #\u{31BE8}; + #\u{31BE9}; + #\u{31BEA}; + #\u{31BEB}; + #\u{31BEC}; + #\u{31BED}; + #\u{31BEE}; + #\u{31BEF}; + #\u{31BF0}; + #\u{31BF1}; + #\u{31BF2}; + #\u{31BF3}; + #\u{31BF4}; + #\u{31BF5}; + #\u{31BF6}; + #\u{31BF7}; + #\u{31BF8}; + #\u{31BF9}; + #\u{31BFA}; + #\u{31BFB}; + #\u{31BFC}; + #\u{31BFD}; + #\u{31BFE}; + #\u{31BFF}; + #\u{31C00}; + #\u{31C01}; + #\u{31C02}; + #\u{31C03}; + #\u{31C04}; + #\u{31C05}; + #\u{31C06}; + #\u{31C07}; + #\u{31C08}; + #\u{31C09}; + #\u{31C0A}; + #\u{31C0B}; + #\u{31C0C}; + #\u{31C0D}; + #\u{31C0E}; + #\u{31C0F}; + #\u{31C10}; + #\u{31C11}; + #\u{31C12}; + #\u{31C13}; + #\u{31C14}; + #\u{31C15}; + #\u{31C16}; + #\u{31C17}; + #\u{31C18}; + #\u{31C19}; + #\u{31C1A}; + #\u{31C1B}; + #\u{31C1C}; + #\u{31C1D}; + #\u{31C1E}; + #\u{31C1F}; + #\u{31C20}; + #\u{31C21}; + #\u{31C22}; + #\u{31C23}; + #\u{31C24}; + #\u{31C25}; + #\u{31C26}; + #\u{31C27}; + #\u{31C28}; + #\u{31C29}; + #\u{31C2A}; + #\u{31C2B}; + #\u{31C2C}; + #\u{31C2D}; + #\u{31C2E}; + #\u{31C2F}; + #\u{31C30}; + #\u{31C31}; + #\u{31C32}; + #\u{31C33}; + #\u{31C34}; + #\u{31C35}; + #\u{31C36}; + #\u{31C37}; + #\u{31C38}; + #\u{31C39}; + #\u{31C3A}; + #\u{31C3B}; + #\u{31C3C}; + #\u{31C3D}; + #\u{31C3E}; + #\u{31C3F}; + #\u{31C40}; + #\u{31C41}; + #\u{31C42}; + #\u{31C43}; + #\u{31C44}; + #\u{31C45}; + #\u{31C46}; + #\u{31C47}; + #\u{31C48}; + #\u{31C49}; + #\u{31C4A}; + #\u{31C4B}; + #\u{31C4C}; + #\u{31C4D}; + #\u{31C4E}; + #\u{31C4F}; + #\u{31C50}; + #\u{31C51}; + #\u{31C52}; + #\u{31C53}; + #\u{31C54}; + #\u{31C55}; + #\u{31C56}; + #\u{31C57}; + #\u{31C58}; + #\u{31C59}; + #\u{31C5A}; + #\u{31C5B}; + #\u{31C5C}; + #\u{31C5D}; + #\u{31C5E}; + #\u{31C5F}; + #\u{31C60}; + #\u{31C61}; + #\u{31C62}; + #\u{31C63}; + #\u{31C64}; + #\u{31C65}; + #\u{31C66}; + #\u{31C67}; + #\u{31C68}; + #\u{31C69}; + #\u{31C6A}; + #\u{31C6B}; + #\u{31C6C}; + #\u{31C6D}; + #\u{31C6E}; + #\u{31C6F}; + #\u{31C70}; + #\u{31C71}; + #\u{31C72}; + #\u{31C73}; + #\u{31C74}; + #\u{31C75}; + #\u{31C76}; + #\u{31C77}; + #\u{31C78}; + #\u{31C79}; + #\u{31C7A}; + #\u{31C7B}; + #\u{31C7C}; + #\u{31C7D}; + #\u{31C7E}; + #\u{31C7F}; + #\u{31C80}; + #\u{31C81}; + #\u{31C82}; + #\u{31C83}; + #\u{31C84}; + #\u{31C85}; + #\u{31C86}; + #\u{31C87}; + #\u{31C88}; + #\u{31C89}; + #\u{31C8A}; + #\u{31C8B}; + #\u{31C8C}; + #\u{31C8D}; + #\u{31C8E}; + #\u{31C8F}; + #\u{31C90}; + #\u{31C91}; + #\u{31C92}; + #\u{31C93}; + #\u{31C94}; + #\u{31C95}; + #\u{31C96}; + #\u{31C97}; + #\u{31C98}; + #\u{31C99}; + #\u{31C9A}; + #\u{31C9B}; + #\u{31C9C}; + #\u{31C9D}; + #\u{31C9E}; + #\u{31C9F}; + #\u{31CA0}; + #\u{31CA1}; + #\u{31CA2}; + #\u{31CA3}; + #\u{31CA4}; + #\u{31CA5}; + #\u{31CA6}; + #\u{31CA7}; + #\u{31CA8}; + #\u{31CA9}; + #\u{31CAA}; + #\u{31CAB}; + #\u{31CAC}; + #\u{31CAD}; + #\u{31CAE}; + #\u{31CAF}; + #\u{31CB0}; + #\u{31CB1}; + #\u{31CB2}; + #\u{31CB3}; + #\u{31CB4}; + #\u{31CB5}; + #\u{31CB6}; + #\u{31CB7}; + #\u{31CB8}; + #\u{31CB9}; + #\u{31CBA}; + #\u{31CBB}; + #\u{31CBC}; + #\u{31CBD}; + #\u{31CBE}; + #\u{31CBF}; + #\u{31CC0}; + #\u{31CC1}; + #\u{31CC2}; + #\u{31CC3}; + #\u{31CC4}; + #\u{31CC5}; + #\u{31CC6}; + #\u{31CC7}; + #\u{31CC8}; + #\u{31CC9}; + #\u{31CCA}; + #\u{31CCB}; + #\u{31CCC}; + #\u{31CCD}; + #\u{31CCE}; + #\u{31CCF}; + #\u{31CD0}; + #\u{31CD1}; + #\u{31CD2}; + #\u{31CD3}; + #\u{31CD4}; + #\u{31CD5}; + #\u{31CD6}; + #\u{31CD7}; + #\u{31CD8}; + #\u{31CD9}; + #\u{31CDA}; + #\u{31CDB}; + #\u{31CDC}; + #\u{31CDD}; + #\u{31CDE}; + #\u{31CDF}; + #\u{31CE0}; + #\u{31CE1}; + #\u{31CE2}; + #\u{31CE3}; + #\u{31CE4}; + #\u{31CE5}; + #\u{31CE6}; + #\u{31CE7}; + #\u{31CE8}; + #\u{31CE9}; + #\u{31CEA}; + #\u{31CEB}; + #\u{31CEC}; + #\u{31CED}; + #\u{31CEE}; + #\u{31CEF}; + #\u{31CF0}; + #\u{31CF1}; + #\u{31CF2}; + #\u{31CF3}; + #\u{31CF4}; + #\u{31CF5}; + #\u{31CF6}; + #\u{31CF7}; + #\u{31CF8}; + #\u{31CF9}; + #\u{31CFA}; + #\u{31CFB}; + #\u{31CFC}; + #\u{31CFD}; + #\u{31CFE}; + #\u{31CFF}; + #\u{31D00}; + #\u{31D01}; + #\u{31D02}; + #\u{31D03}; + #\u{31D04}; + #\u{31D05}; + #\u{31D06}; + #\u{31D07}; + #\u{31D08}; + #\u{31D09}; + #\u{31D0A}; + #\u{31D0B}; + #\u{31D0C}; + #\u{31D0D}; + #\u{31D0E}; + #\u{31D0F}; + #\u{31D10}; + #\u{31D11}; + #\u{31D12}; + #\u{31D13}; + #\u{31D14}; + #\u{31D15}; + #\u{31D16}; + #\u{31D17}; + #\u{31D18}; + #\u{31D19}; + #\u{31D1A}; + #\u{31D1B}; + #\u{31D1C}; + #\u{31D1D}; + #\u{31D1E}; + #\u{31D1F}; + #\u{31D20}; + #\u{31D21}; + #\u{31D22}; + #\u{31D23}; + #\u{31D24}; + #\u{31D25}; + #\u{31D26}; + #\u{31D27}; + #\u{31D28}; + #\u{31D29}; + #\u{31D2A}; + #\u{31D2B}; + #\u{31D2C}; + #\u{31D2D}; + #\u{31D2E}; + #\u{31D2F}; + #\u{31D30}; + #\u{31D31}; + #\u{31D32}; + #\u{31D33}; + #\u{31D34}; + #\u{31D35}; + #\u{31D36}; + #\u{31D37}; + #\u{31D38}; + #\u{31D39}; + #\u{31D3A}; + #\u{31D3B}; + #\u{31D3C}; + #\u{31D3D}; + #\u{31D3E}; + #\u{31D3F}; + #\u{31D40}; + #\u{31D41}; + #\u{31D42}; + #\u{31D43}; + #\u{31D44}; + #\u{31D45}; + #\u{31D46}; + #\u{31D47}; + #\u{31D48}; + #\u{31D49}; + #\u{31D4A}; + #\u{31D4B}; + #\u{31D4C}; + #\u{31D4D}; + #\u{31D4E}; + #\u{31D4F}; + #\u{31D50}; + #\u{31D51}; + #\u{31D52}; + #\u{31D53}; + #\u{31D54}; + #\u{31D55}; + #\u{31D56}; + #\u{31D57}; + #\u{31D58}; + #\u{31D59}; + #\u{31D5A}; + #\u{31D5B}; + #\u{31D5C}; + #\u{31D5D}; + #\u{31D5E}; + #\u{31D5F}; + #\u{31D60}; + #\u{31D61}; + #\u{31D62}; + #\u{31D63}; + #\u{31D64}; + #\u{31D65}; + #\u{31D66}; + #\u{31D67}; + #\u{31D68}; + #\u{31D69}; + #\u{31D6A}; + #\u{31D6B}; + #\u{31D6C}; + #\u{31D6D}; + #\u{31D6E}; + #\u{31D6F}; + #\u{31D70}; + #\u{31D71}; + #\u{31D72}; + #\u{31D73}; + #\u{31D74}; + #\u{31D75}; + #\u{31D76}; + #\u{31D77}; + #\u{31D78}; + #\u{31D79}; + #\u{31D7A}; + #\u{31D7B}; + #\u{31D7C}; + #\u{31D7D}; + #\u{31D7E}; + #\u{31D7F}; + #\u{31D80}; + #\u{31D81}; + #\u{31D82}; + #\u{31D83}; + #\u{31D84}; + #\u{31D85}; + #\u{31D86}; + #\u{31D87}; + #\u{31D88}; + #\u{31D89}; + #\u{31D8A}; + #\u{31D8B}; + #\u{31D8C}; + #\u{31D8D}; + #\u{31D8E}; + #\u{31D8F}; + #\u{31D90}; + #\u{31D91}; + #\u{31D92}; + #\u{31D93}; + #\u{31D94}; + #\u{31D95}; + #\u{31D96}; + #\u{31D97}; + #\u{31D98}; + #\u{31D99}; + #\u{31D9A}; + #\u{31D9B}; + #\u{31D9C}; + #\u{31D9D}; + #\u{31D9E}; + #\u{31D9F}; + #\u{31DA0}; + #\u{31DA1}; + #\u{31DA2}; + #\u{31DA3}; + #\u{31DA4}; + #\u{31DA5}; + #\u{31DA6}; + #\u{31DA7}; + #\u{31DA8}; + #\u{31DA9}; + #\u{31DAA}; + #\u{31DAB}; + #\u{31DAC}; + #\u{31DAD}; + #\u{31DAE}; + #\u{31DAF}; + #\u{31DB0}; + #\u{31DB1}; + #\u{31DB2}; + #\u{31DB3}; + #\u{31DB4}; + #\u{31DB5}; + #\u{31DB6}; + #\u{31DB7}; + #\u{31DB8}; + #\u{31DB9}; + #\u{31DBA}; + #\u{31DBB}; + #\u{31DBC}; + #\u{31DBD}; + #\u{31DBE}; + #\u{31DBF}; + #\u{31DC0}; + #\u{31DC1}; + #\u{31DC2}; + #\u{31DC3}; + #\u{31DC4}; + #\u{31DC5}; + #\u{31DC6}; + #\u{31DC7}; + #\u{31DC8}; + #\u{31DC9}; + #\u{31DCA}; + #\u{31DCB}; + #\u{31DCC}; + #\u{31DCD}; + #\u{31DCE}; + #\u{31DCF}; + #\u{31DD0}; + #\u{31DD1}; + #\u{31DD2}; + #\u{31DD3}; + #\u{31DD4}; + #\u{31DD5}; + #\u{31DD6}; + #\u{31DD7}; + #\u{31DD8}; + #\u{31DD9}; + #\u{31DDA}; + #\u{31DDB}; + #\u{31DDC}; + #\u{31DDD}; + #\u{31DDE}; + #\u{31DDF}; + #\u{31DE0}; + #\u{31DE1}; + #\u{31DE2}; + #\u{31DE3}; + #\u{31DE4}; + #\u{31DE5}; + #\u{31DE6}; + #\u{31DE7}; + #\u{31DE8}; + #\u{31DE9}; + #\u{31DEA}; + #\u{31DEB}; + #\u{31DEC}; + #\u{31DED}; + #\u{31DEE}; + #\u{31DEF}; + #\u{31DF0}; + #\u{31DF1}; + #\u{31DF2}; + #\u{31DF3}; + #\u{31DF4}; + #\u{31DF5}; + #\u{31DF6}; + #\u{31DF7}; + #\u{31DF8}; + #\u{31DF9}; + #\u{31DFA}; + #\u{31DFB}; + #\u{31DFC}; + #\u{31DFD}; + #\u{31DFE}; + #\u{31DFF}; + #\u{31E00}; + #\u{31E01}; + #\u{31E02}; + #\u{31E03}; + #\u{31E04}; + #\u{31E05}; + #\u{31E06}; + #\u{31E07}; + #\u{31E08}; + #\u{31E09}; + #\u{31E0A}; + #\u{31E0B}; + #\u{31E0C}; + #\u{31E0D}; + #\u{31E0E}; + #\u{31E0F}; + #\u{31E10}; + #\u{31E11}; + #\u{31E12}; + #\u{31E13}; + #\u{31E14}; + #\u{31E15}; + #\u{31E16}; + #\u{31E17}; + #\u{31E18}; + #\u{31E19}; + #\u{31E1A}; + #\u{31E1B}; + #\u{31E1C}; + #\u{31E1D}; + #\u{31E1E}; + #\u{31E1F}; + #\u{31E20}; + #\u{31E21}; + #\u{31E22}; + #\u{31E23}; + #\u{31E24}; + #\u{31E25}; + #\u{31E26}; + #\u{31E27}; + #\u{31E28}; + #\u{31E29}; + #\u{31E2A}; + #\u{31E2B}; + #\u{31E2C}; + #\u{31E2D}; + #\u{31E2E}; + #\u{31E2F}; + #\u{31E30}; + #\u{31E31}; + #\u{31E32}; + #\u{31E33}; + #\u{31E34}; + #\u{31E35}; + #\u{31E36}; + #\u{31E37}; + #\u{31E38}; + #\u{31E39}; + #\u{31E3A}; + #\u{31E3B}; + #\u{31E3C}; + #\u{31E3D}; + #\u{31E3E}; + #\u{31E3F}; + #\u{31E40}; + #\u{31E41}; + #\u{31E42}; + #\u{31E43}; + #\u{31E44}; + #\u{31E45}; + #\u{31E46}; + #\u{31E47}; + #\u{31E48}; + #\u{31E49}; + #\u{31E4A}; + #\u{31E4B}; + #\u{31E4C}; + #\u{31E4D}; + #\u{31E4E}; + #\u{31E4F}; + #\u{31E50}; + #\u{31E51}; + #\u{31E52}; + #\u{31E53}; + #\u{31E54}; + #\u{31E55}; + #\u{31E56}; + #\u{31E57}; + #\u{31E58}; + #\u{31E59}; + #\u{31E5A}; + #\u{31E5B}; + #\u{31E5C}; + #\u{31E5D}; + #\u{31E5E}; + #\u{31E5F}; + #\u{31E60}; + #\u{31E61}; + #\u{31E62}; + #\u{31E63}; + #\u{31E64}; + #\u{31E65}; + #\u{31E66}; + #\u{31E67}; + #\u{31E68}; + #\u{31E69}; + #\u{31E6A}; + #\u{31E6B}; + #\u{31E6C}; + #\u{31E6D}; + #\u{31E6E}; + #\u{31E6F}; + #\u{31E70}; + #\u{31E71}; + #\u{31E72}; + #\u{31E73}; + #\u{31E74}; + #\u{31E75}; + #\u{31E76}; + #\u{31E77}; + #\u{31E78}; + #\u{31E79}; + #\u{31E7A}; + #\u{31E7B}; + #\u{31E7C}; + #\u{31E7D}; + #\u{31E7E}; + #\u{31E7F}; + #\u{31E80}; + #\u{31E81}; + #\u{31E82}; + #\u{31E83}; + #\u{31E84}; + #\u{31E85}; + #\u{31E86}; + #\u{31E87}; + #\u{31E88}; + #\u{31E89}; + #\u{31E8A}; + #\u{31E8B}; + #\u{31E8C}; + #\u{31E8D}; + #\u{31E8E}; + #\u{31E8F}; + #\u{31E90}; + #\u{31E91}; + #\u{31E92}; + #\u{31E93}; + #\u{31E94}; + #\u{31E95}; + #\u{31E96}; + #\u{31E97}; + #\u{31E98}; + #\u{31E99}; + #\u{31E9A}; + #\u{31E9B}; + #\u{31E9C}; + #\u{31E9D}; + #\u{31E9E}; + #\u{31E9F}; + #\u{31EA0}; + #\u{31EA1}; + #\u{31EA2}; + #\u{31EA3}; + #\u{31EA4}; + #\u{31EA5}; + #\u{31EA6}; + #\u{31EA7}; + #\u{31EA8}; + #\u{31EA9}; + #\u{31EAA}; + #\u{31EAB}; + #\u{31EAC}; + #\u{31EAD}; + #\u{31EAE}; + #\u{31EAF}; + #\u{31EB0}; + #\u{31EB1}; + #\u{31EB2}; + #\u{31EB3}; + #\u{31EB4}; + #\u{31EB5}; + #\u{31EB6}; + #\u{31EB7}; + #\u{31EB8}; + #\u{31EB9}; + #\u{31EBA}; + #\u{31EBB}; + #\u{31EBC}; + #\u{31EBD}; + #\u{31EBE}; + #\u{31EBF}; + #\u{31EC0}; + #\u{31EC1}; + #\u{31EC2}; + #\u{31EC3}; + #\u{31EC4}; + #\u{31EC5}; + #\u{31EC6}; + #\u{31EC7}; + #\u{31EC8}; + #\u{31EC9}; + #\u{31ECA}; + #\u{31ECB}; + #\u{31ECC}; + #\u{31ECD}; + #\u{31ECE}; + #\u{31ECF}; + #\u{31ED0}; + #\u{31ED1}; + #\u{31ED2}; + #\u{31ED3}; + #\u{31ED4}; + #\u{31ED5}; + #\u{31ED6}; + #\u{31ED7}; + #\u{31ED8}; + #\u{31ED9}; + #\u{31EDA}; + #\u{31EDB}; + #\u{31EDC}; + #\u{31EDD}; + #\u{31EDE}; + #\u{31EDF}; + #\u{31EE0}; + #\u{31EE1}; + #\u{31EE2}; + #\u{31EE3}; + #\u{31EE4}; + #\u{31EE5}; + #\u{31EE6}; + #\u{31EE7}; + #\u{31EE8}; + #\u{31EE9}; + #\u{31EEA}; + #\u{31EEB}; + #\u{31EEC}; + #\u{31EED}; + #\u{31EEE}; + #\u{31EEF}; + #\u{31EF0}; + #\u{31EF1}; + #\u{31EF2}; + #\u{31EF3}; + #\u{31EF4}; + #\u{31EF5}; + #\u{31EF6}; + #\u{31EF7}; + #\u{31EF8}; + #\u{31EF9}; + #\u{31EFA}; + #\u{31EFB}; + #\u{31EFC}; + #\u{31EFD}; + #\u{31EFE}; + #\u{31EFF}; + #\u{31F00}; + #\u{31F01}; + #\u{31F02}; + #\u{31F03}; + #\u{31F04}; + #\u{31F05}; + #\u{31F06}; + #\u{31F07}; + #\u{31F08}; + #\u{31F09}; + #\u{31F0A}; + #\u{31F0B}; + #\u{31F0C}; + #\u{31F0D}; + #\u{31F0E}; + #\u{31F0F}; + #\u{31F10}; + #\u{31F11}; + #\u{31F12}; + #\u{31F13}; + #\u{31F14}; + #\u{31F15}; + #\u{31F16}; + #\u{31F17}; + #\u{31F18}; + #\u{31F19}; + #\u{31F1A}; + #\u{31F1B}; + #\u{31F1C}; + #\u{31F1D}; + #\u{31F1E}; + #\u{31F1F}; + #\u{31F20}; + #\u{31F21}; + #\u{31F22}; + #\u{31F23}; + #\u{31F24}; + #\u{31F25}; + #\u{31F26}; + #\u{31F27}; + #\u{31F28}; + #\u{31F29}; + #\u{31F2A}; + #\u{31F2B}; + #\u{31F2C}; + #\u{31F2D}; + #\u{31F2E}; + #\u{31F2F}; + #\u{31F30}; + #\u{31F31}; + #\u{31F32}; + #\u{31F33}; + #\u{31F34}; + #\u{31F35}; + #\u{31F36}; + #\u{31F37}; + #\u{31F38}; + #\u{31F39}; + #\u{31F3A}; + #\u{31F3B}; + #\u{31F3C}; + #\u{31F3D}; + #\u{31F3E}; + #\u{31F3F}; + #\u{31F40}; + #\u{31F41}; + #\u{31F42}; + #\u{31F43}; + #\u{31F44}; + #\u{31F45}; + #\u{31F46}; + #\u{31F47}; + #\u{31F48}; + #\u{31F49}; + #\u{31F4A}; + #\u{31F4B}; + #\u{31F4C}; + #\u{31F4D}; + #\u{31F4E}; + #\u{31F4F}; + #\u{31F50}; + #\u{31F51}; + #\u{31F52}; + #\u{31F53}; + #\u{31F54}; + #\u{31F55}; + #\u{31F56}; + #\u{31F57}; + #\u{31F58}; + #\u{31F59}; + #\u{31F5A}; + #\u{31F5B}; + #\u{31F5C}; + #\u{31F5D}; + #\u{31F5E}; + #\u{31F5F}; + #\u{31F60}; + #\u{31F61}; + #\u{31F62}; + #\u{31F63}; + #\u{31F64}; + #\u{31F65}; + #\u{31F66}; + #\u{31F67}; + #\u{31F68}; + #\u{31F69}; + #\u{31F6A}; + #\u{31F6B}; + #\u{31F6C}; + #\u{31F6D}; + #\u{31F6E}; + #\u{31F6F}; + #\u{31F70}; + #\u{31F71}; + #\u{31F72}; + #\u{31F73}; + #\u{31F74}; + #\u{31F75}; + #\u{31F76}; + #\u{31F77}; + #\u{31F78}; + #\u{31F79}; + #\u{31F7A}; + #\u{31F7B}; + #\u{31F7C}; + #\u{31F7D}; + #\u{31F7E}; + #\u{31F7F}; + #\u{31F80}; + #\u{31F81}; + #\u{31F82}; + #\u{31F83}; + #\u{31F84}; + #\u{31F85}; + #\u{31F86}; + #\u{31F87}; + #\u{31F88}; + #\u{31F89}; + #\u{31F8A}; + #\u{31F8B}; + #\u{31F8C}; + #\u{31F8D}; + #\u{31F8E}; + #\u{31F8F}; + #\u{31F90}; + #\u{31F91}; + #\u{31F92}; + #\u{31F93}; + #\u{31F94}; + #\u{31F95}; + #\u{31F96}; + #\u{31F97}; + #\u{31F98}; + #\u{31F99}; + #\u{31F9A}; + #\u{31F9B}; + #\u{31F9C}; + #\u{31F9D}; + #\u{31F9E}; + #\u{31F9F}; + #\u{31FA0}; + #\u{31FA1}; + #\u{31FA2}; + #\u{31FA3}; + #\u{31FA4}; + #\u{31FA5}; + #\u{31FA6}; + #\u{31FA7}; + #\u{31FA8}; + #\u{31FA9}; + #\u{31FAA}; + #\u{31FAB}; + #\u{31FAC}; + #\u{31FAD}; + #\u{31FAE}; + #\u{31FAF}; + #\u{31FB0}; + #\u{31FB1}; + #\u{31FB2}; + #\u{31FB3}; + #\u{31FB4}; + #\u{31FB5}; + #\u{31FB6}; + #\u{31FB7}; + #\u{31FB8}; + #\u{31FB9}; + #\u{31FBA}; + #\u{31FBB}; + #\u{31FBC}; + #\u{31FBD}; + #\u{31FBE}; + #\u{31FBF}; + #\u{31FC0}; + #\u{31FC1}; + #\u{31FC2}; + #\u{31FC3}; + #\u{31FC4}; + #\u{31FC5}; + #\u{31FC6}; + #\u{31FC7}; + #\u{31FC8}; + #\u{31FC9}; + #\u{31FCA}; + #\u{31FCB}; + #\u{31FCC}; + #\u{31FCD}; + #\u{31FCE}; + #\u{31FCF}; + #\u{31FD0}; + #\u{31FD1}; + #\u{31FD2}; + #\u{31FD3}; + #\u{31FD4}; + #\u{31FD5}; + #\u{31FD6}; + #\u{31FD7}; + #\u{31FD8}; + #\u{31FD9}; + #\u{31FDA}; + #\u{31FDB}; + #\u{31FDC}; + #\u{31FDD}; + #\u{31FDE}; + #\u{31FDF}; + #\u{31FE0}; + #\u{31FE1}; + #\u{31FE2}; + #\u{31FE3}; + #\u{31FE4}; + #\u{31FE5}; + #\u{31FE6}; + #\u{31FE7}; + #\u{31FE8}; + #\u{31FE9}; + #\u{31FEA}; + #\u{31FEB}; + #\u{31FEC}; + #\u{31FED}; + #\u{31FEE}; + #\u{31FEF}; + #\u{31FF0}; + #\u{31FF1}; + #\u{31FF2}; + #\u{31FF3}; + #\u{31FF4}; + #\u{31FF5}; + #\u{31FF6}; + #\u{31FF7}; + #\u{31FF8}; + #\u{31FF9}; + #\u{31FFA}; + #\u{31FFB}; + #\u{31FFC}; + #\u{31FFD}; + #\u{31FFE}; + #\u{31FFF}; + #\u{32000}; + #\u{32001}; + #\u{32002}; + #\u{32003}; + #\u{32004}; + #\u{32005}; + #\u{32006}; + #\u{32007}; + #\u{32008}; + #\u{32009}; + #\u{3200A}; + #\u{3200B}; + #\u{3200C}; + #\u{3200D}; + #\u{3200E}; + #\u{3200F}; + #\u{32010}; + #\u{32011}; + #\u{32012}; + #\u{32013}; + #\u{32014}; + #\u{32015}; + #\u{32016}; + #\u{32017}; + #\u{32018}; + #\u{32019}; + #\u{3201A}; + #\u{3201B}; + #\u{3201C}; + #\u{3201D}; + #\u{3201E}; + #\u{3201F}; + #\u{32020}; + #\u{32021}; + #\u{32022}; + #\u{32023}; + #\u{32024}; + #\u{32025}; + #\u{32026}; + #\u{32027}; + #\u{32028}; + #\u{32029}; + #\u{3202A}; + #\u{3202B}; + #\u{3202C}; + #\u{3202D}; + #\u{3202E}; + #\u{3202F}; + #\u{32030}; + #\u{32031}; + #\u{32032}; + #\u{32033}; + #\u{32034}; + #\u{32035}; + #\u{32036}; + #\u{32037}; + #\u{32038}; + #\u{32039}; + #\u{3203A}; + #\u{3203B}; + #\u{3203C}; + #\u{3203D}; + #\u{3203E}; + #\u{3203F}; + #\u{32040}; + #\u{32041}; + #\u{32042}; + #\u{32043}; + #\u{32044}; + #\u{32045}; + #\u{32046}; + #\u{32047}; + #\u{32048}; + #\u{32049}; + #\u{3204A}; + #\u{3204B}; + #\u{3204C}; + #\u{3204D}; + #\u{3204E}; + #\u{3204F}; + #\u{32050}; + #\u{32051}; + #\u{32052}; + #\u{32053}; + #\u{32054}; + #\u{32055}; + #\u{32056}; + #\u{32057}; + #\u{32058}; + #\u{32059}; + #\u{3205A}; + #\u{3205B}; + #\u{3205C}; + #\u{3205D}; + #\u{3205E}; + #\u{3205F}; + #\u{32060}; + #\u{32061}; + #\u{32062}; + #\u{32063}; + #\u{32064}; + #\u{32065}; + #\u{32066}; + #\u{32067}; + #\u{32068}; + #\u{32069}; + #\u{3206A}; + #\u{3206B}; + #\u{3206C}; + #\u{3206D}; + #\u{3206E}; + #\u{3206F}; + #\u{32070}; + #\u{32071}; + #\u{32072}; + #\u{32073}; + #\u{32074}; + #\u{32075}; + #\u{32076}; + #\u{32077}; + #\u{32078}; + #\u{32079}; + #\u{3207A}; + #\u{3207B}; + #\u{3207C}; + #\u{3207D}; + #\u{3207E}; + #\u{3207F}; + #\u{32080}; + #\u{32081}; + #\u{32082}; + #\u{32083}; + #\u{32084}; + #\u{32085}; + #\u{32086}; + #\u{32087}; + #\u{32088}; + #\u{32089}; + #\u{3208A}; + #\u{3208B}; + #\u{3208C}; + #\u{3208D}; + #\u{3208E}; + #\u{3208F}; + #\u{32090}; + #\u{32091}; + #\u{32092}; + #\u{32093}; + #\u{32094}; + #\u{32095}; + #\u{32096}; + #\u{32097}; + #\u{32098}; + #\u{32099}; + #\u{3209A}; + #\u{3209B}; + #\u{3209C}; + #\u{3209D}; + #\u{3209E}; + #\u{3209F}; + #\u{320A0}; + #\u{320A1}; + #\u{320A2}; + #\u{320A3}; + #\u{320A4}; + #\u{320A5}; + #\u{320A6}; + #\u{320A7}; + #\u{320A8}; + #\u{320A9}; + #\u{320AA}; + #\u{320AB}; + #\u{320AC}; + #\u{320AD}; + #\u{320AE}; + #\u{320AF}; + #\u{320B0}; + #\u{320B1}; + #\u{320B2}; + #\u{320B3}; + #\u{320B4}; + #\u{320B5}; + #\u{320B6}; + #\u{320B7}; + #\u{320B8}; + #\u{320B9}; + #\u{320BA}; + #\u{320BB}; + #\u{320BC}; + #\u{320BD}; + #\u{320BE}; + #\u{320BF}; + #\u{320C0}; + #\u{320C1}; + #\u{320C2}; + #\u{320C3}; + #\u{320C4}; + #\u{320C5}; + #\u{320C6}; + #\u{320C7}; + #\u{320C8}; + #\u{320C9}; + #\u{320CA}; + #\u{320CB}; + #\u{320CC}; + #\u{320CD}; + #\u{320CE}; + #\u{320CF}; + #\u{320D0}; + #\u{320D1}; + #\u{320D2}; + #\u{320D3}; + #\u{320D4}; + #\u{320D5}; + #\u{320D6}; + #\u{320D7}; + #\u{320D8}; + #\u{320D9}; + #\u{320DA}; + #\u{320DB}; + #\u{320DC}; + #\u{320DD}; + #\u{320DE}; + #\u{320DF}; + #\u{320E0}; + #\u{320E1}; + #\u{320E2}; + #\u{320E3}; + #\u{320E4}; + #\u{320E5}; + #\u{320E6}; + #\u{320E7}; + #\u{320E8}; + #\u{320E9}; + #\u{320EA}; + #\u{320EB}; + #\u{320EC}; + #\u{320ED}; + #\u{320EE}; + #\u{320EF}; + #\u{320F0}; + #\u{320F1}; + #\u{320F2}; + #\u{320F3}; + #\u{320F4}; + #\u{320F5}; + #\u{320F6}; + #\u{320F7}; + #\u{320F8}; + #\u{320F9}; + #\u{320FA}; + #\u{320FB}; + #\u{320FC}; + #\u{320FD}; + #\u{320FE}; + #\u{320FF}; + #\u{32100}; + #\u{32101}; + #\u{32102}; + #\u{32103}; + #\u{32104}; + #\u{32105}; + #\u{32106}; + #\u{32107}; + #\u{32108}; + #\u{32109}; + #\u{3210A}; + #\u{3210B}; + #\u{3210C}; + #\u{3210D}; + #\u{3210E}; + #\u{3210F}; + #\u{32110}; + #\u{32111}; + #\u{32112}; + #\u{32113}; + #\u{32114}; + #\u{32115}; + #\u{32116}; + #\u{32117}; + #\u{32118}; + #\u{32119}; + #\u{3211A}; + #\u{3211B}; + #\u{3211C}; + #\u{3211D}; + #\u{3211E}; + #\u{3211F}; + #\u{32120}; + #\u{32121}; + #\u{32122}; + #\u{32123}; + #\u{32124}; + #\u{32125}; + #\u{32126}; + #\u{32127}; + #\u{32128}; + #\u{32129}; + #\u{3212A}; + #\u{3212B}; + #\u{3212C}; + #\u{3212D}; + #\u{3212E}; + #\u{3212F}; + #\u{32130}; + #\u{32131}; + #\u{32132}; + #\u{32133}; + #\u{32134}; + #\u{32135}; + #\u{32136}; + #\u{32137}; + #\u{32138}; + #\u{32139}; + #\u{3213A}; + #\u{3213B}; + #\u{3213C}; + #\u{3213D}; + #\u{3213E}; + #\u{3213F}; + #\u{32140}; + #\u{32141}; + #\u{32142}; + #\u{32143}; + #\u{32144}; + #\u{32145}; + #\u{32146}; + #\u{32147}; + #\u{32148}; + #\u{32149}; + #\u{3214A}; + #\u{3214B}; + #\u{3214C}; + #\u{3214D}; + #\u{3214E}; + #\u{3214F}; + #\u{32150}; + #\u{32151}; + #\u{32152}; + #\u{32153}; + #\u{32154}; + #\u{32155}; + #\u{32156}; + #\u{32157}; + #\u{32158}; + #\u{32159}; + #\u{3215A}; + #\u{3215B}; + #\u{3215C}; + #\u{3215D}; + #\u{3215E}; + #\u{3215F}; + #\u{32160}; + #\u{32161}; + #\u{32162}; + #\u{32163}; + #\u{32164}; + #\u{32165}; + #\u{32166}; + #\u{32167}; + #\u{32168}; + #\u{32169}; + #\u{3216A}; + #\u{3216B}; + #\u{3216C}; + #\u{3216D}; + #\u{3216E}; + #\u{3216F}; + #\u{32170}; + #\u{32171}; + #\u{32172}; + #\u{32173}; + #\u{32174}; + #\u{32175}; + #\u{32176}; + #\u{32177}; + #\u{32178}; + #\u{32179}; + #\u{3217A}; + #\u{3217B}; + #\u{3217C}; + #\u{3217D}; + #\u{3217E}; + #\u{3217F}; + #\u{32180}; + #\u{32181}; + #\u{32182}; + #\u{32183}; + #\u{32184}; + #\u{32185}; + #\u{32186}; + #\u{32187}; + #\u{32188}; + #\u{32189}; + #\u{3218A}; + #\u{3218B}; + #\u{3218C}; + #\u{3218D}; + #\u{3218E}; + #\u{3218F}; + #\u{32190}; + #\u{32191}; + #\u{32192}; + #\u{32193}; + #\u{32194}; + #\u{32195}; + #\u{32196}; + #\u{32197}; + #\u{32198}; + #\u{32199}; + #\u{3219A}; + #\u{3219B}; + #\u{3219C}; + #\u{3219D}; + #\u{3219E}; + #\u{3219F}; + #\u{321A0}; + #\u{321A1}; + #\u{321A2}; + #\u{321A3}; + #\u{321A4}; + #\u{321A5}; + #\u{321A6}; + #\u{321A7}; + #\u{321A8}; + #\u{321A9}; + #\u{321AA}; + #\u{321AB}; + #\u{321AC}; + #\u{321AD}; + #\u{321AE}; + #\u{321AF}; + #\u{321B0}; + #\u{321B1}; + #\u{321B2}; + #\u{321B3}; + #\u{321B4}; + #\u{321B5}; + #\u{321B6}; + #\u{321B7}; + #\u{321B8}; + #\u{321B9}; + #\u{321BA}; + #\u{321BB}; + #\u{321BC}; + #\u{321BD}; + #\u{321BE}; + #\u{321BF}; + #\u{321C0}; + #\u{321C1}; + #\u{321C2}; + #\u{321C3}; + #\u{321C4}; + #\u{321C5}; + #\u{321C6}; + #\u{321C7}; + #\u{321C8}; + #\u{321C9}; + #\u{321CA}; + #\u{321CB}; + #\u{321CC}; + #\u{321CD}; + #\u{321CE}; + #\u{321CF}; + #\u{321D0}; + #\u{321D1}; + #\u{321D2}; + #\u{321D3}; + #\u{321D4}; + #\u{321D5}; + #\u{321D6}; + #\u{321D7}; + #\u{321D8}; + #\u{321D9}; + #\u{321DA}; + #\u{321DB}; + #\u{321DC}; + #\u{321DD}; + #\u{321DE}; + #\u{321DF}; + #\u{321E0}; + #\u{321E1}; + #\u{321E2}; + #\u{321E3}; + #\u{321E4}; + #\u{321E5}; + #\u{321E6}; + #\u{321E7}; + #\u{321E8}; + #\u{321E9}; + #\u{321EA}; + #\u{321EB}; + #\u{321EC}; + #\u{321ED}; + #\u{321EE}; + #\u{321EF}; + #\u{321F0}; + #\u{321F1}; + #\u{321F2}; + #\u{321F3}; + #\u{321F4}; + #\u{321F5}; + #\u{321F6}; + #\u{321F7}; + #\u{321F8}; + #\u{321F9}; + #\u{321FA}; + #\u{321FB}; + #\u{321FC}; + #\u{321FD}; + #\u{321FE}; + #\u{321FF}; + #\u{32200}; + #\u{32201}; + #\u{32202}; + #\u{32203}; + #\u{32204}; + #\u{32205}; + #\u{32206}; + #\u{32207}; + #\u{32208}; + #\u{32209}; + #\u{3220A}; + #\u{3220B}; + #\u{3220C}; + #\u{3220D}; + #\u{3220E}; + #\u{3220F}; + #\u{32210}; + #\u{32211}; + #\u{32212}; + #\u{32213}; + #\u{32214}; + #\u{32215}; + #\u{32216}; + #\u{32217}; + #\u{32218}; + #\u{32219}; + #\u{3221A}; + #\u{3221B}; + #\u{3221C}; + #\u{3221D}; + #\u{3221E}; + #\u{3221F}; + #\u{32220}; + #\u{32221}; + #\u{32222}; + #\u{32223}; + #\u{32224}; + #\u{32225}; + #\u{32226}; + #\u{32227}; + #\u{32228}; + #\u{32229}; + #\u{3222A}; + #\u{3222B}; + #\u{3222C}; + #\u{3222D}; + #\u{3222E}; + #\u{3222F}; + #\u{32230}; + #\u{32231}; + #\u{32232}; + #\u{32233}; + #\u{32234}; + #\u{32235}; + #\u{32236}; + #\u{32237}; + #\u{32238}; + #\u{32239}; + #\u{3223A}; + #\u{3223B}; + #\u{3223C}; + #\u{3223D}; + #\u{3223E}; + #\u{3223F}; + #\u{32240}; + #\u{32241}; + #\u{32242}; + #\u{32243}; + #\u{32244}; + #\u{32245}; + #\u{32246}; + #\u{32247}; + #\u{32248}; + #\u{32249}; + #\u{3224A}; + #\u{3224B}; + #\u{3224C}; + #\u{3224D}; + #\u{3224E}; + #\u{3224F}; + #\u{32250}; + #\u{32251}; + #\u{32252}; + #\u{32253}; + #\u{32254}; + #\u{32255}; + #\u{32256}; + #\u{32257}; + #\u{32258}; + #\u{32259}; + #\u{3225A}; + #\u{3225B}; + #\u{3225C}; + #\u{3225D}; + #\u{3225E}; + #\u{3225F}; + #\u{32260}; + #\u{32261}; + #\u{32262}; + #\u{32263}; + #\u{32264}; + #\u{32265}; + #\u{32266}; + #\u{32267}; + #\u{32268}; + #\u{32269}; + #\u{3226A}; + #\u{3226B}; + #\u{3226C}; + #\u{3226D}; + #\u{3226E}; + #\u{3226F}; + #\u{32270}; + #\u{32271}; + #\u{32272}; + #\u{32273}; + #\u{32274}; + #\u{32275}; + #\u{32276}; + #\u{32277}; + #\u{32278}; + #\u{32279}; + #\u{3227A}; + #\u{3227B}; + #\u{3227C}; + #\u{3227D}; + #\u{3227E}; + #\u{3227F}; + #\u{32280}; + #\u{32281}; + #\u{32282}; + #\u{32283}; + #\u{32284}; + #\u{32285}; + #\u{32286}; + #\u{32287}; + #\u{32288}; + #\u{32289}; + #\u{3228A}; + #\u{3228B}; + #\u{3228C}; + #\u{3228D}; + #\u{3228E}; + #\u{3228F}; + #\u{32290}; + #\u{32291}; + #\u{32292}; + #\u{32293}; + #\u{32294}; + #\u{32295}; + #\u{32296}; + #\u{32297}; + #\u{32298}; + #\u{32299}; + #\u{3229A}; + #\u{3229B}; + #\u{3229C}; + #\u{3229D}; + #\u{3229E}; + #\u{3229F}; + #\u{322A0}; + #\u{322A1}; + #\u{322A2}; + #\u{322A3}; + #\u{322A4}; + #\u{322A5}; + #\u{322A6}; + #\u{322A7}; + #\u{322A8}; + #\u{322A9}; + #\u{322AA}; + #\u{322AB}; + #\u{322AC}; + #\u{322AD}; + #\u{322AE}; + #\u{322AF}; + #\u{322B0}; + #\u{322B1}; + #\u{322B2}; + #\u{322B3}; + #\u{322B4}; + #\u{322B5}; + #\u{322B6}; + #\u{322B7}; + #\u{322B8}; + #\u{322B9}; + #\u{322BA}; + #\u{322BB}; + #\u{322BC}; + #\u{322BD}; + #\u{322BE}; + #\u{322BF}; + #\u{322C0}; + #\u{322C1}; + #\u{322C2}; + #\u{322C3}; + #\u{322C4}; + #\u{322C5}; + #\u{322C6}; + #\u{322C7}; + #\u{322C8}; + #\u{322C9}; + #\u{322CA}; + #\u{322CB}; + #\u{322CC}; + #\u{322CD}; + #\u{322CE}; + #\u{322CF}; + #\u{322D0}; + #\u{322D1}; + #\u{322D2}; + #\u{322D3}; + #\u{322D4}; + #\u{322D5}; + #\u{322D6}; + #\u{322D7}; + #\u{322D8}; + #\u{322D9}; + #\u{322DA}; + #\u{322DB}; + #\u{322DC}; + #\u{322DD}; + #\u{322DE}; + #\u{322DF}; + #\u{322E0}; + #\u{322E1}; + #\u{322E2}; + #\u{322E3}; + #\u{322E4}; + #\u{322E5}; + #\u{322E6}; + #\u{322E7}; + #\u{322E8}; + #\u{322E9}; + #\u{322EA}; + #\u{322EB}; + #\u{322EC}; + #\u{322ED}; + #\u{322EE}; + #\u{322EF}; + #\u{322F0}; + #\u{322F1}; + #\u{322F2}; + #\u{322F3}; + #\u{322F4}; + #\u{322F5}; + #\u{322F6}; + #\u{322F7}; + #\u{322F8}; + #\u{322F9}; + #\u{322FA}; + #\u{322FB}; + #\u{322FC}; + #\u{322FD}; + #\u{322FE}; + #\u{322FF}; + #\u{32300}; + #\u{32301}; + #\u{32302}; + #\u{32303}; + #\u{32304}; + #\u{32305}; + #\u{32306}; + #\u{32307}; + #\u{32308}; + #\u{32309}; + #\u{3230A}; + #\u{3230B}; + #\u{3230C}; + #\u{3230D}; + #\u{3230E}; + #\u{3230F}; + #\u{32310}; + #\u{32311}; + #\u{32312}; + #\u{32313}; + #\u{32314}; + #\u{32315}; + #\u{32316}; + #\u{32317}; + #\u{32318}; + #\u{32319}; + #\u{3231A}; + #\u{3231B}; + #\u{3231C}; + #\u{3231D}; + #\u{3231E}; + #\u{3231F}; + #\u{32320}; + #\u{32321}; + #\u{32322}; + #\u{32323}; + #\u{32324}; + #\u{32325}; + #\u{32326}; + #\u{32327}; + #\u{32328}; + #\u{32329}; + #\u{3232A}; + #\u{3232B}; + #\u{3232C}; + #\u{3232D}; + #\u{3232E}; + #\u{3232F}; + #\u{32330}; + #\u{32331}; + #\u{32332}; + #\u{32333}; + #\u{32334}; + #\u{32335}; + #\u{32336}; + #\u{32337}; + #\u{32338}; + #\u{32339}; + #\u{3233A}; + #\u{3233B}; + #\u{3233C}; + #\u{3233D}; + #\u{3233E}; + #\u{3233F}; + #\u{32340}; + #\u{32341}; + #\u{32342}; + #\u{32343}; + #\u{32344}; + #\u{32345}; + #\u{32346}; + #\u{32347}; + #\u{32348}; + #\u{32349}; + #\u{3234A}; + #\u{3234B}; + #\u{3234C}; + #\u{3234D}; + #\u{3234E}; + #\u{3234F}; + #\u{32350}; + #\u{32351}; + #\u{32352}; + #\u{32353}; + #\u{32354}; + #\u{32355}; + #\u{32356}; + #\u{32357}; + #\u{32358}; + #\u{32359}; + #\u{3235A}; + #\u{3235B}; + #\u{3235C}; + #\u{3235D}; + #\u{3235E}; + #\u{3235F}; + #\u{32360}; + #\u{32361}; + #\u{32362}; + #\u{32363}; + #\u{32364}; + #\u{32365}; + #\u{32366}; + #\u{32367}; + #\u{32368}; + #\u{32369}; + #\u{3236A}; + #\u{3236B}; + #\u{3236C}; + #\u{3236D}; + #\u{3236E}; + #\u{3236F}; + #\u{32370}; + #\u{32371}; + #\u{32372}; + #\u{32373}; + #\u{32374}; + #\u{32375}; + #\u{32376}; + #\u{32377}; + #\u{32378}; + #\u{32379}; + #\u{3237A}; + #\u{3237B}; + #\u{3237C}; + #\u{3237D}; + #\u{3237E}; + #\u{3237F}; + #\u{32380}; + #\u{32381}; + #\u{32382}; + #\u{32383}; + #\u{32384}; + #\u{32385}; + #\u{32386}; + #\u{32387}; + #\u{32388}; + #\u{32389}; + #\u{3238A}; + #\u{3238B}; + #\u{3238C}; + #\u{3238D}; + #\u{3238E}; + #\u{3238F}; + #\u{32390}; + #\u{32391}; + #\u{32392}; + #\u{32393}; + #\u{32394}; + #\u{32395}; + #\u{32396}; + #\u{32397}; + #\u{32398}; + #\u{32399}; + #\u{3239A}; + #\u{3239B}; + #\u{3239C}; + #\u{3239D}; + #\u{3239E}; + #\u{3239F}; + #\u{323A0}; + #\u{323A1}; + #\u{323A2}; + #\u{323A3}; + #\u{323A4}; + #\u{323A5}; + #\u{323A6}; + #\u{323A7}; + #\u{323A8}; + #\u{323A9}; + #\u{323AA}; + #\u{323AB}; + #\u{323AC}; + #\u{323AD}; + #\u{323AE}; + #\u{323AF}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0-class.js new file mode 100644 index 000000000..ab22f3186 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0-class.js @@ -0,0 +1,4364 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v15.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #𑈿; + #𑉀; + #𑼂; + #𑼄; + #𑼅; + #𑼆; + #𑼇; + #𑼈; + #𑼉; + #𑼊; + #𑼋; + #𑼌; + #𑼍; + #𑼎; + #𑼏; + #𑼐; + #𑼒; + #𑼓; + #𑼔; + #𑼕; + #𑼖; + #𑼗; + #𑼘; + #𑼙; + #𑼚; + #𑼛; + #𑼜; + #𑼝; + #𑼞; + #𑼟; + #𑼠; + #𑼡; + #𑼢; + #𑼣; + #𑼤; + #𑼥; + #𑼦; + #𑼧; + #𑼨; + #𑼩; + #𑼪; + #𑼫; + #𑼬; + #𑼭; + #𑼮; + #𑼯; + #𑼰; + #𑼱; + #𑼲; + #𑼳; + #𓐯; + #𓑁; + #𓑂; + #𓑃; + #𓑄; + #𓑅; + #𓑆; + #𛄲; + #𛅕; + #𝼥; + #𝼦; + #𝼧; + #𝼨; + #𝼩; + #𝼪; + #𞀰; + #𞀱; + #𞀲; + #𞀳; + #𞀴; + #𞀵; + #𞀶; + #𞀷; + #𞀸; + #𞀹; + #𞀺; + #𞀻; + #𞀼; + #𞀽; + #𞀾; + #𞀿; + #𞁀; + #𞁁; + #𞁂; + #𞁃; + #𞁄; + #𞁅; + #𞁆; + #𞁇; + #𞁈; + #𞁉; + #𞁊; + #𞁋; + #𞁌; + #𞁍; + #𞁎; + #𞁏; + #𞁐; + #𞁑; + #𞁒; + #𞁓; + #𞁔; + #𞁕; + #𞁖; + #𞁗; + #𞁘; + #𞁙; + #𞁚; + #𞁛; + #𞁜; + #𞁝; + #𞁞; + #𞁟; + #𞁠; + #𞁡; + #𞁢; + #𞁣; + #𞁤; + #𞁥; + #𞁦; + #𞁧; + #𞁨; + #𞁩; + #𞁪; + #𞁫; + #𞁬; + #𞁭; + #𞓐; + #𞓑; + #𞓒; + #𞓓; + #𞓔; + #𞓕; + #𞓖; + #𞓗; + #𞓘; + #𞓙; + #𞓚; + #𞓛; + #𞓜; + #𞓝; + #𞓞; + #𞓟; + #𞓠; + #𞓡; + #𞓢; + #𞓣; + #𞓤; + #𞓥; + #𞓦; + #𞓧; + #𞓨; + #𞓩; + #𞓪; + #𞓫; + #𫜹; + #𱍐; + #𱍑; + #𱍒; + #𱍓; + #𱍔; + #𱍕; + #𱍖; + #𱍗; + #𱍘; + #𱍙; + #𱍚; + #𱍛; + #𱍜; + #𱍝; + #𱍞; + #𱍟; + #𱍠; + #𱍡; + #𱍢; + #𱍣; + #𱍤; + #𱍥; + #𱍦; + #𱍧; + #𱍨; + #𱍩; + #𱍪; + #𱍫; + #𱍬; + #𱍭; + #𱍮; + #𱍯; + #𱍰; + #𱍱; + #𱍲; + #𱍳; + #𱍴; + #𱍵; + #𱍶; + #𱍷; + #𱍸; + #𱍹; + #𱍺; + #𱍻; + #𱍼; + #𱍽; + #𱍾; + #𱍿; + #𱎀; + #𱎁; + #𱎂; + #𱎃; + #𱎄; + #𱎅; + #𱎆; + #𱎇; + #𱎈; + #𱎉; + #𱎊; + #𱎋; + #𱎌; + #𱎍; + #𱎎; + #𱎏; + #𱎐; + #𱎑; + #𱎒; + #𱎓; + #𱎔; + #𱎕; + #𱎖; + #𱎗; + #𱎘; + #𱎙; + #𱎚; + #𱎛; + #𱎜; + #𱎝; + #𱎞; + #𱎟; + #𱎠; + #𱎡; + #𱎢; + #𱎣; + #𱎤; + #𱎥; + #𱎦; + #𱎧; + #𱎨; + #𱎩; + #𱎪; + #𱎫; + #𱎬; + #𱎭; + #𱎮; + #𱎯; + #𱎰; + #𱎱; + #𱎲; + #𱎳; + #𱎴; + #𱎵; + #𱎶; + #𱎷; + #𱎸; + #𱎹; + #𱎺; + #𱎻; + #𱎼; + #𱎽; + #𱎾; + #𱎿; + #𱏀; + #𱏁; + #𱏂; + #𱏃; + #𱏄; + #𱏅; + #𱏆; + #𱏇; + #𱏈; + #𱏉; + #𱏊; + #𱏋; + #𱏌; + #𱏍; + #𱏎; + #𱏏; + #𱏐; + #𱏑; + #𱏒; + #𱏓; + #𱏔; + #𱏕; + #𱏖; + #𱏗; + #𱏘; + #𱏙; + #𱏚; + #𱏛; + #𱏜; + #𱏝; + #𱏞; + #𱏟; + #𱏠; + #𱏡; + #𱏢; + #𱏣; + #𱏤; + #𱏥; + #𱏦; + #𱏧; + #𱏨; + #𱏩; + #𱏪; + #𱏫; + #𱏬; + #𱏭; + #𱏮; + #𱏯; + #𱏰; + #𱏱; + #𱏲; + #𱏳; + #𱏴; + #𱏵; + #𱏶; + #𱏷; + #𱏸; + #𱏹; + #𱏺; + #𱏻; + #𱏼; + #𱏽; + #𱏾; + #𱏿; + #𱐀; + #𱐁; + #𱐂; + #𱐃; + #𱐄; + #𱐅; + #𱐆; + #𱐇; + #𱐈; + #𱐉; + #𱐊; + #𱐋; + #𱐌; + #𱐍; + #𱐎; + #𱐏; + #𱐐; + #𱐑; + #𱐒; + #𱐓; + #𱐔; + #𱐕; + #𱐖; + #𱐗; + #𱐘; + #𱐙; + #𱐚; + #𱐛; + #𱐜; + #𱐝; + #𱐞; + #𱐟; + #𱐠; + #𱐡; + #𱐢; + #𱐣; + #𱐤; + #𱐥; + #𱐦; + #𱐧; + #𱐨; + #𱐩; + #𱐪; + #𱐫; + #𱐬; + #𱐭; + #𱐮; + #𱐯; + #𱐰; + #𱐱; + #𱐲; + #𱐳; + #𱐴; + #𱐵; + #𱐶; + #𱐷; + #𱐸; + #𱐹; + #𱐺; + #𱐻; + #𱐼; + #𱐽; + #𱐾; + #𱐿; + #𱑀; + #𱑁; + #𱑂; + #𱑃; + #𱑄; + #𱑅; + #𱑆; + #𱑇; + #𱑈; + #𱑉; + #𱑊; + #𱑋; + #𱑌; + #𱑍; + #𱑎; + #𱑏; + #𱑐; + #𱑑; + #𱑒; + #𱑓; + #𱑔; + #𱑕; + #𱑖; + #𱑗; + #𱑘; + #𱑙; + #𱑚; + #𱑛; + #𱑜; + #𱑝; + #𱑞; + #𱑟; + #𱑠; + #𱑡; + #𱑢; + #𱑣; + #𱑤; + #𱑥; + #𱑦; + #𱑧; + #𱑨; + #𱑩; + #𱑪; + #𱑫; + #𱑬; + #𱑭; + #𱑮; + #𱑯; + #𱑰; + #𱑱; + #𱑲; + #𱑳; + #𱑴; + #𱑵; + #𱑶; + #𱑷; + #𱑸; + #𱑹; + #𱑺; + #𱑻; + #𱑼; + #𱑽; + #𱑾; + #𱑿; + #𱒀; + #𱒁; + #𱒂; + #𱒃; + #𱒄; + #𱒅; + #𱒆; + #𱒇; + #𱒈; + #𱒉; + #𱒊; + #𱒋; + #𱒌; + #𱒍; + #𱒎; + #𱒏; + #𱒐; + #𱒑; + #𱒒; + #𱒓; + #𱒔; + #𱒕; + #𱒖; + #𱒗; + #𱒘; + #𱒙; + #𱒚; + #𱒛; + #𱒜; + #𱒝; + #𱒞; + #𱒟; + #𱒠; + #𱒡; + #𱒢; + #𱒣; + #𱒤; + #𱒥; + #𱒦; + #𱒧; + #𱒨; + #𱒩; + #𱒪; + #𱒫; + #𱒬; + #𱒭; + #𱒮; + #𱒯; + #𱒰; + #𱒱; + #𱒲; + #𱒳; + #𱒴; + #𱒵; + #𱒶; + #𱒷; + #𱒸; + #𱒹; + #𱒺; + #𱒻; + #𱒼; + #𱒽; + #𱒾; + #𱒿; + #𱓀; + #𱓁; + #𱓂; + #𱓃; + #𱓄; + #𱓅; + #𱓆; + #𱓇; + #𱓈; + #𱓉; + #𱓊; + #𱓋; + #𱓌; + #𱓍; + #𱓎; + #𱓏; + #𱓐; + #𱓑; + #𱓒; + #𱓓; + #𱓔; + #𱓕; + #𱓖; + #𱓗; + #𱓘; + #𱓙; + #𱓚; + #𱓛; + #𱓜; + #𱓝; + #𱓞; + #𱓟; + #𱓠; + #𱓡; + #𱓢; + #𱓣; + #𱓤; + #𱓥; + #𱓦; + #𱓧; + #𱓨; + #𱓩; + #𱓪; + #𱓫; + #𱓬; + #𱓭; + #𱓮; + #𱓯; + #𱓰; + #𱓱; + #𱓲; + #𱓳; + #𱓴; + #𱓵; + #𱓶; + #𱓷; + #𱓸; + #𱓹; + #𱓺; + #𱓻; + #𱓼; + #𱓽; + #𱓾; + #𱓿; + #𱔀; + #𱔁; + #𱔂; + #𱔃; + #𱔄; + #𱔅; + #𱔆; + #𱔇; + #𱔈; + #𱔉; + #𱔊; + #𱔋; + #𱔌; + #𱔍; + #𱔎; + #𱔏; + #𱔐; + #𱔑; + #𱔒; + #𱔓; + #𱔔; + #𱔕; + #𱔖; + #𱔗; + #𱔘; + #𱔙; + #𱔚; + #𱔛; + #𱔜; + #𱔝; + #𱔞; + #𱔟; + #𱔠; + #𱔡; + #𱔢; + #𱔣; + #𱔤; + #𱔥; + #𱔦; + #𱔧; + #𱔨; + #𱔩; + #𱔪; + #𱔫; + #𱔬; + #𱔭; + #𱔮; + #𱔯; + #𱔰; + #𱔱; + #𱔲; + #𱔳; + #𱔴; + #𱔵; + #𱔶; + #𱔷; + #𱔸; + #𱔹; + #𱔺; + #𱔻; + #𱔼; + #𱔽; + #𱔾; + #𱔿; + #𱕀; + #𱕁; + #𱕂; + #𱕃; + #𱕄; + #𱕅; + #𱕆; + #𱕇; + #𱕈; + #𱕉; + #𱕊; + #𱕋; + #𱕌; + #𱕍; + #𱕎; + #𱕏; + #𱕐; + #𱕑; + #𱕒; + #𱕓; + #𱕔; + #𱕕; + #𱕖; + #𱕗; + #𱕘; + #𱕙; + #𱕚; + #𱕛; + #𱕜; + #𱕝; + #𱕞; + #𱕟; + #𱕠; + #𱕡; + #𱕢; + #𱕣; + #𱕤; + #𱕥; + #𱕦; + #𱕧; + #𱕨; + #𱕩; + #𱕪; + #𱕫; + #𱕬; + #𱕭; + #𱕮; + #𱕯; + #𱕰; + #𱕱; + #𱕲; + #𱕳; + #𱕴; + #𱕵; + #𱕶; + #𱕷; + #𱕸; + #𱕹; + #𱕺; + #𱕻; + #𱕼; + #𱕽; + #𱕾; + #𱕿; + #𱖀; + #𱖁; + #𱖂; + #𱖃; + #𱖄; + #𱖅; + #𱖆; + #𱖇; + #𱖈; + #𱖉; + #𱖊; + #𱖋; + #𱖌; + #𱖍; + #𱖎; + #𱖏; + #𱖐; + #𱖑; + #𱖒; + #𱖓; + #𱖔; + #𱖕; + #𱖖; + #𱖗; + #𱖘; + #𱖙; + #𱖚; + #𱖛; + #𱖜; + #𱖝; + #𱖞; + #𱖟; + #𱖠; + #𱖡; + #𱖢; + #𱖣; + #𱖤; + #𱖥; + #𱖦; + #𱖧; + #𱖨; + #𱖩; + #𱖪; + #𱖫; + #𱖬; + #𱖭; + #𱖮; + #𱖯; + #𱖰; + #𱖱; + #𱖲; + #𱖳; + #𱖴; + #𱖵; + #𱖶; + #𱖷; + #𱖸; + #𱖹; + #𱖺; + #𱖻; + #𱖼; + #𱖽; + #𱖾; + #𱖿; + #𱗀; + #𱗁; + #𱗂; + #𱗃; + #𱗄; + #𱗅; + #𱗆; + #𱗇; + #𱗈; + #𱗉; + #𱗊; + #𱗋; + #𱗌; + #𱗍; + #𱗎; + #𱗏; + #𱗐; + #𱗑; + #𱗒; + #𱗓; + #𱗔; + #𱗕; + #𱗖; + #𱗗; + #𱗘; + #𱗙; + #𱗚; + #𱗛; + #𱗜; + #𱗝; + #𱗞; + #𱗟; + #𱗠; + #𱗡; + #𱗢; + #𱗣; + #𱗤; + #𱗥; + #𱗦; + #𱗧; + #𱗨; + #𱗩; + #𱗪; + #𱗫; + #𱗬; + #𱗭; + #𱗮; + #𱗯; + #𱗰; + #𱗱; + #𱗲; + #𱗳; + #𱗴; + #𱗵; + #𱗶; + #𱗷; + #𱗸; + #𱗹; + #𱗺; + #𱗻; + #𱗼; + #𱗽; + #𱗾; + #𱗿; + #𱘀; + #𱘁; + #𱘂; + #𱘃; + #𱘄; + #𱘅; + #𱘆; + #𱘇; + #𱘈; + #𱘉; + #𱘊; + #𱘋; + #𱘌; + #𱘍; + #𱘎; + #𱘏; + #𱘐; + #𱘑; + #𱘒; + #𱘓; + #𱘔; + #𱘕; + #𱘖; + #𱘗; + #𱘘; + #𱘙; + #𱘚; + #𱘛; + #𱘜; + #𱘝; + #𱘞; + #𱘟; + #𱘠; + #𱘡; + #𱘢; + #𱘣; + #𱘤; + #𱘥; + #𱘦; + #𱘧; + #𱘨; + #𱘩; + #𱘪; + #𱘫; + #𱘬; + #𱘭; + #𱘮; + #𱘯; + #𱘰; + #𱘱; + #𱘲; + #𱘳; + #𱘴; + #𱘵; + #𱘶; + #𱘷; + #𱘸; + #𱘹; + #𱘺; + #𱘻; + #𱘼; + #𱘽; + #𱘾; + #𱘿; + #𱙀; + #𱙁; + #𱙂; + #𱙃; + #𱙄; + #𱙅; + #𱙆; + #𱙇; + #𱙈; + #𱙉; + #𱙊; + #𱙋; + #𱙌; + #𱙍; + #𱙎; + #𱙏; + #𱙐; + #𱙑; + #𱙒; + #𱙓; + #𱙔; + #𱙕; + #𱙖; + #𱙗; + #𱙘; + #𱙙; + #𱙚; + #𱙛; + #𱙜; + #𱙝; + #𱙞; + #𱙟; + #𱙠; + #𱙡; + #𱙢; + #𱙣; + #𱙤; + #𱙥; + #𱙦; + #𱙧; + #𱙨; + #𱙩; + #𱙪; + #𱙫; + #𱙬; + #𱙭; + #𱙮; + #𱙯; + #𱙰; + #𱙱; + #𱙲; + #𱙳; + #𱙴; + #𱙵; + #𱙶; + #𱙷; + #𱙸; + #𱙹; + #𱙺; + #𱙻; + #𱙼; + #𱙽; + #𱙾; + #𱙿; + #𱚀; + #𱚁; + #𱚂; + #𱚃; + #𱚄; + #𱚅; + #𱚆; + #𱚇; + #𱚈; + #𱚉; + #𱚊; + #𱚋; + #𱚌; + #𱚍; + #𱚎; + #𱚏; + #𱚐; + #𱚑; + #𱚒; + #𱚓; + #𱚔; + #𱚕; + #𱚖; + #𱚗; + #𱚘; + #𱚙; + #𱚚; + #𱚛; + #𱚜; + #𱚝; + #𱚞; + #𱚟; + #𱚠; + #𱚡; + #𱚢; + #𱚣; + #𱚤; + #𱚥; + #𱚦; + #𱚧; + #𱚨; + #𱚩; + #𱚪; + #𱚫; + #𱚬; + #𱚭; + #𱚮; + #𱚯; + #𱚰; + #𱚱; + #𱚲; + #𱚳; + #𱚴; + #𱚵; + #𱚶; + #𱚷; + #𱚸; + #𱚹; + #𱚺; + #𱚻; + #𱚼; + #𱚽; + #𱚾; + #𱚿; + #𱛀; + #𱛁; + #𱛂; + #𱛃; + #𱛄; + #𱛅; + #𱛆; + #𱛇; + #𱛈; + #𱛉; + #𱛊; + #𱛋; + #𱛌; + #𱛍; + #𱛎; + #𱛏; + #𱛐; + #𱛑; + #𱛒; + #𱛓; + #𱛔; + #𱛕; + #𱛖; + #𱛗; + #𱛘; + #𱛙; + #𱛚; + #𱛛; + #𱛜; + #𱛝; + #𱛞; + #𱛟; + #𱛠; + #𱛡; + #𱛢; + #𱛣; + #𱛤; + #𱛥; + #𱛦; + #𱛧; + #𱛨; + #𱛩; + #𱛪; + #𱛫; + #𱛬; + #𱛭; + #𱛮; + #𱛯; + #𱛰; + #𱛱; + #𱛲; + #𱛳; + #𱛴; + #𱛵; + #𱛶; + #𱛷; + #𱛸; + #𱛹; + #𱛺; + #𱛻; + #𱛼; + #𱛽; + #𱛾; + #𱛿; + #𱜀; + #𱜁; + #𱜂; + #𱜃; + #𱜄; + #𱜅; + #𱜆; + #𱜇; + #𱜈; + #𱜉; + #𱜊; + #𱜋; + #𱜌; + #𱜍; + #𱜎; + #𱜏; + #𱜐; + #𱜑; + #𱜒; + #𱜓; + #𱜔; + #𱜕; + #𱜖; + #𱜗; + #𱜘; + #𱜙; + #𱜚; + #𱜛; + #𱜜; + #𱜝; + #𱜞; + #𱜟; + #𱜠; + #𱜡; + #𱜢; + #𱜣; + #𱜤; + #𱜥; + #𱜦; + #𱜧; + #𱜨; + #𱜩; + #𱜪; + #𱜫; + #𱜬; + #𱜭; + #𱜮; + #𱜯; + #𱜰; + #𱜱; + #𱜲; + #𱜳; + #𱜴; + #𱜵; + #𱜶; + #𱜷; + #𱜸; + #𱜹; + #𱜺; + #𱜻; + #𱜼; + #𱜽; + #𱜾; + #𱜿; + #𱝀; + #𱝁; + #𱝂; + #𱝃; + #𱝄; + #𱝅; + #𱝆; + #𱝇; + #𱝈; + #𱝉; + #𱝊; + #𱝋; + #𱝌; + #𱝍; + #𱝎; + #𱝏; + #𱝐; + #𱝑; + #𱝒; + #𱝓; + #𱝔; + #𱝕; + #𱝖; + #𱝗; + #𱝘; + #𱝙; + #𱝚; + #𱝛; + #𱝜; + #𱝝; + #𱝞; + #𱝟; + #𱝠; + #𱝡; + #𱝢; + #𱝣; + #𱝤; + #𱝥; + #𱝦; + #𱝧; + #𱝨; + #𱝩; + #𱝪; + #𱝫; + #𱝬; + #𱝭; + #𱝮; + #𱝯; + #𱝰; + #𱝱; + #𱝲; + #𱝳; + #𱝴; + #𱝵; + #𱝶; + #𱝷; + #𱝸; + #𱝹; + #𱝺; + #𱝻; + #𱝼; + #𱝽; + #𱝾; + #𱝿; + #𱞀; + #𱞁; + #𱞂; + #𱞃; + #𱞄; + #𱞅; + #𱞆; + #𱞇; + #𱞈; + #𱞉; + #𱞊; + #𱞋; + #𱞌; + #𱞍; + #𱞎; + #𱞏; + #𱞐; + #𱞑; + #𱞒; + #𱞓; + #𱞔; + #𱞕; + #𱞖; + #𱞗; + #𱞘; + #𱞙; + #𱞚; + #𱞛; + #𱞜; + #𱞝; + #𱞞; + #𱞟; + #𱞠; + #𱞡; + #𱞢; + #𱞣; + #𱞤; + #𱞥; + #𱞦; + #𱞧; + #𱞨; + #𱞩; + #𱞪; + #𱞫; + #𱞬; + #𱞭; + #𱞮; + #𱞯; + #𱞰; + #𱞱; + #𱞲; + #𱞳; + #𱞴; + #𱞵; + #𱞶; + #𱞷; + #𱞸; + #𱞹; + #𱞺; + #𱞻; + #𱞼; + #𱞽; + #𱞾; + #𱞿; + #𱟀; + #𱟁; + #𱟂; + #𱟃; + #𱟄; + #𱟅; + #𱟆; + #𱟇; + #𱟈; + #𱟉; + #𱟊; + #𱟋; + #𱟌; + #𱟍; + #𱟎; + #𱟏; + #𱟐; + #𱟑; + #𱟒; + #𱟓; + #𱟔; + #𱟕; + #𱟖; + #𱟗; + #𱟘; + #𱟙; + #𱟚; + #𱟛; + #𱟜; + #𱟝; + #𱟞; + #𱟟; + #𱟠; + #𱟡; + #𱟢; + #𱟣; + #𱟤; + #𱟥; + #𱟦; + #𱟧; + #𱟨; + #𱟩; + #𱟪; + #𱟫; + #𱟬; + #𱟭; + #𱟮; + #𱟯; + #𱟰; + #𱟱; + #𱟲; + #𱟳; + #𱟴; + #𱟵; + #𱟶; + #𱟷; + #𱟸; + #𱟹; + #𱟺; + #𱟻; + #𱟼; + #𱟽; + #𱟾; + #𱟿; + #𱠀; + #𱠁; + #𱠂; + #𱠃; + #𱠄; + #𱠅; + #𱠆; + #𱠇; + #𱠈; + #𱠉; + #𱠊; + #𱠋; + #𱠌; + #𱠍; + #𱠎; + #𱠏; + #𱠐; + #𱠑; + #𱠒; + #𱠓; + #𱠔; + #𱠕; + #𱠖; + #𱠗; + #𱠘; + #𱠙; + #𱠚; + #𱠛; + #𱠜; + #𱠝; + #𱠞; + #𱠟; + #𱠠; + #𱠡; + #𱠢; + #𱠣; + #𱠤; + #𱠥; + #𱠦; + #𱠧; + #𱠨; + #𱠩; + #𱠪; + #𱠫; + #𱠬; + #𱠭; + #𱠮; + #𱠯; + #𱠰; + #𱠱; + #𱠲; + #𱠳; + #𱠴; + #𱠵; + #𱠶; + #𱠷; + #𱠸; + #𱠹; + #𱠺; + #𱠻; + #𱠼; + #𱠽; + #𱠾; + #𱠿; + #𱡀; + #𱡁; + #𱡂; + #𱡃; + #𱡄; + #𱡅; + #𱡆; + #𱡇; + #𱡈; + #𱡉; + #𱡊; + #𱡋; + #𱡌; + #𱡍; + #𱡎; + #𱡏; + #𱡐; + #𱡑; + #𱡒; + #𱡓; + #𱡔; + #𱡕; + #𱡖; + #𱡗; + #𱡘; + #𱡙; + #𱡚; + #𱡛; + #𱡜; + #𱡝; + #𱡞; + #𱡟; + #𱡠; + #𱡡; + #𱡢; + #𱡣; + #𱡤; + #𱡥; + #𱡦; + #𱡧; + #𱡨; + #𱡩; + #𱡪; + #𱡫; + #𱡬; + #𱡭; + #𱡮; + #𱡯; + #𱡰; + #𱡱; + #𱡲; + #𱡳; + #𱡴; + #𱡵; + #𱡶; + #𱡷; + #𱡸; + #𱡹; + #𱡺; + #𱡻; + #𱡼; + #𱡽; + #𱡾; + #𱡿; + #𱢀; + #𱢁; + #𱢂; + #𱢃; + #𱢄; + #𱢅; + #𱢆; + #𱢇; + #𱢈; + #𱢉; + #𱢊; + #𱢋; + #𱢌; + #𱢍; + #𱢎; + #𱢏; + #𱢐; + #𱢑; + #𱢒; + #𱢓; + #𱢔; + #𱢕; + #𱢖; + #𱢗; + #𱢘; + #𱢙; + #𱢚; + #𱢛; + #𱢜; + #𱢝; + #𱢞; + #𱢟; + #𱢠; + #𱢡; + #𱢢; + #𱢣; + #𱢤; + #𱢥; + #𱢦; + #𱢧; + #𱢨; + #𱢩; + #𱢪; + #𱢫; + #𱢬; + #𱢭; + #𱢮; + #𱢯; + #𱢰; + #𱢱; + #𱢲; + #𱢳; + #𱢴; + #𱢵; + #𱢶; + #𱢷; + #𱢸; + #𱢹; + #𱢺; + #𱢻; + #𱢼; + #𱢽; + #𱢾; + #𱢿; + #𱣀; + #𱣁; + #𱣂; + #𱣃; + #𱣄; + #𱣅; + #𱣆; + #𱣇; + #𱣈; + #𱣉; + #𱣊; + #𱣋; + #𱣌; + #𱣍; + #𱣎; + #𱣏; + #𱣐; + #𱣑; + #𱣒; + #𱣓; + #𱣔; + #𱣕; + #𱣖; + #𱣗; + #𱣘; + #𱣙; + #𱣚; + #𱣛; + #𱣜; + #𱣝; + #𱣞; + #𱣟; + #𱣠; + #𱣡; + #𱣢; + #𱣣; + #𱣤; + #𱣥; + #𱣦; + #𱣧; + #𱣨; + #𱣩; + #𱣪; + #𱣫; + #𱣬; + #𱣭; + #𱣮; + #𱣯; + #𱣰; + #𱣱; + #𱣲; + #𱣳; + #𱣴; + #𱣵; + #𱣶; + #𱣷; + #𱣸; + #𱣹; + #𱣺; + #𱣻; + #𱣼; + #𱣽; + #𱣾; + #𱣿; + #𱤀; + #𱤁; + #𱤂; + #𱤃; + #𱤄; + #𱤅; + #𱤆; + #𱤇; + #𱤈; + #𱤉; + #𱤊; + #𱤋; + #𱤌; + #𱤍; + #𱤎; + #𱤏; + #𱤐; + #𱤑; + #𱤒; + #𱤓; + #𱤔; + #𱤕; + #𱤖; + #𱤗; + #𱤘; + #𱤙; + #𱤚; + #𱤛; + #𱤜; + #𱤝; + #𱤞; + #𱤟; + #𱤠; + #𱤡; + #𱤢; + #𱤣; + #𱤤; + #𱤥; + #𱤦; + #𱤧; + #𱤨; + #𱤩; + #𱤪; + #𱤫; + #𱤬; + #𱤭; + #𱤮; + #𱤯; + #𱤰; + #𱤱; + #𱤲; + #𱤳; + #𱤴; + #𱤵; + #𱤶; + #𱤷; + #𱤸; + #𱤹; + #𱤺; + #𱤻; + #𱤼; + #𱤽; + #𱤾; + #𱤿; + #𱥀; + #𱥁; + #𱥂; + #𱥃; + #𱥄; + #𱥅; + #𱥆; + #𱥇; + #𱥈; + #𱥉; + #𱥊; + #𱥋; + #𱥌; + #𱥍; + #𱥎; + #𱥏; + #𱥐; + #𱥑; + #𱥒; + #𱥓; + #𱥔; + #𱥕; + #𱥖; + #𱥗; + #𱥘; + #𱥙; + #𱥚; + #𱥛; + #𱥜; + #𱥝; + #𱥞; + #𱥟; + #𱥠; + #𱥡; + #𱥢; + #𱥣; + #𱥤; + #𱥥; + #𱥦; + #𱥧; + #𱥨; + #𱥩; + #𱥪; + #𱥫; + #𱥬; + #𱥭; + #𱥮; + #𱥯; + #𱥰; + #𱥱; + #𱥲; + #𱥳; + #𱥴; + #𱥵; + #𱥶; + #𱥷; + #𱥸; + #𱥹; + #𱥺; + #𱥻; + #𱥼; + #𱥽; + #𱥾; + #𱥿; + #𱦀; + #𱦁; + #𱦂; + #𱦃; + #𱦄; + #𱦅; + #𱦆; + #𱦇; + #𱦈; + #𱦉; + #𱦊; + #𱦋; + #𱦌; + #𱦍; + #𱦎; + #𱦏; + #𱦐; + #𱦑; + #𱦒; + #𱦓; + #𱦔; + #𱦕; + #𱦖; + #𱦗; + #𱦘; + #𱦙; + #𱦚; + #𱦛; + #𱦜; + #𱦝; + #𱦞; + #𱦟; + #𱦠; + #𱦡; + #𱦢; + #𱦣; + #𱦤; + #𱦥; + #𱦦; + #𱦧; + #𱦨; + #𱦩; + #𱦪; + #𱦫; + #𱦬; + #𱦭; + #𱦮; + #𱦯; + #𱦰; + #𱦱; + #𱦲; + #𱦳; + #𱦴; + #𱦵; + #𱦶; + #𱦷; + #𱦸; + #𱦹; + #𱦺; + #𱦻; + #𱦼; + #𱦽; + #𱦾; + #𱦿; + #𱧀; + #𱧁; + #𱧂; + #𱧃; + #𱧄; + #𱧅; + #𱧆; + #𱧇; + #𱧈; + #𱧉; + #𱧊; + #𱧋; + #𱧌; + #𱧍; + #𱧎; + #𱧏; + #𱧐; + #𱧑; + #𱧒; + #𱧓; + #𱧔; + #𱧕; + #𱧖; + #𱧗; + #𱧘; + #𱧙; + #𱧚; + #𱧛; + #𱧜; + #𱧝; + #𱧞; + #𱧟; + #𱧠; + #𱧡; + #𱧢; + #𱧣; + #𱧤; + #𱧥; + #𱧦; + #𱧧; + #𱧨; + #𱧩; + #𱧪; + #𱧫; + #𱧬; + #𱧭; + #𱧮; + #𱧯; + #𱧰; + #𱧱; + #𱧲; + #𱧳; + #𱧴; + #𱧵; + #𱧶; + #𱧷; + #𱧸; + #𱧹; + #𱧺; + #𱧻; + #𱧼; + #𱧽; + #𱧾; + #𱧿; + #𱨀; + #𱨁; + #𱨂; + #𱨃; + #𱨄; + #𱨅; + #𱨆; + #𱨇; + #𱨈; + #𱨉; + #𱨊; + #𱨋; + #𱨌; + #𱨍; + #𱨎; + #𱨏; + #𱨐; + #𱨑; + #𱨒; + #𱨓; + #𱨔; + #𱨕; + #𱨖; + #𱨗; + #𱨘; + #𱨙; + #𱨚; + #𱨛; + #𱨜; + #𱨝; + #𱨞; + #𱨟; + #𱨠; + #𱨡; + #𱨢; + #𱨣; + #𱨤; + #𱨥; + #𱨦; + #𱨧; + #𱨨; + #𱨩; + #𱨪; + #𱨫; + #𱨬; + #𱨭; + #𱨮; + #𱨯; + #𱨰; + #𱨱; + #𱨲; + #𱨳; + #𱨴; + #𱨵; + #𱨶; + #𱨷; + #𱨸; + #𱨹; + #𱨺; + #𱨻; + #𱨼; + #𱨽; + #𱨾; + #𱨿; + #𱩀; + #𱩁; + #𱩂; + #𱩃; + #𱩄; + #𱩅; + #𱩆; + #𱩇; + #𱩈; + #𱩉; + #𱩊; + #𱩋; + #𱩌; + #𱩍; + #𱩎; + #𱩏; + #𱩐; + #𱩑; + #𱩒; + #𱩓; + #𱩔; + #𱩕; + #𱩖; + #𱩗; + #𱩘; + #𱩙; + #𱩚; + #𱩛; + #𱩜; + #𱩝; + #𱩞; + #𱩟; + #𱩠; + #𱩡; + #𱩢; + #𱩣; + #𱩤; + #𱩥; + #𱩦; + #𱩧; + #𱩨; + #𱩩; + #𱩪; + #𱩫; + #𱩬; + #𱩭; + #𱩮; + #𱩯; + #𱩰; + #𱩱; + #𱩲; + #𱩳; + #𱩴; + #𱩵; + #𱩶; + #𱩷; + #𱩸; + #𱩹; + #𱩺; + #𱩻; + #𱩼; + #𱩽; + #𱩾; + #𱩿; + #𱪀; + #𱪁; + #𱪂; + #𱪃; + #𱪄; + #𱪅; + #𱪆; + #𱪇; + #𱪈; + #𱪉; + #𱪊; + #𱪋; + #𱪌; + #𱪍; + #𱪎; + #𱪏; + #𱪐; + #𱪑; + #𱪒; + #𱪓; + #𱪔; + #𱪕; + #𱪖; + #𱪗; + #𱪘; + #𱪙; + #𱪚; + #𱪛; + #𱪜; + #𱪝; + #𱪞; + #𱪟; + #𱪠; + #𱪡; + #𱪢; + #𱪣; + #𱪤; + #𱪥; + #𱪦; + #𱪧; + #𱪨; + #𱪩; + #𱪪; + #𱪫; + #𱪬; + #𱪭; + #𱪮; + #𱪯; + #𱪰; + #𱪱; + #𱪲; + #𱪳; + #𱪴; + #𱪵; + #𱪶; + #𱪷; + #𱪸; + #𱪹; + #𱪺; + #𱪻; + #𱪼; + #𱪽; + #𱪾; + #𱪿; + #𱫀; + #𱫁; + #𱫂; + #𱫃; + #𱫄; + #𱫅; + #𱫆; + #𱫇; + #𱫈; + #𱫉; + #𱫊; + #𱫋; + #𱫌; + #𱫍; + #𱫎; + #𱫏; + #𱫐; + #𱫑; + #𱫒; + #𱫓; + #𱫔; + #𱫕; + #𱫖; + #𱫗; + #𱫘; + #𱫙; + #𱫚; + #𱫛; + #𱫜; + #𱫝; + #𱫞; + #𱫟; + #𱫠; + #𱫡; + #𱫢; + #𱫣; + #𱫤; + #𱫥; + #𱫦; + #𱫧; + #𱫨; + #𱫩; + #𱫪; + #𱫫; + #𱫬; + #𱫭; + #𱫮; + #𱫯; + #𱫰; + #𱫱; + #𱫲; + #𱫳; + #𱫴; + #𱫵; + #𱫶; + #𱫷; + #𱫸; + #𱫹; + #𱫺; + #𱫻; + #𱫼; + #𱫽; + #𱫾; + #𱫿; + #𱬀; + #𱬁; + #𱬂; + #𱬃; + #𱬄; + #𱬅; + #𱬆; + #𱬇; + #𱬈; + #𱬉; + #𱬊; + #𱬋; + #𱬌; + #𱬍; + #𱬎; + #𱬏; + #𱬐; + #𱬑; + #𱬒; + #𱬓; + #𱬔; + #𱬕; + #𱬖; + #𱬗; + #𱬘; + #𱬙; + #𱬚; + #𱬛; + #𱬜; + #𱬝; + #𱬞; + #𱬟; + #𱬠; + #𱬡; + #𱬢; + #𱬣; + #𱬤; + #𱬥; + #𱬦; + #𱬧; + #𱬨; + #𱬩; + #𱬪; + #𱬫; + #𱬬; + #𱬭; + #𱬮; + #𱬯; + #𱬰; + #𱬱; + #𱬲; + #𱬳; + #𱬴; + #𱬵; + #𱬶; + #𱬷; + #𱬸; + #𱬹; + #𱬺; + #𱬻; + #𱬼; + #𱬽; + #𱬾; + #𱬿; + #𱭀; + #𱭁; + #𱭂; + #𱭃; + #𱭄; + #𱭅; + #𱭆; + #𱭇; + #𱭈; + #𱭉; + #𱭊; + #𱭋; + #𱭌; + #𱭍; + #𱭎; + #𱭏; + #𱭐; + #𱭑; + #𱭒; + #𱭓; + #𱭔; + #𱭕; + #𱭖; + #𱭗; + #𱭘; + #𱭙; + #𱭚; + #𱭛; + #𱭜; + #𱭝; + #𱭞; + #𱭟; + #𱭠; + #𱭡; + #𱭢; + #𱭣; + #𱭤; + #𱭥; + #𱭦; + #𱭧; + #𱭨; + #𱭩; + #𱭪; + #𱭫; + #𱭬; + #𱭭; + #𱭮; + #𱭯; + #𱭰; + #𱭱; + #𱭲; + #𱭳; + #𱭴; + #𱭵; + #𱭶; + #𱭷; + #𱭸; + #𱭹; + #𱭺; + #𱭻; + #𱭼; + #𱭽; + #𱭾; + #𱭿; + #𱮀; + #𱮁; + #𱮂; + #𱮃; + #𱮄; + #𱮅; + #𱮆; + #𱮇; + #𱮈; + #𱮉; + #𱮊; + #𱮋; + #𱮌; + #𱮍; + #𱮎; + #𱮏; + #𱮐; + #𱮑; + #𱮒; + #𱮓; + #𱮔; + #𱮕; + #𱮖; + #𱮗; + #𱮘; + #𱮙; + #𱮚; + #𱮛; + #𱮜; + #𱮝; + #𱮞; + #𱮟; + #𱮠; + #𱮡; + #𱮢; + #𱮣; + #𱮤; + #𱮥; + #𱮦; + #𱮧; + #𱮨; + #𱮩; + #𱮪; + #𱮫; + #𱮬; + #𱮭; + #𱮮; + #𱮯; + #𱮰; + #𱮱; + #𱮲; + #𱮳; + #𱮴; + #𱮵; + #𱮶; + #𱮷; + #𱮸; + #𱮹; + #𱮺; + #𱮻; + #𱮼; + #𱮽; + #𱮾; + #𱮿; + #𱯀; + #𱯁; + #𱯂; + #𱯃; + #𱯄; + #𱯅; + #𱯆; + #𱯇; + #𱯈; + #𱯉; + #𱯊; + #𱯋; + #𱯌; + #𱯍; + #𱯎; + #𱯏; + #𱯐; + #𱯑; + #𱯒; + #𱯓; + #𱯔; + #𱯕; + #𱯖; + #𱯗; + #𱯘; + #𱯙; + #𱯚; + #𱯛; + #𱯜; + #𱯝; + #𱯞; + #𱯟; + #𱯠; + #𱯡; + #𱯢; + #𱯣; + #𱯤; + #𱯥; + #𱯦; + #𱯧; + #𱯨; + #𱯩; + #𱯪; + #𱯫; + #𱯬; + #𱯭; + #𱯮; + #𱯯; + #𱯰; + #𱯱; + #𱯲; + #𱯳; + #𱯴; + #𱯵; + #𱯶; + #𱯷; + #𱯸; + #𱯹; + #𱯺; + #𱯻; + #𱯼; + #𱯽; + #𱯾; + #𱯿; + #𱰀; + #𱰁; + #𱰂; + #𱰃; + #𱰄; + #𱰅; + #𱰆; + #𱰇; + #𱰈; + #𱰉; + #𱰊; + #𱰋; + #𱰌; + #𱰍; + #𱰎; + #𱰏; + #𱰐; + #𱰑; + #𱰒; + #𱰓; + #𱰔; + #𱰕; + #𱰖; + #𱰗; + #𱰘; + #𱰙; + #𱰚; + #𱰛; + #𱰜; + #𱰝; + #𱰞; + #𱰟; + #𱰠; + #𱰡; + #𱰢; + #𱰣; + #𱰤; + #𱰥; + #𱰦; + #𱰧; + #𱰨; + #𱰩; + #𱰪; + #𱰫; + #𱰬; + #𱰭; + #𱰮; + #𱰯; + #𱰰; + #𱰱; + #𱰲; + #𱰳; + #𱰴; + #𱰵; + #𱰶; + #𱰷; + #𱰸; + #𱰹; + #𱰺; + #𱰻; + #𱰼; + #𱰽; + #𱰾; + #𱰿; + #𱱀; + #𱱁; + #𱱂; + #𱱃; + #𱱄; + #𱱅; + #𱱆; + #𱱇; + #𱱈; + #𱱉; + #𱱊; + #𱱋; + #𱱌; + #𱱍; + #𱱎; + #𱱏; + #𱱐; + #𱱑; + #𱱒; + #𱱓; + #𱱔; + #𱱕; + #𱱖; + #𱱗; + #𱱘; + #𱱙; + #𱱚; + #𱱛; + #𱱜; + #𱱝; + #𱱞; + #𱱟; + #𱱠; + #𱱡; + #𱱢; + #𱱣; + #𱱤; + #𱱥; + #𱱦; + #𱱧; + #𱱨; + #𱱩; + #𱱪; + #𱱫; + #𱱬; + #𱱭; + #𱱮; + #𱱯; + #𱱰; + #𱱱; + #𱱲; + #𱱳; + #𱱴; + #𱱵; + #𱱶; + #𱱷; + #𱱸; + #𱱹; + #𱱺; + #𱱻; + #𱱼; + #𱱽; + #𱱾; + #𱱿; + #𱲀; + #𱲁; + #𱲂; + #𱲃; + #𱲄; + #𱲅; + #𱲆; + #𱲇; + #𱲈; + #𱲉; + #𱲊; + #𱲋; + #𱲌; + #𱲍; + #𱲎; + #𱲏; + #𱲐; + #𱲑; + #𱲒; + #𱲓; + #𱲔; + #𱲕; + #𱲖; + #𱲗; + #𱲘; + #𱲙; + #𱲚; + #𱲛; + #𱲜; + #𱲝; + #𱲞; + #𱲟; + #𱲠; + #𱲡; + #𱲢; + #𱲣; + #𱲤; + #𱲥; + #𱲦; + #𱲧; + #𱲨; + #𱲩; + #𱲪; + #𱲫; + #𱲬; + #𱲭; + #𱲮; + #𱲯; + #𱲰; + #𱲱; + #𱲲; + #𱲳; + #𱲴; + #𱲵; + #𱲶; + #𱲷; + #𱲸; + #𱲹; + #𱲺; + #𱲻; + #𱲼; + #𱲽; + #𱲾; + #𱲿; + #𱳀; + #𱳁; + #𱳂; + #𱳃; + #𱳄; + #𱳅; + #𱳆; + #𱳇; + #𱳈; + #𱳉; + #𱳊; + #𱳋; + #𱳌; + #𱳍; + #𱳎; + #𱳏; + #𱳐; + #𱳑; + #𱳒; + #𱳓; + #𱳔; + #𱳕; + #𱳖; + #𱳗; + #𱳘; + #𱳙; + #𱳚; + #𱳛; + #𱳜; + #𱳝; + #𱳞; + #𱳟; + #𱳠; + #𱳡; + #𱳢; + #𱳣; + #𱳤; + #𱳥; + #𱳦; + #𱳧; + #𱳨; + #𱳩; + #𱳪; + #𱳫; + #𱳬; + #𱳭; + #𱳮; + #𱳯; + #𱳰; + #𱳱; + #𱳲; + #𱳳; + #𱳴; + #𱳵; + #𱳶; + #𱳷; + #𱳸; + #𱳹; + #𱳺; + #𱳻; + #𱳼; + #𱳽; + #𱳾; + #𱳿; + #𱴀; + #𱴁; + #𱴂; + #𱴃; + #𱴄; + #𱴅; + #𱴆; + #𱴇; + #𱴈; + #𱴉; + #𱴊; + #𱴋; + #𱴌; + #𱴍; + #𱴎; + #𱴏; + #𱴐; + #𱴑; + #𱴒; + #𱴓; + #𱴔; + #𱴕; + #𱴖; + #𱴗; + #𱴘; + #𱴙; + #𱴚; + #𱴛; + #𱴜; + #𱴝; + #𱴞; + #𱴟; + #𱴠; + #𱴡; + #𱴢; + #𱴣; + #𱴤; + #𱴥; + #𱴦; + #𱴧; + #𱴨; + #𱴩; + #𱴪; + #𱴫; + #𱴬; + #𱴭; + #𱴮; + #𱴯; + #𱴰; + #𱴱; + #𱴲; + #𱴳; + #𱴴; + #𱴵; + #𱴶; + #𱴷; + #𱴸; + #𱴹; + #𱴺; + #𱴻; + #𱴼; + #𱴽; + #𱴾; + #𱴿; + #𱵀; + #𱵁; + #𱵂; + #𱵃; + #𱵄; + #𱵅; + #𱵆; + #𱵇; + #𱵈; + #𱵉; + #𱵊; + #𱵋; + #𱵌; + #𱵍; + #𱵎; + #𱵏; + #𱵐; + #𱵑; + #𱵒; + #𱵓; + #𱵔; + #𱵕; + #𱵖; + #𱵗; + #𱵘; + #𱵙; + #𱵚; + #𱵛; + #𱵜; + #𱵝; + #𱵞; + #𱵟; + #𱵠; + #𱵡; + #𱵢; + #𱵣; + #𱵤; + #𱵥; + #𱵦; + #𱵧; + #𱵨; + #𱵩; + #𱵪; + #𱵫; + #𱵬; + #𱵭; + #𱵮; + #𱵯; + #𱵰; + #𱵱; + #𱵲; + #𱵳; + #𱵴; + #𱵵; + #𱵶; + #𱵷; + #𱵸; + #𱵹; + #𱵺; + #𱵻; + #𱵼; + #𱵽; + #𱵾; + #𱵿; + #𱶀; + #𱶁; + #𱶂; + #𱶃; + #𱶄; + #𱶅; + #𱶆; + #𱶇; + #𱶈; + #𱶉; + #𱶊; + #𱶋; + #𱶌; + #𱶍; + #𱶎; + #𱶏; + #𱶐; + #𱶑; + #𱶒; + #𱶓; + #𱶔; + #𱶕; + #𱶖; + #𱶗; + #𱶘; + #𱶙; + #𱶚; + #𱶛; + #𱶜; + #𱶝; + #𱶞; + #𱶟; + #𱶠; + #𱶡; + #𱶢; + #𱶣; + #𱶤; + #𱶥; + #𱶦; + #𱶧; + #𱶨; + #𱶩; + #𱶪; + #𱶫; + #𱶬; + #𱶭; + #𱶮; + #𱶯; + #𱶰; + #𱶱; + #𱶲; + #𱶳; + #𱶴; + #𱶵; + #𱶶; + #𱶷; + #𱶸; + #𱶹; + #𱶺; + #𱶻; + #𱶼; + #𱶽; + #𱶾; + #𱶿; + #𱷀; + #𱷁; + #𱷂; + #𱷃; + #𱷄; + #𱷅; + #𱷆; + #𱷇; + #𱷈; + #𱷉; + #𱷊; + #𱷋; + #𱷌; + #𱷍; + #𱷎; + #𱷏; + #𱷐; + #𱷑; + #𱷒; + #𱷓; + #𱷔; + #𱷕; + #𱷖; + #𱷗; + #𱷘; + #𱷙; + #𱷚; + #𱷛; + #𱷜; + #𱷝; + #𱷞; + #𱷟; + #𱷠; + #𱷡; + #𱷢; + #𱷣; + #𱷤; + #𱷥; + #𱷦; + #𱷧; + #𱷨; + #𱷩; + #𱷪; + #𱷫; + #𱷬; + #𱷭; + #𱷮; + #𱷯; + #𱷰; + #𱷱; + #𱷲; + #𱷳; + #𱷴; + #𱷵; + #𱷶; + #𱷷; + #𱷸; + #𱷹; + #𱷺; + #𱷻; + #𱷼; + #𱷽; + #𱷾; + #𱷿; + #𱸀; + #𱸁; + #𱸂; + #𱸃; + #𱸄; + #𱸅; + #𱸆; + #𱸇; + #𱸈; + #𱸉; + #𱸊; + #𱸋; + #𱸌; + #𱸍; + #𱸎; + #𱸏; + #𱸐; + #𱸑; + #𱸒; + #𱸓; + #𱸔; + #𱸕; + #𱸖; + #𱸗; + #𱸘; + #𱸙; + #𱸚; + #𱸛; + #𱸜; + #𱸝; + #𱸞; + #𱸟; + #𱸠; + #𱸡; + #𱸢; + #𱸣; + #𱸤; + #𱸥; + #𱸦; + #𱸧; + #𱸨; + #𱸩; + #𱸪; + #𱸫; + #𱸬; + #𱸭; + #𱸮; + #𱸯; + #𱸰; + #𱸱; + #𱸲; + #𱸳; + #𱸴; + #𱸵; + #𱸶; + #𱸷; + #𱸸; + #𱸹; + #𱸺; + #𱸻; + #𱸼; + #𱸽; + #𱸾; + #𱸿; + #𱹀; + #𱹁; + #𱹂; + #𱹃; + #𱹄; + #𱹅; + #𱹆; + #𱹇; + #𱹈; + #𱹉; + #𱹊; + #𱹋; + #𱹌; + #𱹍; + #𱹎; + #𱹏; + #𱹐; + #𱹑; + #𱹒; + #𱹓; + #𱹔; + #𱹕; + #𱹖; + #𱹗; + #𱹘; + #𱹙; + #𱹚; + #𱹛; + #𱹜; + #𱹝; + #𱹞; + #𱹟; + #𱹠; + #𱹡; + #𱹢; + #𱹣; + #𱹤; + #𱹥; + #𱹦; + #𱹧; + #𱹨; + #𱹩; + #𱹪; + #𱹫; + #𱹬; + #𱹭; + #𱹮; + #𱹯; + #𱹰; + #𱹱; + #𱹲; + #𱹳; + #𱹴; + #𱹵; + #𱹶; + #𱹷; + #𱹸; + #𱹹; + #𱹺; + #𱹻; + #𱹼; + #𱹽; + #𱹾; + #𱹿; + #𱺀; + #𱺁; + #𱺂; + #𱺃; + #𱺄; + #𱺅; + #𱺆; + #𱺇; + #𱺈; + #𱺉; + #𱺊; + #𱺋; + #𱺌; + #𱺍; + #𱺎; + #𱺏; + #𱺐; + #𱺑; + #𱺒; + #𱺓; + #𱺔; + #𱺕; + #𱺖; + #𱺗; + #𱺘; + #𱺙; + #𱺚; + #𱺛; + #𱺜; + #𱺝; + #𱺞; + #𱺟; + #𱺠; + #𱺡; + #𱺢; + #𱺣; + #𱺤; + #𱺥; + #𱺦; + #𱺧; + #𱺨; + #𱺩; + #𱺪; + #𱺫; + #𱺬; + #𱺭; + #𱺮; + #𱺯; + #𱺰; + #𱺱; + #𱺲; + #𱺳; + #𱺴; + #𱺵; + #𱺶; + #𱺷; + #𱺸; + #𱺹; + #𱺺; + #𱺻; + #𱺼; + #𱺽; + #𱺾; + #𱺿; + #𱻀; + #𱻁; + #𱻂; + #𱻃; + #𱻄; + #𱻅; + #𱻆; + #𱻇; + #𱻈; + #𱻉; + #𱻊; + #𱻋; + #𱻌; + #𱻍; + #𱻎; + #𱻏; + #𱻐; + #𱻑; + #𱻒; + #𱻓; + #𱻔; + #𱻕; + #𱻖; + #𱻗; + #𱻘; + #𱻙; + #𱻚; + #𱻛; + #𱻜; + #𱻝; + #𱻞; + #𱻟; + #𱻠; + #𱻡; + #𱻢; + #𱻣; + #𱻤; + #𱻥; + #𱻦; + #𱻧; + #𱻨; + #𱻩; + #𱻪; + #𱻫; + #𱻬; + #𱻭; + #𱻮; + #𱻯; + #𱻰; + #𱻱; + #𱻲; + #𱻳; + #𱻴; + #𱻵; + #𱻶; + #𱻷; + #𱻸; + #𱻹; + #𱻺; + #𱻻; + #𱻼; + #𱻽; + #𱻾; + #𱻿; + #𱼀; + #𱼁; + #𱼂; + #𱼃; + #𱼄; + #𱼅; + #𱼆; + #𱼇; + #𱼈; + #𱼉; + #𱼊; + #𱼋; + #𱼌; + #𱼍; + #𱼎; + #𱼏; + #𱼐; + #𱼑; + #𱼒; + #𱼓; + #𱼔; + #𱼕; + #𱼖; + #𱼗; + #𱼘; + #𱼙; + #𱼚; + #𱼛; + #𱼜; + #𱼝; + #𱼞; + #𱼟; + #𱼠; + #𱼡; + #𱼢; + #𱼣; + #𱼤; + #𱼥; + #𱼦; + #𱼧; + #𱼨; + #𱼩; + #𱼪; + #𱼫; + #𱼬; + #𱼭; + #𱼮; + #𱼯; + #𱼰; + #𱼱; + #𱼲; + #𱼳; + #𱼴; + #𱼵; + #𱼶; + #𱼷; + #𱼸; + #𱼹; + #𱼺; + #𱼻; + #𱼼; + #𱼽; + #𱼾; + #𱼿; + #𱽀; + #𱽁; + #𱽂; + #𱽃; + #𱽄; + #𱽅; + #𱽆; + #𱽇; + #𱽈; + #𱽉; + #𱽊; + #𱽋; + #𱽌; + #𱽍; + #𱽎; + #𱽏; + #𱽐; + #𱽑; + #𱽒; + #𱽓; + #𱽔; + #𱽕; + #𱽖; + #𱽗; + #𱽘; + #𱽙; + #𱽚; + #𱽛; + #𱽜; + #𱽝; + #𱽞; + #𱽟; + #𱽠; + #𱽡; + #𱽢; + #𱽣; + #𱽤; + #𱽥; + #𱽦; + #𱽧; + #𱽨; + #𱽩; + #𱽪; + #𱽫; + #𱽬; + #𱽭; + #𱽮; + #𱽯; + #𱽰; + #𱽱; + #𱽲; + #𱽳; + #𱽴; + #𱽵; + #𱽶; + #𱽷; + #𱽸; + #𱽹; + #𱽺; + #𱽻; + #𱽼; + #𱽽; + #𱽾; + #𱽿; + #𱾀; + #𱾁; + #𱾂; + #𱾃; + #𱾄; + #𱾅; + #𱾆; + #𱾇; + #𱾈; + #𱾉; + #𱾊; + #𱾋; + #𱾌; + #𱾍; + #𱾎; + #𱾏; + #𱾐; + #𱾑; + #𱾒; + #𱾓; + #𱾔; + #𱾕; + #𱾖; + #𱾗; + #𱾘; + #𱾙; + #𱾚; + #𱾛; + #𱾜; + #𱾝; + #𱾞; + #𱾟; + #𱾠; + #𱾡; + #𱾢; + #𱾣; + #𱾤; + #𱾥; + #𱾦; + #𱾧; + #𱾨; + #𱾩; + #𱾪; + #𱾫; + #𱾬; + #𱾭; + #𱾮; + #𱾯; + #𱾰; + #𱾱; + #𱾲; + #𱾳; + #𱾴; + #𱾵; + #𱾶; + #𱾷; + #𱾸; + #𱾹; + #𱾺; + #𱾻; + #𱾼; + #𱾽; + #𱾾; + #𱾿; + #𱿀; + #𱿁; + #𱿂; + #𱿃; + #𱿄; + #𱿅; + #𱿆; + #𱿇; + #𱿈; + #𱿉; + #𱿊; + #𱿋; + #𱿌; + #𱿍; + #𱿎; + #𱿏; + #𱿐; + #𱿑; + #𱿒; + #𱿓; + #𱿔; + #𱿕; + #𱿖; + #𱿗; + #𱿘; + #𱿙; + #𱿚; + #𱿛; + #𱿜; + #𱿝; + #𱿞; + #𱿟; + #𱿠; + #𱿡; + #𱿢; + #𱿣; + #𱿤; + #𱿥; + #𱿦; + #𱿧; + #𱿨; + #𱿩; + #𱿪; + #𱿫; + #𱿬; + #𱿭; + #𱿮; + #𱿯; + #𱿰; + #𱿱; + #𱿲; + #𱿳; + #𱿴; + #𱿵; + #𱿶; + #𱿷; + #𱿸; + #𱿹; + #𱿺; + #𱿻; + #𱿼; + #𱿽; + #𱿾; + #𱿿; + #𲀀; + #𲀁; + #𲀂; + #𲀃; + #𲀄; + #𲀅; + #𲀆; + #𲀇; + #𲀈; + #𲀉; + #𲀊; + #𲀋; + #𲀌; + #𲀍; + #𲀎; + #𲀏; + #𲀐; + #𲀑; + #𲀒; + #𲀓; + #𲀔; + #𲀕; + #𲀖; + #𲀗; + #𲀘; + #𲀙; + #𲀚; + #𲀛; + #𲀜; + #𲀝; + #𲀞; + #𲀟; + #𲀠; + #𲀡; + #𲀢; + #𲀣; + #𲀤; + #𲀥; + #𲀦; + #𲀧; + #𲀨; + #𲀩; + #𲀪; + #𲀫; + #𲀬; + #𲀭; + #𲀮; + #𲀯; + #𲀰; + #𲀱; + #𲀲; + #𲀳; + #𲀴; + #𲀵; + #𲀶; + #𲀷; + #𲀸; + #𲀹; + #𲀺; + #𲀻; + #𲀼; + #𲀽; + #𲀾; + #𲀿; + #𲁀; + #𲁁; + #𲁂; + #𲁃; + #𲁄; + #𲁅; + #𲁆; + #𲁇; + #𲁈; + #𲁉; + #𲁊; + #𲁋; + #𲁌; + #𲁍; + #𲁎; + #𲁏; + #𲁐; + #𲁑; + #𲁒; + #𲁓; + #𲁔; + #𲁕; + #𲁖; + #𲁗; + #𲁘; + #𲁙; + #𲁚; + #𲁛; + #𲁜; + #𲁝; + #𲁞; + #𲁟; + #𲁠; + #𲁡; + #𲁢; + #𲁣; + #𲁤; + #𲁥; + #𲁦; + #𲁧; + #𲁨; + #𲁩; + #𲁪; + #𲁫; + #𲁬; + #𲁭; + #𲁮; + #𲁯; + #𲁰; + #𲁱; + #𲁲; + #𲁳; + #𲁴; + #𲁵; + #𲁶; + #𲁷; + #𲁸; + #𲁹; + #𲁺; + #𲁻; + #𲁼; + #𲁽; + #𲁾; + #𲁿; + #𲂀; + #𲂁; + #𲂂; + #𲂃; + #𲂄; + #𲂅; + #𲂆; + #𲂇; + #𲂈; + #𲂉; + #𲂊; + #𲂋; + #𲂌; + #𲂍; + #𲂎; + #𲂏; + #𲂐; + #𲂑; + #𲂒; + #𲂓; + #𲂔; + #𲂕; + #𲂖; + #𲂗; + #𲂘; + #𲂙; + #𲂚; + #𲂛; + #𲂜; + #𲂝; + #𲂞; + #𲂟; + #𲂠; + #𲂡; + #𲂢; + #𲂣; + #𲂤; + #𲂥; + #𲂦; + #𲂧; + #𲂨; + #𲂩; + #𲂪; + #𲂫; + #𲂬; + #𲂭; + #𲂮; + #𲂯; + #𲂰; + #𲂱; + #𲂲; + #𲂳; + #𲂴; + #𲂵; + #𲂶; + #𲂷; + #𲂸; + #𲂹; + #𲂺; + #𲂻; + #𲂼; + #𲂽; + #𲂾; + #𲂿; + #𲃀; + #𲃁; + #𲃂; + #𲃃; + #𲃄; + #𲃅; + #𲃆; + #𲃇; + #𲃈; + #𲃉; + #𲃊; + #𲃋; + #𲃌; + #𲃍; + #𲃎; + #𲃏; + #𲃐; + #𲃑; + #𲃒; + #𲃓; + #𲃔; + #𲃕; + #𲃖; + #𲃗; + #𲃘; + #𲃙; + #𲃚; + #𲃛; + #𲃜; + #𲃝; + #𲃞; + #𲃟; + #𲃠; + #𲃡; + #𲃢; + #𲃣; + #𲃤; + #𲃥; + #𲃦; + #𲃧; + #𲃨; + #𲃩; + #𲃪; + #𲃫; + #𲃬; + #𲃭; + #𲃮; + #𲃯; + #𲃰; + #𲃱; + #𲃲; + #𲃳; + #𲃴; + #𲃵; + #𲃶; + #𲃷; + #𲃸; + #𲃹; + #𲃺; + #𲃻; + #𲃼; + #𲃽; + #𲃾; + #𲃿; + #𲄀; + #𲄁; + #𲄂; + #𲄃; + #𲄄; + #𲄅; + #𲄆; + #𲄇; + #𲄈; + #𲄉; + #𲄊; + #𲄋; + #𲄌; + #𲄍; + #𲄎; + #𲄏; + #𲄐; + #𲄑; + #𲄒; + #𲄓; + #𲄔; + #𲄕; + #𲄖; + #𲄗; + #𲄘; + #𲄙; + #𲄚; + #𲄛; + #𲄜; + #𲄝; + #𲄞; + #𲄟; + #𲄠; + #𲄡; + #𲄢; + #𲄣; + #𲄤; + #𲄥; + #𲄦; + #𲄧; + #𲄨; + #𲄩; + #𲄪; + #𲄫; + #𲄬; + #𲄭; + #𲄮; + #𲄯; + #𲄰; + #𲄱; + #𲄲; + #𲄳; + #𲄴; + #𲄵; + #𲄶; + #𲄷; + #𲄸; + #𲄹; + #𲄺; + #𲄻; + #𲄼; + #𲄽; + #𲄾; + #𲄿; + #𲅀; + #𲅁; + #𲅂; + #𲅃; + #𲅄; + #𲅅; + #𲅆; + #𲅇; + #𲅈; + #𲅉; + #𲅊; + #𲅋; + #𲅌; + #𲅍; + #𲅎; + #𲅏; + #𲅐; + #𲅑; + #𲅒; + #𲅓; + #𲅔; + #𲅕; + #𲅖; + #𲅗; + #𲅘; + #𲅙; + #𲅚; + #𲅛; + #𲅜; + #𲅝; + #𲅞; + #𲅟; + #𲅠; + #𲅡; + #𲅢; + #𲅣; + #𲅤; + #𲅥; + #𲅦; + #𲅧; + #𲅨; + #𲅩; + #𲅪; + #𲅫; + #𲅬; + #𲅭; + #𲅮; + #𲅯; + #𲅰; + #𲅱; + #𲅲; + #𲅳; + #𲅴; + #𲅵; + #𲅶; + #𲅷; + #𲅸; + #𲅹; + #𲅺; + #𲅻; + #𲅼; + #𲅽; + #𲅾; + #𲅿; + #𲆀; + #𲆁; + #𲆂; + #𲆃; + #𲆄; + #𲆅; + #𲆆; + #𲆇; + #𲆈; + #𲆉; + #𲆊; + #𲆋; + #𲆌; + #𲆍; + #𲆎; + #𲆏; + #𲆐; + #𲆑; + #𲆒; + #𲆓; + #𲆔; + #𲆕; + #𲆖; + #𲆗; + #𲆘; + #𲆙; + #𲆚; + #𲆛; + #𲆜; + #𲆝; + #𲆞; + #𲆟; + #𲆠; + #𲆡; + #𲆢; + #𲆣; + #𲆤; + #𲆥; + #𲆦; + #𲆧; + #𲆨; + #𲆩; + #𲆪; + #𲆫; + #𲆬; + #𲆭; + #𲆮; + #𲆯; + #𲆰; + #𲆱; + #𲆲; + #𲆳; + #𲆴; + #𲆵; + #𲆶; + #𲆷; + #𲆸; + #𲆹; + #𲆺; + #𲆻; + #𲆼; + #𲆽; + #𲆾; + #𲆿; + #𲇀; + #𲇁; + #𲇂; + #𲇃; + #𲇄; + #𲇅; + #𲇆; + #𲇇; + #𲇈; + #𲇉; + #𲇊; + #𲇋; + #𲇌; + #𲇍; + #𲇎; + #𲇏; + #𲇐; + #𲇑; + #𲇒; + #𲇓; + #𲇔; + #𲇕; + #𲇖; + #𲇗; + #𲇘; + #𲇙; + #𲇚; + #𲇛; + #𲇜; + #𲇝; + #𲇞; + #𲇟; + #𲇠; + #𲇡; + #𲇢; + #𲇣; + #𲇤; + #𲇥; + #𲇦; + #𲇧; + #𲇨; + #𲇩; + #𲇪; + #𲇫; + #𲇬; + #𲇭; + #𲇮; + #𲇯; + #𲇰; + #𲇱; + #𲇲; + #𲇳; + #𲇴; + #𲇵; + #𲇶; + #𲇷; + #𲇸; + #𲇹; + #𲇺; + #𲇻; + #𲇼; + #𲇽; + #𲇾; + #𲇿; + #𲈀; + #𲈁; + #𲈂; + #𲈃; + #𲈄; + #𲈅; + #𲈆; + #𲈇; + #𲈈; + #𲈉; + #𲈊; + #𲈋; + #𲈌; + #𲈍; + #𲈎; + #𲈏; + #𲈐; + #𲈑; + #𲈒; + #𲈓; + #𲈔; + #𲈕; + #𲈖; + #𲈗; + #𲈘; + #𲈙; + #𲈚; + #𲈛; + #𲈜; + #𲈝; + #𲈞; + #𲈟; + #𲈠; + #𲈡; + #𲈢; + #𲈣; + #𲈤; + #𲈥; + #𲈦; + #𲈧; + #𲈨; + #𲈩; + #𲈪; + #𲈫; + #𲈬; + #𲈭; + #𲈮; + #𲈯; + #𲈰; + #𲈱; + #𲈲; + #𲈳; + #𲈴; + #𲈵; + #𲈶; + #𲈷; + #𲈸; + #𲈹; + #𲈺; + #𲈻; + #𲈼; + #𲈽; + #𲈾; + #𲈿; + #𲉀; + #𲉁; + #𲉂; + #𲉃; + #𲉄; + #𲉅; + #𲉆; + #𲉇; + #𲉈; + #𲉉; + #𲉊; + #𲉋; + #𲉌; + #𲉍; + #𲉎; + #𲉏; + #𲉐; + #𲉑; + #𲉒; + #𲉓; + #𲉔; + #𲉕; + #𲉖; + #𲉗; + #𲉘; + #𲉙; + #𲉚; + #𲉛; + #𲉜; + #𲉝; + #𲉞; + #𲉟; + #𲉠; + #𲉡; + #𲉢; + #𲉣; + #𲉤; + #𲉥; + #𲉦; + #𲉧; + #𲉨; + #𲉩; + #𲉪; + #𲉫; + #𲉬; + #𲉭; + #𲉮; + #𲉯; + #𲉰; + #𲉱; + #𲉲; + #𲉳; + #𲉴; + #𲉵; + #𲉶; + #𲉷; + #𲉸; + #𲉹; + #𲉺; + #𲉻; + #𲉼; + #𲉽; + #𲉾; + #𲉿; + #𲊀; + #𲊁; + #𲊂; + #𲊃; + #𲊄; + #𲊅; + #𲊆; + #𲊇; + #𲊈; + #𲊉; + #𲊊; + #𲊋; + #𲊌; + #𲊍; + #𲊎; + #𲊏; + #𲊐; + #𲊑; + #𲊒; + #𲊓; + #𲊔; + #𲊕; + #𲊖; + #𲊗; + #𲊘; + #𲊙; + #𲊚; + #𲊛; + #𲊜; + #𲊝; + #𲊞; + #𲊟; + #𲊠; + #𲊡; + #𲊢; + #𲊣; + #𲊤; + #𲊥; + #𲊦; + #𲊧; + #𲊨; + #𲊩; + #𲊪; + #𲊫; + #𲊬; + #𲊭; + #𲊮; + #𲊯; + #𲊰; + #𲊱; + #𲊲; + #𲊳; + #𲊴; + #𲊵; + #𲊶; + #𲊷; + #𲊸; + #𲊹; + #𲊺; + #𲊻; + #𲊼; + #𲊽; + #𲊾; + #𲊿; + #𲋀; + #𲋁; + #𲋂; + #𲋃; + #𲋄; + #𲋅; + #𲋆; + #𲋇; + #𲋈; + #𲋉; + #𲋊; + #𲋋; + #𲋌; + #𲋍; + #𲋎; + #𲋏; + #𲋐; + #𲋑; + #𲋒; + #𲋓; + #𲋔; + #𲋕; + #𲋖; + #𲋗; + #𲋘; + #𲋙; + #𲋚; + #𲋛; + #𲋜; + #𲋝; + #𲋞; + #𲋟; + #𲋠; + #𲋡; + #𲋢; + #𲋣; + #𲋤; + #𲋥; + #𲋦; + #𲋧; + #𲋨; + #𲋩; + #𲋪; + #𲋫; + #𲋬; + #𲋭; + #𲋮; + #𲋯; + #𲋰; + #𲋱; + #𲋲; + #𲋳; + #𲋴; + #𲋵; + #𲋶; + #𲋷; + #𲋸; + #𲋹; + #𲋺; + #𲋻; + #𲋼; + #𲋽; + #𲋾; + #𲋿; + #𲌀; + #𲌁; + #𲌂; + #𲌃; + #𲌄; + #𲌅; + #𲌆; + #𲌇; + #𲌈; + #𲌉; + #𲌊; + #𲌋; + #𲌌; + #𲌍; + #𲌎; + #𲌏; + #𲌐; + #𲌑; + #𲌒; + #𲌓; + #𲌔; + #𲌕; + #𲌖; + #𲌗; + #𲌘; + #𲌙; + #𲌚; + #𲌛; + #𲌜; + #𲌝; + #𲌞; + #𲌟; + #𲌠; + #𲌡; + #𲌢; + #𲌣; + #𲌤; + #𲌥; + #𲌦; + #𲌧; + #𲌨; + #𲌩; + #𲌪; + #𲌫; + #𲌬; + #𲌭; + #𲌮; + #𲌯; + #𲌰; + #𲌱; + #𲌲; + #𲌳; + #𲌴; + #𲌵; + #𲌶; + #𲌷; + #𲌸; + #𲌹; + #𲌺; + #𲌻; + #𲌼; + #𲌽; + #𲌾; + #𲌿; + #𲍀; + #𲍁; + #𲍂; + #𲍃; + #𲍄; + #𲍅; + #𲍆; + #𲍇; + #𲍈; + #𲍉; + #𲍊; + #𲍋; + #𲍌; + #𲍍; + #𲍎; + #𲍏; + #𲍐; + #𲍑; + #𲍒; + #𲍓; + #𲍔; + #𲍕; + #𲍖; + #𲍗; + #𲍘; + #𲍙; + #𲍚; + #𲍛; + #𲍜; + #𲍝; + #𲍞; + #𲍟; + #𲍠; + #𲍡; + #𲍢; + #𲍣; + #𲍤; + #𲍥; + #𲍦; + #𲍧; + #𲍨; + #𲍩; + #𲍪; + #𲍫; + #𲍬; + #𲍭; + #𲍮; + #𲍯; + #𲍰; + #𲍱; + #𲍲; + #𲍳; + #𲍴; + #𲍵; + #𲍶; + #𲍷; + #𲍸; + #𲍹; + #𲍺; + #𲍻; + #𲍼; + #𲍽; + #𲍾; + #𲍿; + #𲎀; + #𲎁; + #𲎂; + #𲎃; + #𲎄; + #𲎅; + #𲎆; + #𲎇; + #𲎈; + #𲎉; + #𲎊; + #𲎋; + #𲎌; + #𲎍; + #𲎎; + #𲎏; + #𲎐; + #𲎑; + #𲎒; + #𲎓; + #𲎔; + #𲎕; + #𲎖; + #𲎗; + #𲎘; + #𲎙; + #𲎚; + #𲎛; + #𲎜; + #𲎝; + #𲎞; + #𲎟; + #𲎠; + #𲎡; + #𲎢; + #𲎣; + #𲎤; + #𲎥; + #𲎦; + #𲎧; + #𲎨; + #𲎩; + #𲎪; + #𲎫; + #𲎬; + #𲎭; + #𲎮; + #𲎯; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0-escaped.js new file mode 100644 index 000000000..b4493e294 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0-escaped.js @@ -0,0 +1,4363 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v15.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u{1123F}; +var \u{11240}; +var \u{11F02}; +var \u{11F04}; +var \u{11F05}; +var \u{11F06}; +var \u{11F07}; +var \u{11F08}; +var \u{11F09}; +var \u{11F0A}; +var \u{11F0B}; +var \u{11F0C}; +var \u{11F0D}; +var \u{11F0E}; +var \u{11F0F}; +var \u{11F10}; +var \u{11F12}; +var \u{11F13}; +var \u{11F14}; +var \u{11F15}; +var \u{11F16}; +var \u{11F17}; +var \u{11F18}; +var \u{11F19}; +var \u{11F1A}; +var \u{11F1B}; +var \u{11F1C}; +var \u{11F1D}; +var \u{11F1E}; +var \u{11F1F}; +var \u{11F20}; +var \u{11F21}; +var \u{11F22}; +var \u{11F23}; +var \u{11F24}; +var \u{11F25}; +var \u{11F26}; +var \u{11F27}; +var \u{11F28}; +var \u{11F29}; +var \u{11F2A}; +var \u{11F2B}; +var \u{11F2C}; +var \u{11F2D}; +var \u{11F2E}; +var \u{11F2F}; +var \u{11F30}; +var \u{11F31}; +var \u{11F32}; +var \u{11F33}; +var \u{1342F}; +var \u{13441}; +var \u{13442}; +var \u{13443}; +var \u{13444}; +var \u{13445}; +var \u{13446}; +var \u{1B132}; +var \u{1B155}; +var \u{1DF25}; +var \u{1DF26}; +var \u{1DF27}; +var \u{1DF28}; +var \u{1DF29}; +var \u{1DF2A}; +var \u{1E030}; +var \u{1E031}; +var \u{1E032}; +var \u{1E033}; +var \u{1E034}; +var \u{1E035}; +var \u{1E036}; +var \u{1E037}; +var \u{1E038}; +var \u{1E039}; +var \u{1E03A}; +var \u{1E03B}; +var \u{1E03C}; +var \u{1E03D}; +var \u{1E03E}; +var \u{1E03F}; +var \u{1E040}; +var \u{1E041}; +var \u{1E042}; +var \u{1E043}; +var \u{1E044}; +var \u{1E045}; +var \u{1E046}; +var \u{1E047}; +var \u{1E048}; +var \u{1E049}; +var \u{1E04A}; +var \u{1E04B}; +var \u{1E04C}; +var \u{1E04D}; +var \u{1E04E}; +var \u{1E04F}; +var \u{1E050}; +var \u{1E051}; +var \u{1E052}; +var \u{1E053}; +var \u{1E054}; +var \u{1E055}; +var \u{1E056}; +var \u{1E057}; +var \u{1E058}; +var \u{1E059}; +var \u{1E05A}; +var \u{1E05B}; +var \u{1E05C}; +var \u{1E05D}; +var \u{1E05E}; +var \u{1E05F}; +var \u{1E060}; +var \u{1E061}; +var \u{1E062}; +var \u{1E063}; +var \u{1E064}; +var \u{1E065}; +var \u{1E066}; +var \u{1E067}; +var \u{1E068}; +var \u{1E069}; +var \u{1E06A}; +var \u{1E06B}; +var \u{1E06C}; +var \u{1E06D}; +var \u{1E4D0}; +var \u{1E4D1}; +var \u{1E4D2}; +var \u{1E4D3}; +var \u{1E4D4}; +var \u{1E4D5}; +var \u{1E4D6}; +var \u{1E4D7}; +var \u{1E4D8}; +var \u{1E4D9}; +var \u{1E4DA}; +var \u{1E4DB}; +var \u{1E4DC}; +var \u{1E4DD}; +var \u{1E4DE}; +var \u{1E4DF}; +var \u{1E4E0}; +var \u{1E4E1}; +var \u{1E4E2}; +var \u{1E4E3}; +var \u{1E4E4}; +var \u{1E4E5}; +var \u{1E4E6}; +var \u{1E4E7}; +var \u{1E4E8}; +var \u{1E4E9}; +var \u{1E4EA}; +var \u{1E4EB}; +var \u{2B739}; +var \u{31350}; +var \u{31351}; +var \u{31352}; +var \u{31353}; +var \u{31354}; +var \u{31355}; +var \u{31356}; +var \u{31357}; +var \u{31358}; +var \u{31359}; +var \u{3135A}; +var \u{3135B}; +var \u{3135C}; +var \u{3135D}; +var \u{3135E}; +var \u{3135F}; +var \u{31360}; +var \u{31361}; +var \u{31362}; +var \u{31363}; +var \u{31364}; +var \u{31365}; +var \u{31366}; +var \u{31367}; +var \u{31368}; +var \u{31369}; +var \u{3136A}; +var \u{3136B}; +var \u{3136C}; +var \u{3136D}; +var \u{3136E}; +var \u{3136F}; +var \u{31370}; +var \u{31371}; +var \u{31372}; +var \u{31373}; +var \u{31374}; +var \u{31375}; +var \u{31376}; +var \u{31377}; +var \u{31378}; +var \u{31379}; +var \u{3137A}; +var \u{3137B}; +var \u{3137C}; +var \u{3137D}; +var \u{3137E}; +var \u{3137F}; +var \u{31380}; +var \u{31381}; +var \u{31382}; +var \u{31383}; +var \u{31384}; +var \u{31385}; +var \u{31386}; +var \u{31387}; +var \u{31388}; +var \u{31389}; +var \u{3138A}; +var \u{3138B}; +var \u{3138C}; +var \u{3138D}; +var \u{3138E}; +var \u{3138F}; +var \u{31390}; +var \u{31391}; +var \u{31392}; +var \u{31393}; +var \u{31394}; +var \u{31395}; +var \u{31396}; +var \u{31397}; +var \u{31398}; +var \u{31399}; +var \u{3139A}; +var \u{3139B}; +var \u{3139C}; +var \u{3139D}; +var \u{3139E}; +var \u{3139F}; +var \u{313A0}; +var \u{313A1}; +var \u{313A2}; +var \u{313A3}; +var \u{313A4}; +var \u{313A5}; +var \u{313A6}; +var \u{313A7}; +var \u{313A8}; +var \u{313A9}; +var \u{313AA}; +var \u{313AB}; +var \u{313AC}; +var \u{313AD}; +var \u{313AE}; +var \u{313AF}; +var \u{313B0}; +var \u{313B1}; +var \u{313B2}; +var \u{313B3}; +var \u{313B4}; +var \u{313B5}; +var \u{313B6}; +var \u{313B7}; +var \u{313B8}; +var \u{313B9}; +var \u{313BA}; +var \u{313BB}; +var \u{313BC}; +var \u{313BD}; +var \u{313BE}; +var \u{313BF}; +var \u{313C0}; +var \u{313C1}; +var \u{313C2}; +var \u{313C3}; +var \u{313C4}; +var \u{313C5}; +var \u{313C6}; +var \u{313C7}; +var \u{313C8}; +var \u{313C9}; +var \u{313CA}; +var \u{313CB}; +var \u{313CC}; +var \u{313CD}; +var \u{313CE}; +var \u{313CF}; +var \u{313D0}; +var \u{313D1}; +var \u{313D2}; +var \u{313D3}; +var \u{313D4}; +var \u{313D5}; +var \u{313D6}; +var \u{313D7}; +var \u{313D8}; +var \u{313D9}; +var \u{313DA}; +var \u{313DB}; +var \u{313DC}; +var \u{313DD}; +var \u{313DE}; +var \u{313DF}; +var \u{313E0}; +var \u{313E1}; +var \u{313E2}; +var \u{313E3}; +var \u{313E4}; +var \u{313E5}; +var \u{313E6}; +var \u{313E7}; +var \u{313E8}; +var \u{313E9}; +var \u{313EA}; +var \u{313EB}; +var \u{313EC}; +var \u{313ED}; +var \u{313EE}; +var \u{313EF}; +var \u{313F0}; +var \u{313F1}; +var \u{313F2}; +var \u{313F3}; +var \u{313F4}; +var \u{313F5}; +var \u{313F6}; +var \u{313F7}; +var \u{313F8}; +var \u{313F9}; +var \u{313FA}; +var \u{313FB}; +var \u{313FC}; +var \u{313FD}; +var \u{313FE}; +var \u{313FF}; +var \u{31400}; +var \u{31401}; +var \u{31402}; +var \u{31403}; +var \u{31404}; +var \u{31405}; +var \u{31406}; +var \u{31407}; +var \u{31408}; +var \u{31409}; +var \u{3140A}; +var \u{3140B}; +var \u{3140C}; +var \u{3140D}; +var \u{3140E}; +var \u{3140F}; +var \u{31410}; +var \u{31411}; +var \u{31412}; +var \u{31413}; +var \u{31414}; +var \u{31415}; +var \u{31416}; +var \u{31417}; +var \u{31418}; +var \u{31419}; +var \u{3141A}; +var \u{3141B}; +var \u{3141C}; +var \u{3141D}; +var \u{3141E}; +var \u{3141F}; +var \u{31420}; +var \u{31421}; +var \u{31422}; +var \u{31423}; +var \u{31424}; +var \u{31425}; +var \u{31426}; +var \u{31427}; +var \u{31428}; +var \u{31429}; +var \u{3142A}; +var \u{3142B}; +var \u{3142C}; +var \u{3142D}; +var \u{3142E}; +var \u{3142F}; +var \u{31430}; +var \u{31431}; +var \u{31432}; +var \u{31433}; +var \u{31434}; +var \u{31435}; +var \u{31436}; +var \u{31437}; +var \u{31438}; +var \u{31439}; +var \u{3143A}; +var \u{3143B}; +var \u{3143C}; +var \u{3143D}; +var \u{3143E}; +var \u{3143F}; +var \u{31440}; +var \u{31441}; +var \u{31442}; +var \u{31443}; +var \u{31444}; +var \u{31445}; +var \u{31446}; +var \u{31447}; +var \u{31448}; +var \u{31449}; +var \u{3144A}; +var \u{3144B}; +var \u{3144C}; +var \u{3144D}; +var \u{3144E}; +var \u{3144F}; +var \u{31450}; +var \u{31451}; +var \u{31452}; +var \u{31453}; +var \u{31454}; +var \u{31455}; +var \u{31456}; +var \u{31457}; +var \u{31458}; +var \u{31459}; +var \u{3145A}; +var \u{3145B}; +var \u{3145C}; +var \u{3145D}; +var \u{3145E}; +var \u{3145F}; +var \u{31460}; +var \u{31461}; +var \u{31462}; +var \u{31463}; +var \u{31464}; +var \u{31465}; +var \u{31466}; +var \u{31467}; +var \u{31468}; +var \u{31469}; +var \u{3146A}; +var \u{3146B}; +var \u{3146C}; +var \u{3146D}; +var \u{3146E}; +var \u{3146F}; +var \u{31470}; +var \u{31471}; +var \u{31472}; +var \u{31473}; +var \u{31474}; +var \u{31475}; +var \u{31476}; +var \u{31477}; +var \u{31478}; +var \u{31479}; +var \u{3147A}; +var \u{3147B}; +var \u{3147C}; +var \u{3147D}; +var \u{3147E}; +var \u{3147F}; +var \u{31480}; +var \u{31481}; +var \u{31482}; +var \u{31483}; +var \u{31484}; +var \u{31485}; +var \u{31486}; +var \u{31487}; +var \u{31488}; +var \u{31489}; +var \u{3148A}; +var \u{3148B}; +var \u{3148C}; +var \u{3148D}; +var \u{3148E}; +var \u{3148F}; +var \u{31490}; +var \u{31491}; +var \u{31492}; +var \u{31493}; +var \u{31494}; +var \u{31495}; +var \u{31496}; +var \u{31497}; +var \u{31498}; +var \u{31499}; +var \u{3149A}; +var \u{3149B}; +var \u{3149C}; +var \u{3149D}; +var \u{3149E}; +var \u{3149F}; +var \u{314A0}; +var \u{314A1}; +var \u{314A2}; +var \u{314A3}; +var \u{314A4}; +var \u{314A5}; +var \u{314A6}; +var \u{314A7}; +var \u{314A8}; +var \u{314A9}; +var \u{314AA}; +var \u{314AB}; +var \u{314AC}; +var \u{314AD}; +var \u{314AE}; +var \u{314AF}; +var \u{314B0}; +var \u{314B1}; +var \u{314B2}; +var \u{314B3}; +var \u{314B4}; +var \u{314B5}; +var \u{314B6}; +var \u{314B7}; +var \u{314B8}; +var \u{314B9}; +var \u{314BA}; +var \u{314BB}; +var \u{314BC}; +var \u{314BD}; +var \u{314BE}; +var \u{314BF}; +var \u{314C0}; +var \u{314C1}; +var \u{314C2}; +var \u{314C3}; +var \u{314C4}; +var \u{314C5}; +var \u{314C6}; +var \u{314C7}; +var \u{314C8}; +var \u{314C9}; +var \u{314CA}; +var \u{314CB}; +var \u{314CC}; +var \u{314CD}; +var \u{314CE}; +var \u{314CF}; +var \u{314D0}; +var \u{314D1}; +var \u{314D2}; +var \u{314D3}; +var \u{314D4}; +var \u{314D5}; +var \u{314D6}; +var \u{314D7}; +var \u{314D8}; +var \u{314D9}; +var \u{314DA}; +var \u{314DB}; +var \u{314DC}; +var \u{314DD}; +var \u{314DE}; +var \u{314DF}; +var \u{314E0}; +var \u{314E1}; +var \u{314E2}; +var \u{314E3}; +var \u{314E4}; +var \u{314E5}; +var \u{314E6}; +var \u{314E7}; +var \u{314E8}; +var \u{314E9}; +var \u{314EA}; +var \u{314EB}; +var \u{314EC}; +var \u{314ED}; +var \u{314EE}; +var \u{314EF}; +var \u{314F0}; +var \u{314F1}; +var \u{314F2}; +var \u{314F3}; +var \u{314F4}; +var \u{314F5}; +var \u{314F6}; +var \u{314F7}; +var \u{314F8}; +var \u{314F9}; +var \u{314FA}; +var \u{314FB}; +var \u{314FC}; +var \u{314FD}; +var \u{314FE}; +var \u{314FF}; +var \u{31500}; +var \u{31501}; +var \u{31502}; +var \u{31503}; +var \u{31504}; +var \u{31505}; +var \u{31506}; +var \u{31507}; +var \u{31508}; +var \u{31509}; +var \u{3150A}; +var \u{3150B}; +var \u{3150C}; +var \u{3150D}; +var \u{3150E}; +var \u{3150F}; +var \u{31510}; +var \u{31511}; +var \u{31512}; +var \u{31513}; +var \u{31514}; +var \u{31515}; +var \u{31516}; +var \u{31517}; +var \u{31518}; +var \u{31519}; +var \u{3151A}; +var \u{3151B}; +var \u{3151C}; +var \u{3151D}; +var \u{3151E}; +var \u{3151F}; +var \u{31520}; +var \u{31521}; +var \u{31522}; +var \u{31523}; +var \u{31524}; +var \u{31525}; +var \u{31526}; +var \u{31527}; +var \u{31528}; +var \u{31529}; +var \u{3152A}; +var \u{3152B}; +var \u{3152C}; +var \u{3152D}; +var \u{3152E}; +var \u{3152F}; +var \u{31530}; +var \u{31531}; +var \u{31532}; +var \u{31533}; +var \u{31534}; +var \u{31535}; +var \u{31536}; +var \u{31537}; +var \u{31538}; +var \u{31539}; +var \u{3153A}; +var \u{3153B}; +var \u{3153C}; +var \u{3153D}; +var \u{3153E}; +var \u{3153F}; +var \u{31540}; +var \u{31541}; +var \u{31542}; +var \u{31543}; +var \u{31544}; +var \u{31545}; +var \u{31546}; +var \u{31547}; +var \u{31548}; +var \u{31549}; +var \u{3154A}; +var \u{3154B}; +var \u{3154C}; +var \u{3154D}; +var \u{3154E}; +var \u{3154F}; +var \u{31550}; +var \u{31551}; +var \u{31552}; +var \u{31553}; +var \u{31554}; +var \u{31555}; +var \u{31556}; +var \u{31557}; +var \u{31558}; +var \u{31559}; +var \u{3155A}; +var \u{3155B}; +var \u{3155C}; +var \u{3155D}; +var \u{3155E}; +var \u{3155F}; +var \u{31560}; +var \u{31561}; +var \u{31562}; +var \u{31563}; +var \u{31564}; +var \u{31565}; +var \u{31566}; +var \u{31567}; +var \u{31568}; +var \u{31569}; +var \u{3156A}; +var \u{3156B}; +var \u{3156C}; +var \u{3156D}; +var \u{3156E}; +var \u{3156F}; +var \u{31570}; +var \u{31571}; +var \u{31572}; +var \u{31573}; +var \u{31574}; +var \u{31575}; +var \u{31576}; +var \u{31577}; +var \u{31578}; +var \u{31579}; +var \u{3157A}; +var \u{3157B}; +var \u{3157C}; +var \u{3157D}; +var \u{3157E}; +var \u{3157F}; +var \u{31580}; +var \u{31581}; +var \u{31582}; +var \u{31583}; +var \u{31584}; +var \u{31585}; +var \u{31586}; +var \u{31587}; +var \u{31588}; +var \u{31589}; +var \u{3158A}; +var \u{3158B}; +var \u{3158C}; +var \u{3158D}; +var \u{3158E}; +var \u{3158F}; +var \u{31590}; +var \u{31591}; +var \u{31592}; +var \u{31593}; +var \u{31594}; +var \u{31595}; +var \u{31596}; +var \u{31597}; +var \u{31598}; +var \u{31599}; +var \u{3159A}; +var \u{3159B}; +var \u{3159C}; +var \u{3159D}; +var \u{3159E}; +var \u{3159F}; +var \u{315A0}; +var \u{315A1}; +var \u{315A2}; +var \u{315A3}; +var \u{315A4}; +var \u{315A5}; +var \u{315A6}; +var \u{315A7}; +var \u{315A8}; +var \u{315A9}; +var \u{315AA}; +var \u{315AB}; +var \u{315AC}; +var \u{315AD}; +var \u{315AE}; +var \u{315AF}; +var \u{315B0}; +var \u{315B1}; +var \u{315B2}; +var \u{315B3}; +var \u{315B4}; +var \u{315B5}; +var \u{315B6}; +var \u{315B7}; +var \u{315B8}; +var \u{315B9}; +var \u{315BA}; +var \u{315BB}; +var \u{315BC}; +var \u{315BD}; +var \u{315BE}; +var \u{315BF}; +var \u{315C0}; +var \u{315C1}; +var \u{315C2}; +var \u{315C3}; +var \u{315C4}; +var \u{315C5}; +var \u{315C6}; +var \u{315C7}; +var \u{315C8}; +var \u{315C9}; +var \u{315CA}; +var \u{315CB}; +var \u{315CC}; +var \u{315CD}; +var \u{315CE}; +var \u{315CF}; +var \u{315D0}; +var \u{315D1}; +var \u{315D2}; +var \u{315D3}; +var \u{315D4}; +var \u{315D5}; +var \u{315D6}; +var \u{315D7}; +var \u{315D8}; +var \u{315D9}; +var \u{315DA}; +var \u{315DB}; +var \u{315DC}; +var \u{315DD}; +var \u{315DE}; +var \u{315DF}; +var \u{315E0}; +var \u{315E1}; +var \u{315E2}; +var \u{315E3}; +var \u{315E4}; +var \u{315E5}; +var \u{315E6}; +var \u{315E7}; +var \u{315E8}; +var \u{315E9}; +var \u{315EA}; +var \u{315EB}; +var \u{315EC}; +var \u{315ED}; +var \u{315EE}; +var \u{315EF}; +var \u{315F0}; +var \u{315F1}; +var \u{315F2}; +var \u{315F3}; +var \u{315F4}; +var \u{315F5}; +var \u{315F6}; +var \u{315F7}; +var \u{315F8}; +var \u{315F9}; +var \u{315FA}; +var \u{315FB}; +var \u{315FC}; +var \u{315FD}; +var \u{315FE}; +var \u{315FF}; +var \u{31600}; +var \u{31601}; +var \u{31602}; +var \u{31603}; +var \u{31604}; +var \u{31605}; +var \u{31606}; +var \u{31607}; +var \u{31608}; +var \u{31609}; +var \u{3160A}; +var \u{3160B}; +var \u{3160C}; +var \u{3160D}; +var \u{3160E}; +var \u{3160F}; +var \u{31610}; +var \u{31611}; +var \u{31612}; +var \u{31613}; +var \u{31614}; +var \u{31615}; +var \u{31616}; +var \u{31617}; +var \u{31618}; +var \u{31619}; +var \u{3161A}; +var \u{3161B}; +var \u{3161C}; +var \u{3161D}; +var \u{3161E}; +var \u{3161F}; +var \u{31620}; +var \u{31621}; +var \u{31622}; +var \u{31623}; +var \u{31624}; +var \u{31625}; +var \u{31626}; +var \u{31627}; +var \u{31628}; +var \u{31629}; +var \u{3162A}; +var \u{3162B}; +var \u{3162C}; +var \u{3162D}; +var \u{3162E}; +var \u{3162F}; +var \u{31630}; +var \u{31631}; +var \u{31632}; +var \u{31633}; +var \u{31634}; +var \u{31635}; +var \u{31636}; +var \u{31637}; +var \u{31638}; +var \u{31639}; +var \u{3163A}; +var \u{3163B}; +var \u{3163C}; +var \u{3163D}; +var \u{3163E}; +var \u{3163F}; +var \u{31640}; +var \u{31641}; +var \u{31642}; +var \u{31643}; +var \u{31644}; +var \u{31645}; +var \u{31646}; +var \u{31647}; +var \u{31648}; +var \u{31649}; +var \u{3164A}; +var \u{3164B}; +var \u{3164C}; +var \u{3164D}; +var \u{3164E}; +var \u{3164F}; +var \u{31650}; +var \u{31651}; +var \u{31652}; +var \u{31653}; +var \u{31654}; +var \u{31655}; +var \u{31656}; +var \u{31657}; +var \u{31658}; +var \u{31659}; +var \u{3165A}; +var \u{3165B}; +var \u{3165C}; +var \u{3165D}; +var \u{3165E}; +var \u{3165F}; +var \u{31660}; +var \u{31661}; +var \u{31662}; +var \u{31663}; +var \u{31664}; +var \u{31665}; +var \u{31666}; +var \u{31667}; +var \u{31668}; +var \u{31669}; +var \u{3166A}; +var \u{3166B}; +var \u{3166C}; +var \u{3166D}; +var \u{3166E}; +var \u{3166F}; +var \u{31670}; +var \u{31671}; +var \u{31672}; +var \u{31673}; +var \u{31674}; +var \u{31675}; +var \u{31676}; +var \u{31677}; +var \u{31678}; +var \u{31679}; +var \u{3167A}; +var \u{3167B}; +var \u{3167C}; +var \u{3167D}; +var \u{3167E}; +var \u{3167F}; +var \u{31680}; +var \u{31681}; +var \u{31682}; +var \u{31683}; +var \u{31684}; +var \u{31685}; +var \u{31686}; +var \u{31687}; +var \u{31688}; +var \u{31689}; +var \u{3168A}; +var \u{3168B}; +var \u{3168C}; +var \u{3168D}; +var \u{3168E}; +var \u{3168F}; +var \u{31690}; +var \u{31691}; +var \u{31692}; +var \u{31693}; +var \u{31694}; +var \u{31695}; +var \u{31696}; +var \u{31697}; +var \u{31698}; +var \u{31699}; +var \u{3169A}; +var \u{3169B}; +var \u{3169C}; +var \u{3169D}; +var \u{3169E}; +var \u{3169F}; +var \u{316A0}; +var \u{316A1}; +var \u{316A2}; +var \u{316A3}; +var \u{316A4}; +var \u{316A5}; +var \u{316A6}; +var \u{316A7}; +var \u{316A8}; +var \u{316A9}; +var \u{316AA}; +var \u{316AB}; +var \u{316AC}; +var \u{316AD}; +var \u{316AE}; +var \u{316AF}; +var \u{316B0}; +var \u{316B1}; +var \u{316B2}; +var \u{316B3}; +var \u{316B4}; +var \u{316B5}; +var \u{316B6}; +var \u{316B7}; +var \u{316B8}; +var \u{316B9}; +var \u{316BA}; +var \u{316BB}; +var \u{316BC}; +var \u{316BD}; +var \u{316BE}; +var \u{316BF}; +var \u{316C0}; +var \u{316C1}; +var \u{316C2}; +var \u{316C3}; +var \u{316C4}; +var \u{316C5}; +var \u{316C6}; +var \u{316C7}; +var \u{316C8}; +var \u{316C9}; +var \u{316CA}; +var \u{316CB}; +var \u{316CC}; +var \u{316CD}; +var \u{316CE}; +var \u{316CF}; +var \u{316D0}; +var \u{316D1}; +var \u{316D2}; +var \u{316D3}; +var \u{316D4}; +var \u{316D5}; +var \u{316D6}; +var \u{316D7}; +var \u{316D8}; +var \u{316D9}; +var \u{316DA}; +var \u{316DB}; +var \u{316DC}; +var \u{316DD}; +var \u{316DE}; +var \u{316DF}; +var \u{316E0}; +var \u{316E1}; +var \u{316E2}; +var \u{316E3}; +var \u{316E4}; +var \u{316E5}; +var \u{316E6}; +var \u{316E7}; +var \u{316E8}; +var \u{316E9}; +var \u{316EA}; +var \u{316EB}; +var \u{316EC}; +var \u{316ED}; +var \u{316EE}; +var \u{316EF}; +var \u{316F0}; +var \u{316F1}; +var \u{316F2}; +var \u{316F3}; +var \u{316F4}; +var \u{316F5}; +var \u{316F6}; +var \u{316F7}; +var \u{316F8}; +var \u{316F9}; +var \u{316FA}; +var \u{316FB}; +var \u{316FC}; +var \u{316FD}; +var \u{316FE}; +var \u{316FF}; +var \u{31700}; +var \u{31701}; +var \u{31702}; +var \u{31703}; +var \u{31704}; +var \u{31705}; +var \u{31706}; +var \u{31707}; +var \u{31708}; +var \u{31709}; +var \u{3170A}; +var \u{3170B}; +var \u{3170C}; +var \u{3170D}; +var \u{3170E}; +var \u{3170F}; +var \u{31710}; +var \u{31711}; +var \u{31712}; +var \u{31713}; +var \u{31714}; +var \u{31715}; +var \u{31716}; +var \u{31717}; +var \u{31718}; +var \u{31719}; +var \u{3171A}; +var \u{3171B}; +var \u{3171C}; +var \u{3171D}; +var \u{3171E}; +var \u{3171F}; +var \u{31720}; +var \u{31721}; +var \u{31722}; +var \u{31723}; +var \u{31724}; +var \u{31725}; +var \u{31726}; +var \u{31727}; +var \u{31728}; +var \u{31729}; +var \u{3172A}; +var \u{3172B}; +var \u{3172C}; +var \u{3172D}; +var \u{3172E}; +var \u{3172F}; +var \u{31730}; +var \u{31731}; +var \u{31732}; +var \u{31733}; +var \u{31734}; +var \u{31735}; +var \u{31736}; +var \u{31737}; +var \u{31738}; +var \u{31739}; +var \u{3173A}; +var \u{3173B}; +var \u{3173C}; +var \u{3173D}; +var \u{3173E}; +var \u{3173F}; +var \u{31740}; +var \u{31741}; +var \u{31742}; +var \u{31743}; +var \u{31744}; +var \u{31745}; +var \u{31746}; +var \u{31747}; +var \u{31748}; +var \u{31749}; +var \u{3174A}; +var \u{3174B}; +var \u{3174C}; +var \u{3174D}; +var \u{3174E}; +var \u{3174F}; +var \u{31750}; +var \u{31751}; +var \u{31752}; +var \u{31753}; +var \u{31754}; +var \u{31755}; +var \u{31756}; +var \u{31757}; +var \u{31758}; +var \u{31759}; +var \u{3175A}; +var \u{3175B}; +var \u{3175C}; +var \u{3175D}; +var \u{3175E}; +var \u{3175F}; +var \u{31760}; +var \u{31761}; +var \u{31762}; +var \u{31763}; +var \u{31764}; +var \u{31765}; +var \u{31766}; +var \u{31767}; +var \u{31768}; +var \u{31769}; +var \u{3176A}; +var \u{3176B}; +var \u{3176C}; +var \u{3176D}; +var \u{3176E}; +var \u{3176F}; +var \u{31770}; +var \u{31771}; +var \u{31772}; +var \u{31773}; +var \u{31774}; +var \u{31775}; +var \u{31776}; +var \u{31777}; +var \u{31778}; +var \u{31779}; +var \u{3177A}; +var \u{3177B}; +var \u{3177C}; +var \u{3177D}; +var \u{3177E}; +var \u{3177F}; +var \u{31780}; +var \u{31781}; +var \u{31782}; +var \u{31783}; +var \u{31784}; +var \u{31785}; +var \u{31786}; +var \u{31787}; +var \u{31788}; +var \u{31789}; +var \u{3178A}; +var \u{3178B}; +var \u{3178C}; +var \u{3178D}; +var \u{3178E}; +var \u{3178F}; +var \u{31790}; +var \u{31791}; +var \u{31792}; +var \u{31793}; +var \u{31794}; +var \u{31795}; +var \u{31796}; +var \u{31797}; +var \u{31798}; +var \u{31799}; +var \u{3179A}; +var \u{3179B}; +var \u{3179C}; +var \u{3179D}; +var \u{3179E}; +var \u{3179F}; +var \u{317A0}; +var \u{317A1}; +var \u{317A2}; +var \u{317A3}; +var \u{317A4}; +var \u{317A5}; +var \u{317A6}; +var \u{317A7}; +var \u{317A8}; +var \u{317A9}; +var \u{317AA}; +var \u{317AB}; +var \u{317AC}; +var \u{317AD}; +var \u{317AE}; +var \u{317AF}; +var \u{317B0}; +var \u{317B1}; +var \u{317B2}; +var \u{317B3}; +var \u{317B4}; +var \u{317B5}; +var \u{317B6}; +var \u{317B7}; +var \u{317B8}; +var \u{317B9}; +var \u{317BA}; +var \u{317BB}; +var \u{317BC}; +var \u{317BD}; +var \u{317BE}; +var \u{317BF}; +var \u{317C0}; +var \u{317C1}; +var \u{317C2}; +var \u{317C3}; +var \u{317C4}; +var \u{317C5}; +var \u{317C6}; +var \u{317C7}; +var \u{317C8}; +var \u{317C9}; +var \u{317CA}; +var \u{317CB}; +var \u{317CC}; +var \u{317CD}; +var \u{317CE}; +var \u{317CF}; +var \u{317D0}; +var \u{317D1}; +var \u{317D2}; +var \u{317D3}; +var \u{317D4}; +var \u{317D5}; +var \u{317D6}; +var \u{317D7}; +var \u{317D8}; +var \u{317D9}; +var \u{317DA}; +var \u{317DB}; +var \u{317DC}; +var \u{317DD}; +var \u{317DE}; +var \u{317DF}; +var \u{317E0}; +var \u{317E1}; +var \u{317E2}; +var \u{317E3}; +var \u{317E4}; +var \u{317E5}; +var \u{317E6}; +var \u{317E7}; +var \u{317E8}; +var \u{317E9}; +var \u{317EA}; +var \u{317EB}; +var \u{317EC}; +var \u{317ED}; +var \u{317EE}; +var \u{317EF}; +var \u{317F0}; +var \u{317F1}; +var \u{317F2}; +var \u{317F3}; +var \u{317F4}; +var \u{317F5}; +var \u{317F6}; +var \u{317F7}; +var \u{317F8}; +var \u{317F9}; +var \u{317FA}; +var \u{317FB}; +var \u{317FC}; +var \u{317FD}; +var \u{317FE}; +var \u{317FF}; +var \u{31800}; +var \u{31801}; +var \u{31802}; +var \u{31803}; +var \u{31804}; +var \u{31805}; +var \u{31806}; +var \u{31807}; +var \u{31808}; +var \u{31809}; +var \u{3180A}; +var \u{3180B}; +var \u{3180C}; +var \u{3180D}; +var \u{3180E}; +var \u{3180F}; +var \u{31810}; +var \u{31811}; +var \u{31812}; +var \u{31813}; +var \u{31814}; +var \u{31815}; +var \u{31816}; +var \u{31817}; +var \u{31818}; +var \u{31819}; +var \u{3181A}; +var \u{3181B}; +var \u{3181C}; +var \u{3181D}; +var \u{3181E}; +var \u{3181F}; +var \u{31820}; +var \u{31821}; +var \u{31822}; +var \u{31823}; +var \u{31824}; +var \u{31825}; +var \u{31826}; +var \u{31827}; +var \u{31828}; +var \u{31829}; +var \u{3182A}; +var \u{3182B}; +var \u{3182C}; +var \u{3182D}; +var \u{3182E}; +var \u{3182F}; +var \u{31830}; +var \u{31831}; +var \u{31832}; +var \u{31833}; +var \u{31834}; +var \u{31835}; +var \u{31836}; +var \u{31837}; +var \u{31838}; +var \u{31839}; +var \u{3183A}; +var \u{3183B}; +var \u{3183C}; +var \u{3183D}; +var \u{3183E}; +var \u{3183F}; +var \u{31840}; +var \u{31841}; +var \u{31842}; +var \u{31843}; +var \u{31844}; +var \u{31845}; +var \u{31846}; +var \u{31847}; +var \u{31848}; +var \u{31849}; +var \u{3184A}; +var \u{3184B}; +var \u{3184C}; +var \u{3184D}; +var \u{3184E}; +var \u{3184F}; +var \u{31850}; +var \u{31851}; +var \u{31852}; +var \u{31853}; +var \u{31854}; +var \u{31855}; +var \u{31856}; +var \u{31857}; +var \u{31858}; +var \u{31859}; +var \u{3185A}; +var \u{3185B}; +var \u{3185C}; +var \u{3185D}; +var \u{3185E}; +var \u{3185F}; +var \u{31860}; +var \u{31861}; +var \u{31862}; +var \u{31863}; +var \u{31864}; +var \u{31865}; +var \u{31866}; +var \u{31867}; +var \u{31868}; +var \u{31869}; +var \u{3186A}; +var \u{3186B}; +var \u{3186C}; +var \u{3186D}; +var \u{3186E}; +var \u{3186F}; +var \u{31870}; +var \u{31871}; +var \u{31872}; +var \u{31873}; +var \u{31874}; +var \u{31875}; +var \u{31876}; +var \u{31877}; +var \u{31878}; +var \u{31879}; +var \u{3187A}; +var \u{3187B}; +var \u{3187C}; +var \u{3187D}; +var \u{3187E}; +var \u{3187F}; +var \u{31880}; +var \u{31881}; +var \u{31882}; +var \u{31883}; +var \u{31884}; +var \u{31885}; +var \u{31886}; +var \u{31887}; +var \u{31888}; +var \u{31889}; +var \u{3188A}; +var \u{3188B}; +var \u{3188C}; +var \u{3188D}; +var \u{3188E}; +var \u{3188F}; +var \u{31890}; +var \u{31891}; +var \u{31892}; +var \u{31893}; +var \u{31894}; +var \u{31895}; +var \u{31896}; +var \u{31897}; +var \u{31898}; +var \u{31899}; +var \u{3189A}; +var \u{3189B}; +var \u{3189C}; +var \u{3189D}; +var \u{3189E}; +var \u{3189F}; +var \u{318A0}; +var \u{318A1}; +var \u{318A2}; +var \u{318A3}; +var \u{318A4}; +var \u{318A5}; +var \u{318A6}; +var \u{318A7}; +var \u{318A8}; +var \u{318A9}; +var \u{318AA}; +var \u{318AB}; +var \u{318AC}; +var \u{318AD}; +var \u{318AE}; +var \u{318AF}; +var \u{318B0}; +var \u{318B1}; +var \u{318B2}; +var \u{318B3}; +var \u{318B4}; +var \u{318B5}; +var \u{318B6}; +var \u{318B7}; +var \u{318B8}; +var \u{318B9}; +var \u{318BA}; +var \u{318BB}; +var \u{318BC}; +var \u{318BD}; +var \u{318BE}; +var \u{318BF}; +var \u{318C0}; +var \u{318C1}; +var \u{318C2}; +var \u{318C3}; +var \u{318C4}; +var \u{318C5}; +var \u{318C6}; +var \u{318C7}; +var \u{318C8}; +var \u{318C9}; +var \u{318CA}; +var \u{318CB}; +var \u{318CC}; +var \u{318CD}; +var \u{318CE}; +var \u{318CF}; +var \u{318D0}; +var \u{318D1}; +var \u{318D2}; +var \u{318D3}; +var \u{318D4}; +var \u{318D5}; +var \u{318D6}; +var \u{318D7}; +var \u{318D8}; +var \u{318D9}; +var \u{318DA}; +var \u{318DB}; +var \u{318DC}; +var \u{318DD}; +var \u{318DE}; +var \u{318DF}; +var \u{318E0}; +var \u{318E1}; +var \u{318E2}; +var \u{318E3}; +var \u{318E4}; +var \u{318E5}; +var \u{318E6}; +var \u{318E7}; +var \u{318E8}; +var \u{318E9}; +var \u{318EA}; +var \u{318EB}; +var \u{318EC}; +var \u{318ED}; +var \u{318EE}; +var \u{318EF}; +var \u{318F0}; +var \u{318F1}; +var \u{318F2}; +var \u{318F3}; +var \u{318F4}; +var \u{318F5}; +var \u{318F6}; +var \u{318F7}; +var \u{318F8}; +var \u{318F9}; +var \u{318FA}; +var \u{318FB}; +var \u{318FC}; +var \u{318FD}; +var \u{318FE}; +var \u{318FF}; +var \u{31900}; +var \u{31901}; +var \u{31902}; +var \u{31903}; +var \u{31904}; +var \u{31905}; +var \u{31906}; +var \u{31907}; +var \u{31908}; +var \u{31909}; +var \u{3190A}; +var \u{3190B}; +var \u{3190C}; +var \u{3190D}; +var \u{3190E}; +var \u{3190F}; +var \u{31910}; +var \u{31911}; +var \u{31912}; +var \u{31913}; +var \u{31914}; +var \u{31915}; +var \u{31916}; +var \u{31917}; +var \u{31918}; +var \u{31919}; +var \u{3191A}; +var \u{3191B}; +var \u{3191C}; +var \u{3191D}; +var \u{3191E}; +var \u{3191F}; +var \u{31920}; +var \u{31921}; +var \u{31922}; +var \u{31923}; +var \u{31924}; +var \u{31925}; +var \u{31926}; +var \u{31927}; +var \u{31928}; +var \u{31929}; +var \u{3192A}; +var \u{3192B}; +var \u{3192C}; +var \u{3192D}; +var \u{3192E}; +var \u{3192F}; +var \u{31930}; +var \u{31931}; +var \u{31932}; +var \u{31933}; +var \u{31934}; +var \u{31935}; +var \u{31936}; +var \u{31937}; +var \u{31938}; +var \u{31939}; +var \u{3193A}; +var \u{3193B}; +var \u{3193C}; +var \u{3193D}; +var \u{3193E}; +var \u{3193F}; +var \u{31940}; +var \u{31941}; +var \u{31942}; +var \u{31943}; +var \u{31944}; +var \u{31945}; +var \u{31946}; +var \u{31947}; +var \u{31948}; +var \u{31949}; +var \u{3194A}; +var \u{3194B}; +var \u{3194C}; +var \u{3194D}; +var \u{3194E}; +var \u{3194F}; +var \u{31950}; +var \u{31951}; +var \u{31952}; +var \u{31953}; +var \u{31954}; +var \u{31955}; +var \u{31956}; +var \u{31957}; +var \u{31958}; +var \u{31959}; +var \u{3195A}; +var \u{3195B}; +var \u{3195C}; +var \u{3195D}; +var \u{3195E}; +var \u{3195F}; +var \u{31960}; +var \u{31961}; +var \u{31962}; +var \u{31963}; +var \u{31964}; +var \u{31965}; +var \u{31966}; +var \u{31967}; +var \u{31968}; +var \u{31969}; +var \u{3196A}; +var \u{3196B}; +var \u{3196C}; +var \u{3196D}; +var \u{3196E}; +var \u{3196F}; +var \u{31970}; +var \u{31971}; +var \u{31972}; +var \u{31973}; +var \u{31974}; +var \u{31975}; +var \u{31976}; +var \u{31977}; +var \u{31978}; +var \u{31979}; +var \u{3197A}; +var \u{3197B}; +var \u{3197C}; +var \u{3197D}; +var \u{3197E}; +var \u{3197F}; +var \u{31980}; +var \u{31981}; +var \u{31982}; +var \u{31983}; +var \u{31984}; +var \u{31985}; +var \u{31986}; +var \u{31987}; +var \u{31988}; +var \u{31989}; +var \u{3198A}; +var \u{3198B}; +var \u{3198C}; +var \u{3198D}; +var \u{3198E}; +var \u{3198F}; +var \u{31990}; +var \u{31991}; +var \u{31992}; +var \u{31993}; +var \u{31994}; +var \u{31995}; +var \u{31996}; +var \u{31997}; +var \u{31998}; +var \u{31999}; +var \u{3199A}; +var \u{3199B}; +var \u{3199C}; +var \u{3199D}; +var \u{3199E}; +var \u{3199F}; +var \u{319A0}; +var \u{319A1}; +var \u{319A2}; +var \u{319A3}; +var \u{319A4}; +var \u{319A5}; +var \u{319A6}; +var \u{319A7}; +var \u{319A8}; +var \u{319A9}; +var \u{319AA}; +var \u{319AB}; +var \u{319AC}; +var \u{319AD}; +var \u{319AE}; +var \u{319AF}; +var \u{319B0}; +var \u{319B1}; +var \u{319B2}; +var \u{319B3}; +var \u{319B4}; +var \u{319B5}; +var \u{319B6}; +var \u{319B7}; +var \u{319B8}; +var \u{319B9}; +var \u{319BA}; +var \u{319BB}; +var \u{319BC}; +var \u{319BD}; +var \u{319BE}; +var \u{319BF}; +var \u{319C0}; +var \u{319C1}; +var \u{319C2}; +var \u{319C3}; +var \u{319C4}; +var \u{319C5}; +var \u{319C6}; +var \u{319C7}; +var \u{319C8}; +var \u{319C9}; +var \u{319CA}; +var \u{319CB}; +var \u{319CC}; +var \u{319CD}; +var \u{319CE}; +var \u{319CF}; +var \u{319D0}; +var \u{319D1}; +var \u{319D2}; +var \u{319D3}; +var \u{319D4}; +var \u{319D5}; +var \u{319D6}; +var \u{319D7}; +var \u{319D8}; +var \u{319D9}; +var \u{319DA}; +var \u{319DB}; +var \u{319DC}; +var \u{319DD}; +var \u{319DE}; +var \u{319DF}; +var \u{319E0}; +var \u{319E1}; +var \u{319E2}; +var \u{319E3}; +var \u{319E4}; +var \u{319E5}; +var \u{319E6}; +var \u{319E7}; +var \u{319E8}; +var \u{319E9}; +var \u{319EA}; +var \u{319EB}; +var \u{319EC}; +var \u{319ED}; +var \u{319EE}; +var \u{319EF}; +var \u{319F0}; +var \u{319F1}; +var \u{319F2}; +var \u{319F3}; +var \u{319F4}; +var \u{319F5}; +var \u{319F6}; +var \u{319F7}; +var \u{319F8}; +var \u{319F9}; +var \u{319FA}; +var \u{319FB}; +var \u{319FC}; +var \u{319FD}; +var \u{319FE}; +var \u{319FF}; +var \u{31A00}; +var \u{31A01}; +var \u{31A02}; +var \u{31A03}; +var \u{31A04}; +var \u{31A05}; +var \u{31A06}; +var \u{31A07}; +var \u{31A08}; +var \u{31A09}; +var \u{31A0A}; +var \u{31A0B}; +var \u{31A0C}; +var \u{31A0D}; +var \u{31A0E}; +var \u{31A0F}; +var \u{31A10}; +var \u{31A11}; +var \u{31A12}; +var \u{31A13}; +var \u{31A14}; +var \u{31A15}; +var \u{31A16}; +var \u{31A17}; +var \u{31A18}; +var \u{31A19}; +var \u{31A1A}; +var \u{31A1B}; +var \u{31A1C}; +var \u{31A1D}; +var \u{31A1E}; +var \u{31A1F}; +var \u{31A20}; +var \u{31A21}; +var \u{31A22}; +var \u{31A23}; +var \u{31A24}; +var \u{31A25}; +var \u{31A26}; +var \u{31A27}; +var \u{31A28}; +var \u{31A29}; +var \u{31A2A}; +var \u{31A2B}; +var \u{31A2C}; +var \u{31A2D}; +var \u{31A2E}; +var \u{31A2F}; +var \u{31A30}; +var \u{31A31}; +var \u{31A32}; +var \u{31A33}; +var \u{31A34}; +var \u{31A35}; +var \u{31A36}; +var \u{31A37}; +var \u{31A38}; +var \u{31A39}; +var \u{31A3A}; +var \u{31A3B}; +var \u{31A3C}; +var \u{31A3D}; +var \u{31A3E}; +var \u{31A3F}; +var \u{31A40}; +var \u{31A41}; +var \u{31A42}; +var \u{31A43}; +var \u{31A44}; +var \u{31A45}; +var \u{31A46}; +var \u{31A47}; +var \u{31A48}; +var \u{31A49}; +var \u{31A4A}; +var \u{31A4B}; +var \u{31A4C}; +var \u{31A4D}; +var \u{31A4E}; +var \u{31A4F}; +var \u{31A50}; +var \u{31A51}; +var \u{31A52}; +var \u{31A53}; +var \u{31A54}; +var \u{31A55}; +var \u{31A56}; +var \u{31A57}; +var \u{31A58}; +var \u{31A59}; +var \u{31A5A}; +var \u{31A5B}; +var \u{31A5C}; +var \u{31A5D}; +var \u{31A5E}; +var \u{31A5F}; +var \u{31A60}; +var \u{31A61}; +var \u{31A62}; +var \u{31A63}; +var \u{31A64}; +var \u{31A65}; +var \u{31A66}; +var \u{31A67}; +var \u{31A68}; +var \u{31A69}; +var \u{31A6A}; +var \u{31A6B}; +var \u{31A6C}; +var \u{31A6D}; +var \u{31A6E}; +var \u{31A6F}; +var \u{31A70}; +var \u{31A71}; +var \u{31A72}; +var \u{31A73}; +var \u{31A74}; +var \u{31A75}; +var \u{31A76}; +var \u{31A77}; +var \u{31A78}; +var \u{31A79}; +var \u{31A7A}; +var \u{31A7B}; +var \u{31A7C}; +var \u{31A7D}; +var \u{31A7E}; +var \u{31A7F}; +var \u{31A80}; +var \u{31A81}; +var \u{31A82}; +var \u{31A83}; +var \u{31A84}; +var \u{31A85}; +var \u{31A86}; +var \u{31A87}; +var \u{31A88}; +var \u{31A89}; +var \u{31A8A}; +var \u{31A8B}; +var \u{31A8C}; +var \u{31A8D}; +var \u{31A8E}; +var \u{31A8F}; +var \u{31A90}; +var \u{31A91}; +var \u{31A92}; +var \u{31A93}; +var \u{31A94}; +var \u{31A95}; +var \u{31A96}; +var \u{31A97}; +var \u{31A98}; +var \u{31A99}; +var \u{31A9A}; +var \u{31A9B}; +var \u{31A9C}; +var \u{31A9D}; +var \u{31A9E}; +var \u{31A9F}; +var \u{31AA0}; +var \u{31AA1}; +var \u{31AA2}; +var \u{31AA3}; +var \u{31AA4}; +var \u{31AA5}; +var \u{31AA6}; +var \u{31AA7}; +var \u{31AA8}; +var \u{31AA9}; +var \u{31AAA}; +var \u{31AAB}; +var \u{31AAC}; +var \u{31AAD}; +var \u{31AAE}; +var \u{31AAF}; +var \u{31AB0}; +var \u{31AB1}; +var \u{31AB2}; +var \u{31AB3}; +var \u{31AB4}; +var \u{31AB5}; +var \u{31AB6}; +var \u{31AB7}; +var \u{31AB8}; +var \u{31AB9}; +var \u{31ABA}; +var \u{31ABB}; +var \u{31ABC}; +var \u{31ABD}; +var \u{31ABE}; +var \u{31ABF}; +var \u{31AC0}; +var \u{31AC1}; +var \u{31AC2}; +var \u{31AC3}; +var \u{31AC4}; +var \u{31AC5}; +var \u{31AC6}; +var \u{31AC7}; +var \u{31AC8}; +var \u{31AC9}; +var \u{31ACA}; +var \u{31ACB}; +var \u{31ACC}; +var \u{31ACD}; +var \u{31ACE}; +var \u{31ACF}; +var \u{31AD0}; +var \u{31AD1}; +var \u{31AD2}; +var \u{31AD3}; +var \u{31AD4}; +var \u{31AD5}; +var \u{31AD6}; +var \u{31AD7}; +var \u{31AD8}; +var \u{31AD9}; +var \u{31ADA}; +var \u{31ADB}; +var \u{31ADC}; +var \u{31ADD}; +var \u{31ADE}; +var \u{31ADF}; +var \u{31AE0}; +var \u{31AE1}; +var \u{31AE2}; +var \u{31AE3}; +var \u{31AE4}; +var \u{31AE5}; +var \u{31AE6}; +var \u{31AE7}; +var \u{31AE8}; +var \u{31AE9}; +var \u{31AEA}; +var \u{31AEB}; +var \u{31AEC}; +var \u{31AED}; +var \u{31AEE}; +var \u{31AEF}; +var \u{31AF0}; +var \u{31AF1}; +var \u{31AF2}; +var \u{31AF3}; +var \u{31AF4}; +var \u{31AF5}; +var \u{31AF6}; +var \u{31AF7}; +var \u{31AF8}; +var \u{31AF9}; +var \u{31AFA}; +var \u{31AFB}; +var \u{31AFC}; +var \u{31AFD}; +var \u{31AFE}; +var \u{31AFF}; +var \u{31B00}; +var \u{31B01}; +var \u{31B02}; +var \u{31B03}; +var \u{31B04}; +var \u{31B05}; +var \u{31B06}; +var \u{31B07}; +var \u{31B08}; +var \u{31B09}; +var \u{31B0A}; +var \u{31B0B}; +var \u{31B0C}; +var \u{31B0D}; +var \u{31B0E}; +var \u{31B0F}; +var \u{31B10}; +var \u{31B11}; +var \u{31B12}; +var \u{31B13}; +var \u{31B14}; +var \u{31B15}; +var \u{31B16}; +var \u{31B17}; +var \u{31B18}; +var \u{31B19}; +var \u{31B1A}; +var \u{31B1B}; +var \u{31B1C}; +var \u{31B1D}; +var \u{31B1E}; +var \u{31B1F}; +var \u{31B20}; +var \u{31B21}; +var \u{31B22}; +var \u{31B23}; +var \u{31B24}; +var \u{31B25}; +var \u{31B26}; +var \u{31B27}; +var \u{31B28}; +var \u{31B29}; +var \u{31B2A}; +var \u{31B2B}; +var \u{31B2C}; +var \u{31B2D}; +var \u{31B2E}; +var \u{31B2F}; +var \u{31B30}; +var \u{31B31}; +var \u{31B32}; +var \u{31B33}; +var \u{31B34}; +var \u{31B35}; +var \u{31B36}; +var \u{31B37}; +var \u{31B38}; +var \u{31B39}; +var \u{31B3A}; +var \u{31B3B}; +var \u{31B3C}; +var \u{31B3D}; +var \u{31B3E}; +var \u{31B3F}; +var \u{31B40}; +var \u{31B41}; +var \u{31B42}; +var \u{31B43}; +var \u{31B44}; +var \u{31B45}; +var \u{31B46}; +var \u{31B47}; +var \u{31B48}; +var \u{31B49}; +var \u{31B4A}; +var \u{31B4B}; +var \u{31B4C}; +var \u{31B4D}; +var \u{31B4E}; +var \u{31B4F}; +var \u{31B50}; +var \u{31B51}; +var \u{31B52}; +var \u{31B53}; +var \u{31B54}; +var \u{31B55}; +var \u{31B56}; +var \u{31B57}; +var \u{31B58}; +var \u{31B59}; +var \u{31B5A}; +var \u{31B5B}; +var \u{31B5C}; +var \u{31B5D}; +var \u{31B5E}; +var \u{31B5F}; +var \u{31B60}; +var \u{31B61}; +var \u{31B62}; +var \u{31B63}; +var \u{31B64}; +var \u{31B65}; +var \u{31B66}; +var \u{31B67}; +var \u{31B68}; +var \u{31B69}; +var \u{31B6A}; +var \u{31B6B}; +var \u{31B6C}; +var \u{31B6D}; +var \u{31B6E}; +var \u{31B6F}; +var \u{31B70}; +var \u{31B71}; +var \u{31B72}; +var \u{31B73}; +var \u{31B74}; +var \u{31B75}; +var \u{31B76}; +var \u{31B77}; +var \u{31B78}; +var \u{31B79}; +var \u{31B7A}; +var \u{31B7B}; +var \u{31B7C}; +var \u{31B7D}; +var \u{31B7E}; +var \u{31B7F}; +var \u{31B80}; +var \u{31B81}; +var \u{31B82}; +var \u{31B83}; +var \u{31B84}; +var \u{31B85}; +var \u{31B86}; +var \u{31B87}; +var \u{31B88}; +var \u{31B89}; +var \u{31B8A}; +var \u{31B8B}; +var \u{31B8C}; +var \u{31B8D}; +var \u{31B8E}; +var \u{31B8F}; +var \u{31B90}; +var \u{31B91}; +var \u{31B92}; +var \u{31B93}; +var \u{31B94}; +var \u{31B95}; +var \u{31B96}; +var \u{31B97}; +var \u{31B98}; +var \u{31B99}; +var \u{31B9A}; +var \u{31B9B}; +var \u{31B9C}; +var \u{31B9D}; +var \u{31B9E}; +var \u{31B9F}; +var \u{31BA0}; +var \u{31BA1}; +var \u{31BA2}; +var \u{31BA3}; +var \u{31BA4}; +var \u{31BA5}; +var \u{31BA6}; +var \u{31BA7}; +var \u{31BA8}; +var \u{31BA9}; +var \u{31BAA}; +var \u{31BAB}; +var \u{31BAC}; +var \u{31BAD}; +var \u{31BAE}; +var \u{31BAF}; +var \u{31BB0}; +var \u{31BB1}; +var \u{31BB2}; +var \u{31BB3}; +var \u{31BB4}; +var \u{31BB5}; +var \u{31BB6}; +var \u{31BB7}; +var \u{31BB8}; +var \u{31BB9}; +var \u{31BBA}; +var \u{31BBB}; +var \u{31BBC}; +var \u{31BBD}; +var \u{31BBE}; +var \u{31BBF}; +var \u{31BC0}; +var \u{31BC1}; +var \u{31BC2}; +var \u{31BC3}; +var \u{31BC4}; +var \u{31BC5}; +var \u{31BC6}; +var \u{31BC7}; +var \u{31BC8}; +var \u{31BC9}; +var \u{31BCA}; +var \u{31BCB}; +var \u{31BCC}; +var \u{31BCD}; +var \u{31BCE}; +var \u{31BCF}; +var \u{31BD0}; +var \u{31BD1}; +var \u{31BD2}; +var \u{31BD3}; +var \u{31BD4}; +var \u{31BD5}; +var \u{31BD6}; +var \u{31BD7}; +var \u{31BD8}; +var \u{31BD9}; +var \u{31BDA}; +var \u{31BDB}; +var \u{31BDC}; +var \u{31BDD}; +var \u{31BDE}; +var \u{31BDF}; +var \u{31BE0}; +var \u{31BE1}; +var \u{31BE2}; +var \u{31BE3}; +var \u{31BE4}; +var \u{31BE5}; +var \u{31BE6}; +var \u{31BE7}; +var \u{31BE8}; +var \u{31BE9}; +var \u{31BEA}; +var \u{31BEB}; +var \u{31BEC}; +var \u{31BED}; +var \u{31BEE}; +var \u{31BEF}; +var \u{31BF0}; +var \u{31BF1}; +var \u{31BF2}; +var \u{31BF3}; +var \u{31BF4}; +var \u{31BF5}; +var \u{31BF6}; +var \u{31BF7}; +var \u{31BF8}; +var \u{31BF9}; +var \u{31BFA}; +var \u{31BFB}; +var \u{31BFC}; +var \u{31BFD}; +var \u{31BFE}; +var \u{31BFF}; +var \u{31C00}; +var \u{31C01}; +var \u{31C02}; +var \u{31C03}; +var \u{31C04}; +var \u{31C05}; +var \u{31C06}; +var \u{31C07}; +var \u{31C08}; +var \u{31C09}; +var \u{31C0A}; +var \u{31C0B}; +var \u{31C0C}; +var \u{31C0D}; +var \u{31C0E}; +var \u{31C0F}; +var \u{31C10}; +var \u{31C11}; +var \u{31C12}; +var \u{31C13}; +var \u{31C14}; +var \u{31C15}; +var \u{31C16}; +var \u{31C17}; +var \u{31C18}; +var \u{31C19}; +var \u{31C1A}; +var \u{31C1B}; +var \u{31C1C}; +var \u{31C1D}; +var \u{31C1E}; +var \u{31C1F}; +var \u{31C20}; +var \u{31C21}; +var \u{31C22}; +var \u{31C23}; +var \u{31C24}; +var \u{31C25}; +var \u{31C26}; +var \u{31C27}; +var \u{31C28}; +var \u{31C29}; +var \u{31C2A}; +var \u{31C2B}; +var \u{31C2C}; +var \u{31C2D}; +var \u{31C2E}; +var \u{31C2F}; +var \u{31C30}; +var \u{31C31}; +var \u{31C32}; +var \u{31C33}; +var \u{31C34}; +var \u{31C35}; +var \u{31C36}; +var \u{31C37}; +var \u{31C38}; +var \u{31C39}; +var \u{31C3A}; +var \u{31C3B}; +var \u{31C3C}; +var \u{31C3D}; +var \u{31C3E}; +var \u{31C3F}; +var \u{31C40}; +var \u{31C41}; +var \u{31C42}; +var \u{31C43}; +var \u{31C44}; +var \u{31C45}; +var \u{31C46}; +var \u{31C47}; +var \u{31C48}; +var \u{31C49}; +var \u{31C4A}; +var \u{31C4B}; +var \u{31C4C}; +var \u{31C4D}; +var \u{31C4E}; +var \u{31C4F}; +var \u{31C50}; +var \u{31C51}; +var \u{31C52}; +var \u{31C53}; +var \u{31C54}; +var \u{31C55}; +var \u{31C56}; +var \u{31C57}; +var \u{31C58}; +var \u{31C59}; +var \u{31C5A}; +var \u{31C5B}; +var \u{31C5C}; +var \u{31C5D}; +var \u{31C5E}; +var \u{31C5F}; +var \u{31C60}; +var \u{31C61}; +var \u{31C62}; +var \u{31C63}; +var \u{31C64}; +var \u{31C65}; +var \u{31C66}; +var \u{31C67}; +var \u{31C68}; +var \u{31C69}; +var \u{31C6A}; +var \u{31C6B}; +var \u{31C6C}; +var \u{31C6D}; +var \u{31C6E}; +var \u{31C6F}; +var \u{31C70}; +var \u{31C71}; +var \u{31C72}; +var \u{31C73}; +var \u{31C74}; +var \u{31C75}; +var \u{31C76}; +var \u{31C77}; +var \u{31C78}; +var \u{31C79}; +var \u{31C7A}; +var \u{31C7B}; +var \u{31C7C}; +var \u{31C7D}; +var \u{31C7E}; +var \u{31C7F}; +var \u{31C80}; +var \u{31C81}; +var \u{31C82}; +var \u{31C83}; +var \u{31C84}; +var \u{31C85}; +var \u{31C86}; +var \u{31C87}; +var \u{31C88}; +var \u{31C89}; +var \u{31C8A}; +var \u{31C8B}; +var \u{31C8C}; +var \u{31C8D}; +var \u{31C8E}; +var \u{31C8F}; +var \u{31C90}; +var \u{31C91}; +var \u{31C92}; +var \u{31C93}; +var \u{31C94}; +var \u{31C95}; +var \u{31C96}; +var \u{31C97}; +var \u{31C98}; +var \u{31C99}; +var \u{31C9A}; +var \u{31C9B}; +var \u{31C9C}; +var \u{31C9D}; +var \u{31C9E}; +var \u{31C9F}; +var \u{31CA0}; +var \u{31CA1}; +var \u{31CA2}; +var \u{31CA3}; +var \u{31CA4}; +var \u{31CA5}; +var \u{31CA6}; +var \u{31CA7}; +var \u{31CA8}; +var \u{31CA9}; +var \u{31CAA}; +var \u{31CAB}; +var \u{31CAC}; +var \u{31CAD}; +var \u{31CAE}; +var \u{31CAF}; +var \u{31CB0}; +var \u{31CB1}; +var \u{31CB2}; +var \u{31CB3}; +var \u{31CB4}; +var \u{31CB5}; +var \u{31CB6}; +var \u{31CB7}; +var \u{31CB8}; +var \u{31CB9}; +var \u{31CBA}; +var \u{31CBB}; +var \u{31CBC}; +var \u{31CBD}; +var \u{31CBE}; +var \u{31CBF}; +var \u{31CC0}; +var \u{31CC1}; +var \u{31CC2}; +var \u{31CC3}; +var \u{31CC4}; +var \u{31CC5}; +var \u{31CC6}; +var \u{31CC7}; +var \u{31CC8}; +var \u{31CC9}; +var \u{31CCA}; +var \u{31CCB}; +var \u{31CCC}; +var \u{31CCD}; +var \u{31CCE}; +var \u{31CCF}; +var \u{31CD0}; +var \u{31CD1}; +var \u{31CD2}; +var \u{31CD3}; +var \u{31CD4}; +var \u{31CD5}; +var \u{31CD6}; +var \u{31CD7}; +var \u{31CD8}; +var \u{31CD9}; +var \u{31CDA}; +var \u{31CDB}; +var \u{31CDC}; +var \u{31CDD}; +var \u{31CDE}; +var \u{31CDF}; +var \u{31CE0}; +var \u{31CE1}; +var \u{31CE2}; +var \u{31CE3}; +var \u{31CE4}; +var \u{31CE5}; +var \u{31CE6}; +var \u{31CE7}; +var \u{31CE8}; +var \u{31CE9}; +var \u{31CEA}; +var \u{31CEB}; +var \u{31CEC}; +var \u{31CED}; +var \u{31CEE}; +var \u{31CEF}; +var \u{31CF0}; +var \u{31CF1}; +var \u{31CF2}; +var \u{31CF3}; +var \u{31CF4}; +var \u{31CF5}; +var \u{31CF6}; +var \u{31CF7}; +var \u{31CF8}; +var \u{31CF9}; +var \u{31CFA}; +var \u{31CFB}; +var \u{31CFC}; +var \u{31CFD}; +var \u{31CFE}; +var \u{31CFF}; +var \u{31D00}; +var \u{31D01}; +var \u{31D02}; +var \u{31D03}; +var \u{31D04}; +var \u{31D05}; +var \u{31D06}; +var \u{31D07}; +var \u{31D08}; +var \u{31D09}; +var \u{31D0A}; +var \u{31D0B}; +var \u{31D0C}; +var \u{31D0D}; +var \u{31D0E}; +var \u{31D0F}; +var \u{31D10}; +var \u{31D11}; +var \u{31D12}; +var \u{31D13}; +var \u{31D14}; +var \u{31D15}; +var \u{31D16}; +var \u{31D17}; +var \u{31D18}; +var \u{31D19}; +var \u{31D1A}; +var \u{31D1B}; +var \u{31D1C}; +var \u{31D1D}; +var \u{31D1E}; +var \u{31D1F}; +var \u{31D20}; +var \u{31D21}; +var \u{31D22}; +var \u{31D23}; +var \u{31D24}; +var \u{31D25}; +var \u{31D26}; +var \u{31D27}; +var \u{31D28}; +var \u{31D29}; +var \u{31D2A}; +var \u{31D2B}; +var \u{31D2C}; +var \u{31D2D}; +var \u{31D2E}; +var \u{31D2F}; +var \u{31D30}; +var \u{31D31}; +var \u{31D32}; +var \u{31D33}; +var \u{31D34}; +var \u{31D35}; +var \u{31D36}; +var \u{31D37}; +var \u{31D38}; +var \u{31D39}; +var \u{31D3A}; +var \u{31D3B}; +var \u{31D3C}; +var \u{31D3D}; +var \u{31D3E}; +var \u{31D3F}; +var \u{31D40}; +var \u{31D41}; +var \u{31D42}; +var \u{31D43}; +var \u{31D44}; +var \u{31D45}; +var \u{31D46}; +var \u{31D47}; +var \u{31D48}; +var \u{31D49}; +var \u{31D4A}; +var \u{31D4B}; +var \u{31D4C}; +var \u{31D4D}; +var \u{31D4E}; +var \u{31D4F}; +var \u{31D50}; +var \u{31D51}; +var \u{31D52}; +var \u{31D53}; +var \u{31D54}; +var \u{31D55}; +var \u{31D56}; +var \u{31D57}; +var \u{31D58}; +var \u{31D59}; +var \u{31D5A}; +var \u{31D5B}; +var \u{31D5C}; +var \u{31D5D}; +var \u{31D5E}; +var \u{31D5F}; +var \u{31D60}; +var \u{31D61}; +var \u{31D62}; +var \u{31D63}; +var \u{31D64}; +var \u{31D65}; +var \u{31D66}; +var \u{31D67}; +var \u{31D68}; +var \u{31D69}; +var \u{31D6A}; +var \u{31D6B}; +var \u{31D6C}; +var \u{31D6D}; +var \u{31D6E}; +var \u{31D6F}; +var \u{31D70}; +var \u{31D71}; +var \u{31D72}; +var \u{31D73}; +var \u{31D74}; +var \u{31D75}; +var \u{31D76}; +var \u{31D77}; +var \u{31D78}; +var \u{31D79}; +var \u{31D7A}; +var \u{31D7B}; +var \u{31D7C}; +var \u{31D7D}; +var \u{31D7E}; +var \u{31D7F}; +var \u{31D80}; +var \u{31D81}; +var \u{31D82}; +var \u{31D83}; +var \u{31D84}; +var \u{31D85}; +var \u{31D86}; +var \u{31D87}; +var \u{31D88}; +var \u{31D89}; +var \u{31D8A}; +var \u{31D8B}; +var \u{31D8C}; +var \u{31D8D}; +var \u{31D8E}; +var \u{31D8F}; +var \u{31D90}; +var \u{31D91}; +var \u{31D92}; +var \u{31D93}; +var \u{31D94}; +var \u{31D95}; +var \u{31D96}; +var \u{31D97}; +var \u{31D98}; +var \u{31D99}; +var \u{31D9A}; +var \u{31D9B}; +var \u{31D9C}; +var \u{31D9D}; +var \u{31D9E}; +var \u{31D9F}; +var \u{31DA0}; +var \u{31DA1}; +var \u{31DA2}; +var \u{31DA3}; +var \u{31DA4}; +var \u{31DA5}; +var \u{31DA6}; +var \u{31DA7}; +var \u{31DA8}; +var \u{31DA9}; +var \u{31DAA}; +var \u{31DAB}; +var \u{31DAC}; +var \u{31DAD}; +var \u{31DAE}; +var \u{31DAF}; +var \u{31DB0}; +var \u{31DB1}; +var \u{31DB2}; +var \u{31DB3}; +var \u{31DB4}; +var \u{31DB5}; +var \u{31DB6}; +var \u{31DB7}; +var \u{31DB8}; +var \u{31DB9}; +var \u{31DBA}; +var \u{31DBB}; +var \u{31DBC}; +var \u{31DBD}; +var \u{31DBE}; +var \u{31DBF}; +var \u{31DC0}; +var \u{31DC1}; +var \u{31DC2}; +var \u{31DC3}; +var \u{31DC4}; +var \u{31DC5}; +var \u{31DC6}; +var \u{31DC7}; +var \u{31DC8}; +var \u{31DC9}; +var \u{31DCA}; +var \u{31DCB}; +var \u{31DCC}; +var \u{31DCD}; +var \u{31DCE}; +var \u{31DCF}; +var \u{31DD0}; +var \u{31DD1}; +var \u{31DD2}; +var \u{31DD3}; +var \u{31DD4}; +var \u{31DD5}; +var \u{31DD6}; +var \u{31DD7}; +var \u{31DD8}; +var \u{31DD9}; +var \u{31DDA}; +var \u{31DDB}; +var \u{31DDC}; +var \u{31DDD}; +var \u{31DDE}; +var \u{31DDF}; +var \u{31DE0}; +var \u{31DE1}; +var \u{31DE2}; +var \u{31DE3}; +var \u{31DE4}; +var \u{31DE5}; +var \u{31DE6}; +var \u{31DE7}; +var \u{31DE8}; +var \u{31DE9}; +var \u{31DEA}; +var \u{31DEB}; +var \u{31DEC}; +var \u{31DED}; +var \u{31DEE}; +var \u{31DEF}; +var \u{31DF0}; +var \u{31DF1}; +var \u{31DF2}; +var \u{31DF3}; +var \u{31DF4}; +var \u{31DF5}; +var \u{31DF6}; +var \u{31DF7}; +var \u{31DF8}; +var \u{31DF9}; +var \u{31DFA}; +var \u{31DFB}; +var \u{31DFC}; +var \u{31DFD}; +var \u{31DFE}; +var \u{31DFF}; +var \u{31E00}; +var \u{31E01}; +var \u{31E02}; +var \u{31E03}; +var \u{31E04}; +var \u{31E05}; +var \u{31E06}; +var \u{31E07}; +var \u{31E08}; +var \u{31E09}; +var \u{31E0A}; +var \u{31E0B}; +var \u{31E0C}; +var \u{31E0D}; +var \u{31E0E}; +var \u{31E0F}; +var \u{31E10}; +var \u{31E11}; +var \u{31E12}; +var \u{31E13}; +var \u{31E14}; +var \u{31E15}; +var \u{31E16}; +var \u{31E17}; +var \u{31E18}; +var \u{31E19}; +var \u{31E1A}; +var \u{31E1B}; +var \u{31E1C}; +var \u{31E1D}; +var \u{31E1E}; +var \u{31E1F}; +var \u{31E20}; +var \u{31E21}; +var \u{31E22}; +var \u{31E23}; +var \u{31E24}; +var \u{31E25}; +var \u{31E26}; +var \u{31E27}; +var \u{31E28}; +var \u{31E29}; +var \u{31E2A}; +var \u{31E2B}; +var \u{31E2C}; +var \u{31E2D}; +var \u{31E2E}; +var \u{31E2F}; +var \u{31E30}; +var \u{31E31}; +var \u{31E32}; +var \u{31E33}; +var \u{31E34}; +var \u{31E35}; +var \u{31E36}; +var \u{31E37}; +var \u{31E38}; +var \u{31E39}; +var \u{31E3A}; +var \u{31E3B}; +var \u{31E3C}; +var \u{31E3D}; +var \u{31E3E}; +var \u{31E3F}; +var \u{31E40}; +var \u{31E41}; +var \u{31E42}; +var \u{31E43}; +var \u{31E44}; +var \u{31E45}; +var \u{31E46}; +var \u{31E47}; +var \u{31E48}; +var \u{31E49}; +var \u{31E4A}; +var \u{31E4B}; +var \u{31E4C}; +var \u{31E4D}; +var \u{31E4E}; +var \u{31E4F}; +var \u{31E50}; +var \u{31E51}; +var \u{31E52}; +var \u{31E53}; +var \u{31E54}; +var \u{31E55}; +var \u{31E56}; +var \u{31E57}; +var \u{31E58}; +var \u{31E59}; +var \u{31E5A}; +var \u{31E5B}; +var \u{31E5C}; +var \u{31E5D}; +var \u{31E5E}; +var \u{31E5F}; +var \u{31E60}; +var \u{31E61}; +var \u{31E62}; +var \u{31E63}; +var \u{31E64}; +var \u{31E65}; +var \u{31E66}; +var \u{31E67}; +var \u{31E68}; +var \u{31E69}; +var \u{31E6A}; +var \u{31E6B}; +var \u{31E6C}; +var \u{31E6D}; +var \u{31E6E}; +var \u{31E6F}; +var \u{31E70}; +var \u{31E71}; +var \u{31E72}; +var \u{31E73}; +var \u{31E74}; +var \u{31E75}; +var \u{31E76}; +var \u{31E77}; +var \u{31E78}; +var \u{31E79}; +var \u{31E7A}; +var \u{31E7B}; +var \u{31E7C}; +var \u{31E7D}; +var \u{31E7E}; +var \u{31E7F}; +var \u{31E80}; +var \u{31E81}; +var \u{31E82}; +var \u{31E83}; +var \u{31E84}; +var \u{31E85}; +var \u{31E86}; +var \u{31E87}; +var \u{31E88}; +var \u{31E89}; +var \u{31E8A}; +var \u{31E8B}; +var \u{31E8C}; +var \u{31E8D}; +var \u{31E8E}; +var \u{31E8F}; +var \u{31E90}; +var \u{31E91}; +var \u{31E92}; +var \u{31E93}; +var \u{31E94}; +var \u{31E95}; +var \u{31E96}; +var \u{31E97}; +var \u{31E98}; +var \u{31E99}; +var \u{31E9A}; +var \u{31E9B}; +var \u{31E9C}; +var \u{31E9D}; +var \u{31E9E}; +var \u{31E9F}; +var \u{31EA0}; +var \u{31EA1}; +var \u{31EA2}; +var \u{31EA3}; +var \u{31EA4}; +var \u{31EA5}; +var \u{31EA6}; +var \u{31EA7}; +var \u{31EA8}; +var \u{31EA9}; +var \u{31EAA}; +var \u{31EAB}; +var \u{31EAC}; +var \u{31EAD}; +var \u{31EAE}; +var \u{31EAF}; +var \u{31EB0}; +var \u{31EB1}; +var \u{31EB2}; +var \u{31EB3}; +var \u{31EB4}; +var \u{31EB5}; +var \u{31EB6}; +var \u{31EB7}; +var \u{31EB8}; +var \u{31EB9}; +var \u{31EBA}; +var \u{31EBB}; +var \u{31EBC}; +var \u{31EBD}; +var \u{31EBE}; +var \u{31EBF}; +var \u{31EC0}; +var \u{31EC1}; +var \u{31EC2}; +var \u{31EC3}; +var \u{31EC4}; +var \u{31EC5}; +var \u{31EC6}; +var \u{31EC7}; +var \u{31EC8}; +var \u{31EC9}; +var \u{31ECA}; +var \u{31ECB}; +var \u{31ECC}; +var \u{31ECD}; +var \u{31ECE}; +var \u{31ECF}; +var \u{31ED0}; +var \u{31ED1}; +var \u{31ED2}; +var \u{31ED3}; +var \u{31ED4}; +var \u{31ED5}; +var \u{31ED6}; +var \u{31ED7}; +var \u{31ED8}; +var \u{31ED9}; +var \u{31EDA}; +var \u{31EDB}; +var \u{31EDC}; +var \u{31EDD}; +var \u{31EDE}; +var \u{31EDF}; +var \u{31EE0}; +var \u{31EE1}; +var \u{31EE2}; +var \u{31EE3}; +var \u{31EE4}; +var \u{31EE5}; +var \u{31EE6}; +var \u{31EE7}; +var \u{31EE8}; +var \u{31EE9}; +var \u{31EEA}; +var \u{31EEB}; +var \u{31EEC}; +var \u{31EED}; +var \u{31EEE}; +var \u{31EEF}; +var \u{31EF0}; +var \u{31EF1}; +var \u{31EF2}; +var \u{31EF3}; +var \u{31EF4}; +var \u{31EF5}; +var \u{31EF6}; +var \u{31EF7}; +var \u{31EF8}; +var \u{31EF9}; +var \u{31EFA}; +var \u{31EFB}; +var \u{31EFC}; +var \u{31EFD}; +var \u{31EFE}; +var \u{31EFF}; +var \u{31F00}; +var \u{31F01}; +var \u{31F02}; +var \u{31F03}; +var \u{31F04}; +var \u{31F05}; +var \u{31F06}; +var \u{31F07}; +var \u{31F08}; +var \u{31F09}; +var \u{31F0A}; +var \u{31F0B}; +var \u{31F0C}; +var \u{31F0D}; +var \u{31F0E}; +var \u{31F0F}; +var \u{31F10}; +var \u{31F11}; +var \u{31F12}; +var \u{31F13}; +var \u{31F14}; +var \u{31F15}; +var \u{31F16}; +var \u{31F17}; +var \u{31F18}; +var \u{31F19}; +var \u{31F1A}; +var \u{31F1B}; +var \u{31F1C}; +var \u{31F1D}; +var \u{31F1E}; +var \u{31F1F}; +var \u{31F20}; +var \u{31F21}; +var \u{31F22}; +var \u{31F23}; +var \u{31F24}; +var \u{31F25}; +var \u{31F26}; +var \u{31F27}; +var \u{31F28}; +var \u{31F29}; +var \u{31F2A}; +var \u{31F2B}; +var \u{31F2C}; +var \u{31F2D}; +var \u{31F2E}; +var \u{31F2F}; +var \u{31F30}; +var \u{31F31}; +var \u{31F32}; +var \u{31F33}; +var \u{31F34}; +var \u{31F35}; +var \u{31F36}; +var \u{31F37}; +var \u{31F38}; +var \u{31F39}; +var \u{31F3A}; +var \u{31F3B}; +var \u{31F3C}; +var \u{31F3D}; +var \u{31F3E}; +var \u{31F3F}; +var \u{31F40}; +var \u{31F41}; +var \u{31F42}; +var \u{31F43}; +var \u{31F44}; +var \u{31F45}; +var \u{31F46}; +var \u{31F47}; +var \u{31F48}; +var \u{31F49}; +var \u{31F4A}; +var \u{31F4B}; +var \u{31F4C}; +var \u{31F4D}; +var \u{31F4E}; +var \u{31F4F}; +var \u{31F50}; +var \u{31F51}; +var \u{31F52}; +var \u{31F53}; +var \u{31F54}; +var \u{31F55}; +var \u{31F56}; +var \u{31F57}; +var \u{31F58}; +var \u{31F59}; +var \u{31F5A}; +var \u{31F5B}; +var \u{31F5C}; +var \u{31F5D}; +var \u{31F5E}; +var \u{31F5F}; +var \u{31F60}; +var \u{31F61}; +var \u{31F62}; +var \u{31F63}; +var \u{31F64}; +var \u{31F65}; +var \u{31F66}; +var \u{31F67}; +var \u{31F68}; +var \u{31F69}; +var \u{31F6A}; +var \u{31F6B}; +var \u{31F6C}; +var \u{31F6D}; +var \u{31F6E}; +var \u{31F6F}; +var \u{31F70}; +var \u{31F71}; +var \u{31F72}; +var \u{31F73}; +var \u{31F74}; +var \u{31F75}; +var \u{31F76}; +var \u{31F77}; +var \u{31F78}; +var \u{31F79}; +var \u{31F7A}; +var \u{31F7B}; +var \u{31F7C}; +var \u{31F7D}; +var \u{31F7E}; +var \u{31F7F}; +var \u{31F80}; +var \u{31F81}; +var \u{31F82}; +var \u{31F83}; +var \u{31F84}; +var \u{31F85}; +var \u{31F86}; +var \u{31F87}; +var \u{31F88}; +var \u{31F89}; +var \u{31F8A}; +var \u{31F8B}; +var \u{31F8C}; +var \u{31F8D}; +var \u{31F8E}; +var \u{31F8F}; +var \u{31F90}; +var \u{31F91}; +var \u{31F92}; +var \u{31F93}; +var \u{31F94}; +var \u{31F95}; +var \u{31F96}; +var \u{31F97}; +var \u{31F98}; +var \u{31F99}; +var \u{31F9A}; +var \u{31F9B}; +var \u{31F9C}; +var \u{31F9D}; +var \u{31F9E}; +var \u{31F9F}; +var \u{31FA0}; +var \u{31FA1}; +var \u{31FA2}; +var \u{31FA3}; +var \u{31FA4}; +var \u{31FA5}; +var \u{31FA6}; +var \u{31FA7}; +var \u{31FA8}; +var \u{31FA9}; +var \u{31FAA}; +var \u{31FAB}; +var \u{31FAC}; +var \u{31FAD}; +var \u{31FAE}; +var \u{31FAF}; +var \u{31FB0}; +var \u{31FB1}; +var \u{31FB2}; +var \u{31FB3}; +var \u{31FB4}; +var \u{31FB5}; +var \u{31FB6}; +var \u{31FB7}; +var \u{31FB8}; +var \u{31FB9}; +var \u{31FBA}; +var \u{31FBB}; +var \u{31FBC}; +var \u{31FBD}; +var \u{31FBE}; +var \u{31FBF}; +var \u{31FC0}; +var \u{31FC1}; +var \u{31FC2}; +var \u{31FC3}; +var \u{31FC4}; +var \u{31FC5}; +var \u{31FC6}; +var \u{31FC7}; +var \u{31FC8}; +var \u{31FC9}; +var \u{31FCA}; +var \u{31FCB}; +var \u{31FCC}; +var \u{31FCD}; +var \u{31FCE}; +var \u{31FCF}; +var \u{31FD0}; +var \u{31FD1}; +var \u{31FD2}; +var \u{31FD3}; +var \u{31FD4}; +var \u{31FD5}; +var \u{31FD6}; +var \u{31FD7}; +var \u{31FD8}; +var \u{31FD9}; +var \u{31FDA}; +var \u{31FDB}; +var \u{31FDC}; +var \u{31FDD}; +var \u{31FDE}; +var \u{31FDF}; +var \u{31FE0}; +var \u{31FE1}; +var \u{31FE2}; +var \u{31FE3}; +var \u{31FE4}; +var \u{31FE5}; +var \u{31FE6}; +var \u{31FE7}; +var \u{31FE8}; +var \u{31FE9}; +var \u{31FEA}; +var \u{31FEB}; +var \u{31FEC}; +var \u{31FED}; +var \u{31FEE}; +var \u{31FEF}; +var \u{31FF0}; +var \u{31FF1}; +var \u{31FF2}; +var \u{31FF3}; +var \u{31FF4}; +var \u{31FF5}; +var \u{31FF6}; +var \u{31FF7}; +var \u{31FF8}; +var \u{31FF9}; +var \u{31FFA}; +var \u{31FFB}; +var \u{31FFC}; +var \u{31FFD}; +var \u{31FFE}; +var \u{31FFF}; +var \u{32000}; +var \u{32001}; +var \u{32002}; +var \u{32003}; +var \u{32004}; +var \u{32005}; +var \u{32006}; +var \u{32007}; +var \u{32008}; +var \u{32009}; +var \u{3200A}; +var \u{3200B}; +var \u{3200C}; +var \u{3200D}; +var \u{3200E}; +var \u{3200F}; +var \u{32010}; +var \u{32011}; +var \u{32012}; +var \u{32013}; +var \u{32014}; +var \u{32015}; +var \u{32016}; +var \u{32017}; +var \u{32018}; +var \u{32019}; +var \u{3201A}; +var \u{3201B}; +var \u{3201C}; +var \u{3201D}; +var \u{3201E}; +var \u{3201F}; +var \u{32020}; +var \u{32021}; +var \u{32022}; +var \u{32023}; +var \u{32024}; +var \u{32025}; +var \u{32026}; +var \u{32027}; +var \u{32028}; +var \u{32029}; +var \u{3202A}; +var \u{3202B}; +var \u{3202C}; +var \u{3202D}; +var \u{3202E}; +var \u{3202F}; +var \u{32030}; +var \u{32031}; +var \u{32032}; +var \u{32033}; +var \u{32034}; +var \u{32035}; +var \u{32036}; +var \u{32037}; +var \u{32038}; +var \u{32039}; +var \u{3203A}; +var \u{3203B}; +var \u{3203C}; +var \u{3203D}; +var \u{3203E}; +var \u{3203F}; +var \u{32040}; +var \u{32041}; +var \u{32042}; +var \u{32043}; +var \u{32044}; +var \u{32045}; +var \u{32046}; +var \u{32047}; +var \u{32048}; +var \u{32049}; +var \u{3204A}; +var \u{3204B}; +var \u{3204C}; +var \u{3204D}; +var \u{3204E}; +var \u{3204F}; +var \u{32050}; +var \u{32051}; +var \u{32052}; +var \u{32053}; +var \u{32054}; +var \u{32055}; +var \u{32056}; +var \u{32057}; +var \u{32058}; +var \u{32059}; +var \u{3205A}; +var \u{3205B}; +var \u{3205C}; +var \u{3205D}; +var \u{3205E}; +var \u{3205F}; +var \u{32060}; +var \u{32061}; +var \u{32062}; +var \u{32063}; +var \u{32064}; +var \u{32065}; +var \u{32066}; +var \u{32067}; +var \u{32068}; +var \u{32069}; +var \u{3206A}; +var \u{3206B}; +var \u{3206C}; +var \u{3206D}; +var \u{3206E}; +var \u{3206F}; +var \u{32070}; +var \u{32071}; +var \u{32072}; +var \u{32073}; +var \u{32074}; +var \u{32075}; +var \u{32076}; +var \u{32077}; +var \u{32078}; +var \u{32079}; +var \u{3207A}; +var \u{3207B}; +var \u{3207C}; +var \u{3207D}; +var \u{3207E}; +var \u{3207F}; +var \u{32080}; +var \u{32081}; +var \u{32082}; +var \u{32083}; +var \u{32084}; +var \u{32085}; +var \u{32086}; +var \u{32087}; +var \u{32088}; +var \u{32089}; +var \u{3208A}; +var \u{3208B}; +var \u{3208C}; +var \u{3208D}; +var \u{3208E}; +var \u{3208F}; +var \u{32090}; +var \u{32091}; +var \u{32092}; +var \u{32093}; +var \u{32094}; +var \u{32095}; +var \u{32096}; +var \u{32097}; +var \u{32098}; +var \u{32099}; +var \u{3209A}; +var \u{3209B}; +var \u{3209C}; +var \u{3209D}; +var \u{3209E}; +var \u{3209F}; +var \u{320A0}; +var \u{320A1}; +var \u{320A2}; +var \u{320A3}; +var \u{320A4}; +var \u{320A5}; +var \u{320A6}; +var \u{320A7}; +var \u{320A8}; +var \u{320A9}; +var \u{320AA}; +var \u{320AB}; +var \u{320AC}; +var \u{320AD}; +var \u{320AE}; +var \u{320AF}; +var \u{320B0}; +var \u{320B1}; +var \u{320B2}; +var \u{320B3}; +var \u{320B4}; +var \u{320B5}; +var \u{320B6}; +var \u{320B7}; +var \u{320B8}; +var \u{320B9}; +var \u{320BA}; +var \u{320BB}; +var \u{320BC}; +var \u{320BD}; +var \u{320BE}; +var \u{320BF}; +var \u{320C0}; +var \u{320C1}; +var \u{320C2}; +var \u{320C3}; +var \u{320C4}; +var \u{320C5}; +var \u{320C6}; +var \u{320C7}; +var \u{320C8}; +var \u{320C9}; +var \u{320CA}; +var \u{320CB}; +var \u{320CC}; +var \u{320CD}; +var \u{320CE}; +var \u{320CF}; +var \u{320D0}; +var \u{320D1}; +var \u{320D2}; +var \u{320D3}; +var \u{320D4}; +var \u{320D5}; +var \u{320D6}; +var \u{320D7}; +var \u{320D8}; +var \u{320D9}; +var \u{320DA}; +var \u{320DB}; +var \u{320DC}; +var \u{320DD}; +var \u{320DE}; +var \u{320DF}; +var \u{320E0}; +var \u{320E1}; +var \u{320E2}; +var \u{320E3}; +var \u{320E4}; +var \u{320E5}; +var \u{320E6}; +var \u{320E7}; +var \u{320E8}; +var \u{320E9}; +var \u{320EA}; +var \u{320EB}; +var \u{320EC}; +var \u{320ED}; +var \u{320EE}; +var \u{320EF}; +var \u{320F0}; +var \u{320F1}; +var \u{320F2}; +var \u{320F3}; +var \u{320F4}; +var \u{320F5}; +var \u{320F6}; +var \u{320F7}; +var \u{320F8}; +var \u{320F9}; +var \u{320FA}; +var \u{320FB}; +var \u{320FC}; +var \u{320FD}; +var \u{320FE}; +var \u{320FF}; +var \u{32100}; +var \u{32101}; +var \u{32102}; +var \u{32103}; +var \u{32104}; +var \u{32105}; +var \u{32106}; +var \u{32107}; +var \u{32108}; +var \u{32109}; +var \u{3210A}; +var \u{3210B}; +var \u{3210C}; +var \u{3210D}; +var \u{3210E}; +var \u{3210F}; +var \u{32110}; +var \u{32111}; +var \u{32112}; +var \u{32113}; +var \u{32114}; +var \u{32115}; +var \u{32116}; +var \u{32117}; +var \u{32118}; +var \u{32119}; +var \u{3211A}; +var \u{3211B}; +var \u{3211C}; +var \u{3211D}; +var \u{3211E}; +var \u{3211F}; +var \u{32120}; +var \u{32121}; +var \u{32122}; +var \u{32123}; +var \u{32124}; +var \u{32125}; +var \u{32126}; +var \u{32127}; +var \u{32128}; +var \u{32129}; +var \u{3212A}; +var \u{3212B}; +var \u{3212C}; +var \u{3212D}; +var \u{3212E}; +var \u{3212F}; +var \u{32130}; +var \u{32131}; +var \u{32132}; +var \u{32133}; +var \u{32134}; +var \u{32135}; +var \u{32136}; +var \u{32137}; +var \u{32138}; +var \u{32139}; +var \u{3213A}; +var \u{3213B}; +var \u{3213C}; +var \u{3213D}; +var \u{3213E}; +var \u{3213F}; +var \u{32140}; +var \u{32141}; +var \u{32142}; +var \u{32143}; +var \u{32144}; +var \u{32145}; +var \u{32146}; +var \u{32147}; +var \u{32148}; +var \u{32149}; +var \u{3214A}; +var \u{3214B}; +var \u{3214C}; +var \u{3214D}; +var \u{3214E}; +var \u{3214F}; +var \u{32150}; +var \u{32151}; +var \u{32152}; +var \u{32153}; +var \u{32154}; +var \u{32155}; +var \u{32156}; +var \u{32157}; +var \u{32158}; +var \u{32159}; +var \u{3215A}; +var \u{3215B}; +var \u{3215C}; +var \u{3215D}; +var \u{3215E}; +var \u{3215F}; +var \u{32160}; +var \u{32161}; +var \u{32162}; +var \u{32163}; +var \u{32164}; +var \u{32165}; +var \u{32166}; +var \u{32167}; +var \u{32168}; +var \u{32169}; +var \u{3216A}; +var \u{3216B}; +var \u{3216C}; +var \u{3216D}; +var \u{3216E}; +var \u{3216F}; +var \u{32170}; +var \u{32171}; +var \u{32172}; +var \u{32173}; +var \u{32174}; +var \u{32175}; +var \u{32176}; +var \u{32177}; +var \u{32178}; +var \u{32179}; +var \u{3217A}; +var \u{3217B}; +var \u{3217C}; +var \u{3217D}; +var \u{3217E}; +var \u{3217F}; +var \u{32180}; +var \u{32181}; +var \u{32182}; +var \u{32183}; +var \u{32184}; +var \u{32185}; +var \u{32186}; +var \u{32187}; +var \u{32188}; +var \u{32189}; +var \u{3218A}; +var \u{3218B}; +var \u{3218C}; +var \u{3218D}; +var \u{3218E}; +var \u{3218F}; +var \u{32190}; +var \u{32191}; +var \u{32192}; +var \u{32193}; +var \u{32194}; +var \u{32195}; +var \u{32196}; +var \u{32197}; +var \u{32198}; +var \u{32199}; +var \u{3219A}; +var \u{3219B}; +var \u{3219C}; +var \u{3219D}; +var \u{3219E}; +var \u{3219F}; +var \u{321A0}; +var \u{321A1}; +var \u{321A2}; +var \u{321A3}; +var \u{321A4}; +var \u{321A5}; +var \u{321A6}; +var \u{321A7}; +var \u{321A8}; +var \u{321A9}; +var \u{321AA}; +var \u{321AB}; +var \u{321AC}; +var \u{321AD}; +var \u{321AE}; +var \u{321AF}; +var \u{321B0}; +var \u{321B1}; +var \u{321B2}; +var \u{321B3}; +var \u{321B4}; +var \u{321B5}; +var \u{321B6}; +var \u{321B7}; +var \u{321B8}; +var \u{321B9}; +var \u{321BA}; +var \u{321BB}; +var \u{321BC}; +var \u{321BD}; +var \u{321BE}; +var \u{321BF}; +var \u{321C0}; +var \u{321C1}; +var \u{321C2}; +var \u{321C3}; +var \u{321C4}; +var \u{321C5}; +var \u{321C6}; +var \u{321C7}; +var \u{321C8}; +var \u{321C9}; +var \u{321CA}; +var \u{321CB}; +var \u{321CC}; +var \u{321CD}; +var \u{321CE}; +var \u{321CF}; +var \u{321D0}; +var \u{321D1}; +var \u{321D2}; +var \u{321D3}; +var \u{321D4}; +var \u{321D5}; +var \u{321D6}; +var \u{321D7}; +var \u{321D8}; +var \u{321D9}; +var \u{321DA}; +var \u{321DB}; +var \u{321DC}; +var \u{321DD}; +var \u{321DE}; +var \u{321DF}; +var \u{321E0}; +var \u{321E1}; +var \u{321E2}; +var \u{321E3}; +var \u{321E4}; +var \u{321E5}; +var \u{321E6}; +var \u{321E7}; +var \u{321E8}; +var \u{321E9}; +var \u{321EA}; +var \u{321EB}; +var \u{321EC}; +var \u{321ED}; +var \u{321EE}; +var \u{321EF}; +var \u{321F0}; +var \u{321F1}; +var \u{321F2}; +var \u{321F3}; +var \u{321F4}; +var \u{321F5}; +var \u{321F6}; +var \u{321F7}; +var \u{321F8}; +var \u{321F9}; +var \u{321FA}; +var \u{321FB}; +var \u{321FC}; +var \u{321FD}; +var \u{321FE}; +var \u{321FF}; +var \u{32200}; +var \u{32201}; +var \u{32202}; +var \u{32203}; +var \u{32204}; +var \u{32205}; +var \u{32206}; +var \u{32207}; +var \u{32208}; +var \u{32209}; +var \u{3220A}; +var \u{3220B}; +var \u{3220C}; +var \u{3220D}; +var \u{3220E}; +var \u{3220F}; +var \u{32210}; +var \u{32211}; +var \u{32212}; +var \u{32213}; +var \u{32214}; +var \u{32215}; +var \u{32216}; +var \u{32217}; +var \u{32218}; +var \u{32219}; +var \u{3221A}; +var \u{3221B}; +var \u{3221C}; +var \u{3221D}; +var \u{3221E}; +var \u{3221F}; +var \u{32220}; +var \u{32221}; +var \u{32222}; +var \u{32223}; +var \u{32224}; +var \u{32225}; +var \u{32226}; +var \u{32227}; +var \u{32228}; +var \u{32229}; +var \u{3222A}; +var \u{3222B}; +var \u{3222C}; +var \u{3222D}; +var \u{3222E}; +var \u{3222F}; +var \u{32230}; +var \u{32231}; +var \u{32232}; +var \u{32233}; +var \u{32234}; +var \u{32235}; +var \u{32236}; +var \u{32237}; +var \u{32238}; +var \u{32239}; +var \u{3223A}; +var \u{3223B}; +var \u{3223C}; +var \u{3223D}; +var \u{3223E}; +var \u{3223F}; +var \u{32240}; +var \u{32241}; +var \u{32242}; +var \u{32243}; +var \u{32244}; +var \u{32245}; +var \u{32246}; +var \u{32247}; +var \u{32248}; +var \u{32249}; +var \u{3224A}; +var \u{3224B}; +var \u{3224C}; +var \u{3224D}; +var \u{3224E}; +var \u{3224F}; +var \u{32250}; +var \u{32251}; +var \u{32252}; +var \u{32253}; +var \u{32254}; +var \u{32255}; +var \u{32256}; +var \u{32257}; +var \u{32258}; +var \u{32259}; +var \u{3225A}; +var \u{3225B}; +var \u{3225C}; +var \u{3225D}; +var \u{3225E}; +var \u{3225F}; +var \u{32260}; +var \u{32261}; +var \u{32262}; +var \u{32263}; +var \u{32264}; +var \u{32265}; +var \u{32266}; +var \u{32267}; +var \u{32268}; +var \u{32269}; +var \u{3226A}; +var \u{3226B}; +var \u{3226C}; +var \u{3226D}; +var \u{3226E}; +var \u{3226F}; +var \u{32270}; +var \u{32271}; +var \u{32272}; +var \u{32273}; +var \u{32274}; +var \u{32275}; +var \u{32276}; +var \u{32277}; +var \u{32278}; +var \u{32279}; +var \u{3227A}; +var \u{3227B}; +var \u{3227C}; +var \u{3227D}; +var \u{3227E}; +var \u{3227F}; +var \u{32280}; +var \u{32281}; +var \u{32282}; +var \u{32283}; +var \u{32284}; +var \u{32285}; +var \u{32286}; +var \u{32287}; +var \u{32288}; +var \u{32289}; +var \u{3228A}; +var \u{3228B}; +var \u{3228C}; +var \u{3228D}; +var \u{3228E}; +var \u{3228F}; +var \u{32290}; +var \u{32291}; +var \u{32292}; +var \u{32293}; +var \u{32294}; +var \u{32295}; +var \u{32296}; +var \u{32297}; +var \u{32298}; +var \u{32299}; +var \u{3229A}; +var \u{3229B}; +var \u{3229C}; +var \u{3229D}; +var \u{3229E}; +var \u{3229F}; +var \u{322A0}; +var \u{322A1}; +var \u{322A2}; +var \u{322A3}; +var \u{322A4}; +var \u{322A5}; +var \u{322A6}; +var \u{322A7}; +var \u{322A8}; +var \u{322A9}; +var \u{322AA}; +var \u{322AB}; +var \u{322AC}; +var \u{322AD}; +var \u{322AE}; +var \u{322AF}; +var \u{322B0}; +var \u{322B1}; +var \u{322B2}; +var \u{322B3}; +var \u{322B4}; +var \u{322B5}; +var \u{322B6}; +var \u{322B7}; +var \u{322B8}; +var \u{322B9}; +var \u{322BA}; +var \u{322BB}; +var \u{322BC}; +var \u{322BD}; +var \u{322BE}; +var \u{322BF}; +var \u{322C0}; +var \u{322C1}; +var \u{322C2}; +var \u{322C3}; +var \u{322C4}; +var \u{322C5}; +var \u{322C6}; +var \u{322C7}; +var \u{322C8}; +var \u{322C9}; +var \u{322CA}; +var \u{322CB}; +var \u{322CC}; +var \u{322CD}; +var \u{322CE}; +var \u{322CF}; +var \u{322D0}; +var \u{322D1}; +var \u{322D2}; +var \u{322D3}; +var \u{322D4}; +var \u{322D5}; +var \u{322D6}; +var \u{322D7}; +var \u{322D8}; +var \u{322D9}; +var \u{322DA}; +var \u{322DB}; +var \u{322DC}; +var \u{322DD}; +var \u{322DE}; +var \u{322DF}; +var \u{322E0}; +var \u{322E1}; +var \u{322E2}; +var \u{322E3}; +var \u{322E4}; +var \u{322E5}; +var \u{322E6}; +var \u{322E7}; +var \u{322E8}; +var \u{322E9}; +var \u{322EA}; +var \u{322EB}; +var \u{322EC}; +var \u{322ED}; +var \u{322EE}; +var \u{322EF}; +var \u{322F0}; +var \u{322F1}; +var \u{322F2}; +var \u{322F3}; +var \u{322F4}; +var \u{322F5}; +var \u{322F6}; +var \u{322F7}; +var \u{322F8}; +var \u{322F9}; +var \u{322FA}; +var \u{322FB}; +var \u{322FC}; +var \u{322FD}; +var \u{322FE}; +var \u{322FF}; +var \u{32300}; +var \u{32301}; +var \u{32302}; +var \u{32303}; +var \u{32304}; +var \u{32305}; +var \u{32306}; +var \u{32307}; +var \u{32308}; +var \u{32309}; +var \u{3230A}; +var \u{3230B}; +var \u{3230C}; +var \u{3230D}; +var \u{3230E}; +var \u{3230F}; +var \u{32310}; +var \u{32311}; +var \u{32312}; +var \u{32313}; +var \u{32314}; +var \u{32315}; +var \u{32316}; +var \u{32317}; +var \u{32318}; +var \u{32319}; +var \u{3231A}; +var \u{3231B}; +var \u{3231C}; +var \u{3231D}; +var \u{3231E}; +var \u{3231F}; +var \u{32320}; +var \u{32321}; +var \u{32322}; +var \u{32323}; +var \u{32324}; +var \u{32325}; +var \u{32326}; +var \u{32327}; +var \u{32328}; +var \u{32329}; +var \u{3232A}; +var \u{3232B}; +var \u{3232C}; +var \u{3232D}; +var \u{3232E}; +var \u{3232F}; +var \u{32330}; +var \u{32331}; +var \u{32332}; +var \u{32333}; +var \u{32334}; +var \u{32335}; +var \u{32336}; +var \u{32337}; +var \u{32338}; +var \u{32339}; +var \u{3233A}; +var \u{3233B}; +var \u{3233C}; +var \u{3233D}; +var \u{3233E}; +var \u{3233F}; +var \u{32340}; +var \u{32341}; +var \u{32342}; +var \u{32343}; +var \u{32344}; +var \u{32345}; +var \u{32346}; +var \u{32347}; +var \u{32348}; +var \u{32349}; +var \u{3234A}; +var \u{3234B}; +var \u{3234C}; +var \u{3234D}; +var \u{3234E}; +var \u{3234F}; +var \u{32350}; +var \u{32351}; +var \u{32352}; +var \u{32353}; +var \u{32354}; +var \u{32355}; +var \u{32356}; +var \u{32357}; +var \u{32358}; +var \u{32359}; +var \u{3235A}; +var \u{3235B}; +var \u{3235C}; +var \u{3235D}; +var \u{3235E}; +var \u{3235F}; +var \u{32360}; +var \u{32361}; +var \u{32362}; +var \u{32363}; +var \u{32364}; +var \u{32365}; +var \u{32366}; +var \u{32367}; +var \u{32368}; +var \u{32369}; +var \u{3236A}; +var \u{3236B}; +var \u{3236C}; +var \u{3236D}; +var \u{3236E}; +var \u{3236F}; +var \u{32370}; +var \u{32371}; +var \u{32372}; +var \u{32373}; +var \u{32374}; +var \u{32375}; +var \u{32376}; +var \u{32377}; +var \u{32378}; +var \u{32379}; +var \u{3237A}; +var \u{3237B}; +var \u{3237C}; +var \u{3237D}; +var \u{3237E}; +var \u{3237F}; +var \u{32380}; +var \u{32381}; +var \u{32382}; +var \u{32383}; +var \u{32384}; +var \u{32385}; +var \u{32386}; +var \u{32387}; +var \u{32388}; +var \u{32389}; +var \u{3238A}; +var \u{3238B}; +var \u{3238C}; +var \u{3238D}; +var \u{3238E}; +var \u{3238F}; +var \u{32390}; +var \u{32391}; +var \u{32392}; +var \u{32393}; +var \u{32394}; +var \u{32395}; +var \u{32396}; +var \u{32397}; +var \u{32398}; +var \u{32399}; +var \u{3239A}; +var \u{3239B}; +var \u{3239C}; +var \u{3239D}; +var \u{3239E}; +var \u{3239F}; +var \u{323A0}; +var \u{323A1}; +var \u{323A2}; +var \u{323A3}; +var \u{323A4}; +var \u{323A5}; +var \u{323A6}; +var \u{323A7}; +var \u{323A8}; +var \u{323A9}; +var \u{323AA}; +var \u{323AB}; +var \u{323AC}; +var \u{323AD}; +var \u{323AE}; +var \u{323AF}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0.js new file mode 100644 index 000000000..d848d2297 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.0.0.js @@ -0,0 +1,4361 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v15.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var 𑈿; +var 𑉀; +var 𑼂; +var 𑼄; +var 𑼅; +var 𑼆; +var 𑼇; +var 𑼈; +var 𑼉; +var 𑼊; +var 𑼋; +var 𑼌; +var 𑼍; +var 𑼎; +var 𑼏; +var 𑼐; +var 𑼒; +var 𑼓; +var 𑼔; +var 𑼕; +var 𑼖; +var 𑼗; +var 𑼘; +var 𑼙; +var 𑼚; +var 𑼛; +var 𑼜; +var 𑼝; +var 𑼞; +var 𑼟; +var 𑼠; +var 𑼡; +var 𑼢; +var 𑼣; +var 𑼤; +var 𑼥; +var 𑼦; +var 𑼧; +var 𑼨; +var 𑼩; +var 𑼪; +var 𑼫; +var 𑼬; +var 𑼭; +var 𑼮; +var 𑼯; +var 𑼰; +var 𑼱; +var 𑼲; +var 𑼳; +var 𓐯; +var 𓑁; +var 𓑂; +var 𓑃; +var 𓑄; +var 𓑅; +var 𓑆; +var 𛄲; +var 𛅕; +var 𝼥; +var 𝼦; +var 𝼧; +var 𝼨; +var 𝼩; +var 𝼪; +var 𞀰; +var 𞀱; +var 𞀲; +var 𞀳; +var 𞀴; +var 𞀵; +var 𞀶; +var 𞀷; +var 𞀸; +var 𞀹; +var 𞀺; +var 𞀻; +var 𞀼; +var 𞀽; +var 𞀾; +var 𞀿; +var 𞁀; +var 𞁁; +var 𞁂; +var 𞁃; +var 𞁄; +var 𞁅; +var 𞁆; +var 𞁇; +var 𞁈; +var 𞁉; +var 𞁊; +var 𞁋; +var 𞁌; +var 𞁍; +var 𞁎; +var 𞁏; +var 𞁐; +var 𞁑; +var 𞁒; +var 𞁓; +var 𞁔; +var 𞁕; +var 𞁖; +var 𞁗; +var 𞁘; +var 𞁙; +var 𞁚; +var 𞁛; +var 𞁜; +var 𞁝; +var 𞁞; +var 𞁟; +var 𞁠; +var 𞁡; +var 𞁢; +var 𞁣; +var 𞁤; +var 𞁥; +var 𞁦; +var 𞁧; +var 𞁨; +var 𞁩; +var 𞁪; +var 𞁫; +var 𞁬; +var 𞁭; +var 𞓐; +var 𞓑; +var 𞓒; +var 𞓓; +var 𞓔; +var 𞓕; +var 𞓖; +var 𞓗; +var 𞓘; +var 𞓙; +var 𞓚; +var 𞓛; +var 𞓜; +var 𞓝; +var 𞓞; +var 𞓟; +var 𞓠; +var 𞓡; +var 𞓢; +var 𞓣; +var 𞓤; +var 𞓥; +var 𞓦; +var 𞓧; +var 𞓨; +var 𞓩; +var 𞓪; +var 𞓫; +var 𫜹; +var 𱍐; +var 𱍑; +var 𱍒; +var 𱍓; +var 𱍔; +var 𱍕; +var 𱍖; +var 𱍗; +var 𱍘; +var 𱍙; +var 𱍚; +var 𱍛; +var 𱍜; +var 𱍝; +var 𱍞; +var 𱍟; +var 𱍠; +var 𱍡; +var 𱍢; +var 𱍣; +var 𱍤; +var 𱍥; +var 𱍦; +var 𱍧; +var 𱍨; +var 𱍩; +var 𱍪; +var 𱍫; +var 𱍬; +var 𱍭; +var 𱍮; +var 𱍯; +var 𱍰; +var 𱍱; +var 𱍲; +var 𱍳; +var 𱍴; +var 𱍵; +var 𱍶; +var 𱍷; +var 𱍸; +var 𱍹; +var 𱍺; +var 𱍻; +var 𱍼; +var 𱍽; +var 𱍾; +var 𱍿; +var 𱎀; +var 𱎁; +var 𱎂; +var 𱎃; +var 𱎄; +var 𱎅; +var 𱎆; +var 𱎇; +var 𱎈; +var 𱎉; +var 𱎊; +var 𱎋; +var 𱎌; +var 𱎍; +var 𱎎; +var 𱎏; +var 𱎐; +var 𱎑; +var 𱎒; +var 𱎓; +var 𱎔; +var 𱎕; +var 𱎖; +var 𱎗; +var 𱎘; +var 𱎙; +var 𱎚; +var 𱎛; +var 𱎜; +var 𱎝; +var 𱎞; +var 𱎟; +var 𱎠; +var 𱎡; +var 𱎢; +var 𱎣; +var 𱎤; +var 𱎥; +var 𱎦; +var 𱎧; +var 𱎨; +var 𱎩; +var 𱎪; +var 𱎫; +var 𱎬; +var 𱎭; +var 𱎮; +var 𱎯; +var 𱎰; +var 𱎱; +var 𱎲; +var 𱎳; +var 𱎴; +var 𱎵; +var 𱎶; +var 𱎷; +var 𱎸; +var 𱎹; +var 𱎺; +var 𱎻; +var 𱎼; +var 𱎽; +var 𱎾; +var 𱎿; +var 𱏀; +var 𱏁; +var 𱏂; +var 𱏃; +var 𱏄; +var 𱏅; +var 𱏆; +var 𱏇; +var 𱏈; +var 𱏉; +var 𱏊; +var 𱏋; +var 𱏌; +var 𱏍; +var 𱏎; +var 𱏏; +var 𱏐; +var 𱏑; +var 𱏒; +var 𱏓; +var 𱏔; +var 𱏕; +var 𱏖; +var 𱏗; +var 𱏘; +var 𱏙; +var 𱏚; +var 𱏛; +var 𱏜; +var 𱏝; +var 𱏞; +var 𱏟; +var 𱏠; +var 𱏡; +var 𱏢; +var 𱏣; +var 𱏤; +var 𱏥; +var 𱏦; +var 𱏧; +var 𱏨; +var 𱏩; +var 𱏪; +var 𱏫; +var 𱏬; +var 𱏭; +var 𱏮; +var 𱏯; +var 𱏰; +var 𱏱; +var 𱏲; +var 𱏳; +var 𱏴; +var 𱏵; +var 𱏶; +var 𱏷; +var 𱏸; +var 𱏹; +var 𱏺; +var 𱏻; +var 𱏼; +var 𱏽; +var 𱏾; +var 𱏿; +var 𱐀; +var 𱐁; +var 𱐂; +var 𱐃; +var 𱐄; +var 𱐅; +var 𱐆; +var 𱐇; +var 𱐈; +var 𱐉; +var 𱐊; +var 𱐋; +var 𱐌; +var 𱐍; +var 𱐎; +var 𱐏; +var 𱐐; +var 𱐑; +var 𱐒; +var 𱐓; +var 𱐔; +var 𱐕; +var 𱐖; +var 𱐗; +var 𱐘; +var 𱐙; +var 𱐚; +var 𱐛; +var 𱐜; +var 𱐝; +var 𱐞; +var 𱐟; +var 𱐠; +var 𱐡; +var 𱐢; +var 𱐣; +var 𱐤; +var 𱐥; +var 𱐦; +var 𱐧; +var 𱐨; +var 𱐩; +var 𱐪; +var 𱐫; +var 𱐬; +var 𱐭; +var 𱐮; +var 𱐯; +var 𱐰; +var 𱐱; +var 𱐲; +var 𱐳; +var 𱐴; +var 𱐵; +var 𱐶; +var 𱐷; +var 𱐸; +var 𱐹; +var 𱐺; +var 𱐻; +var 𱐼; +var 𱐽; +var 𱐾; +var 𱐿; +var 𱑀; +var 𱑁; +var 𱑂; +var 𱑃; +var 𱑄; +var 𱑅; +var 𱑆; +var 𱑇; +var 𱑈; +var 𱑉; +var 𱑊; +var 𱑋; +var 𱑌; +var 𱑍; +var 𱑎; +var 𱑏; +var 𱑐; +var 𱑑; +var 𱑒; +var 𱑓; +var 𱑔; +var 𱑕; +var 𱑖; +var 𱑗; +var 𱑘; +var 𱑙; +var 𱑚; +var 𱑛; +var 𱑜; +var 𱑝; +var 𱑞; +var 𱑟; +var 𱑠; +var 𱑡; +var 𱑢; +var 𱑣; +var 𱑤; +var 𱑥; +var 𱑦; +var 𱑧; +var 𱑨; +var 𱑩; +var 𱑪; +var 𱑫; +var 𱑬; +var 𱑭; +var 𱑮; +var 𱑯; +var 𱑰; +var 𱑱; +var 𱑲; +var 𱑳; +var 𱑴; +var 𱑵; +var 𱑶; +var 𱑷; +var 𱑸; +var 𱑹; +var 𱑺; +var 𱑻; +var 𱑼; +var 𱑽; +var 𱑾; +var 𱑿; +var 𱒀; +var 𱒁; +var 𱒂; +var 𱒃; +var 𱒄; +var 𱒅; +var 𱒆; +var 𱒇; +var 𱒈; +var 𱒉; +var 𱒊; +var 𱒋; +var 𱒌; +var 𱒍; +var 𱒎; +var 𱒏; +var 𱒐; +var 𱒑; +var 𱒒; +var 𱒓; +var 𱒔; +var 𱒕; +var 𱒖; +var 𱒗; +var 𱒘; +var 𱒙; +var 𱒚; +var 𱒛; +var 𱒜; +var 𱒝; +var 𱒞; +var 𱒟; +var 𱒠; +var 𱒡; +var 𱒢; +var 𱒣; +var 𱒤; +var 𱒥; +var 𱒦; +var 𱒧; +var 𱒨; +var 𱒩; +var 𱒪; +var 𱒫; +var 𱒬; +var 𱒭; +var 𱒮; +var 𱒯; +var 𱒰; +var 𱒱; +var 𱒲; +var 𱒳; +var 𱒴; +var 𱒵; +var 𱒶; +var 𱒷; +var 𱒸; +var 𱒹; +var 𱒺; +var 𱒻; +var 𱒼; +var 𱒽; +var 𱒾; +var 𱒿; +var 𱓀; +var 𱓁; +var 𱓂; +var 𱓃; +var 𱓄; +var 𱓅; +var 𱓆; +var 𱓇; +var 𱓈; +var 𱓉; +var 𱓊; +var 𱓋; +var 𱓌; +var 𱓍; +var 𱓎; +var 𱓏; +var 𱓐; +var 𱓑; +var 𱓒; +var 𱓓; +var 𱓔; +var 𱓕; +var 𱓖; +var 𱓗; +var 𱓘; +var 𱓙; +var 𱓚; +var 𱓛; +var 𱓜; +var 𱓝; +var 𱓞; +var 𱓟; +var 𱓠; +var 𱓡; +var 𱓢; +var 𱓣; +var 𱓤; +var 𱓥; +var 𱓦; +var 𱓧; +var 𱓨; +var 𱓩; +var 𱓪; +var 𱓫; +var 𱓬; +var 𱓭; +var 𱓮; +var 𱓯; +var 𱓰; +var 𱓱; +var 𱓲; +var 𱓳; +var 𱓴; +var 𱓵; +var 𱓶; +var 𱓷; +var 𱓸; +var 𱓹; +var 𱓺; +var 𱓻; +var 𱓼; +var 𱓽; +var 𱓾; +var 𱓿; +var 𱔀; +var 𱔁; +var 𱔂; +var 𱔃; +var 𱔄; +var 𱔅; +var 𱔆; +var 𱔇; +var 𱔈; +var 𱔉; +var 𱔊; +var 𱔋; +var 𱔌; +var 𱔍; +var 𱔎; +var 𱔏; +var 𱔐; +var 𱔑; +var 𱔒; +var 𱔓; +var 𱔔; +var 𱔕; +var 𱔖; +var 𱔗; +var 𱔘; +var 𱔙; +var 𱔚; +var 𱔛; +var 𱔜; +var 𱔝; +var 𱔞; +var 𱔟; +var 𱔠; +var 𱔡; +var 𱔢; +var 𱔣; +var 𱔤; +var 𱔥; +var 𱔦; +var 𱔧; +var 𱔨; +var 𱔩; +var 𱔪; +var 𱔫; +var 𱔬; +var 𱔭; +var 𱔮; +var 𱔯; +var 𱔰; +var 𱔱; +var 𱔲; +var 𱔳; +var 𱔴; +var 𱔵; +var 𱔶; +var 𱔷; +var 𱔸; +var 𱔹; +var 𱔺; +var 𱔻; +var 𱔼; +var 𱔽; +var 𱔾; +var 𱔿; +var 𱕀; +var 𱕁; +var 𱕂; +var 𱕃; +var 𱕄; +var 𱕅; +var 𱕆; +var 𱕇; +var 𱕈; +var 𱕉; +var 𱕊; +var 𱕋; +var 𱕌; +var 𱕍; +var 𱕎; +var 𱕏; +var 𱕐; +var 𱕑; +var 𱕒; +var 𱕓; +var 𱕔; +var 𱕕; +var 𱕖; +var 𱕗; +var 𱕘; +var 𱕙; +var 𱕚; +var 𱕛; +var 𱕜; +var 𱕝; +var 𱕞; +var 𱕟; +var 𱕠; +var 𱕡; +var 𱕢; +var 𱕣; +var 𱕤; +var 𱕥; +var 𱕦; +var 𱕧; +var 𱕨; +var 𱕩; +var 𱕪; +var 𱕫; +var 𱕬; +var 𱕭; +var 𱕮; +var 𱕯; +var 𱕰; +var 𱕱; +var 𱕲; +var 𱕳; +var 𱕴; +var 𱕵; +var 𱕶; +var 𱕷; +var 𱕸; +var 𱕹; +var 𱕺; +var 𱕻; +var 𱕼; +var 𱕽; +var 𱕾; +var 𱕿; +var 𱖀; +var 𱖁; +var 𱖂; +var 𱖃; +var 𱖄; +var 𱖅; +var 𱖆; +var 𱖇; +var 𱖈; +var 𱖉; +var 𱖊; +var 𱖋; +var 𱖌; +var 𱖍; +var 𱖎; +var 𱖏; +var 𱖐; +var 𱖑; +var 𱖒; +var 𱖓; +var 𱖔; +var 𱖕; +var 𱖖; +var 𱖗; +var 𱖘; +var 𱖙; +var 𱖚; +var 𱖛; +var 𱖜; +var 𱖝; +var 𱖞; +var 𱖟; +var 𱖠; +var 𱖡; +var 𱖢; +var 𱖣; +var 𱖤; +var 𱖥; +var 𱖦; +var 𱖧; +var 𱖨; +var 𱖩; +var 𱖪; +var 𱖫; +var 𱖬; +var 𱖭; +var 𱖮; +var 𱖯; +var 𱖰; +var 𱖱; +var 𱖲; +var 𱖳; +var 𱖴; +var 𱖵; +var 𱖶; +var 𱖷; +var 𱖸; +var 𱖹; +var 𱖺; +var 𱖻; +var 𱖼; +var 𱖽; +var 𱖾; +var 𱖿; +var 𱗀; +var 𱗁; +var 𱗂; +var 𱗃; +var 𱗄; +var 𱗅; +var 𱗆; +var 𱗇; +var 𱗈; +var 𱗉; +var 𱗊; +var 𱗋; +var 𱗌; +var 𱗍; +var 𱗎; +var 𱗏; +var 𱗐; +var 𱗑; +var 𱗒; +var 𱗓; +var 𱗔; +var 𱗕; +var 𱗖; +var 𱗗; +var 𱗘; +var 𱗙; +var 𱗚; +var 𱗛; +var 𱗜; +var 𱗝; +var 𱗞; +var 𱗟; +var 𱗠; +var 𱗡; +var 𱗢; +var 𱗣; +var 𱗤; +var 𱗥; +var 𱗦; +var 𱗧; +var 𱗨; +var 𱗩; +var 𱗪; +var 𱗫; +var 𱗬; +var 𱗭; +var 𱗮; +var 𱗯; +var 𱗰; +var 𱗱; +var 𱗲; +var 𱗳; +var 𱗴; +var 𱗵; +var 𱗶; +var 𱗷; +var 𱗸; +var 𱗹; +var 𱗺; +var 𱗻; +var 𱗼; +var 𱗽; +var 𱗾; +var 𱗿; +var 𱘀; +var 𱘁; +var 𱘂; +var 𱘃; +var 𱘄; +var 𱘅; +var 𱘆; +var 𱘇; +var 𱘈; +var 𱘉; +var 𱘊; +var 𱘋; +var 𱘌; +var 𱘍; +var 𱘎; +var 𱘏; +var 𱘐; +var 𱘑; +var 𱘒; +var 𱘓; +var 𱘔; +var 𱘕; +var 𱘖; +var 𱘗; +var 𱘘; +var 𱘙; +var 𱘚; +var 𱘛; +var 𱘜; +var 𱘝; +var 𱘞; +var 𱘟; +var 𱘠; +var 𱘡; +var 𱘢; +var 𱘣; +var 𱘤; +var 𱘥; +var 𱘦; +var 𱘧; +var 𱘨; +var 𱘩; +var 𱘪; +var 𱘫; +var 𱘬; +var 𱘭; +var 𱘮; +var 𱘯; +var 𱘰; +var 𱘱; +var 𱘲; +var 𱘳; +var 𱘴; +var 𱘵; +var 𱘶; +var 𱘷; +var 𱘸; +var 𱘹; +var 𱘺; +var 𱘻; +var 𱘼; +var 𱘽; +var 𱘾; +var 𱘿; +var 𱙀; +var 𱙁; +var 𱙂; +var 𱙃; +var 𱙄; +var 𱙅; +var 𱙆; +var 𱙇; +var 𱙈; +var 𱙉; +var 𱙊; +var 𱙋; +var 𱙌; +var 𱙍; +var 𱙎; +var 𱙏; +var 𱙐; +var 𱙑; +var 𱙒; +var 𱙓; +var 𱙔; +var 𱙕; +var 𱙖; +var 𱙗; +var 𱙘; +var 𱙙; +var 𱙚; +var 𱙛; +var 𱙜; +var 𱙝; +var 𱙞; +var 𱙟; +var 𱙠; +var 𱙡; +var 𱙢; +var 𱙣; +var 𱙤; +var 𱙥; +var 𱙦; +var 𱙧; +var 𱙨; +var 𱙩; +var 𱙪; +var 𱙫; +var 𱙬; +var 𱙭; +var 𱙮; +var 𱙯; +var 𱙰; +var 𱙱; +var 𱙲; +var 𱙳; +var 𱙴; +var 𱙵; +var 𱙶; +var 𱙷; +var 𱙸; +var 𱙹; +var 𱙺; +var 𱙻; +var 𱙼; +var 𱙽; +var 𱙾; +var 𱙿; +var 𱚀; +var 𱚁; +var 𱚂; +var 𱚃; +var 𱚄; +var 𱚅; +var 𱚆; +var 𱚇; +var 𱚈; +var 𱚉; +var 𱚊; +var 𱚋; +var 𱚌; +var 𱚍; +var 𱚎; +var 𱚏; +var 𱚐; +var 𱚑; +var 𱚒; +var 𱚓; +var 𱚔; +var 𱚕; +var 𱚖; +var 𱚗; +var 𱚘; +var 𱚙; +var 𱚚; +var 𱚛; +var 𱚜; +var 𱚝; +var 𱚞; +var 𱚟; +var 𱚠; +var 𱚡; +var 𱚢; +var 𱚣; +var 𱚤; +var 𱚥; +var 𱚦; +var 𱚧; +var 𱚨; +var 𱚩; +var 𱚪; +var 𱚫; +var 𱚬; +var 𱚭; +var 𱚮; +var 𱚯; +var 𱚰; +var 𱚱; +var 𱚲; +var 𱚳; +var 𱚴; +var 𱚵; +var 𱚶; +var 𱚷; +var 𱚸; +var 𱚹; +var 𱚺; +var 𱚻; +var 𱚼; +var 𱚽; +var 𱚾; +var 𱚿; +var 𱛀; +var 𱛁; +var 𱛂; +var 𱛃; +var 𱛄; +var 𱛅; +var 𱛆; +var 𱛇; +var 𱛈; +var 𱛉; +var 𱛊; +var 𱛋; +var 𱛌; +var 𱛍; +var 𱛎; +var 𱛏; +var 𱛐; +var 𱛑; +var 𱛒; +var 𱛓; +var 𱛔; +var 𱛕; +var 𱛖; +var 𱛗; +var 𱛘; +var 𱛙; +var 𱛚; +var 𱛛; +var 𱛜; +var 𱛝; +var 𱛞; +var 𱛟; +var 𱛠; +var 𱛡; +var 𱛢; +var 𱛣; +var 𱛤; +var 𱛥; +var 𱛦; +var 𱛧; +var 𱛨; +var 𱛩; +var 𱛪; +var 𱛫; +var 𱛬; +var 𱛭; +var 𱛮; +var 𱛯; +var 𱛰; +var 𱛱; +var 𱛲; +var 𱛳; +var 𱛴; +var 𱛵; +var 𱛶; +var 𱛷; +var 𱛸; +var 𱛹; +var 𱛺; +var 𱛻; +var 𱛼; +var 𱛽; +var 𱛾; +var 𱛿; +var 𱜀; +var 𱜁; +var 𱜂; +var 𱜃; +var 𱜄; +var 𱜅; +var 𱜆; +var 𱜇; +var 𱜈; +var 𱜉; +var 𱜊; +var 𱜋; +var 𱜌; +var 𱜍; +var 𱜎; +var 𱜏; +var 𱜐; +var 𱜑; +var 𱜒; +var 𱜓; +var 𱜔; +var 𱜕; +var 𱜖; +var 𱜗; +var 𱜘; +var 𱜙; +var 𱜚; +var 𱜛; +var 𱜜; +var 𱜝; +var 𱜞; +var 𱜟; +var 𱜠; +var 𱜡; +var 𱜢; +var 𱜣; +var 𱜤; +var 𱜥; +var 𱜦; +var 𱜧; +var 𱜨; +var 𱜩; +var 𱜪; +var 𱜫; +var 𱜬; +var 𱜭; +var 𱜮; +var 𱜯; +var 𱜰; +var 𱜱; +var 𱜲; +var 𱜳; +var 𱜴; +var 𱜵; +var 𱜶; +var 𱜷; +var 𱜸; +var 𱜹; +var 𱜺; +var 𱜻; +var 𱜼; +var 𱜽; +var 𱜾; +var 𱜿; +var 𱝀; +var 𱝁; +var 𱝂; +var 𱝃; +var 𱝄; +var 𱝅; +var 𱝆; +var 𱝇; +var 𱝈; +var 𱝉; +var 𱝊; +var 𱝋; +var 𱝌; +var 𱝍; +var 𱝎; +var 𱝏; +var 𱝐; +var 𱝑; +var 𱝒; +var 𱝓; +var 𱝔; +var 𱝕; +var 𱝖; +var 𱝗; +var 𱝘; +var 𱝙; +var 𱝚; +var 𱝛; +var 𱝜; +var 𱝝; +var 𱝞; +var 𱝟; +var 𱝠; +var 𱝡; +var 𱝢; +var 𱝣; +var 𱝤; +var 𱝥; +var 𱝦; +var 𱝧; +var 𱝨; +var 𱝩; +var 𱝪; +var 𱝫; +var 𱝬; +var 𱝭; +var 𱝮; +var 𱝯; +var 𱝰; +var 𱝱; +var 𱝲; +var 𱝳; +var 𱝴; +var 𱝵; +var 𱝶; +var 𱝷; +var 𱝸; +var 𱝹; +var 𱝺; +var 𱝻; +var 𱝼; +var 𱝽; +var 𱝾; +var 𱝿; +var 𱞀; +var 𱞁; +var 𱞂; +var 𱞃; +var 𱞄; +var 𱞅; +var 𱞆; +var 𱞇; +var 𱞈; +var 𱞉; +var 𱞊; +var 𱞋; +var 𱞌; +var 𱞍; +var 𱞎; +var 𱞏; +var 𱞐; +var 𱞑; +var 𱞒; +var 𱞓; +var 𱞔; +var 𱞕; +var 𱞖; +var 𱞗; +var 𱞘; +var 𱞙; +var 𱞚; +var 𱞛; +var 𱞜; +var 𱞝; +var 𱞞; +var 𱞟; +var 𱞠; +var 𱞡; +var 𱞢; +var 𱞣; +var 𱞤; +var 𱞥; +var 𱞦; +var 𱞧; +var 𱞨; +var 𱞩; +var 𱞪; +var 𱞫; +var 𱞬; +var 𱞭; +var 𱞮; +var 𱞯; +var 𱞰; +var 𱞱; +var 𱞲; +var 𱞳; +var 𱞴; +var 𱞵; +var 𱞶; +var 𱞷; +var 𱞸; +var 𱞹; +var 𱞺; +var 𱞻; +var 𱞼; +var 𱞽; +var 𱞾; +var 𱞿; +var 𱟀; +var 𱟁; +var 𱟂; +var 𱟃; +var 𱟄; +var 𱟅; +var 𱟆; +var 𱟇; +var 𱟈; +var 𱟉; +var 𱟊; +var 𱟋; +var 𱟌; +var 𱟍; +var 𱟎; +var 𱟏; +var 𱟐; +var 𱟑; +var 𱟒; +var 𱟓; +var 𱟔; +var 𱟕; +var 𱟖; +var 𱟗; +var 𱟘; +var 𱟙; +var 𱟚; +var 𱟛; +var 𱟜; +var 𱟝; +var 𱟞; +var 𱟟; +var 𱟠; +var 𱟡; +var 𱟢; +var 𱟣; +var 𱟤; +var 𱟥; +var 𱟦; +var 𱟧; +var 𱟨; +var 𱟩; +var 𱟪; +var 𱟫; +var 𱟬; +var 𱟭; +var 𱟮; +var 𱟯; +var 𱟰; +var 𱟱; +var 𱟲; +var 𱟳; +var 𱟴; +var 𱟵; +var 𱟶; +var 𱟷; +var 𱟸; +var 𱟹; +var 𱟺; +var 𱟻; +var 𱟼; +var 𱟽; +var 𱟾; +var 𱟿; +var 𱠀; +var 𱠁; +var 𱠂; +var 𱠃; +var 𱠄; +var 𱠅; +var 𱠆; +var 𱠇; +var 𱠈; +var 𱠉; +var 𱠊; +var 𱠋; +var 𱠌; +var 𱠍; +var 𱠎; +var 𱠏; +var 𱠐; +var 𱠑; +var 𱠒; +var 𱠓; +var 𱠔; +var 𱠕; +var 𱠖; +var 𱠗; +var 𱠘; +var 𱠙; +var 𱠚; +var 𱠛; +var 𱠜; +var 𱠝; +var 𱠞; +var 𱠟; +var 𱠠; +var 𱠡; +var 𱠢; +var 𱠣; +var 𱠤; +var 𱠥; +var 𱠦; +var 𱠧; +var 𱠨; +var 𱠩; +var 𱠪; +var 𱠫; +var 𱠬; +var 𱠭; +var 𱠮; +var 𱠯; +var 𱠰; +var 𱠱; +var 𱠲; +var 𱠳; +var 𱠴; +var 𱠵; +var 𱠶; +var 𱠷; +var 𱠸; +var 𱠹; +var 𱠺; +var 𱠻; +var 𱠼; +var 𱠽; +var 𱠾; +var 𱠿; +var 𱡀; +var 𱡁; +var 𱡂; +var 𱡃; +var 𱡄; +var 𱡅; +var 𱡆; +var 𱡇; +var 𱡈; +var 𱡉; +var 𱡊; +var 𱡋; +var 𱡌; +var 𱡍; +var 𱡎; +var 𱡏; +var 𱡐; +var 𱡑; +var 𱡒; +var 𱡓; +var 𱡔; +var 𱡕; +var 𱡖; +var 𱡗; +var 𱡘; +var 𱡙; +var 𱡚; +var 𱡛; +var 𱡜; +var 𱡝; +var 𱡞; +var 𱡟; +var 𱡠; +var 𱡡; +var 𱡢; +var 𱡣; +var 𱡤; +var 𱡥; +var 𱡦; +var 𱡧; +var 𱡨; +var 𱡩; +var 𱡪; +var 𱡫; +var 𱡬; +var 𱡭; +var 𱡮; +var 𱡯; +var 𱡰; +var 𱡱; +var 𱡲; +var 𱡳; +var 𱡴; +var 𱡵; +var 𱡶; +var 𱡷; +var 𱡸; +var 𱡹; +var 𱡺; +var 𱡻; +var 𱡼; +var 𱡽; +var 𱡾; +var 𱡿; +var 𱢀; +var 𱢁; +var 𱢂; +var 𱢃; +var 𱢄; +var 𱢅; +var 𱢆; +var 𱢇; +var 𱢈; +var 𱢉; +var 𱢊; +var 𱢋; +var 𱢌; +var 𱢍; +var 𱢎; +var 𱢏; +var 𱢐; +var 𱢑; +var 𱢒; +var 𱢓; +var 𱢔; +var 𱢕; +var 𱢖; +var 𱢗; +var 𱢘; +var 𱢙; +var 𱢚; +var 𱢛; +var 𱢜; +var 𱢝; +var 𱢞; +var 𱢟; +var 𱢠; +var 𱢡; +var 𱢢; +var 𱢣; +var 𱢤; +var 𱢥; +var 𱢦; +var 𱢧; +var 𱢨; +var 𱢩; +var 𱢪; +var 𱢫; +var 𱢬; +var 𱢭; +var 𱢮; +var 𱢯; +var 𱢰; +var 𱢱; +var 𱢲; +var 𱢳; +var 𱢴; +var 𱢵; +var 𱢶; +var 𱢷; +var 𱢸; +var 𱢹; +var 𱢺; +var 𱢻; +var 𱢼; +var 𱢽; +var 𱢾; +var 𱢿; +var 𱣀; +var 𱣁; +var 𱣂; +var 𱣃; +var 𱣄; +var 𱣅; +var 𱣆; +var 𱣇; +var 𱣈; +var 𱣉; +var 𱣊; +var 𱣋; +var 𱣌; +var 𱣍; +var 𱣎; +var 𱣏; +var 𱣐; +var 𱣑; +var 𱣒; +var 𱣓; +var 𱣔; +var 𱣕; +var 𱣖; +var 𱣗; +var 𱣘; +var 𱣙; +var 𱣚; +var 𱣛; +var 𱣜; +var 𱣝; +var 𱣞; +var 𱣟; +var 𱣠; +var 𱣡; +var 𱣢; +var 𱣣; +var 𱣤; +var 𱣥; +var 𱣦; +var 𱣧; +var 𱣨; +var 𱣩; +var 𱣪; +var 𱣫; +var 𱣬; +var 𱣭; +var 𱣮; +var 𱣯; +var 𱣰; +var 𱣱; +var 𱣲; +var 𱣳; +var 𱣴; +var 𱣵; +var 𱣶; +var 𱣷; +var 𱣸; +var 𱣹; +var 𱣺; +var 𱣻; +var 𱣼; +var 𱣽; +var 𱣾; +var 𱣿; +var 𱤀; +var 𱤁; +var 𱤂; +var 𱤃; +var 𱤄; +var 𱤅; +var 𱤆; +var 𱤇; +var 𱤈; +var 𱤉; +var 𱤊; +var 𱤋; +var 𱤌; +var 𱤍; +var 𱤎; +var 𱤏; +var 𱤐; +var 𱤑; +var 𱤒; +var 𱤓; +var 𱤔; +var 𱤕; +var 𱤖; +var 𱤗; +var 𱤘; +var 𱤙; +var 𱤚; +var 𱤛; +var 𱤜; +var 𱤝; +var 𱤞; +var 𱤟; +var 𱤠; +var 𱤡; +var 𱤢; +var 𱤣; +var 𱤤; +var 𱤥; +var 𱤦; +var 𱤧; +var 𱤨; +var 𱤩; +var 𱤪; +var 𱤫; +var 𱤬; +var 𱤭; +var 𱤮; +var 𱤯; +var 𱤰; +var 𱤱; +var 𱤲; +var 𱤳; +var 𱤴; +var 𱤵; +var 𱤶; +var 𱤷; +var 𱤸; +var 𱤹; +var 𱤺; +var 𱤻; +var 𱤼; +var 𱤽; +var 𱤾; +var 𱤿; +var 𱥀; +var 𱥁; +var 𱥂; +var 𱥃; +var 𱥄; +var 𱥅; +var 𱥆; +var 𱥇; +var 𱥈; +var 𱥉; +var 𱥊; +var 𱥋; +var 𱥌; +var 𱥍; +var 𱥎; +var 𱥏; +var 𱥐; +var 𱥑; +var 𱥒; +var 𱥓; +var 𱥔; +var 𱥕; +var 𱥖; +var 𱥗; +var 𱥘; +var 𱥙; +var 𱥚; +var 𱥛; +var 𱥜; +var 𱥝; +var 𱥞; +var 𱥟; +var 𱥠; +var 𱥡; +var 𱥢; +var 𱥣; +var 𱥤; +var 𱥥; +var 𱥦; +var 𱥧; +var 𱥨; +var 𱥩; +var 𱥪; +var 𱥫; +var 𱥬; +var 𱥭; +var 𱥮; +var 𱥯; +var 𱥰; +var 𱥱; +var 𱥲; +var 𱥳; +var 𱥴; +var 𱥵; +var 𱥶; +var 𱥷; +var 𱥸; +var 𱥹; +var 𱥺; +var 𱥻; +var 𱥼; +var 𱥽; +var 𱥾; +var 𱥿; +var 𱦀; +var 𱦁; +var 𱦂; +var 𱦃; +var 𱦄; +var 𱦅; +var 𱦆; +var 𱦇; +var 𱦈; +var 𱦉; +var 𱦊; +var 𱦋; +var 𱦌; +var 𱦍; +var 𱦎; +var 𱦏; +var 𱦐; +var 𱦑; +var 𱦒; +var 𱦓; +var 𱦔; +var 𱦕; +var 𱦖; +var 𱦗; +var 𱦘; +var 𱦙; +var 𱦚; +var 𱦛; +var 𱦜; +var 𱦝; +var 𱦞; +var 𱦟; +var 𱦠; +var 𱦡; +var 𱦢; +var 𱦣; +var 𱦤; +var 𱦥; +var 𱦦; +var 𱦧; +var 𱦨; +var 𱦩; +var 𱦪; +var 𱦫; +var 𱦬; +var 𱦭; +var 𱦮; +var 𱦯; +var 𱦰; +var 𱦱; +var 𱦲; +var 𱦳; +var 𱦴; +var 𱦵; +var 𱦶; +var 𱦷; +var 𱦸; +var 𱦹; +var 𱦺; +var 𱦻; +var 𱦼; +var 𱦽; +var 𱦾; +var 𱦿; +var 𱧀; +var 𱧁; +var 𱧂; +var 𱧃; +var 𱧄; +var 𱧅; +var 𱧆; +var 𱧇; +var 𱧈; +var 𱧉; +var 𱧊; +var 𱧋; +var 𱧌; +var 𱧍; +var 𱧎; +var 𱧏; +var 𱧐; +var 𱧑; +var 𱧒; +var 𱧓; +var 𱧔; +var 𱧕; +var 𱧖; +var 𱧗; +var 𱧘; +var 𱧙; +var 𱧚; +var 𱧛; +var 𱧜; +var 𱧝; +var 𱧞; +var 𱧟; +var 𱧠; +var 𱧡; +var 𱧢; +var 𱧣; +var 𱧤; +var 𱧥; +var 𱧦; +var 𱧧; +var 𱧨; +var 𱧩; +var 𱧪; +var 𱧫; +var 𱧬; +var 𱧭; +var 𱧮; +var 𱧯; +var 𱧰; +var 𱧱; +var 𱧲; +var 𱧳; +var 𱧴; +var 𱧵; +var 𱧶; +var 𱧷; +var 𱧸; +var 𱧹; +var 𱧺; +var 𱧻; +var 𱧼; +var 𱧽; +var 𱧾; +var 𱧿; +var 𱨀; +var 𱨁; +var 𱨂; +var 𱨃; +var 𱨄; +var 𱨅; +var 𱨆; +var 𱨇; +var 𱨈; +var 𱨉; +var 𱨊; +var 𱨋; +var 𱨌; +var 𱨍; +var 𱨎; +var 𱨏; +var 𱨐; +var 𱨑; +var 𱨒; +var 𱨓; +var 𱨔; +var 𱨕; +var 𱨖; +var 𱨗; +var 𱨘; +var 𱨙; +var 𱨚; +var 𱨛; +var 𱨜; +var 𱨝; +var 𱨞; +var 𱨟; +var 𱨠; +var 𱨡; +var 𱨢; +var 𱨣; +var 𱨤; +var 𱨥; +var 𱨦; +var 𱨧; +var 𱨨; +var 𱨩; +var 𱨪; +var 𱨫; +var 𱨬; +var 𱨭; +var 𱨮; +var 𱨯; +var 𱨰; +var 𱨱; +var 𱨲; +var 𱨳; +var 𱨴; +var 𱨵; +var 𱨶; +var 𱨷; +var 𱨸; +var 𱨹; +var 𱨺; +var 𱨻; +var 𱨼; +var 𱨽; +var 𱨾; +var 𱨿; +var 𱩀; +var 𱩁; +var 𱩂; +var 𱩃; +var 𱩄; +var 𱩅; +var 𱩆; +var 𱩇; +var 𱩈; +var 𱩉; +var 𱩊; +var 𱩋; +var 𱩌; +var 𱩍; +var 𱩎; +var 𱩏; +var 𱩐; +var 𱩑; +var 𱩒; +var 𱩓; +var 𱩔; +var 𱩕; +var 𱩖; +var 𱩗; +var 𱩘; +var 𱩙; +var 𱩚; +var 𱩛; +var 𱩜; +var 𱩝; +var 𱩞; +var 𱩟; +var 𱩠; +var 𱩡; +var 𱩢; +var 𱩣; +var 𱩤; +var 𱩥; +var 𱩦; +var 𱩧; +var 𱩨; +var 𱩩; +var 𱩪; +var 𱩫; +var 𱩬; +var 𱩭; +var 𱩮; +var 𱩯; +var 𱩰; +var 𱩱; +var 𱩲; +var 𱩳; +var 𱩴; +var 𱩵; +var 𱩶; +var 𱩷; +var 𱩸; +var 𱩹; +var 𱩺; +var 𱩻; +var 𱩼; +var 𱩽; +var 𱩾; +var 𱩿; +var 𱪀; +var 𱪁; +var 𱪂; +var 𱪃; +var 𱪄; +var 𱪅; +var 𱪆; +var 𱪇; +var 𱪈; +var 𱪉; +var 𱪊; +var 𱪋; +var 𱪌; +var 𱪍; +var 𱪎; +var 𱪏; +var 𱪐; +var 𱪑; +var 𱪒; +var 𱪓; +var 𱪔; +var 𱪕; +var 𱪖; +var 𱪗; +var 𱪘; +var 𱪙; +var 𱪚; +var 𱪛; +var 𱪜; +var 𱪝; +var 𱪞; +var 𱪟; +var 𱪠; +var 𱪡; +var 𱪢; +var 𱪣; +var 𱪤; +var 𱪥; +var 𱪦; +var 𱪧; +var 𱪨; +var 𱪩; +var 𱪪; +var 𱪫; +var 𱪬; +var 𱪭; +var 𱪮; +var 𱪯; +var 𱪰; +var 𱪱; +var 𱪲; +var 𱪳; +var 𱪴; +var 𱪵; +var 𱪶; +var 𱪷; +var 𱪸; +var 𱪹; +var 𱪺; +var 𱪻; +var 𱪼; +var 𱪽; +var 𱪾; +var 𱪿; +var 𱫀; +var 𱫁; +var 𱫂; +var 𱫃; +var 𱫄; +var 𱫅; +var 𱫆; +var 𱫇; +var 𱫈; +var 𱫉; +var 𱫊; +var 𱫋; +var 𱫌; +var 𱫍; +var 𱫎; +var 𱫏; +var 𱫐; +var 𱫑; +var 𱫒; +var 𱫓; +var 𱫔; +var 𱫕; +var 𱫖; +var 𱫗; +var 𱫘; +var 𱫙; +var 𱫚; +var 𱫛; +var 𱫜; +var 𱫝; +var 𱫞; +var 𱫟; +var 𱫠; +var 𱫡; +var 𱫢; +var 𱫣; +var 𱫤; +var 𱫥; +var 𱫦; +var 𱫧; +var 𱫨; +var 𱫩; +var 𱫪; +var 𱫫; +var 𱫬; +var 𱫭; +var 𱫮; +var 𱫯; +var 𱫰; +var 𱫱; +var 𱫲; +var 𱫳; +var 𱫴; +var 𱫵; +var 𱫶; +var 𱫷; +var 𱫸; +var 𱫹; +var 𱫺; +var 𱫻; +var 𱫼; +var 𱫽; +var 𱫾; +var 𱫿; +var 𱬀; +var 𱬁; +var 𱬂; +var 𱬃; +var 𱬄; +var 𱬅; +var 𱬆; +var 𱬇; +var 𱬈; +var 𱬉; +var 𱬊; +var 𱬋; +var 𱬌; +var 𱬍; +var 𱬎; +var 𱬏; +var 𱬐; +var 𱬑; +var 𱬒; +var 𱬓; +var 𱬔; +var 𱬕; +var 𱬖; +var 𱬗; +var 𱬘; +var 𱬙; +var 𱬚; +var 𱬛; +var 𱬜; +var 𱬝; +var 𱬞; +var 𱬟; +var 𱬠; +var 𱬡; +var 𱬢; +var 𱬣; +var 𱬤; +var 𱬥; +var 𱬦; +var 𱬧; +var 𱬨; +var 𱬩; +var 𱬪; +var 𱬫; +var 𱬬; +var 𱬭; +var 𱬮; +var 𱬯; +var 𱬰; +var 𱬱; +var 𱬲; +var 𱬳; +var 𱬴; +var 𱬵; +var 𱬶; +var 𱬷; +var 𱬸; +var 𱬹; +var 𱬺; +var 𱬻; +var 𱬼; +var 𱬽; +var 𱬾; +var 𱬿; +var 𱭀; +var 𱭁; +var 𱭂; +var 𱭃; +var 𱭄; +var 𱭅; +var 𱭆; +var 𱭇; +var 𱭈; +var 𱭉; +var 𱭊; +var 𱭋; +var 𱭌; +var 𱭍; +var 𱭎; +var 𱭏; +var 𱭐; +var 𱭑; +var 𱭒; +var 𱭓; +var 𱭔; +var 𱭕; +var 𱭖; +var 𱭗; +var 𱭘; +var 𱭙; +var 𱭚; +var 𱭛; +var 𱭜; +var 𱭝; +var 𱭞; +var 𱭟; +var 𱭠; +var 𱭡; +var 𱭢; +var 𱭣; +var 𱭤; +var 𱭥; +var 𱭦; +var 𱭧; +var 𱭨; +var 𱭩; +var 𱭪; +var 𱭫; +var 𱭬; +var 𱭭; +var 𱭮; +var 𱭯; +var 𱭰; +var 𱭱; +var 𱭲; +var 𱭳; +var 𱭴; +var 𱭵; +var 𱭶; +var 𱭷; +var 𱭸; +var 𱭹; +var 𱭺; +var 𱭻; +var 𱭼; +var 𱭽; +var 𱭾; +var 𱭿; +var 𱮀; +var 𱮁; +var 𱮂; +var 𱮃; +var 𱮄; +var 𱮅; +var 𱮆; +var 𱮇; +var 𱮈; +var 𱮉; +var 𱮊; +var 𱮋; +var 𱮌; +var 𱮍; +var 𱮎; +var 𱮏; +var 𱮐; +var 𱮑; +var 𱮒; +var 𱮓; +var 𱮔; +var 𱮕; +var 𱮖; +var 𱮗; +var 𱮘; +var 𱮙; +var 𱮚; +var 𱮛; +var 𱮜; +var 𱮝; +var 𱮞; +var 𱮟; +var 𱮠; +var 𱮡; +var 𱮢; +var 𱮣; +var 𱮤; +var 𱮥; +var 𱮦; +var 𱮧; +var 𱮨; +var 𱮩; +var 𱮪; +var 𱮫; +var 𱮬; +var 𱮭; +var 𱮮; +var 𱮯; +var 𱮰; +var 𱮱; +var 𱮲; +var 𱮳; +var 𱮴; +var 𱮵; +var 𱮶; +var 𱮷; +var 𱮸; +var 𱮹; +var 𱮺; +var 𱮻; +var 𱮼; +var 𱮽; +var 𱮾; +var 𱮿; +var 𱯀; +var 𱯁; +var 𱯂; +var 𱯃; +var 𱯄; +var 𱯅; +var 𱯆; +var 𱯇; +var 𱯈; +var 𱯉; +var 𱯊; +var 𱯋; +var 𱯌; +var 𱯍; +var 𱯎; +var 𱯏; +var 𱯐; +var 𱯑; +var 𱯒; +var 𱯓; +var 𱯔; +var 𱯕; +var 𱯖; +var 𱯗; +var 𱯘; +var 𱯙; +var 𱯚; +var 𱯛; +var 𱯜; +var 𱯝; +var 𱯞; +var 𱯟; +var 𱯠; +var 𱯡; +var 𱯢; +var 𱯣; +var 𱯤; +var 𱯥; +var 𱯦; +var 𱯧; +var 𱯨; +var 𱯩; +var 𱯪; +var 𱯫; +var 𱯬; +var 𱯭; +var 𱯮; +var 𱯯; +var 𱯰; +var 𱯱; +var 𱯲; +var 𱯳; +var 𱯴; +var 𱯵; +var 𱯶; +var 𱯷; +var 𱯸; +var 𱯹; +var 𱯺; +var 𱯻; +var 𱯼; +var 𱯽; +var 𱯾; +var 𱯿; +var 𱰀; +var 𱰁; +var 𱰂; +var 𱰃; +var 𱰄; +var 𱰅; +var 𱰆; +var 𱰇; +var 𱰈; +var 𱰉; +var 𱰊; +var 𱰋; +var 𱰌; +var 𱰍; +var 𱰎; +var 𱰏; +var 𱰐; +var 𱰑; +var 𱰒; +var 𱰓; +var 𱰔; +var 𱰕; +var 𱰖; +var 𱰗; +var 𱰘; +var 𱰙; +var 𱰚; +var 𱰛; +var 𱰜; +var 𱰝; +var 𱰞; +var 𱰟; +var 𱰠; +var 𱰡; +var 𱰢; +var 𱰣; +var 𱰤; +var 𱰥; +var 𱰦; +var 𱰧; +var 𱰨; +var 𱰩; +var 𱰪; +var 𱰫; +var 𱰬; +var 𱰭; +var 𱰮; +var 𱰯; +var 𱰰; +var 𱰱; +var 𱰲; +var 𱰳; +var 𱰴; +var 𱰵; +var 𱰶; +var 𱰷; +var 𱰸; +var 𱰹; +var 𱰺; +var 𱰻; +var 𱰼; +var 𱰽; +var 𱰾; +var 𱰿; +var 𱱀; +var 𱱁; +var 𱱂; +var 𱱃; +var 𱱄; +var 𱱅; +var 𱱆; +var 𱱇; +var 𱱈; +var 𱱉; +var 𱱊; +var 𱱋; +var 𱱌; +var 𱱍; +var 𱱎; +var 𱱏; +var 𱱐; +var 𱱑; +var 𱱒; +var 𱱓; +var 𱱔; +var 𱱕; +var 𱱖; +var 𱱗; +var 𱱘; +var 𱱙; +var 𱱚; +var 𱱛; +var 𱱜; +var 𱱝; +var 𱱞; +var 𱱟; +var 𱱠; +var 𱱡; +var 𱱢; +var 𱱣; +var 𱱤; +var 𱱥; +var 𱱦; +var 𱱧; +var 𱱨; +var 𱱩; +var 𱱪; +var 𱱫; +var 𱱬; +var 𱱭; +var 𱱮; +var 𱱯; +var 𱱰; +var 𱱱; +var 𱱲; +var 𱱳; +var 𱱴; +var 𱱵; +var 𱱶; +var 𱱷; +var 𱱸; +var 𱱹; +var 𱱺; +var 𱱻; +var 𱱼; +var 𱱽; +var 𱱾; +var 𱱿; +var 𱲀; +var 𱲁; +var 𱲂; +var 𱲃; +var 𱲄; +var 𱲅; +var 𱲆; +var 𱲇; +var 𱲈; +var 𱲉; +var 𱲊; +var 𱲋; +var 𱲌; +var 𱲍; +var 𱲎; +var 𱲏; +var 𱲐; +var 𱲑; +var 𱲒; +var 𱲓; +var 𱲔; +var 𱲕; +var 𱲖; +var 𱲗; +var 𱲘; +var 𱲙; +var 𱲚; +var 𱲛; +var 𱲜; +var 𱲝; +var 𱲞; +var 𱲟; +var 𱲠; +var 𱲡; +var 𱲢; +var 𱲣; +var 𱲤; +var 𱲥; +var 𱲦; +var 𱲧; +var 𱲨; +var 𱲩; +var 𱲪; +var 𱲫; +var 𱲬; +var 𱲭; +var 𱲮; +var 𱲯; +var 𱲰; +var 𱲱; +var 𱲲; +var 𱲳; +var 𱲴; +var 𱲵; +var 𱲶; +var 𱲷; +var 𱲸; +var 𱲹; +var 𱲺; +var 𱲻; +var 𱲼; +var 𱲽; +var 𱲾; +var 𱲿; +var 𱳀; +var 𱳁; +var 𱳂; +var 𱳃; +var 𱳄; +var 𱳅; +var 𱳆; +var 𱳇; +var 𱳈; +var 𱳉; +var 𱳊; +var 𱳋; +var 𱳌; +var 𱳍; +var 𱳎; +var 𱳏; +var 𱳐; +var 𱳑; +var 𱳒; +var 𱳓; +var 𱳔; +var 𱳕; +var 𱳖; +var 𱳗; +var 𱳘; +var 𱳙; +var 𱳚; +var 𱳛; +var 𱳜; +var 𱳝; +var 𱳞; +var 𱳟; +var 𱳠; +var 𱳡; +var 𱳢; +var 𱳣; +var 𱳤; +var 𱳥; +var 𱳦; +var 𱳧; +var 𱳨; +var 𱳩; +var 𱳪; +var 𱳫; +var 𱳬; +var 𱳭; +var 𱳮; +var 𱳯; +var 𱳰; +var 𱳱; +var 𱳲; +var 𱳳; +var 𱳴; +var 𱳵; +var 𱳶; +var 𱳷; +var 𱳸; +var 𱳹; +var 𱳺; +var 𱳻; +var 𱳼; +var 𱳽; +var 𱳾; +var 𱳿; +var 𱴀; +var 𱴁; +var 𱴂; +var 𱴃; +var 𱴄; +var 𱴅; +var 𱴆; +var 𱴇; +var 𱴈; +var 𱴉; +var 𱴊; +var 𱴋; +var 𱴌; +var 𱴍; +var 𱴎; +var 𱴏; +var 𱴐; +var 𱴑; +var 𱴒; +var 𱴓; +var 𱴔; +var 𱴕; +var 𱴖; +var 𱴗; +var 𱴘; +var 𱴙; +var 𱴚; +var 𱴛; +var 𱴜; +var 𱴝; +var 𱴞; +var 𱴟; +var 𱴠; +var 𱴡; +var 𱴢; +var 𱴣; +var 𱴤; +var 𱴥; +var 𱴦; +var 𱴧; +var 𱴨; +var 𱴩; +var 𱴪; +var 𱴫; +var 𱴬; +var 𱴭; +var 𱴮; +var 𱴯; +var 𱴰; +var 𱴱; +var 𱴲; +var 𱴳; +var 𱴴; +var 𱴵; +var 𱴶; +var 𱴷; +var 𱴸; +var 𱴹; +var 𱴺; +var 𱴻; +var 𱴼; +var 𱴽; +var 𱴾; +var 𱴿; +var 𱵀; +var 𱵁; +var 𱵂; +var 𱵃; +var 𱵄; +var 𱵅; +var 𱵆; +var 𱵇; +var 𱵈; +var 𱵉; +var 𱵊; +var 𱵋; +var 𱵌; +var 𱵍; +var 𱵎; +var 𱵏; +var 𱵐; +var 𱵑; +var 𱵒; +var 𱵓; +var 𱵔; +var 𱵕; +var 𱵖; +var 𱵗; +var 𱵘; +var 𱵙; +var 𱵚; +var 𱵛; +var 𱵜; +var 𱵝; +var 𱵞; +var 𱵟; +var 𱵠; +var 𱵡; +var 𱵢; +var 𱵣; +var 𱵤; +var 𱵥; +var 𱵦; +var 𱵧; +var 𱵨; +var 𱵩; +var 𱵪; +var 𱵫; +var 𱵬; +var 𱵭; +var 𱵮; +var 𱵯; +var 𱵰; +var 𱵱; +var 𱵲; +var 𱵳; +var 𱵴; +var 𱵵; +var 𱵶; +var 𱵷; +var 𱵸; +var 𱵹; +var 𱵺; +var 𱵻; +var 𱵼; +var 𱵽; +var 𱵾; +var 𱵿; +var 𱶀; +var 𱶁; +var 𱶂; +var 𱶃; +var 𱶄; +var 𱶅; +var 𱶆; +var 𱶇; +var 𱶈; +var 𱶉; +var 𱶊; +var 𱶋; +var 𱶌; +var 𱶍; +var 𱶎; +var 𱶏; +var 𱶐; +var 𱶑; +var 𱶒; +var 𱶓; +var 𱶔; +var 𱶕; +var 𱶖; +var 𱶗; +var 𱶘; +var 𱶙; +var 𱶚; +var 𱶛; +var 𱶜; +var 𱶝; +var 𱶞; +var 𱶟; +var 𱶠; +var 𱶡; +var 𱶢; +var 𱶣; +var 𱶤; +var 𱶥; +var 𱶦; +var 𱶧; +var 𱶨; +var 𱶩; +var 𱶪; +var 𱶫; +var 𱶬; +var 𱶭; +var 𱶮; +var 𱶯; +var 𱶰; +var 𱶱; +var 𱶲; +var 𱶳; +var 𱶴; +var 𱶵; +var 𱶶; +var 𱶷; +var 𱶸; +var 𱶹; +var 𱶺; +var 𱶻; +var 𱶼; +var 𱶽; +var 𱶾; +var 𱶿; +var 𱷀; +var 𱷁; +var 𱷂; +var 𱷃; +var 𱷄; +var 𱷅; +var 𱷆; +var 𱷇; +var 𱷈; +var 𱷉; +var 𱷊; +var 𱷋; +var 𱷌; +var 𱷍; +var 𱷎; +var 𱷏; +var 𱷐; +var 𱷑; +var 𱷒; +var 𱷓; +var 𱷔; +var 𱷕; +var 𱷖; +var 𱷗; +var 𱷘; +var 𱷙; +var 𱷚; +var 𱷛; +var 𱷜; +var 𱷝; +var 𱷞; +var 𱷟; +var 𱷠; +var 𱷡; +var 𱷢; +var 𱷣; +var 𱷤; +var 𱷥; +var 𱷦; +var 𱷧; +var 𱷨; +var 𱷩; +var 𱷪; +var 𱷫; +var 𱷬; +var 𱷭; +var 𱷮; +var 𱷯; +var 𱷰; +var 𱷱; +var 𱷲; +var 𱷳; +var 𱷴; +var 𱷵; +var 𱷶; +var 𱷷; +var 𱷸; +var 𱷹; +var 𱷺; +var 𱷻; +var 𱷼; +var 𱷽; +var 𱷾; +var 𱷿; +var 𱸀; +var 𱸁; +var 𱸂; +var 𱸃; +var 𱸄; +var 𱸅; +var 𱸆; +var 𱸇; +var 𱸈; +var 𱸉; +var 𱸊; +var 𱸋; +var 𱸌; +var 𱸍; +var 𱸎; +var 𱸏; +var 𱸐; +var 𱸑; +var 𱸒; +var 𱸓; +var 𱸔; +var 𱸕; +var 𱸖; +var 𱸗; +var 𱸘; +var 𱸙; +var 𱸚; +var 𱸛; +var 𱸜; +var 𱸝; +var 𱸞; +var 𱸟; +var 𱸠; +var 𱸡; +var 𱸢; +var 𱸣; +var 𱸤; +var 𱸥; +var 𱸦; +var 𱸧; +var 𱸨; +var 𱸩; +var 𱸪; +var 𱸫; +var 𱸬; +var 𱸭; +var 𱸮; +var 𱸯; +var 𱸰; +var 𱸱; +var 𱸲; +var 𱸳; +var 𱸴; +var 𱸵; +var 𱸶; +var 𱸷; +var 𱸸; +var 𱸹; +var 𱸺; +var 𱸻; +var 𱸼; +var 𱸽; +var 𱸾; +var 𱸿; +var 𱹀; +var 𱹁; +var 𱹂; +var 𱹃; +var 𱹄; +var 𱹅; +var 𱹆; +var 𱹇; +var 𱹈; +var 𱹉; +var 𱹊; +var 𱹋; +var 𱹌; +var 𱹍; +var 𱹎; +var 𱹏; +var 𱹐; +var 𱹑; +var 𱹒; +var 𱹓; +var 𱹔; +var 𱹕; +var 𱹖; +var 𱹗; +var 𱹘; +var 𱹙; +var 𱹚; +var 𱹛; +var 𱹜; +var 𱹝; +var 𱹞; +var 𱹟; +var 𱹠; +var 𱹡; +var 𱹢; +var 𱹣; +var 𱹤; +var 𱹥; +var 𱹦; +var 𱹧; +var 𱹨; +var 𱹩; +var 𱹪; +var 𱹫; +var 𱹬; +var 𱹭; +var 𱹮; +var 𱹯; +var 𱹰; +var 𱹱; +var 𱹲; +var 𱹳; +var 𱹴; +var 𱹵; +var 𱹶; +var 𱹷; +var 𱹸; +var 𱹹; +var 𱹺; +var 𱹻; +var 𱹼; +var 𱹽; +var 𱹾; +var 𱹿; +var 𱺀; +var 𱺁; +var 𱺂; +var 𱺃; +var 𱺄; +var 𱺅; +var 𱺆; +var 𱺇; +var 𱺈; +var 𱺉; +var 𱺊; +var 𱺋; +var 𱺌; +var 𱺍; +var 𱺎; +var 𱺏; +var 𱺐; +var 𱺑; +var 𱺒; +var 𱺓; +var 𱺔; +var 𱺕; +var 𱺖; +var 𱺗; +var 𱺘; +var 𱺙; +var 𱺚; +var 𱺛; +var 𱺜; +var 𱺝; +var 𱺞; +var 𱺟; +var 𱺠; +var 𱺡; +var 𱺢; +var 𱺣; +var 𱺤; +var 𱺥; +var 𱺦; +var 𱺧; +var 𱺨; +var 𱺩; +var 𱺪; +var 𱺫; +var 𱺬; +var 𱺭; +var 𱺮; +var 𱺯; +var 𱺰; +var 𱺱; +var 𱺲; +var 𱺳; +var 𱺴; +var 𱺵; +var 𱺶; +var 𱺷; +var 𱺸; +var 𱺹; +var 𱺺; +var 𱺻; +var 𱺼; +var 𱺽; +var 𱺾; +var 𱺿; +var 𱻀; +var 𱻁; +var 𱻂; +var 𱻃; +var 𱻄; +var 𱻅; +var 𱻆; +var 𱻇; +var 𱻈; +var 𱻉; +var 𱻊; +var 𱻋; +var 𱻌; +var 𱻍; +var 𱻎; +var 𱻏; +var 𱻐; +var 𱻑; +var 𱻒; +var 𱻓; +var 𱻔; +var 𱻕; +var 𱻖; +var 𱻗; +var 𱻘; +var 𱻙; +var 𱻚; +var 𱻛; +var 𱻜; +var 𱻝; +var 𱻞; +var 𱻟; +var 𱻠; +var 𱻡; +var 𱻢; +var 𱻣; +var 𱻤; +var 𱻥; +var 𱻦; +var 𱻧; +var 𱻨; +var 𱻩; +var 𱻪; +var 𱻫; +var 𱻬; +var 𱻭; +var 𱻮; +var 𱻯; +var 𱻰; +var 𱻱; +var 𱻲; +var 𱻳; +var 𱻴; +var 𱻵; +var 𱻶; +var 𱻷; +var 𱻸; +var 𱻹; +var 𱻺; +var 𱻻; +var 𱻼; +var 𱻽; +var 𱻾; +var 𱻿; +var 𱼀; +var 𱼁; +var 𱼂; +var 𱼃; +var 𱼄; +var 𱼅; +var 𱼆; +var 𱼇; +var 𱼈; +var 𱼉; +var 𱼊; +var 𱼋; +var 𱼌; +var 𱼍; +var 𱼎; +var 𱼏; +var 𱼐; +var 𱼑; +var 𱼒; +var 𱼓; +var 𱼔; +var 𱼕; +var 𱼖; +var 𱼗; +var 𱼘; +var 𱼙; +var 𱼚; +var 𱼛; +var 𱼜; +var 𱼝; +var 𱼞; +var 𱼟; +var 𱼠; +var 𱼡; +var 𱼢; +var 𱼣; +var 𱼤; +var 𱼥; +var 𱼦; +var 𱼧; +var 𱼨; +var 𱼩; +var 𱼪; +var 𱼫; +var 𱼬; +var 𱼭; +var 𱼮; +var 𱼯; +var 𱼰; +var 𱼱; +var 𱼲; +var 𱼳; +var 𱼴; +var 𱼵; +var 𱼶; +var 𱼷; +var 𱼸; +var 𱼹; +var 𱼺; +var 𱼻; +var 𱼼; +var 𱼽; +var 𱼾; +var 𱼿; +var 𱽀; +var 𱽁; +var 𱽂; +var 𱽃; +var 𱽄; +var 𱽅; +var 𱽆; +var 𱽇; +var 𱽈; +var 𱽉; +var 𱽊; +var 𱽋; +var 𱽌; +var 𱽍; +var 𱽎; +var 𱽏; +var 𱽐; +var 𱽑; +var 𱽒; +var 𱽓; +var 𱽔; +var 𱽕; +var 𱽖; +var 𱽗; +var 𱽘; +var 𱽙; +var 𱽚; +var 𱽛; +var 𱽜; +var 𱽝; +var 𱽞; +var 𱽟; +var 𱽠; +var 𱽡; +var 𱽢; +var 𱽣; +var 𱽤; +var 𱽥; +var 𱽦; +var 𱽧; +var 𱽨; +var 𱽩; +var 𱽪; +var 𱽫; +var 𱽬; +var 𱽭; +var 𱽮; +var 𱽯; +var 𱽰; +var 𱽱; +var 𱽲; +var 𱽳; +var 𱽴; +var 𱽵; +var 𱽶; +var 𱽷; +var 𱽸; +var 𱽹; +var 𱽺; +var 𱽻; +var 𱽼; +var 𱽽; +var 𱽾; +var 𱽿; +var 𱾀; +var 𱾁; +var 𱾂; +var 𱾃; +var 𱾄; +var 𱾅; +var 𱾆; +var 𱾇; +var 𱾈; +var 𱾉; +var 𱾊; +var 𱾋; +var 𱾌; +var 𱾍; +var 𱾎; +var 𱾏; +var 𱾐; +var 𱾑; +var 𱾒; +var 𱾓; +var 𱾔; +var 𱾕; +var 𱾖; +var 𱾗; +var 𱾘; +var 𱾙; +var 𱾚; +var 𱾛; +var 𱾜; +var 𱾝; +var 𱾞; +var 𱾟; +var 𱾠; +var 𱾡; +var 𱾢; +var 𱾣; +var 𱾤; +var 𱾥; +var 𱾦; +var 𱾧; +var 𱾨; +var 𱾩; +var 𱾪; +var 𱾫; +var 𱾬; +var 𱾭; +var 𱾮; +var 𱾯; +var 𱾰; +var 𱾱; +var 𱾲; +var 𱾳; +var 𱾴; +var 𱾵; +var 𱾶; +var 𱾷; +var 𱾸; +var 𱾹; +var 𱾺; +var 𱾻; +var 𱾼; +var 𱾽; +var 𱾾; +var 𱾿; +var 𱿀; +var 𱿁; +var 𱿂; +var 𱿃; +var 𱿄; +var 𱿅; +var 𱿆; +var 𱿇; +var 𱿈; +var 𱿉; +var 𱿊; +var 𱿋; +var 𱿌; +var 𱿍; +var 𱿎; +var 𱿏; +var 𱿐; +var 𱿑; +var 𱿒; +var 𱿓; +var 𱿔; +var 𱿕; +var 𱿖; +var 𱿗; +var 𱿘; +var 𱿙; +var 𱿚; +var 𱿛; +var 𱿜; +var 𱿝; +var 𱿞; +var 𱿟; +var 𱿠; +var 𱿡; +var 𱿢; +var 𱿣; +var 𱿤; +var 𱿥; +var 𱿦; +var 𱿧; +var 𱿨; +var 𱿩; +var 𱿪; +var 𱿫; +var 𱿬; +var 𱿭; +var 𱿮; +var 𱿯; +var 𱿰; +var 𱿱; +var 𱿲; +var 𱿳; +var 𱿴; +var 𱿵; +var 𱿶; +var 𱿷; +var 𱿸; +var 𱿹; +var 𱿺; +var 𱿻; +var 𱿼; +var 𱿽; +var 𱿾; +var 𱿿; +var 𲀀; +var 𲀁; +var 𲀂; +var 𲀃; +var 𲀄; +var 𲀅; +var 𲀆; +var 𲀇; +var 𲀈; +var 𲀉; +var 𲀊; +var 𲀋; +var 𲀌; +var 𲀍; +var 𲀎; +var 𲀏; +var 𲀐; +var 𲀑; +var 𲀒; +var 𲀓; +var 𲀔; +var 𲀕; +var 𲀖; +var 𲀗; +var 𲀘; +var 𲀙; +var 𲀚; +var 𲀛; +var 𲀜; +var 𲀝; +var 𲀞; +var 𲀟; +var 𲀠; +var 𲀡; +var 𲀢; +var 𲀣; +var 𲀤; +var 𲀥; +var 𲀦; +var 𲀧; +var 𲀨; +var 𲀩; +var 𲀪; +var 𲀫; +var 𲀬; +var 𲀭; +var 𲀮; +var 𲀯; +var 𲀰; +var 𲀱; +var 𲀲; +var 𲀳; +var 𲀴; +var 𲀵; +var 𲀶; +var 𲀷; +var 𲀸; +var 𲀹; +var 𲀺; +var 𲀻; +var 𲀼; +var 𲀽; +var 𲀾; +var 𲀿; +var 𲁀; +var 𲁁; +var 𲁂; +var 𲁃; +var 𲁄; +var 𲁅; +var 𲁆; +var 𲁇; +var 𲁈; +var 𲁉; +var 𲁊; +var 𲁋; +var 𲁌; +var 𲁍; +var 𲁎; +var 𲁏; +var 𲁐; +var 𲁑; +var 𲁒; +var 𲁓; +var 𲁔; +var 𲁕; +var 𲁖; +var 𲁗; +var 𲁘; +var 𲁙; +var 𲁚; +var 𲁛; +var 𲁜; +var 𲁝; +var 𲁞; +var 𲁟; +var 𲁠; +var 𲁡; +var 𲁢; +var 𲁣; +var 𲁤; +var 𲁥; +var 𲁦; +var 𲁧; +var 𲁨; +var 𲁩; +var 𲁪; +var 𲁫; +var 𲁬; +var 𲁭; +var 𲁮; +var 𲁯; +var 𲁰; +var 𲁱; +var 𲁲; +var 𲁳; +var 𲁴; +var 𲁵; +var 𲁶; +var 𲁷; +var 𲁸; +var 𲁹; +var 𲁺; +var 𲁻; +var 𲁼; +var 𲁽; +var 𲁾; +var 𲁿; +var 𲂀; +var 𲂁; +var 𲂂; +var 𲂃; +var 𲂄; +var 𲂅; +var 𲂆; +var 𲂇; +var 𲂈; +var 𲂉; +var 𲂊; +var 𲂋; +var 𲂌; +var 𲂍; +var 𲂎; +var 𲂏; +var 𲂐; +var 𲂑; +var 𲂒; +var 𲂓; +var 𲂔; +var 𲂕; +var 𲂖; +var 𲂗; +var 𲂘; +var 𲂙; +var 𲂚; +var 𲂛; +var 𲂜; +var 𲂝; +var 𲂞; +var 𲂟; +var 𲂠; +var 𲂡; +var 𲂢; +var 𲂣; +var 𲂤; +var 𲂥; +var 𲂦; +var 𲂧; +var 𲂨; +var 𲂩; +var 𲂪; +var 𲂫; +var 𲂬; +var 𲂭; +var 𲂮; +var 𲂯; +var 𲂰; +var 𲂱; +var 𲂲; +var 𲂳; +var 𲂴; +var 𲂵; +var 𲂶; +var 𲂷; +var 𲂸; +var 𲂹; +var 𲂺; +var 𲂻; +var 𲂼; +var 𲂽; +var 𲂾; +var 𲂿; +var 𲃀; +var 𲃁; +var 𲃂; +var 𲃃; +var 𲃄; +var 𲃅; +var 𲃆; +var 𲃇; +var 𲃈; +var 𲃉; +var 𲃊; +var 𲃋; +var 𲃌; +var 𲃍; +var 𲃎; +var 𲃏; +var 𲃐; +var 𲃑; +var 𲃒; +var 𲃓; +var 𲃔; +var 𲃕; +var 𲃖; +var 𲃗; +var 𲃘; +var 𲃙; +var 𲃚; +var 𲃛; +var 𲃜; +var 𲃝; +var 𲃞; +var 𲃟; +var 𲃠; +var 𲃡; +var 𲃢; +var 𲃣; +var 𲃤; +var 𲃥; +var 𲃦; +var 𲃧; +var 𲃨; +var 𲃩; +var 𲃪; +var 𲃫; +var 𲃬; +var 𲃭; +var 𲃮; +var 𲃯; +var 𲃰; +var 𲃱; +var 𲃲; +var 𲃳; +var 𲃴; +var 𲃵; +var 𲃶; +var 𲃷; +var 𲃸; +var 𲃹; +var 𲃺; +var 𲃻; +var 𲃼; +var 𲃽; +var 𲃾; +var 𲃿; +var 𲄀; +var 𲄁; +var 𲄂; +var 𲄃; +var 𲄄; +var 𲄅; +var 𲄆; +var 𲄇; +var 𲄈; +var 𲄉; +var 𲄊; +var 𲄋; +var 𲄌; +var 𲄍; +var 𲄎; +var 𲄏; +var 𲄐; +var 𲄑; +var 𲄒; +var 𲄓; +var 𲄔; +var 𲄕; +var 𲄖; +var 𲄗; +var 𲄘; +var 𲄙; +var 𲄚; +var 𲄛; +var 𲄜; +var 𲄝; +var 𲄞; +var 𲄟; +var 𲄠; +var 𲄡; +var 𲄢; +var 𲄣; +var 𲄤; +var 𲄥; +var 𲄦; +var 𲄧; +var 𲄨; +var 𲄩; +var 𲄪; +var 𲄫; +var 𲄬; +var 𲄭; +var 𲄮; +var 𲄯; +var 𲄰; +var 𲄱; +var 𲄲; +var 𲄳; +var 𲄴; +var 𲄵; +var 𲄶; +var 𲄷; +var 𲄸; +var 𲄹; +var 𲄺; +var 𲄻; +var 𲄼; +var 𲄽; +var 𲄾; +var 𲄿; +var 𲅀; +var 𲅁; +var 𲅂; +var 𲅃; +var 𲅄; +var 𲅅; +var 𲅆; +var 𲅇; +var 𲅈; +var 𲅉; +var 𲅊; +var 𲅋; +var 𲅌; +var 𲅍; +var 𲅎; +var 𲅏; +var 𲅐; +var 𲅑; +var 𲅒; +var 𲅓; +var 𲅔; +var 𲅕; +var 𲅖; +var 𲅗; +var 𲅘; +var 𲅙; +var 𲅚; +var 𲅛; +var 𲅜; +var 𲅝; +var 𲅞; +var 𲅟; +var 𲅠; +var 𲅡; +var 𲅢; +var 𲅣; +var 𲅤; +var 𲅥; +var 𲅦; +var 𲅧; +var 𲅨; +var 𲅩; +var 𲅪; +var 𲅫; +var 𲅬; +var 𲅭; +var 𲅮; +var 𲅯; +var 𲅰; +var 𲅱; +var 𲅲; +var 𲅳; +var 𲅴; +var 𲅵; +var 𲅶; +var 𲅷; +var 𲅸; +var 𲅹; +var 𲅺; +var 𲅻; +var 𲅼; +var 𲅽; +var 𲅾; +var 𲅿; +var 𲆀; +var 𲆁; +var 𲆂; +var 𲆃; +var 𲆄; +var 𲆅; +var 𲆆; +var 𲆇; +var 𲆈; +var 𲆉; +var 𲆊; +var 𲆋; +var 𲆌; +var 𲆍; +var 𲆎; +var 𲆏; +var 𲆐; +var 𲆑; +var 𲆒; +var 𲆓; +var 𲆔; +var 𲆕; +var 𲆖; +var 𲆗; +var 𲆘; +var 𲆙; +var 𲆚; +var 𲆛; +var 𲆜; +var 𲆝; +var 𲆞; +var 𲆟; +var 𲆠; +var 𲆡; +var 𲆢; +var 𲆣; +var 𲆤; +var 𲆥; +var 𲆦; +var 𲆧; +var 𲆨; +var 𲆩; +var 𲆪; +var 𲆫; +var 𲆬; +var 𲆭; +var 𲆮; +var 𲆯; +var 𲆰; +var 𲆱; +var 𲆲; +var 𲆳; +var 𲆴; +var 𲆵; +var 𲆶; +var 𲆷; +var 𲆸; +var 𲆹; +var 𲆺; +var 𲆻; +var 𲆼; +var 𲆽; +var 𲆾; +var 𲆿; +var 𲇀; +var 𲇁; +var 𲇂; +var 𲇃; +var 𲇄; +var 𲇅; +var 𲇆; +var 𲇇; +var 𲇈; +var 𲇉; +var 𲇊; +var 𲇋; +var 𲇌; +var 𲇍; +var 𲇎; +var 𲇏; +var 𲇐; +var 𲇑; +var 𲇒; +var 𲇓; +var 𲇔; +var 𲇕; +var 𲇖; +var 𲇗; +var 𲇘; +var 𲇙; +var 𲇚; +var 𲇛; +var 𲇜; +var 𲇝; +var 𲇞; +var 𲇟; +var 𲇠; +var 𲇡; +var 𲇢; +var 𲇣; +var 𲇤; +var 𲇥; +var 𲇦; +var 𲇧; +var 𲇨; +var 𲇩; +var 𲇪; +var 𲇫; +var 𲇬; +var 𲇭; +var 𲇮; +var 𲇯; +var 𲇰; +var 𲇱; +var 𲇲; +var 𲇳; +var 𲇴; +var 𲇵; +var 𲇶; +var 𲇷; +var 𲇸; +var 𲇹; +var 𲇺; +var 𲇻; +var 𲇼; +var 𲇽; +var 𲇾; +var 𲇿; +var 𲈀; +var 𲈁; +var 𲈂; +var 𲈃; +var 𲈄; +var 𲈅; +var 𲈆; +var 𲈇; +var 𲈈; +var 𲈉; +var 𲈊; +var 𲈋; +var 𲈌; +var 𲈍; +var 𲈎; +var 𲈏; +var 𲈐; +var 𲈑; +var 𲈒; +var 𲈓; +var 𲈔; +var 𲈕; +var 𲈖; +var 𲈗; +var 𲈘; +var 𲈙; +var 𲈚; +var 𲈛; +var 𲈜; +var 𲈝; +var 𲈞; +var 𲈟; +var 𲈠; +var 𲈡; +var 𲈢; +var 𲈣; +var 𲈤; +var 𲈥; +var 𲈦; +var 𲈧; +var 𲈨; +var 𲈩; +var 𲈪; +var 𲈫; +var 𲈬; +var 𲈭; +var 𲈮; +var 𲈯; +var 𲈰; +var 𲈱; +var 𲈲; +var 𲈳; +var 𲈴; +var 𲈵; +var 𲈶; +var 𲈷; +var 𲈸; +var 𲈹; +var 𲈺; +var 𲈻; +var 𲈼; +var 𲈽; +var 𲈾; +var 𲈿; +var 𲉀; +var 𲉁; +var 𲉂; +var 𲉃; +var 𲉄; +var 𲉅; +var 𲉆; +var 𲉇; +var 𲉈; +var 𲉉; +var 𲉊; +var 𲉋; +var 𲉌; +var 𲉍; +var 𲉎; +var 𲉏; +var 𲉐; +var 𲉑; +var 𲉒; +var 𲉓; +var 𲉔; +var 𲉕; +var 𲉖; +var 𲉗; +var 𲉘; +var 𲉙; +var 𲉚; +var 𲉛; +var 𲉜; +var 𲉝; +var 𲉞; +var 𲉟; +var 𲉠; +var 𲉡; +var 𲉢; +var 𲉣; +var 𲉤; +var 𲉥; +var 𲉦; +var 𲉧; +var 𲉨; +var 𲉩; +var 𲉪; +var 𲉫; +var 𲉬; +var 𲉭; +var 𲉮; +var 𲉯; +var 𲉰; +var 𲉱; +var 𲉲; +var 𲉳; +var 𲉴; +var 𲉵; +var 𲉶; +var 𲉷; +var 𲉸; +var 𲉹; +var 𲉺; +var 𲉻; +var 𲉼; +var 𲉽; +var 𲉾; +var 𲉿; +var 𲊀; +var 𲊁; +var 𲊂; +var 𲊃; +var 𲊄; +var 𲊅; +var 𲊆; +var 𲊇; +var 𲊈; +var 𲊉; +var 𲊊; +var 𲊋; +var 𲊌; +var 𲊍; +var 𲊎; +var 𲊏; +var 𲊐; +var 𲊑; +var 𲊒; +var 𲊓; +var 𲊔; +var 𲊕; +var 𲊖; +var 𲊗; +var 𲊘; +var 𲊙; +var 𲊚; +var 𲊛; +var 𲊜; +var 𲊝; +var 𲊞; +var 𲊟; +var 𲊠; +var 𲊡; +var 𲊢; +var 𲊣; +var 𲊤; +var 𲊥; +var 𲊦; +var 𲊧; +var 𲊨; +var 𲊩; +var 𲊪; +var 𲊫; +var 𲊬; +var 𲊭; +var 𲊮; +var 𲊯; +var 𲊰; +var 𲊱; +var 𲊲; +var 𲊳; +var 𲊴; +var 𲊵; +var 𲊶; +var 𲊷; +var 𲊸; +var 𲊹; +var 𲊺; +var 𲊻; +var 𲊼; +var 𲊽; +var 𲊾; +var 𲊿; +var 𲋀; +var 𲋁; +var 𲋂; +var 𲋃; +var 𲋄; +var 𲋅; +var 𲋆; +var 𲋇; +var 𲋈; +var 𲋉; +var 𲋊; +var 𲋋; +var 𲋌; +var 𲋍; +var 𲋎; +var 𲋏; +var 𲋐; +var 𲋑; +var 𲋒; +var 𲋓; +var 𲋔; +var 𲋕; +var 𲋖; +var 𲋗; +var 𲋘; +var 𲋙; +var 𲋚; +var 𲋛; +var 𲋜; +var 𲋝; +var 𲋞; +var 𲋟; +var 𲋠; +var 𲋡; +var 𲋢; +var 𲋣; +var 𲋤; +var 𲋥; +var 𲋦; +var 𲋧; +var 𲋨; +var 𲋩; +var 𲋪; +var 𲋫; +var 𲋬; +var 𲋭; +var 𲋮; +var 𲋯; +var 𲋰; +var 𲋱; +var 𲋲; +var 𲋳; +var 𲋴; +var 𲋵; +var 𲋶; +var 𲋷; +var 𲋸; +var 𲋹; +var 𲋺; +var 𲋻; +var 𲋼; +var 𲋽; +var 𲋾; +var 𲋿; +var 𲌀; +var 𲌁; +var 𲌂; +var 𲌃; +var 𲌄; +var 𲌅; +var 𲌆; +var 𲌇; +var 𲌈; +var 𲌉; +var 𲌊; +var 𲌋; +var 𲌌; +var 𲌍; +var 𲌎; +var 𲌏; +var 𲌐; +var 𲌑; +var 𲌒; +var 𲌓; +var 𲌔; +var 𲌕; +var 𲌖; +var 𲌗; +var 𲌘; +var 𲌙; +var 𲌚; +var 𲌛; +var 𲌜; +var 𲌝; +var 𲌞; +var 𲌟; +var 𲌠; +var 𲌡; +var 𲌢; +var 𲌣; +var 𲌤; +var 𲌥; +var 𲌦; +var 𲌧; +var 𲌨; +var 𲌩; +var 𲌪; +var 𲌫; +var 𲌬; +var 𲌭; +var 𲌮; +var 𲌯; +var 𲌰; +var 𲌱; +var 𲌲; +var 𲌳; +var 𲌴; +var 𲌵; +var 𲌶; +var 𲌷; +var 𲌸; +var 𲌹; +var 𲌺; +var 𲌻; +var 𲌼; +var 𲌽; +var 𲌾; +var 𲌿; +var 𲍀; +var 𲍁; +var 𲍂; +var 𲍃; +var 𲍄; +var 𲍅; +var 𲍆; +var 𲍇; +var 𲍈; +var 𲍉; +var 𲍊; +var 𲍋; +var 𲍌; +var 𲍍; +var 𲍎; +var 𲍏; +var 𲍐; +var 𲍑; +var 𲍒; +var 𲍓; +var 𲍔; +var 𲍕; +var 𲍖; +var 𲍗; +var 𲍘; +var 𲍙; +var 𲍚; +var 𲍛; +var 𲍜; +var 𲍝; +var 𲍞; +var 𲍟; +var 𲍠; +var 𲍡; +var 𲍢; +var 𲍣; +var 𲍤; +var 𲍥; +var 𲍦; +var 𲍧; +var 𲍨; +var 𲍩; +var 𲍪; +var 𲍫; +var 𲍬; +var 𲍭; +var 𲍮; +var 𲍯; +var 𲍰; +var 𲍱; +var 𲍲; +var 𲍳; +var 𲍴; +var 𲍵; +var 𲍶; +var 𲍷; +var 𲍸; +var 𲍹; +var 𲍺; +var 𲍻; +var 𲍼; +var 𲍽; +var 𲍾; +var 𲍿; +var 𲎀; +var 𲎁; +var 𲎂; +var 𲎃; +var 𲎄; +var 𲎅; +var 𲎆; +var 𲎇; +var 𲎈; +var 𲎉; +var 𲎊; +var 𲎋; +var 𲎌; +var 𲎍; +var 𲎎; +var 𲎏; +var 𲎐; +var 𲎑; +var 𲎒; +var 𲎓; +var 𲎔; +var 𲎕; +var 𲎖; +var 𲎗; +var 𲎘; +var 𲎙; +var 𲎚; +var 𲎛; +var 𲎜; +var 𲎝; +var 𲎞; +var 𲎟; +var 𲎠; +var 𲎡; +var 𲎢; +var 𲎣; +var 𲎤; +var 𲎥; +var 𲎦; +var 𲎧; +var 𲎨; +var 𲎩; +var 𲎪; +var 𲎫; +var 𲎬; +var 𲎭; +var 𲎮; +var 𲎯; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0-class-escaped.js new file mode 100644 index 000000000..64d1f9e77 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0-class-escaped.js @@ -0,0 +1,641 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v15.1.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u{2EBF0}; + #\u{2EBF1}; + #\u{2EBF2}; + #\u{2EBF3}; + #\u{2EBF4}; + #\u{2EBF5}; + #\u{2EBF6}; + #\u{2EBF7}; + #\u{2EBF8}; + #\u{2EBF9}; + #\u{2EBFA}; + #\u{2EBFB}; + #\u{2EBFC}; + #\u{2EBFD}; + #\u{2EBFE}; + #\u{2EBFF}; + #\u{2EC00}; + #\u{2EC01}; + #\u{2EC02}; + #\u{2EC03}; + #\u{2EC04}; + #\u{2EC05}; + #\u{2EC06}; + #\u{2EC07}; + #\u{2EC08}; + #\u{2EC09}; + #\u{2EC0A}; + #\u{2EC0B}; + #\u{2EC0C}; + #\u{2EC0D}; + #\u{2EC0E}; + #\u{2EC0F}; + #\u{2EC10}; + #\u{2EC11}; + #\u{2EC12}; + #\u{2EC13}; + #\u{2EC14}; + #\u{2EC15}; + #\u{2EC16}; + #\u{2EC17}; + #\u{2EC18}; + #\u{2EC19}; + #\u{2EC1A}; + #\u{2EC1B}; + #\u{2EC1C}; + #\u{2EC1D}; + #\u{2EC1E}; + #\u{2EC1F}; + #\u{2EC20}; + #\u{2EC21}; + #\u{2EC22}; + #\u{2EC23}; + #\u{2EC24}; + #\u{2EC25}; + #\u{2EC26}; + #\u{2EC27}; + #\u{2EC28}; + #\u{2EC29}; + #\u{2EC2A}; + #\u{2EC2B}; + #\u{2EC2C}; + #\u{2EC2D}; + #\u{2EC2E}; + #\u{2EC2F}; + #\u{2EC30}; + #\u{2EC31}; + #\u{2EC32}; + #\u{2EC33}; + #\u{2EC34}; + #\u{2EC35}; + #\u{2EC36}; + #\u{2EC37}; + #\u{2EC38}; + #\u{2EC39}; + #\u{2EC3A}; + #\u{2EC3B}; + #\u{2EC3C}; + #\u{2EC3D}; + #\u{2EC3E}; + #\u{2EC3F}; + #\u{2EC40}; + #\u{2EC41}; + #\u{2EC42}; + #\u{2EC43}; + #\u{2EC44}; + #\u{2EC45}; + #\u{2EC46}; + #\u{2EC47}; + #\u{2EC48}; + #\u{2EC49}; + #\u{2EC4A}; + #\u{2EC4B}; + #\u{2EC4C}; + #\u{2EC4D}; + #\u{2EC4E}; + #\u{2EC4F}; + #\u{2EC50}; + #\u{2EC51}; + #\u{2EC52}; + #\u{2EC53}; + #\u{2EC54}; + #\u{2EC55}; + #\u{2EC56}; + #\u{2EC57}; + #\u{2EC58}; + #\u{2EC59}; + #\u{2EC5A}; + #\u{2EC5B}; + #\u{2EC5C}; + #\u{2EC5D}; + #\u{2EC5E}; + #\u{2EC5F}; + #\u{2EC60}; + #\u{2EC61}; + #\u{2EC62}; + #\u{2EC63}; + #\u{2EC64}; + #\u{2EC65}; + #\u{2EC66}; + #\u{2EC67}; + #\u{2EC68}; + #\u{2EC69}; + #\u{2EC6A}; + #\u{2EC6B}; + #\u{2EC6C}; + #\u{2EC6D}; + #\u{2EC6E}; + #\u{2EC6F}; + #\u{2EC70}; + #\u{2EC71}; + #\u{2EC72}; + #\u{2EC73}; + #\u{2EC74}; + #\u{2EC75}; + #\u{2EC76}; + #\u{2EC77}; + #\u{2EC78}; + #\u{2EC79}; + #\u{2EC7A}; + #\u{2EC7B}; + #\u{2EC7C}; + #\u{2EC7D}; + #\u{2EC7E}; + #\u{2EC7F}; + #\u{2EC80}; + #\u{2EC81}; + #\u{2EC82}; + #\u{2EC83}; + #\u{2EC84}; + #\u{2EC85}; + #\u{2EC86}; + #\u{2EC87}; + #\u{2EC88}; + #\u{2EC89}; + #\u{2EC8A}; + #\u{2EC8B}; + #\u{2EC8C}; + #\u{2EC8D}; + #\u{2EC8E}; + #\u{2EC8F}; + #\u{2EC90}; + #\u{2EC91}; + #\u{2EC92}; + #\u{2EC93}; + #\u{2EC94}; + #\u{2EC95}; + #\u{2EC96}; + #\u{2EC97}; + #\u{2EC98}; + #\u{2EC99}; + #\u{2EC9A}; + #\u{2EC9B}; + #\u{2EC9C}; + #\u{2EC9D}; + #\u{2EC9E}; + #\u{2EC9F}; + #\u{2ECA0}; + #\u{2ECA1}; + #\u{2ECA2}; + #\u{2ECA3}; + #\u{2ECA4}; + #\u{2ECA5}; + #\u{2ECA6}; + #\u{2ECA7}; + #\u{2ECA8}; + #\u{2ECA9}; + #\u{2ECAA}; + #\u{2ECAB}; + #\u{2ECAC}; + #\u{2ECAD}; + #\u{2ECAE}; + #\u{2ECAF}; + #\u{2ECB0}; + #\u{2ECB1}; + #\u{2ECB2}; + #\u{2ECB3}; + #\u{2ECB4}; + #\u{2ECB5}; + #\u{2ECB6}; + #\u{2ECB7}; + #\u{2ECB8}; + #\u{2ECB9}; + #\u{2ECBA}; + #\u{2ECBB}; + #\u{2ECBC}; + #\u{2ECBD}; + #\u{2ECBE}; + #\u{2ECBF}; + #\u{2ECC0}; + #\u{2ECC1}; + #\u{2ECC2}; + #\u{2ECC3}; + #\u{2ECC4}; + #\u{2ECC5}; + #\u{2ECC6}; + #\u{2ECC7}; + #\u{2ECC8}; + #\u{2ECC9}; + #\u{2ECCA}; + #\u{2ECCB}; + #\u{2ECCC}; + #\u{2ECCD}; + #\u{2ECCE}; + #\u{2ECCF}; + #\u{2ECD0}; + #\u{2ECD1}; + #\u{2ECD2}; + #\u{2ECD3}; + #\u{2ECD4}; + #\u{2ECD5}; + #\u{2ECD6}; + #\u{2ECD7}; + #\u{2ECD8}; + #\u{2ECD9}; + #\u{2ECDA}; + #\u{2ECDB}; + #\u{2ECDC}; + #\u{2ECDD}; + #\u{2ECDE}; + #\u{2ECDF}; + #\u{2ECE0}; + #\u{2ECE1}; + #\u{2ECE2}; + #\u{2ECE3}; + #\u{2ECE4}; + #\u{2ECE5}; + #\u{2ECE6}; + #\u{2ECE7}; + #\u{2ECE8}; + #\u{2ECE9}; + #\u{2ECEA}; + #\u{2ECEB}; + #\u{2ECEC}; + #\u{2ECED}; + #\u{2ECEE}; + #\u{2ECEF}; + #\u{2ECF0}; + #\u{2ECF1}; + #\u{2ECF2}; + #\u{2ECF3}; + #\u{2ECF4}; + #\u{2ECF5}; + #\u{2ECF6}; + #\u{2ECF7}; + #\u{2ECF8}; + #\u{2ECF9}; + #\u{2ECFA}; + #\u{2ECFB}; + #\u{2ECFC}; + #\u{2ECFD}; + #\u{2ECFE}; + #\u{2ECFF}; + #\u{2ED00}; + #\u{2ED01}; + #\u{2ED02}; + #\u{2ED03}; + #\u{2ED04}; + #\u{2ED05}; + #\u{2ED06}; + #\u{2ED07}; + #\u{2ED08}; + #\u{2ED09}; + #\u{2ED0A}; + #\u{2ED0B}; + #\u{2ED0C}; + #\u{2ED0D}; + #\u{2ED0E}; + #\u{2ED0F}; + #\u{2ED10}; + #\u{2ED11}; + #\u{2ED12}; + #\u{2ED13}; + #\u{2ED14}; + #\u{2ED15}; + #\u{2ED16}; + #\u{2ED17}; + #\u{2ED18}; + #\u{2ED19}; + #\u{2ED1A}; + #\u{2ED1B}; + #\u{2ED1C}; + #\u{2ED1D}; + #\u{2ED1E}; + #\u{2ED1F}; + #\u{2ED20}; + #\u{2ED21}; + #\u{2ED22}; + #\u{2ED23}; + #\u{2ED24}; + #\u{2ED25}; + #\u{2ED26}; + #\u{2ED27}; + #\u{2ED28}; + #\u{2ED29}; + #\u{2ED2A}; + #\u{2ED2B}; + #\u{2ED2C}; + #\u{2ED2D}; + #\u{2ED2E}; + #\u{2ED2F}; + #\u{2ED30}; + #\u{2ED31}; + #\u{2ED32}; + #\u{2ED33}; + #\u{2ED34}; + #\u{2ED35}; + #\u{2ED36}; + #\u{2ED37}; + #\u{2ED38}; + #\u{2ED39}; + #\u{2ED3A}; + #\u{2ED3B}; + #\u{2ED3C}; + #\u{2ED3D}; + #\u{2ED3E}; + #\u{2ED3F}; + #\u{2ED40}; + #\u{2ED41}; + #\u{2ED42}; + #\u{2ED43}; + #\u{2ED44}; + #\u{2ED45}; + #\u{2ED46}; + #\u{2ED47}; + #\u{2ED48}; + #\u{2ED49}; + #\u{2ED4A}; + #\u{2ED4B}; + #\u{2ED4C}; + #\u{2ED4D}; + #\u{2ED4E}; + #\u{2ED4F}; + #\u{2ED50}; + #\u{2ED51}; + #\u{2ED52}; + #\u{2ED53}; + #\u{2ED54}; + #\u{2ED55}; + #\u{2ED56}; + #\u{2ED57}; + #\u{2ED58}; + #\u{2ED59}; + #\u{2ED5A}; + #\u{2ED5B}; + #\u{2ED5C}; + #\u{2ED5D}; + #\u{2ED5E}; + #\u{2ED5F}; + #\u{2ED60}; + #\u{2ED61}; + #\u{2ED62}; + #\u{2ED63}; + #\u{2ED64}; + #\u{2ED65}; + #\u{2ED66}; + #\u{2ED67}; + #\u{2ED68}; + #\u{2ED69}; + #\u{2ED6A}; + #\u{2ED6B}; + #\u{2ED6C}; + #\u{2ED6D}; + #\u{2ED6E}; + #\u{2ED6F}; + #\u{2ED70}; + #\u{2ED71}; + #\u{2ED72}; + #\u{2ED73}; + #\u{2ED74}; + #\u{2ED75}; + #\u{2ED76}; + #\u{2ED77}; + #\u{2ED78}; + #\u{2ED79}; + #\u{2ED7A}; + #\u{2ED7B}; + #\u{2ED7C}; + #\u{2ED7D}; + #\u{2ED7E}; + #\u{2ED7F}; + #\u{2ED80}; + #\u{2ED81}; + #\u{2ED82}; + #\u{2ED83}; + #\u{2ED84}; + #\u{2ED85}; + #\u{2ED86}; + #\u{2ED87}; + #\u{2ED88}; + #\u{2ED89}; + #\u{2ED8A}; + #\u{2ED8B}; + #\u{2ED8C}; + #\u{2ED8D}; + #\u{2ED8E}; + #\u{2ED8F}; + #\u{2ED90}; + #\u{2ED91}; + #\u{2ED92}; + #\u{2ED93}; + #\u{2ED94}; + #\u{2ED95}; + #\u{2ED96}; + #\u{2ED97}; + #\u{2ED98}; + #\u{2ED99}; + #\u{2ED9A}; + #\u{2ED9B}; + #\u{2ED9C}; + #\u{2ED9D}; + #\u{2ED9E}; + #\u{2ED9F}; + #\u{2EDA0}; + #\u{2EDA1}; + #\u{2EDA2}; + #\u{2EDA3}; + #\u{2EDA4}; + #\u{2EDA5}; + #\u{2EDA6}; + #\u{2EDA7}; + #\u{2EDA8}; + #\u{2EDA9}; + #\u{2EDAA}; + #\u{2EDAB}; + #\u{2EDAC}; + #\u{2EDAD}; + #\u{2EDAE}; + #\u{2EDAF}; + #\u{2EDB0}; + #\u{2EDB1}; + #\u{2EDB2}; + #\u{2EDB3}; + #\u{2EDB4}; + #\u{2EDB5}; + #\u{2EDB6}; + #\u{2EDB7}; + #\u{2EDB8}; + #\u{2EDB9}; + #\u{2EDBA}; + #\u{2EDBB}; + #\u{2EDBC}; + #\u{2EDBD}; + #\u{2EDBE}; + #\u{2EDBF}; + #\u{2EDC0}; + #\u{2EDC1}; + #\u{2EDC2}; + #\u{2EDC3}; + #\u{2EDC4}; + #\u{2EDC5}; + #\u{2EDC6}; + #\u{2EDC7}; + #\u{2EDC8}; + #\u{2EDC9}; + #\u{2EDCA}; + #\u{2EDCB}; + #\u{2EDCC}; + #\u{2EDCD}; + #\u{2EDCE}; + #\u{2EDCF}; + #\u{2EDD0}; + #\u{2EDD1}; + #\u{2EDD2}; + #\u{2EDD3}; + #\u{2EDD4}; + #\u{2EDD5}; + #\u{2EDD6}; + #\u{2EDD7}; + #\u{2EDD8}; + #\u{2EDD9}; + #\u{2EDDA}; + #\u{2EDDB}; + #\u{2EDDC}; + #\u{2EDDD}; + #\u{2EDDE}; + #\u{2EDDF}; + #\u{2EDE0}; + #\u{2EDE1}; + #\u{2EDE2}; + #\u{2EDE3}; + #\u{2EDE4}; + #\u{2EDE5}; + #\u{2EDE6}; + #\u{2EDE7}; + #\u{2EDE8}; + #\u{2EDE9}; + #\u{2EDEA}; + #\u{2EDEB}; + #\u{2EDEC}; + #\u{2EDED}; + #\u{2EDEE}; + #\u{2EDEF}; + #\u{2EDF0}; + #\u{2EDF1}; + #\u{2EDF2}; + #\u{2EDF3}; + #\u{2EDF4}; + #\u{2EDF5}; + #\u{2EDF6}; + #\u{2EDF7}; + #\u{2EDF8}; + #\u{2EDF9}; + #\u{2EDFA}; + #\u{2EDFB}; + #\u{2EDFC}; + #\u{2EDFD}; + #\u{2EDFE}; + #\u{2EDFF}; + #\u{2EE00}; + #\u{2EE01}; + #\u{2EE02}; + #\u{2EE03}; + #\u{2EE04}; + #\u{2EE05}; + #\u{2EE06}; + #\u{2EE07}; + #\u{2EE08}; + #\u{2EE09}; + #\u{2EE0A}; + #\u{2EE0B}; + #\u{2EE0C}; + #\u{2EE0D}; + #\u{2EE0E}; + #\u{2EE0F}; + #\u{2EE10}; + #\u{2EE11}; + #\u{2EE12}; + #\u{2EE13}; + #\u{2EE14}; + #\u{2EE15}; + #\u{2EE16}; + #\u{2EE17}; + #\u{2EE18}; + #\u{2EE19}; + #\u{2EE1A}; + #\u{2EE1B}; + #\u{2EE1C}; + #\u{2EE1D}; + #\u{2EE1E}; + #\u{2EE1F}; + #\u{2EE20}; + #\u{2EE21}; + #\u{2EE22}; + #\u{2EE23}; + #\u{2EE24}; + #\u{2EE25}; + #\u{2EE26}; + #\u{2EE27}; + #\u{2EE28}; + #\u{2EE29}; + #\u{2EE2A}; + #\u{2EE2B}; + #\u{2EE2C}; + #\u{2EE2D}; + #\u{2EE2E}; + #\u{2EE2F}; + #\u{2EE30}; + #\u{2EE31}; + #\u{2EE32}; + #\u{2EE33}; + #\u{2EE34}; + #\u{2EE35}; + #\u{2EE36}; + #\u{2EE37}; + #\u{2EE38}; + #\u{2EE39}; + #\u{2EE3A}; + #\u{2EE3B}; + #\u{2EE3C}; + #\u{2EE3D}; + #\u{2EE3E}; + #\u{2EE3F}; + #\u{2EE40}; + #\u{2EE41}; + #\u{2EE42}; + #\u{2EE43}; + #\u{2EE44}; + #\u{2EE45}; + #\u{2EE46}; + #\u{2EE47}; + #\u{2EE48}; + #\u{2EE49}; + #\u{2EE4A}; + #\u{2EE4B}; + #\u{2EE4C}; + #\u{2EE4D}; + #\u{2EE4E}; + #\u{2EE4F}; + #\u{2EE50}; + #\u{2EE51}; + #\u{2EE52}; + #\u{2EE53}; + #\u{2EE54}; + #\u{2EE55}; + #\u{2EE56}; + #\u{2EE57}; + #\u{2EE58}; + #\u{2EE59}; + #\u{2EE5A}; + #\u{2EE5B}; + #\u{2EE5C}; + #\u{2EE5D}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0-class.js new file mode 100644 index 000000000..8b3723154 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0-class.js @@ -0,0 +1,638 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v15.1.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #𮯰; + #𮯱; + #𮯲; + #𮯳; + #𮯴; + #𮯵; + #𮯶; + #𮯷; + #𮯸; + #𮯹; + #𮯺; + #𮯻; + #𮯼; + #𮯽; + #𮯾; + #𮯿; + #𮰀; + #𮰁; + #𮰂; + #𮰃; + #𮰄; + #𮰅; + #𮰆; + #𮰇; + #𮰈; + #𮰉; + #𮰊; + #𮰋; + #𮰌; + #𮰍; + #𮰎; + #𮰏; + #𮰐; + #𮰑; + #𮰒; + #𮰓; + #𮰔; + #𮰕; + #𮰖; + #𮰗; + #𮰘; + #𮰙; + #𮰚; + #𮰛; + #𮰜; + #𮰝; + #𮰞; + #𮰟; + #𮰠; + #𮰡; + #𮰢; + #𮰣; + #𮰤; + #𮰥; + #𮰦; + #𮰧; + #𮰨; + #𮰩; + #𮰪; + #𮰫; + #𮰬; + #𮰭; + #𮰮; + #𮰯; + #𮰰; + #𮰱; + #𮰲; + #𮰳; + #𮰴; + #𮰵; + #𮰶; + #𮰷; + #𮰸; + #𮰹; + #𮰺; + #𮰻; + #𮰼; + #𮰽; + #𮰾; + #𮰿; + #𮱀; + #𮱁; + #𮱂; + #𮱃; + #𮱄; + #𮱅; + #𮱆; + #𮱇; + #𮱈; + #𮱉; + #𮱊; + #𮱋; + #𮱌; + #𮱍; + #𮱎; + #𮱏; + #𮱐; + #𮱑; + #𮱒; + #𮱓; + #𮱔; + #𮱕; + #𮱖; + #𮱗; + #𮱘; + #𮱙; + #𮱚; + #𮱛; + #𮱜; + #𮱝; + #𮱞; + #𮱟; + #𮱠; + #𮱡; + #𮱢; + #𮱣; + #𮱤; + #𮱥; + #𮱦; + #𮱧; + #𮱨; + #𮱩; + #𮱪; + #𮱫; + #𮱬; + #𮱭; + #𮱮; + #𮱯; + #𮱰; + #𮱱; + #𮱲; + #𮱳; + #𮱴; + #𮱵; + #𮱶; + #𮱷; + #𮱸; + #𮱹; + #𮱺; + #𮱻; + #𮱼; + #𮱽; + #𮱾; + #𮱿; + #𮲀; + #𮲁; + #𮲂; + #𮲃; + #𮲄; + #𮲅; + #𮲆; + #𮲇; + #𮲈; + #𮲉; + #𮲊; + #𮲋; + #𮲌; + #𮲍; + #𮲎; + #𮲏; + #𮲐; + #𮲑; + #𮲒; + #𮲓; + #𮲔; + #𮲕; + #𮲖; + #𮲗; + #𮲘; + #𮲙; + #𮲚; + #𮲛; + #𮲜; + #𮲝; + #𮲞; + #𮲟; + #𮲠; + #𮲡; + #𮲢; + #𮲣; + #𮲤; + #𮲥; + #𮲦; + #𮲧; + #𮲨; + #𮲩; + #𮲪; + #𮲫; + #𮲬; + #𮲭; + #𮲮; + #𮲯; + #𮲰; + #𮲱; + #𮲲; + #𮲳; + #𮲴; + #𮲵; + #𮲶; + #𮲷; + #𮲸; + #𮲹; + #𮲺; + #𮲻; + #𮲼; + #𮲽; + #𮲾; + #𮲿; + #𮳀; + #𮳁; + #𮳂; + #𮳃; + #𮳄; + #𮳅; + #𮳆; + #𮳇; + #𮳈; + #𮳉; + #𮳊; + #𮳋; + #𮳌; + #𮳍; + #𮳎; + #𮳏; + #𮳐; + #𮳑; + #𮳒; + #𮳓; + #𮳔; + #𮳕; + #𮳖; + #𮳗; + #𮳘; + #𮳙; + #𮳚; + #𮳛; + #𮳜; + #𮳝; + #𮳞; + #𮳟; + #𮳠; + #𮳡; + #𮳢; + #𮳣; + #𮳤; + #𮳥; + #𮳦; + #𮳧; + #𮳨; + #𮳩; + #𮳪; + #𮳫; + #𮳬; + #𮳭; + #𮳮; + #𮳯; + #𮳰; + #𮳱; + #𮳲; + #𮳳; + #𮳴; + #𮳵; + #𮳶; + #𮳷; + #𮳸; + #𮳹; + #𮳺; + #𮳻; + #𮳼; + #𮳽; + #𮳾; + #𮳿; + #𮴀; + #𮴁; + #𮴂; + #𮴃; + #𮴄; + #𮴅; + #𮴆; + #𮴇; + #𮴈; + #𮴉; + #𮴊; + #𮴋; + #𮴌; + #𮴍; + #𮴎; + #𮴏; + #𮴐; + #𮴑; + #𮴒; + #𮴓; + #𮴔; + #𮴕; + #𮴖; + #𮴗; + #𮴘; + #𮴙; + #𮴚; + #𮴛; + #𮴜; + #𮴝; + #𮴞; + #𮴟; + #𮴠; + #𮴡; + #𮴢; + #𮴣; + #𮴤; + #𮴥; + #𮴦; + #𮴧; + #𮴨; + #𮴩; + #𮴪; + #𮴫; + #𮴬; + #𮴭; + #𮴮; + #𮴯; + #𮴰; + #𮴱; + #𮴲; + #𮴳; + #𮴴; + #𮴵; + #𮴶; + #𮴷; + #𮴸; + #𮴹; + #𮴺; + #𮴻; + #𮴼; + #𮴽; + #𮴾; + #𮴿; + #𮵀; + #𮵁; + #𮵂; + #𮵃; + #𮵄; + #𮵅; + #𮵆; + #𮵇; + #𮵈; + #𮵉; + #𮵊; + #𮵋; + #𮵌; + #𮵍; + #𮵎; + #𮵏; + #𮵐; + #𮵑; + #𮵒; + #𮵓; + #𮵔; + #𮵕; + #𮵖; + #𮵗; + #𮵘; + #𮵙; + #𮵚; + #𮵛; + #𮵜; + #𮵝; + #𮵞; + #𮵟; + #𮵠; + #𮵡; + #𮵢; + #𮵣; + #𮵤; + #𮵥; + #𮵦; + #𮵧; + #𮵨; + #𮵩; + #𮵪; + #𮵫; + #𮵬; + #𮵭; + #𮵮; + #𮵯; + #𮵰; + #𮵱; + #𮵲; + #𮵳; + #𮵴; + #𮵵; + #𮵶; + #𮵷; + #𮵸; + #𮵹; + #𮵺; + #𮵻; + #𮵼; + #𮵽; + #𮵾; + #𮵿; + #𮶀; + #𮶁; + #𮶂; + #𮶃; + #𮶄; + #𮶅; + #𮶆; + #𮶇; + #𮶈; + #𮶉; + #𮶊; + #𮶋; + #𮶌; + #𮶍; + #𮶎; + #𮶏; + #𮶐; + #𮶑; + #𮶒; + #𮶓; + #𮶔; + #𮶕; + #𮶖; + #𮶗; + #𮶘; + #𮶙; + #𮶚; + #𮶛; + #𮶜; + #𮶝; + #𮶞; + #𮶟; + #𮶠; + #𮶡; + #𮶢; + #𮶣; + #𮶤; + #𮶥; + #𮶦; + #𮶧; + #𮶨; + #𮶩; + #𮶪; + #𮶫; + #𮶬; + #𮶭; + #𮶮; + #𮶯; + #𮶰; + #𮶱; + #𮶲; + #𮶳; + #𮶴; + #𮶵; + #𮶶; + #𮶷; + #𮶸; + #𮶹; + #𮶺; + #𮶻; + #𮶼; + #𮶽; + #𮶾; + #𮶿; + #𮷀; + #𮷁; + #𮷂; + #𮷃; + #𮷄; + #𮷅; + #𮷆; + #𮷇; + #𮷈; + #𮷉; + #𮷊; + #𮷋; + #𮷌; + #𮷍; + #𮷎; + #𮷏; + #𮷐; + #𮷑; + #𮷒; + #𮷓; + #𮷔; + #𮷕; + #𮷖; + #𮷗; + #𮷘; + #𮷙; + #𮷚; + #𮷛; + #𮷜; + #𮷝; + #𮷞; + #𮷟; + #𮷠; + #𮷡; + #𮷢; + #𮷣; + #𮷤; + #𮷥; + #𮷦; + #𮷧; + #𮷨; + #𮷩; + #𮷪; + #𮷫; + #𮷬; + #𮷭; + #𮷮; + #𮷯; + #𮷰; + #𮷱; + #𮷲; + #𮷳; + #𮷴; + #𮷵; + #𮷶; + #𮷷; + #𮷸; + #𮷹; + #𮷺; + #𮷻; + #𮷼; + #𮷽; + #𮷾; + #𮷿; + #𮸀; + #𮸁; + #𮸂; + #𮸃; + #𮸄; + #𮸅; + #𮸆; + #𮸇; + #𮸈; + #𮸉; + #𮸊; + #𮸋; + #𮸌; + #𮸍; + #𮸎; + #𮸏; + #𮸐; + #𮸑; + #𮸒; + #𮸓; + #𮸔; + #𮸕; + #𮸖; + #𮸗; + #𮸘; + #𮸙; + #𮸚; + #𮸛; + #𮸜; + #𮸝; + #𮸞; + #𮸟; + #𮸠; + #𮸡; + #𮸢; + #𮸣; + #𮸤; + #𮸥; + #𮸦; + #𮸧; + #𮸨; + #𮸩; + #𮸪; + #𮸫; + #𮸬; + #𮸭; + #𮸮; + #𮸯; + #𮸰; + #𮸱; + #𮸲; + #𮸳; + #𮸴; + #𮸵; + #𮸶; + #𮸷; + #𮸸; + #𮸹; + #𮸺; + #𮸻; + #𮸼; + #𮸽; + #𮸾; + #𮸿; + #𮹀; + #𮹁; + #𮹂; + #𮹃; + #𮹄; + #𮹅; + #𮹆; + #𮹇; + #𮹈; + #𮹉; + #𮹊; + #𮹋; + #𮹌; + #𮹍; + #𮹎; + #𮹏; + #𮹐; + #𮹑; + #𮹒; + #𮹓; + #𮹔; + #𮹕; + #𮹖; + #𮹗; + #𮹘; + #𮹙; + #𮹚; + #𮹛; + #𮹜; + #𮹝; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0-escaped.js new file mode 100644 index 000000000..23005f35b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0-escaped.js @@ -0,0 +1,637 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v15.1.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u{2EBF0}; +var \u{2EBF1}; +var \u{2EBF2}; +var \u{2EBF3}; +var \u{2EBF4}; +var \u{2EBF5}; +var \u{2EBF6}; +var \u{2EBF7}; +var \u{2EBF8}; +var \u{2EBF9}; +var \u{2EBFA}; +var \u{2EBFB}; +var \u{2EBFC}; +var \u{2EBFD}; +var \u{2EBFE}; +var \u{2EBFF}; +var \u{2EC00}; +var \u{2EC01}; +var \u{2EC02}; +var \u{2EC03}; +var \u{2EC04}; +var \u{2EC05}; +var \u{2EC06}; +var \u{2EC07}; +var \u{2EC08}; +var \u{2EC09}; +var \u{2EC0A}; +var \u{2EC0B}; +var \u{2EC0C}; +var \u{2EC0D}; +var \u{2EC0E}; +var \u{2EC0F}; +var \u{2EC10}; +var \u{2EC11}; +var \u{2EC12}; +var \u{2EC13}; +var \u{2EC14}; +var \u{2EC15}; +var \u{2EC16}; +var \u{2EC17}; +var \u{2EC18}; +var \u{2EC19}; +var \u{2EC1A}; +var \u{2EC1B}; +var \u{2EC1C}; +var \u{2EC1D}; +var \u{2EC1E}; +var \u{2EC1F}; +var \u{2EC20}; +var \u{2EC21}; +var \u{2EC22}; +var \u{2EC23}; +var \u{2EC24}; +var \u{2EC25}; +var \u{2EC26}; +var \u{2EC27}; +var \u{2EC28}; +var \u{2EC29}; +var \u{2EC2A}; +var \u{2EC2B}; +var \u{2EC2C}; +var \u{2EC2D}; +var \u{2EC2E}; +var \u{2EC2F}; +var \u{2EC30}; +var \u{2EC31}; +var \u{2EC32}; +var \u{2EC33}; +var \u{2EC34}; +var \u{2EC35}; +var \u{2EC36}; +var \u{2EC37}; +var \u{2EC38}; +var \u{2EC39}; +var \u{2EC3A}; +var \u{2EC3B}; +var \u{2EC3C}; +var \u{2EC3D}; +var \u{2EC3E}; +var \u{2EC3F}; +var \u{2EC40}; +var \u{2EC41}; +var \u{2EC42}; +var \u{2EC43}; +var \u{2EC44}; +var \u{2EC45}; +var \u{2EC46}; +var \u{2EC47}; +var \u{2EC48}; +var \u{2EC49}; +var \u{2EC4A}; +var \u{2EC4B}; +var \u{2EC4C}; +var \u{2EC4D}; +var \u{2EC4E}; +var \u{2EC4F}; +var \u{2EC50}; +var \u{2EC51}; +var \u{2EC52}; +var \u{2EC53}; +var \u{2EC54}; +var \u{2EC55}; +var \u{2EC56}; +var \u{2EC57}; +var \u{2EC58}; +var \u{2EC59}; +var \u{2EC5A}; +var \u{2EC5B}; +var \u{2EC5C}; +var \u{2EC5D}; +var \u{2EC5E}; +var \u{2EC5F}; +var \u{2EC60}; +var \u{2EC61}; +var \u{2EC62}; +var \u{2EC63}; +var \u{2EC64}; +var \u{2EC65}; +var \u{2EC66}; +var \u{2EC67}; +var \u{2EC68}; +var \u{2EC69}; +var \u{2EC6A}; +var \u{2EC6B}; +var \u{2EC6C}; +var \u{2EC6D}; +var \u{2EC6E}; +var \u{2EC6F}; +var \u{2EC70}; +var \u{2EC71}; +var \u{2EC72}; +var \u{2EC73}; +var \u{2EC74}; +var \u{2EC75}; +var \u{2EC76}; +var \u{2EC77}; +var \u{2EC78}; +var \u{2EC79}; +var \u{2EC7A}; +var \u{2EC7B}; +var \u{2EC7C}; +var \u{2EC7D}; +var \u{2EC7E}; +var \u{2EC7F}; +var \u{2EC80}; +var \u{2EC81}; +var \u{2EC82}; +var \u{2EC83}; +var \u{2EC84}; +var \u{2EC85}; +var \u{2EC86}; +var \u{2EC87}; +var \u{2EC88}; +var \u{2EC89}; +var \u{2EC8A}; +var \u{2EC8B}; +var \u{2EC8C}; +var \u{2EC8D}; +var \u{2EC8E}; +var \u{2EC8F}; +var \u{2EC90}; +var \u{2EC91}; +var \u{2EC92}; +var \u{2EC93}; +var \u{2EC94}; +var \u{2EC95}; +var \u{2EC96}; +var \u{2EC97}; +var \u{2EC98}; +var \u{2EC99}; +var \u{2EC9A}; +var \u{2EC9B}; +var \u{2EC9C}; +var \u{2EC9D}; +var \u{2EC9E}; +var \u{2EC9F}; +var \u{2ECA0}; +var \u{2ECA1}; +var \u{2ECA2}; +var \u{2ECA3}; +var \u{2ECA4}; +var \u{2ECA5}; +var \u{2ECA6}; +var \u{2ECA7}; +var \u{2ECA8}; +var \u{2ECA9}; +var \u{2ECAA}; +var \u{2ECAB}; +var \u{2ECAC}; +var \u{2ECAD}; +var \u{2ECAE}; +var \u{2ECAF}; +var \u{2ECB0}; +var \u{2ECB1}; +var \u{2ECB2}; +var \u{2ECB3}; +var \u{2ECB4}; +var \u{2ECB5}; +var \u{2ECB6}; +var \u{2ECB7}; +var \u{2ECB8}; +var \u{2ECB9}; +var \u{2ECBA}; +var \u{2ECBB}; +var \u{2ECBC}; +var \u{2ECBD}; +var \u{2ECBE}; +var \u{2ECBF}; +var \u{2ECC0}; +var \u{2ECC1}; +var \u{2ECC2}; +var \u{2ECC3}; +var \u{2ECC4}; +var \u{2ECC5}; +var \u{2ECC6}; +var \u{2ECC7}; +var \u{2ECC8}; +var \u{2ECC9}; +var \u{2ECCA}; +var \u{2ECCB}; +var \u{2ECCC}; +var \u{2ECCD}; +var \u{2ECCE}; +var \u{2ECCF}; +var \u{2ECD0}; +var \u{2ECD1}; +var \u{2ECD2}; +var \u{2ECD3}; +var \u{2ECD4}; +var \u{2ECD5}; +var \u{2ECD6}; +var \u{2ECD7}; +var \u{2ECD8}; +var \u{2ECD9}; +var \u{2ECDA}; +var \u{2ECDB}; +var \u{2ECDC}; +var \u{2ECDD}; +var \u{2ECDE}; +var \u{2ECDF}; +var \u{2ECE0}; +var \u{2ECE1}; +var \u{2ECE2}; +var \u{2ECE3}; +var \u{2ECE4}; +var \u{2ECE5}; +var \u{2ECE6}; +var \u{2ECE7}; +var \u{2ECE8}; +var \u{2ECE9}; +var \u{2ECEA}; +var \u{2ECEB}; +var \u{2ECEC}; +var \u{2ECED}; +var \u{2ECEE}; +var \u{2ECEF}; +var \u{2ECF0}; +var \u{2ECF1}; +var \u{2ECF2}; +var \u{2ECF3}; +var \u{2ECF4}; +var \u{2ECF5}; +var \u{2ECF6}; +var \u{2ECF7}; +var \u{2ECF8}; +var \u{2ECF9}; +var \u{2ECFA}; +var \u{2ECFB}; +var \u{2ECFC}; +var \u{2ECFD}; +var \u{2ECFE}; +var \u{2ECFF}; +var \u{2ED00}; +var \u{2ED01}; +var \u{2ED02}; +var \u{2ED03}; +var \u{2ED04}; +var \u{2ED05}; +var \u{2ED06}; +var \u{2ED07}; +var \u{2ED08}; +var \u{2ED09}; +var \u{2ED0A}; +var \u{2ED0B}; +var \u{2ED0C}; +var \u{2ED0D}; +var \u{2ED0E}; +var \u{2ED0F}; +var \u{2ED10}; +var \u{2ED11}; +var \u{2ED12}; +var \u{2ED13}; +var \u{2ED14}; +var \u{2ED15}; +var \u{2ED16}; +var \u{2ED17}; +var \u{2ED18}; +var \u{2ED19}; +var \u{2ED1A}; +var \u{2ED1B}; +var \u{2ED1C}; +var \u{2ED1D}; +var \u{2ED1E}; +var \u{2ED1F}; +var \u{2ED20}; +var \u{2ED21}; +var \u{2ED22}; +var \u{2ED23}; +var \u{2ED24}; +var \u{2ED25}; +var \u{2ED26}; +var \u{2ED27}; +var \u{2ED28}; +var \u{2ED29}; +var \u{2ED2A}; +var \u{2ED2B}; +var \u{2ED2C}; +var \u{2ED2D}; +var \u{2ED2E}; +var \u{2ED2F}; +var \u{2ED30}; +var \u{2ED31}; +var \u{2ED32}; +var \u{2ED33}; +var \u{2ED34}; +var \u{2ED35}; +var \u{2ED36}; +var \u{2ED37}; +var \u{2ED38}; +var \u{2ED39}; +var \u{2ED3A}; +var \u{2ED3B}; +var \u{2ED3C}; +var \u{2ED3D}; +var \u{2ED3E}; +var \u{2ED3F}; +var \u{2ED40}; +var \u{2ED41}; +var \u{2ED42}; +var \u{2ED43}; +var \u{2ED44}; +var \u{2ED45}; +var \u{2ED46}; +var \u{2ED47}; +var \u{2ED48}; +var \u{2ED49}; +var \u{2ED4A}; +var \u{2ED4B}; +var \u{2ED4C}; +var \u{2ED4D}; +var \u{2ED4E}; +var \u{2ED4F}; +var \u{2ED50}; +var \u{2ED51}; +var \u{2ED52}; +var \u{2ED53}; +var \u{2ED54}; +var \u{2ED55}; +var \u{2ED56}; +var \u{2ED57}; +var \u{2ED58}; +var \u{2ED59}; +var \u{2ED5A}; +var \u{2ED5B}; +var \u{2ED5C}; +var \u{2ED5D}; +var \u{2ED5E}; +var \u{2ED5F}; +var \u{2ED60}; +var \u{2ED61}; +var \u{2ED62}; +var \u{2ED63}; +var \u{2ED64}; +var \u{2ED65}; +var \u{2ED66}; +var \u{2ED67}; +var \u{2ED68}; +var \u{2ED69}; +var \u{2ED6A}; +var \u{2ED6B}; +var \u{2ED6C}; +var \u{2ED6D}; +var \u{2ED6E}; +var \u{2ED6F}; +var \u{2ED70}; +var \u{2ED71}; +var \u{2ED72}; +var \u{2ED73}; +var \u{2ED74}; +var \u{2ED75}; +var \u{2ED76}; +var \u{2ED77}; +var \u{2ED78}; +var \u{2ED79}; +var \u{2ED7A}; +var \u{2ED7B}; +var \u{2ED7C}; +var \u{2ED7D}; +var \u{2ED7E}; +var \u{2ED7F}; +var \u{2ED80}; +var \u{2ED81}; +var \u{2ED82}; +var \u{2ED83}; +var \u{2ED84}; +var \u{2ED85}; +var \u{2ED86}; +var \u{2ED87}; +var \u{2ED88}; +var \u{2ED89}; +var \u{2ED8A}; +var \u{2ED8B}; +var \u{2ED8C}; +var \u{2ED8D}; +var \u{2ED8E}; +var \u{2ED8F}; +var \u{2ED90}; +var \u{2ED91}; +var \u{2ED92}; +var \u{2ED93}; +var \u{2ED94}; +var \u{2ED95}; +var \u{2ED96}; +var \u{2ED97}; +var \u{2ED98}; +var \u{2ED99}; +var \u{2ED9A}; +var \u{2ED9B}; +var \u{2ED9C}; +var \u{2ED9D}; +var \u{2ED9E}; +var \u{2ED9F}; +var \u{2EDA0}; +var \u{2EDA1}; +var \u{2EDA2}; +var \u{2EDA3}; +var \u{2EDA4}; +var \u{2EDA5}; +var \u{2EDA6}; +var \u{2EDA7}; +var \u{2EDA8}; +var \u{2EDA9}; +var \u{2EDAA}; +var \u{2EDAB}; +var \u{2EDAC}; +var \u{2EDAD}; +var \u{2EDAE}; +var \u{2EDAF}; +var \u{2EDB0}; +var \u{2EDB1}; +var \u{2EDB2}; +var \u{2EDB3}; +var \u{2EDB4}; +var \u{2EDB5}; +var \u{2EDB6}; +var \u{2EDB7}; +var \u{2EDB8}; +var \u{2EDB9}; +var \u{2EDBA}; +var \u{2EDBB}; +var \u{2EDBC}; +var \u{2EDBD}; +var \u{2EDBE}; +var \u{2EDBF}; +var \u{2EDC0}; +var \u{2EDC1}; +var \u{2EDC2}; +var \u{2EDC3}; +var \u{2EDC4}; +var \u{2EDC5}; +var \u{2EDC6}; +var \u{2EDC7}; +var \u{2EDC8}; +var \u{2EDC9}; +var \u{2EDCA}; +var \u{2EDCB}; +var \u{2EDCC}; +var \u{2EDCD}; +var \u{2EDCE}; +var \u{2EDCF}; +var \u{2EDD0}; +var \u{2EDD1}; +var \u{2EDD2}; +var \u{2EDD3}; +var \u{2EDD4}; +var \u{2EDD5}; +var \u{2EDD6}; +var \u{2EDD7}; +var \u{2EDD8}; +var \u{2EDD9}; +var \u{2EDDA}; +var \u{2EDDB}; +var \u{2EDDC}; +var \u{2EDDD}; +var \u{2EDDE}; +var \u{2EDDF}; +var \u{2EDE0}; +var \u{2EDE1}; +var \u{2EDE2}; +var \u{2EDE3}; +var \u{2EDE4}; +var \u{2EDE5}; +var \u{2EDE6}; +var \u{2EDE7}; +var \u{2EDE8}; +var \u{2EDE9}; +var \u{2EDEA}; +var \u{2EDEB}; +var \u{2EDEC}; +var \u{2EDED}; +var \u{2EDEE}; +var \u{2EDEF}; +var \u{2EDF0}; +var \u{2EDF1}; +var \u{2EDF2}; +var \u{2EDF3}; +var \u{2EDF4}; +var \u{2EDF5}; +var \u{2EDF6}; +var \u{2EDF7}; +var \u{2EDF8}; +var \u{2EDF9}; +var \u{2EDFA}; +var \u{2EDFB}; +var \u{2EDFC}; +var \u{2EDFD}; +var \u{2EDFE}; +var \u{2EDFF}; +var \u{2EE00}; +var \u{2EE01}; +var \u{2EE02}; +var \u{2EE03}; +var \u{2EE04}; +var \u{2EE05}; +var \u{2EE06}; +var \u{2EE07}; +var \u{2EE08}; +var \u{2EE09}; +var \u{2EE0A}; +var \u{2EE0B}; +var \u{2EE0C}; +var \u{2EE0D}; +var \u{2EE0E}; +var \u{2EE0F}; +var \u{2EE10}; +var \u{2EE11}; +var \u{2EE12}; +var \u{2EE13}; +var \u{2EE14}; +var \u{2EE15}; +var \u{2EE16}; +var \u{2EE17}; +var \u{2EE18}; +var \u{2EE19}; +var \u{2EE1A}; +var \u{2EE1B}; +var \u{2EE1C}; +var \u{2EE1D}; +var \u{2EE1E}; +var \u{2EE1F}; +var \u{2EE20}; +var \u{2EE21}; +var \u{2EE22}; +var \u{2EE23}; +var \u{2EE24}; +var \u{2EE25}; +var \u{2EE26}; +var \u{2EE27}; +var \u{2EE28}; +var \u{2EE29}; +var \u{2EE2A}; +var \u{2EE2B}; +var \u{2EE2C}; +var \u{2EE2D}; +var \u{2EE2E}; +var \u{2EE2F}; +var \u{2EE30}; +var \u{2EE31}; +var \u{2EE32}; +var \u{2EE33}; +var \u{2EE34}; +var \u{2EE35}; +var \u{2EE36}; +var \u{2EE37}; +var \u{2EE38}; +var \u{2EE39}; +var \u{2EE3A}; +var \u{2EE3B}; +var \u{2EE3C}; +var \u{2EE3D}; +var \u{2EE3E}; +var \u{2EE3F}; +var \u{2EE40}; +var \u{2EE41}; +var \u{2EE42}; +var \u{2EE43}; +var \u{2EE44}; +var \u{2EE45}; +var \u{2EE46}; +var \u{2EE47}; +var \u{2EE48}; +var \u{2EE49}; +var \u{2EE4A}; +var \u{2EE4B}; +var \u{2EE4C}; +var \u{2EE4D}; +var \u{2EE4E}; +var \u{2EE4F}; +var \u{2EE50}; +var \u{2EE51}; +var \u{2EE52}; +var \u{2EE53}; +var \u{2EE54}; +var \u{2EE55}; +var \u{2EE56}; +var \u{2EE57}; +var \u{2EE58}; +var \u{2EE59}; +var \u{2EE5A}; +var \u{2EE5B}; +var \u{2EE5C}; +var \u{2EE5D}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0.js new file mode 100644 index 000000000..45d7a4510 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-15.1.0.js @@ -0,0 +1,635 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v15.1.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var 𮯰; +var 𮯱; +var 𮯲; +var 𮯳; +var 𮯴; +var 𮯵; +var 𮯶; +var 𮯷; +var 𮯸; +var 𮯹; +var 𮯺; +var 𮯻; +var 𮯼; +var 𮯽; +var 𮯾; +var 𮯿; +var 𮰀; +var 𮰁; +var 𮰂; +var 𮰃; +var 𮰄; +var 𮰅; +var 𮰆; +var 𮰇; +var 𮰈; +var 𮰉; +var 𮰊; +var 𮰋; +var 𮰌; +var 𮰍; +var 𮰎; +var 𮰏; +var 𮰐; +var 𮰑; +var 𮰒; +var 𮰓; +var 𮰔; +var 𮰕; +var 𮰖; +var 𮰗; +var 𮰘; +var 𮰙; +var 𮰚; +var 𮰛; +var 𮰜; +var 𮰝; +var 𮰞; +var 𮰟; +var 𮰠; +var 𮰡; +var 𮰢; +var 𮰣; +var 𮰤; +var 𮰥; +var 𮰦; +var 𮰧; +var 𮰨; +var 𮰩; +var 𮰪; +var 𮰫; +var 𮰬; +var 𮰭; +var 𮰮; +var 𮰯; +var 𮰰; +var 𮰱; +var 𮰲; +var 𮰳; +var 𮰴; +var 𮰵; +var 𮰶; +var 𮰷; +var 𮰸; +var 𮰹; +var 𮰺; +var 𮰻; +var 𮰼; +var 𮰽; +var 𮰾; +var 𮰿; +var 𮱀; +var 𮱁; +var 𮱂; +var 𮱃; +var 𮱄; +var 𮱅; +var 𮱆; +var 𮱇; +var 𮱈; +var 𮱉; +var 𮱊; +var 𮱋; +var 𮱌; +var 𮱍; +var 𮱎; +var 𮱏; +var 𮱐; +var 𮱑; +var 𮱒; +var 𮱓; +var 𮱔; +var 𮱕; +var 𮱖; +var 𮱗; +var 𮱘; +var 𮱙; +var 𮱚; +var 𮱛; +var 𮱜; +var 𮱝; +var 𮱞; +var 𮱟; +var 𮱠; +var 𮱡; +var 𮱢; +var 𮱣; +var 𮱤; +var 𮱥; +var 𮱦; +var 𮱧; +var 𮱨; +var 𮱩; +var 𮱪; +var 𮱫; +var 𮱬; +var 𮱭; +var 𮱮; +var 𮱯; +var 𮱰; +var 𮱱; +var 𮱲; +var 𮱳; +var 𮱴; +var 𮱵; +var 𮱶; +var 𮱷; +var 𮱸; +var 𮱹; +var 𮱺; +var 𮱻; +var 𮱼; +var 𮱽; +var 𮱾; +var 𮱿; +var 𮲀; +var 𮲁; +var 𮲂; +var 𮲃; +var 𮲄; +var 𮲅; +var 𮲆; +var 𮲇; +var 𮲈; +var 𮲉; +var 𮲊; +var 𮲋; +var 𮲌; +var 𮲍; +var 𮲎; +var 𮲏; +var 𮲐; +var 𮲑; +var 𮲒; +var 𮲓; +var 𮲔; +var 𮲕; +var 𮲖; +var 𮲗; +var 𮲘; +var 𮲙; +var 𮲚; +var 𮲛; +var 𮲜; +var 𮲝; +var 𮲞; +var 𮲟; +var 𮲠; +var 𮲡; +var 𮲢; +var 𮲣; +var 𮲤; +var 𮲥; +var 𮲦; +var 𮲧; +var 𮲨; +var 𮲩; +var 𮲪; +var 𮲫; +var 𮲬; +var 𮲭; +var 𮲮; +var 𮲯; +var 𮲰; +var 𮲱; +var 𮲲; +var 𮲳; +var 𮲴; +var 𮲵; +var 𮲶; +var 𮲷; +var 𮲸; +var 𮲹; +var 𮲺; +var 𮲻; +var 𮲼; +var 𮲽; +var 𮲾; +var 𮲿; +var 𮳀; +var 𮳁; +var 𮳂; +var 𮳃; +var 𮳄; +var 𮳅; +var 𮳆; +var 𮳇; +var 𮳈; +var 𮳉; +var 𮳊; +var 𮳋; +var 𮳌; +var 𮳍; +var 𮳎; +var 𮳏; +var 𮳐; +var 𮳑; +var 𮳒; +var 𮳓; +var 𮳔; +var 𮳕; +var 𮳖; +var 𮳗; +var 𮳘; +var 𮳙; +var 𮳚; +var 𮳛; +var 𮳜; +var 𮳝; +var 𮳞; +var 𮳟; +var 𮳠; +var 𮳡; +var 𮳢; +var 𮳣; +var 𮳤; +var 𮳥; +var 𮳦; +var 𮳧; +var 𮳨; +var 𮳩; +var 𮳪; +var 𮳫; +var 𮳬; +var 𮳭; +var 𮳮; +var 𮳯; +var 𮳰; +var 𮳱; +var 𮳲; +var 𮳳; +var 𮳴; +var 𮳵; +var 𮳶; +var 𮳷; +var 𮳸; +var 𮳹; +var 𮳺; +var 𮳻; +var 𮳼; +var 𮳽; +var 𮳾; +var 𮳿; +var 𮴀; +var 𮴁; +var 𮴂; +var 𮴃; +var 𮴄; +var 𮴅; +var 𮴆; +var 𮴇; +var 𮴈; +var 𮴉; +var 𮴊; +var 𮴋; +var 𮴌; +var 𮴍; +var 𮴎; +var 𮴏; +var 𮴐; +var 𮴑; +var 𮴒; +var 𮴓; +var 𮴔; +var 𮴕; +var 𮴖; +var 𮴗; +var 𮴘; +var 𮴙; +var 𮴚; +var 𮴛; +var 𮴜; +var 𮴝; +var 𮴞; +var 𮴟; +var 𮴠; +var 𮴡; +var 𮴢; +var 𮴣; +var 𮴤; +var 𮴥; +var 𮴦; +var 𮴧; +var 𮴨; +var 𮴩; +var 𮴪; +var 𮴫; +var 𮴬; +var 𮴭; +var 𮴮; +var 𮴯; +var 𮴰; +var 𮴱; +var 𮴲; +var 𮴳; +var 𮴴; +var 𮴵; +var 𮴶; +var 𮴷; +var 𮴸; +var 𮴹; +var 𮴺; +var 𮴻; +var 𮴼; +var 𮴽; +var 𮴾; +var 𮴿; +var 𮵀; +var 𮵁; +var 𮵂; +var 𮵃; +var 𮵄; +var 𮵅; +var 𮵆; +var 𮵇; +var 𮵈; +var 𮵉; +var 𮵊; +var 𮵋; +var 𮵌; +var 𮵍; +var 𮵎; +var 𮵏; +var 𮵐; +var 𮵑; +var 𮵒; +var 𮵓; +var 𮵔; +var 𮵕; +var 𮵖; +var 𮵗; +var 𮵘; +var 𮵙; +var 𮵚; +var 𮵛; +var 𮵜; +var 𮵝; +var 𮵞; +var 𮵟; +var 𮵠; +var 𮵡; +var 𮵢; +var 𮵣; +var 𮵤; +var 𮵥; +var 𮵦; +var 𮵧; +var 𮵨; +var 𮵩; +var 𮵪; +var 𮵫; +var 𮵬; +var 𮵭; +var 𮵮; +var 𮵯; +var 𮵰; +var 𮵱; +var 𮵲; +var 𮵳; +var 𮵴; +var 𮵵; +var 𮵶; +var 𮵷; +var 𮵸; +var 𮵹; +var 𮵺; +var 𮵻; +var 𮵼; +var 𮵽; +var 𮵾; +var 𮵿; +var 𮶀; +var 𮶁; +var 𮶂; +var 𮶃; +var 𮶄; +var 𮶅; +var 𮶆; +var 𮶇; +var 𮶈; +var 𮶉; +var 𮶊; +var 𮶋; +var 𮶌; +var 𮶍; +var 𮶎; +var 𮶏; +var 𮶐; +var 𮶑; +var 𮶒; +var 𮶓; +var 𮶔; +var 𮶕; +var 𮶖; +var 𮶗; +var 𮶘; +var 𮶙; +var 𮶚; +var 𮶛; +var 𮶜; +var 𮶝; +var 𮶞; +var 𮶟; +var 𮶠; +var 𮶡; +var 𮶢; +var 𮶣; +var 𮶤; +var 𮶥; +var 𮶦; +var 𮶧; +var 𮶨; +var 𮶩; +var 𮶪; +var 𮶫; +var 𮶬; +var 𮶭; +var 𮶮; +var 𮶯; +var 𮶰; +var 𮶱; +var 𮶲; +var 𮶳; +var 𮶴; +var 𮶵; +var 𮶶; +var 𮶷; +var 𮶸; +var 𮶹; +var 𮶺; +var 𮶻; +var 𮶼; +var 𮶽; +var 𮶾; +var 𮶿; +var 𮷀; +var 𮷁; +var 𮷂; +var 𮷃; +var 𮷄; +var 𮷅; +var 𮷆; +var 𮷇; +var 𮷈; +var 𮷉; +var 𮷊; +var 𮷋; +var 𮷌; +var 𮷍; +var 𮷎; +var 𮷏; +var 𮷐; +var 𮷑; +var 𮷒; +var 𮷓; +var 𮷔; +var 𮷕; +var 𮷖; +var 𮷗; +var 𮷘; +var 𮷙; +var 𮷚; +var 𮷛; +var 𮷜; +var 𮷝; +var 𮷞; +var 𮷟; +var 𮷠; +var 𮷡; +var 𮷢; +var 𮷣; +var 𮷤; +var 𮷥; +var 𮷦; +var 𮷧; +var 𮷨; +var 𮷩; +var 𮷪; +var 𮷫; +var 𮷬; +var 𮷭; +var 𮷮; +var 𮷯; +var 𮷰; +var 𮷱; +var 𮷲; +var 𮷳; +var 𮷴; +var 𮷵; +var 𮷶; +var 𮷷; +var 𮷸; +var 𮷹; +var 𮷺; +var 𮷻; +var 𮷼; +var 𮷽; +var 𮷾; +var 𮷿; +var 𮸀; +var 𮸁; +var 𮸂; +var 𮸃; +var 𮸄; +var 𮸅; +var 𮸆; +var 𮸇; +var 𮸈; +var 𮸉; +var 𮸊; +var 𮸋; +var 𮸌; +var 𮸍; +var 𮸎; +var 𮸏; +var 𮸐; +var 𮸑; +var 𮸒; +var 𮸓; +var 𮸔; +var 𮸕; +var 𮸖; +var 𮸗; +var 𮸘; +var 𮸙; +var 𮸚; +var 𮸛; +var 𮸜; +var 𮸝; +var 𮸞; +var 𮸟; +var 𮸠; +var 𮸡; +var 𮸢; +var 𮸣; +var 𮸤; +var 𮸥; +var 𮸦; +var 𮸧; +var 𮸨; +var 𮸩; +var 𮸪; +var 𮸫; +var 𮸬; +var 𮸭; +var 𮸮; +var 𮸯; +var 𮸰; +var 𮸱; +var 𮸲; +var 𮸳; +var 𮸴; +var 𮸵; +var 𮸶; +var 𮸷; +var 𮸸; +var 𮸹; +var 𮸺; +var 𮸻; +var 𮸼; +var 𮸽; +var 𮸾; +var 𮸿; +var 𮹀; +var 𮹁; +var 𮹂; +var 𮹃; +var 𮹄; +var 𮹅; +var 𮹆; +var 𮹇; +var 𮹈; +var 𮹉; +var 𮹊; +var 𮹋; +var 𮹌; +var 𮹍; +var 𮹎; +var 𮹏; +var 𮹐; +var 𮹑; +var 𮹒; +var 𮹓; +var 𮹔; +var 𮹕; +var 𮹖; +var 𮹗; +var 𮹘; +var 𮹙; +var 𮹚; +var 𮹛; +var 𮹜; +var 𮹝; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0-class-escaped.js new file mode 100644 index 000000000..8d3b8717a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0-class-escaped.js @@ -0,0 +1,4321 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v16.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u1C89; + #\u1C8A; + #\uA7CB; + #\uA7CC; + #\uA7CD; + #\uA7DA; + #\uA7DB; + #\uA7DC; + #\u{105C0}; + #\u{105C1}; + #\u{105C2}; + #\u{105C3}; + #\u{105C4}; + #\u{105C5}; + #\u{105C6}; + #\u{105C7}; + #\u{105C8}; + #\u{105C9}; + #\u{105CA}; + #\u{105CB}; + #\u{105CC}; + #\u{105CD}; + #\u{105CE}; + #\u{105CF}; + #\u{105D0}; + #\u{105D1}; + #\u{105D2}; + #\u{105D3}; + #\u{105D4}; + #\u{105D5}; + #\u{105D6}; + #\u{105D7}; + #\u{105D8}; + #\u{105D9}; + #\u{105DA}; + #\u{105DB}; + #\u{105DC}; + #\u{105DD}; + #\u{105DE}; + #\u{105DF}; + #\u{105E0}; + #\u{105E1}; + #\u{105E2}; + #\u{105E3}; + #\u{105E4}; + #\u{105E5}; + #\u{105E6}; + #\u{105E7}; + #\u{105E8}; + #\u{105E9}; + #\u{105EA}; + #\u{105EB}; + #\u{105EC}; + #\u{105ED}; + #\u{105EE}; + #\u{105EF}; + #\u{105F0}; + #\u{105F1}; + #\u{105F2}; + #\u{105F3}; + #\u{10D4A}; + #\u{10D4B}; + #\u{10D4C}; + #\u{10D4D}; + #\u{10D4E}; + #\u{10D4F}; + #\u{10D50}; + #\u{10D51}; + #\u{10D52}; + #\u{10D53}; + #\u{10D54}; + #\u{10D55}; + #\u{10D56}; + #\u{10D57}; + #\u{10D58}; + #\u{10D59}; + #\u{10D5A}; + #\u{10D5B}; + #\u{10D5C}; + #\u{10D5D}; + #\u{10D5E}; + #\u{10D5F}; + #\u{10D60}; + #\u{10D61}; + #\u{10D62}; + #\u{10D63}; + #\u{10D64}; + #\u{10D65}; + #\u{10D6F}; + #\u{10D70}; + #\u{10D71}; + #\u{10D72}; + #\u{10D73}; + #\u{10D74}; + #\u{10D75}; + #\u{10D76}; + #\u{10D77}; + #\u{10D78}; + #\u{10D79}; + #\u{10D7A}; + #\u{10D7B}; + #\u{10D7C}; + #\u{10D7D}; + #\u{10D7E}; + #\u{10D7F}; + #\u{10D80}; + #\u{10D81}; + #\u{10D82}; + #\u{10D83}; + #\u{10D84}; + #\u{10D85}; + #\u{10EC2}; + #\u{10EC3}; + #\u{10EC4}; + #\u{11380}; + #\u{11381}; + #\u{11382}; + #\u{11383}; + #\u{11384}; + #\u{11385}; + #\u{11386}; + #\u{11387}; + #\u{11388}; + #\u{11389}; + #\u{1138B}; + #\u{1138E}; + #\u{11390}; + #\u{11391}; + #\u{11392}; + #\u{11393}; + #\u{11394}; + #\u{11395}; + #\u{11396}; + #\u{11397}; + #\u{11398}; + #\u{11399}; + #\u{1139A}; + #\u{1139B}; + #\u{1139C}; + #\u{1139D}; + #\u{1139E}; + #\u{1139F}; + #\u{113A0}; + #\u{113A1}; + #\u{113A2}; + #\u{113A3}; + #\u{113A4}; + #\u{113A5}; + #\u{113A6}; + #\u{113A7}; + #\u{113A8}; + #\u{113A9}; + #\u{113AA}; + #\u{113AB}; + #\u{113AC}; + #\u{113AD}; + #\u{113AE}; + #\u{113AF}; + #\u{113B0}; + #\u{113B1}; + #\u{113B2}; + #\u{113B3}; + #\u{113B4}; + #\u{113B5}; + #\u{113B7}; + #\u{113D1}; + #\u{113D3}; + #\u{11BC0}; + #\u{11BC1}; + #\u{11BC2}; + #\u{11BC3}; + #\u{11BC4}; + #\u{11BC5}; + #\u{11BC6}; + #\u{11BC7}; + #\u{11BC8}; + #\u{11BC9}; + #\u{11BCA}; + #\u{11BCB}; + #\u{11BCC}; + #\u{11BCD}; + #\u{11BCE}; + #\u{11BCF}; + #\u{11BD0}; + #\u{11BD1}; + #\u{11BD2}; + #\u{11BD3}; + #\u{11BD4}; + #\u{11BD5}; + #\u{11BD6}; + #\u{11BD7}; + #\u{11BD8}; + #\u{11BD9}; + #\u{11BDA}; + #\u{11BDB}; + #\u{11BDC}; + #\u{11BDD}; + #\u{11BDE}; + #\u{11BDF}; + #\u{11BE0}; + #\u{13460}; + #\u{13461}; + #\u{13462}; + #\u{13463}; + #\u{13464}; + #\u{13465}; + #\u{13466}; + #\u{13467}; + #\u{13468}; + #\u{13469}; + #\u{1346A}; + #\u{1346B}; + #\u{1346C}; + #\u{1346D}; + #\u{1346E}; + #\u{1346F}; + #\u{13470}; + #\u{13471}; + #\u{13472}; + #\u{13473}; + #\u{13474}; + #\u{13475}; + #\u{13476}; + #\u{13477}; + #\u{13478}; + #\u{13479}; + #\u{1347A}; + #\u{1347B}; + #\u{1347C}; + #\u{1347D}; + #\u{1347E}; + #\u{1347F}; + #\u{13480}; + #\u{13481}; + #\u{13482}; + #\u{13483}; + #\u{13484}; + #\u{13485}; + #\u{13486}; + #\u{13487}; + #\u{13488}; + #\u{13489}; + #\u{1348A}; + #\u{1348B}; + #\u{1348C}; + #\u{1348D}; + #\u{1348E}; + #\u{1348F}; + #\u{13490}; + #\u{13491}; + #\u{13492}; + #\u{13493}; + #\u{13494}; + #\u{13495}; + #\u{13496}; + #\u{13497}; + #\u{13498}; + #\u{13499}; + #\u{1349A}; + #\u{1349B}; + #\u{1349C}; + #\u{1349D}; + #\u{1349E}; + #\u{1349F}; + #\u{134A0}; + #\u{134A1}; + #\u{134A2}; + #\u{134A3}; + #\u{134A4}; + #\u{134A5}; + #\u{134A6}; + #\u{134A7}; + #\u{134A8}; + #\u{134A9}; + #\u{134AA}; + #\u{134AB}; + #\u{134AC}; + #\u{134AD}; + #\u{134AE}; + #\u{134AF}; + #\u{134B0}; + #\u{134B1}; + #\u{134B2}; + #\u{134B3}; + #\u{134B4}; + #\u{134B5}; + #\u{134B6}; + #\u{134B7}; + #\u{134B8}; + #\u{134B9}; + #\u{134BA}; + #\u{134BB}; + #\u{134BC}; + #\u{134BD}; + #\u{134BE}; + #\u{134BF}; + #\u{134C0}; + #\u{134C1}; + #\u{134C2}; + #\u{134C3}; + #\u{134C4}; + #\u{134C5}; + #\u{134C6}; + #\u{134C7}; + #\u{134C8}; + #\u{134C9}; + #\u{134CA}; + #\u{134CB}; + #\u{134CC}; + #\u{134CD}; + #\u{134CE}; + #\u{134CF}; + #\u{134D0}; + #\u{134D1}; + #\u{134D2}; + #\u{134D3}; + #\u{134D4}; + #\u{134D5}; + #\u{134D6}; + #\u{134D7}; + #\u{134D8}; + #\u{134D9}; + #\u{134DA}; + #\u{134DB}; + #\u{134DC}; + #\u{134DD}; + #\u{134DE}; + #\u{134DF}; + #\u{134E0}; + #\u{134E1}; + #\u{134E2}; + #\u{134E3}; + #\u{134E4}; + #\u{134E5}; + #\u{134E6}; + #\u{134E7}; + #\u{134E8}; + #\u{134E9}; + #\u{134EA}; + #\u{134EB}; + #\u{134EC}; + #\u{134ED}; + #\u{134EE}; + #\u{134EF}; + #\u{134F0}; + #\u{134F1}; + #\u{134F2}; + #\u{134F3}; + #\u{134F4}; + #\u{134F5}; + #\u{134F6}; + #\u{134F7}; + #\u{134F8}; + #\u{134F9}; + #\u{134FA}; + #\u{134FB}; + #\u{134FC}; + #\u{134FD}; + #\u{134FE}; + #\u{134FF}; + #\u{13500}; + #\u{13501}; + #\u{13502}; + #\u{13503}; + #\u{13504}; + #\u{13505}; + #\u{13506}; + #\u{13507}; + #\u{13508}; + #\u{13509}; + #\u{1350A}; + #\u{1350B}; + #\u{1350C}; + #\u{1350D}; + #\u{1350E}; + #\u{1350F}; + #\u{13510}; + #\u{13511}; + #\u{13512}; + #\u{13513}; + #\u{13514}; + #\u{13515}; + #\u{13516}; + #\u{13517}; + #\u{13518}; + #\u{13519}; + #\u{1351A}; + #\u{1351B}; + #\u{1351C}; + #\u{1351D}; + #\u{1351E}; + #\u{1351F}; + #\u{13520}; + #\u{13521}; + #\u{13522}; + #\u{13523}; + #\u{13524}; + #\u{13525}; + #\u{13526}; + #\u{13527}; + #\u{13528}; + #\u{13529}; + #\u{1352A}; + #\u{1352B}; + #\u{1352C}; + #\u{1352D}; + #\u{1352E}; + #\u{1352F}; + #\u{13530}; + #\u{13531}; + #\u{13532}; + #\u{13533}; + #\u{13534}; + #\u{13535}; + #\u{13536}; + #\u{13537}; + #\u{13538}; + #\u{13539}; + #\u{1353A}; + #\u{1353B}; + #\u{1353C}; + #\u{1353D}; + #\u{1353E}; + #\u{1353F}; + #\u{13540}; + #\u{13541}; + #\u{13542}; + #\u{13543}; + #\u{13544}; + #\u{13545}; + #\u{13546}; + #\u{13547}; + #\u{13548}; + #\u{13549}; + #\u{1354A}; + #\u{1354B}; + #\u{1354C}; + #\u{1354D}; + #\u{1354E}; + #\u{1354F}; + #\u{13550}; + #\u{13551}; + #\u{13552}; + #\u{13553}; + #\u{13554}; + #\u{13555}; + #\u{13556}; + #\u{13557}; + #\u{13558}; + #\u{13559}; + #\u{1355A}; + #\u{1355B}; + #\u{1355C}; + #\u{1355D}; + #\u{1355E}; + #\u{1355F}; + #\u{13560}; + #\u{13561}; + #\u{13562}; + #\u{13563}; + #\u{13564}; + #\u{13565}; + #\u{13566}; + #\u{13567}; + #\u{13568}; + #\u{13569}; + #\u{1356A}; + #\u{1356B}; + #\u{1356C}; + #\u{1356D}; + #\u{1356E}; + #\u{1356F}; + #\u{13570}; + #\u{13571}; + #\u{13572}; + #\u{13573}; + #\u{13574}; + #\u{13575}; + #\u{13576}; + #\u{13577}; + #\u{13578}; + #\u{13579}; + #\u{1357A}; + #\u{1357B}; + #\u{1357C}; + #\u{1357D}; + #\u{1357E}; + #\u{1357F}; + #\u{13580}; + #\u{13581}; + #\u{13582}; + #\u{13583}; + #\u{13584}; + #\u{13585}; + #\u{13586}; + #\u{13587}; + #\u{13588}; + #\u{13589}; + #\u{1358A}; + #\u{1358B}; + #\u{1358C}; + #\u{1358D}; + #\u{1358E}; + #\u{1358F}; + #\u{13590}; + #\u{13591}; + #\u{13592}; + #\u{13593}; + #\u{13594}; + #\u{13595}; + #\u{13596}; + #\u{13597}; + #\u{13598}; + #\u{13599}; + #\u{1359A}; + #\u{1359B}; + #\u{1359C}; + #\u{1359D}; + #\u{1359E}; + #\u{1359F}; + #\u{135A0}; + #\u{135A1}; + #\u{135A2}; + #\u{135A3}; + #\u{135A4}; + #\u{135A5}; + #\u{135A6}; + #\u{135A7}; + #\u{135A8}; + #\u{135A9}; + #\u{135AA}; + #\u{135AB}; + #\u{135AC}; + #\u{135AD}; + #\u{135AE}; + #\u{135AF}; + #\u{135B0}; + #\u{135B1}; + #\u{135B2}; + #\u{135B3}; + #\u{135B4}; + #\u{135B5}; + #\u{135B6}; + #\u{135B7}; + #\u{135B8}; + #\u{135B9}; + #\u{135BA}; + #\u{135BB}; + #\u{135BC}; + #\u{135BD}; + #\u{135BE}; + #\u{135BF}; + #\u{135C0}; + #\u{135C1}; + #\u{135C2}; + #\u{135C3}; + #\u{135C4}; + #\u{135C5}; + #\u{135C6}; + #\u{135C7}; + #\u{135C8}; + #\u{135C9}; + #\u{135CA}; + #\u{135CB}; + #\u{135CC}; + #\u{135CD}; + #\u{135CE}; + #\u{135CF}; + #\u{135D0}; + #\u{135D1}; + #\u{135D2}; + #\u{135D3}; + #\u{135D4}; + #\u{135D5}; + #\u{135D6}; + #\u{135D7}; + #\u{135D8}; + #\u{135D9}; + #\u{135DA}; + #\u{135DB}; + #\u{135DC}; + #\u{135DD}; + #\u{135DE}; + #\u{135DF}; + #\u{135E0}; + #\u{135E1}; + #\u{135E2}; + #\u{135E3}; + #\u{135E4}; + #\u{135E5}; + #\u{135E6}; + #\u{135E7}; + #\u{135E8}; + #\u{135E9}; + #\u{135EA}; + #\u{135EB}; + #\u{135EC}; + #\u{135ED}; + #\u{135EE}; + #\u{135EF}; + #\u{135F0}; + #\u{135F1}; + #\u{135F2}; + #\u{135F3}; + #\u{135F4}; + #\u{135F5}; + #\u{135F6}; + #\u{135F7}; + #\u{135F8}; + #\u{135F9}; + #\u{135FA}; + #\u{135FB}; + #\u{135FC}; + #\u{135FD}; + #\u{135FE}; + #\u{135FF}; + #\u{13600}; + #\u{13601}; + #\u{13602}; + #\u{13603}; + #\u{13604}; + #\u{13605}; + #\u{13606}; + #\u{13607}; + #\u{13608}; + #\u{13609}; + #\u{1360A}; + #\u{1360B}; + #\u{1360C}; + #\u{1360D}; + #\u{1360E}; + #\u{1360F}; + #\u{13610}; + #\u{13611}; + #\u{13612}; + #\u{13613}; + #\u{13614}; + #\u{13615}; + #\u{13616}; + #\u{13617}; + #\u{13618}; + #\u{13619}; + #\u{1361A}; + #\u{1361B}; + #\u{1361C}; + #\u{1361D}; + #\u{1361E}; + #\u{1361F}; + #\u{13620}; + #\u{13621}; + #\u{13622}; + #\u{13623}; + #\u{13624}; + #\u{13625}; + #\u{13626}; + #\u{13627}; + #\u{13628}; + #\u{13629}; + #\u{1362A}; + #\u{1362B}; + #\u{1362C}; + #\u{1362D}; + #\u{1362E}; + #\u{1362F}; + #\u{13630}; + #\u{13631}; + #\u{13632}; + #\u{13633}; + #\u{13634}; + #\u{13635}; + #\u{13636}; + #\u{13637}; + #\u{13638}; + #\u{13639}; + #\u{1363A}; + #\u{1363B}; + #\u{1363C}; + #\u{1363D}; + #\u{1363E}; + #\u{1363F}; + #\u{13640}; + #\u{13641}; + #\u{13642}; + #\u{13643}; + #\u{13644}; + #\u{13645}; + #\u{13646}; + #\u{13647}; + #\u{13648}; + #\u{13649}; + #\u{1364A}; + #\u{1364B}; + #\u{1364C}; + #\u{1364D}; + #\u{1364E}; + #\u{1364F}; + #\u{13650}; + #\u{13651}; + #\u{13652}; + #\u{13653}; + #\u{13654}; + #\u{13655}; + #\u{13656}; + #\u{13657}; + #\u{13658}; + #\u{13659}; + #\u{1365A}; + #\u{1365B}; + #\u{1365C}; + #\u{1365D}; + #\u{1365E}; + #\u{1365F}; + #\u{13660}; + #\u{13661}; + #\u{13662}; + #\u{13663}; + #\u{13664}; + #\u{13665}; + #\u{13666}; + #\u{13667}; + #\u{13668}; + #\u{13669}; + #\u{1366A}; + #\u{1366B}; + #\u{1366C}; + #\u{1366D}; + #\u{1366E}; + #\u{1366F}; + #\u{13670}; + #\u{13671}; + #\u{13672}; + #\u{13673}; + #\u{13674}; + #\u{13675}; + #\u{13676}; + #\u{13677}; + #\u{13678}; + #\u{13679}; + #\u{1367A}; + #\u{1367B}; + #\u{1367C}; + #\u{1367D}; + #\u{1367E}; + #\u{1367F}; + #\u{13680}; + #\u{13681}; + #\u{13682}; + #\u{13683}; + #\u{13684}; + #\u{13685}; + #\u{13686}; + #\u{13687}; + #\u{13688}; + #\u{13689}; + #\u{1368A}; + #\u{1368B}; + #\u{1368C}; + #\u{1368D}; + #\u{1368E}; + #\u{1368F}; + #\u{13690}; + #\u{13691}; + #\u{13692}; + #\u{13693}; + #\u{13694}; + #\u{13695}; + #\u{13696}; + #\u{13697}; + #\u{13698}; + #\u{13699}; + #\u{1369A}; + #\u{1369B}; + #\u{1369C}; + #\u{1369D}; + #\u{1369E}; + #\u{1369F}; + #\u{136A0}; + #\u{136A1}; + #\u{136A2}; + #\u{136A3}; + #\u{136A4}; + #\u{136A5}; + #\u{136A6}; + #\u{136A7}; + #\u{136A8}; + #\u{136A9}; + #\u{136AA}; + #\u{136AB}; + #\u{136AC}; + #\u{136AD}; + #\u{136AE}; + #\u{136AF}; + #\u{136B0}; + #\u{136B1}; + #\u{136B2}; + #\u{136B3}; + #\u{136B4}; + #\u{136B5}; + #\u{136B6}; + #\u{136B7}; + #\u{136B8}; + #\u{136B9}; + #\u{136BA}; + #\u{136BB}; + #\u{136BC}; + #\u{136BD}; + #\u{136BE}; + #\u{136BF}; + #\u{136C0}; + #\u{136C1}; + #\u{136C2}; + #\u{136C3}; + #\u{136C4}; + #\u{136C5}; + #\u{136C6}; + #\u{136C7}; + #\u{136C8}; + #\u{136C9}; + #\u{136CA}; + #\u{136CB}; + #\u{136CC}; + #\u{136CD}; + #\u{136CE}; + #\u{136CF}; + #\u{136D0}; + #\u{136D1}; + #\u{136D2}; + #\u{136D3}; + #\u{136D4}; + #\u{136D5}; + #\u{136D6}; + #\u{136D7}; + #\u{136D8}; + #\u{136D9}; + #\u{136DA}; + #\u{136DB}; + #\u{136DC}; + #\u{136DD}; + #\u{136DE}; + #\u{136DF}; + #\u{136E0}; + #\u{136E1}; + #\u{136E2}; + #\u{136E3}; + #\u{136E4}; + #\u{136E5}; + #\u{136E6}; + #\u{136E7}; + #\u{136E8}; + #\u{136E9}; + #\u{136EA}; + #\u{136EB}; + #\u{136EC}; + #\u{136ED}; + #\u{136EE}; + #\u{136EF}; + #\u{136F0}; + #\u{136F1}; + #\u{136F2}; + #\u{136F3}; + #\u{136F4}; + #\u{136F5}; + #\u{136F6}; + #\u{136F7}; + #\u{136F8}; + #\u{136F9}; + #\u{136FA}; + #\u{136FB}; + #\u{136FC}; + #\u{136FD}; + #\u{136FE}; + #\u{136FF}; + #\u{13700}; + #\u{13701}; + #\u{13702}; + #\u{13703}; + #\u{13704}; + #\u{13705}; + #\u{13706}; + #\u{13707}; + #\u{13708}; + #\u{13709}; + #\u{1370A}; + #\u{1370B}; + #\u{1370C}; + #\u{1370D}; + #\u{1370E}; + #\u{1370F}; + #\u{13710}; + #\u{13711}; + #\u{13712}; + #\u{13713}; + #\u{13714}; + #\u{13715}; + #\u{13716}; + #\u{13717}; + #\u{13718}; + #\u{13719}; + #\u{1371A}; + #\u{1371B}; + #\u{1371C}; + #\u{1371D}; + #\u{1371E}; + #\u{1371F}; + #\u{13720}; + #\u{13721}; + #\u{13722}; + #\u{13723}; + #\u{13724}; + #\u{13725}; + #\u{13726}; + #\u{13727}; + #\u{13728}; + #\u{13729}; + #\u{1372A}; + #\u{1372B}; + #\u{1372C}; + #\u{1372D}; + #\u{1372E}; + #\u{1372F}; + #\u{13730}; + #\u{13731}; + #\u{13732}; + #\u{13733}; + #\u{13734}; + #\u{13735}; + #\u{13736}; + #\u{13737}; + #\u{13738}; + #\u{13739}; + #\u{1373A}; + #\u{1373B}; + #\u{1373C}; + #\u{1373D}; + #\u{1373E}; + #\u{1373F}; + #\u{13740}; + #\u{13741}; + #\u{13742}; + #\u{13743}; + #\u{13744}; + #\u{13745}; + #\u{13746}; + #\u{13747}; + #\u{13748}; + #\u{13749}; + #\u{1374A}; + #\u{1374B}; + #\u{1374C}; + #\u{1374D}; + #\u{1374E}; + #\u{1374F}; + #\u{13750}; + #\u{13751}; + #\u{13752}; + #\u{13753}; + #\u{13754}; + #\u{13755}; + #\u{13756}; + #\u{13757}; + #\u{13758}; + #\u{13759}; + #\u{1375A}; + #\u{1375B}; + #\u{1375C}; + #\u{1375D}; + #\u{1375E}; + #\u{1375F}; + #\u{13760}; + #\u{13761}; + #\u{13762}; + #\u{13763}; + #\u{13764}; + #\u{13765}; + #\u{13766}; + #\u{13767}; + #\u{13768}; + #\u{13769}; + #\u{1376A}; + #\u{1376B}; + #\u{1376C}; + #\u{1376D}; + #\u{1376E}; + #\u{1376F}; + #\u{13770}; + #\u{13771}; + #\u{13772}; + #\u{13773}; + #\u{13774}; + #\u{13775}; + #\u{13776}; + #\u{13777}; + #\u{13778}; + #\u{13779}; + #\u{1377A}; + #\u{1377B}; + #\u{1377C}; + #\u{1377D}; + #\u{1377E}; + #\u{1377F}; + #\u{13780}; + #\u{13781}; + #\u{13782}; + #\u{13783}; + #\u{13784}; + #\u{13785}; + #\u{13786}; + #\u{13787}; + #\u{13788}; + #\u{13789}; + #\u{1378A}; + #\u{1378B}; + #\u{1378C}; + #\u{1378D}; + #\u{1378E}; + #\u{1378F}; + #\u{13790}; + #\u{13791}; + #\u{13792}; + #\u{13793}; + #\u{13794}; + #\u{13795}; + #\u{13796}; + #\u{13797}; + #\u{13798}; + #\u{13799}; + #\u{1379A}; + #\u{1379B}; + #\u{1379C}; + #\u{1379D}; + #\u{1379E}; + #\u{1379F}; + #\u{137A0}; + #\u{137A1}; + #\u{137A2}; + #\u{137A3}; + #\u{137A4}; + #\u{137A5}; + #\u{137A6}; + #\u{137A7}; + #\u{137A8}; + #\u{137A9}; + #\u{137AA}; + #\u{137AB}; + #\u{137AC}; + #\u{137AD}; + #\u{137AE}; + #\u{137AF}; + #\u{137B0}; + #\u{137B1}; + #\u{137B2}; + #\u{137B3}; + #\u{137B4}; + #\u{137B5}; + #\u{137B6}; + #\u{137B7}; + #\u{137B8}; + #\u{137B9}; + #\u{137BA}; + #\u{137BB}; + #\u{137BC}; + #\u{137BD}; + #\u{137BE}; + #\u{137BF}; + #\u{137C0}; + #\u{137C1}; + #\u{137C2}; + #\u{137C3}; + #\u{137C4}; + #\u{137C5}; + #\u{137C6}; + #\u{137C7}; + #\u{137C8}; + #\u{137C9}; + #\u{137CA}; + #\u{137CB}; + #\u{137CC}; + #\u{137CD}; + #\u{137CE}; + #\u{137CF}; + #\u{137D0}; + #\u{137D1}; + #\u{137D2}; + #\u{137D3}; + #\u{137D4}; + #\u{137D5}; + #\u{137D6}; + #\u{137D7}; + #\u{137D8}; + #\u{137D9}; + #\u{137DA}; + #\u{137DB}; + #\u{137DC}; + #\u{137DD}; + #\u{137DE}; + #\u{137DF}; + #\u{137E0}; + #\u{137E1}; + #\u{137E2}; + #\u{137E3}; + #\u{137E4}; + #\u{137E5}; + #\u{137E6}; + #\u{137E7}; + #\u{137E8}; + #\u{137E9}; + #\u{137EA}; + #\u{137EB}; + #\u{137EC}; + #\u{137ED}; + #\u{137EE}; + #\u{137EF}; + #\u{137F0}; + #\u{137F1}; + #\u{137F2}; + #\u{137F3}; + #\u{137F4}; + #\u{137F5}; + #\u{137F6}; + #\u{137F7}; + #\u{137F8}; + #\u{137F9}; + #\u{137FA}; + #\u{137FB}; + #\u{137FC}; + #\u{137FD}; + #\u{137FE}; + #\u{137FF}; + #\u{13800}; + #\u{13801}; + #\u{13802}; + #\u{13803}; + #\u{13804}; + #\u{13805}; + #\u{13806}; + #\u{13807}; + #\u{13808}; + #\u{13809}; + #\u{1380A}; + #\u{1380B}; + #\u{1380C}; + #\u{1380D}; + #\u{1380E}; + #\u{1380F}; + #\u{13810}; + #\u{13811}; + #\u{13812}; + #\u{13813}; + #\u{13814}; + #\u{13815}; + #\u{13816}; + #\u{13817}; + #\u{13818}; + #\u{13819}; + #\u{1381A}; + #\u{1381B}; + #\u{1381C}; + #\u{1381D}; + #\u{1381E}; + #\u{1381F}; + #\u{13820}; + #\u{13821}; + #\u{13822}; + #\u{13823}; + #\u{13824}; + #\u{13825}; + #\u{13826}; + #\u{13827}; + #\u{13828}; + #\u{13829}; + #\u{1382A}; + #\u{1382B}; + #\u{1382C}; + #\u{1382D}; + #\u{1382E}; + #\u{1382F}; + #\u{13830}; + #\u{13831}; + #\u{13832}; + #\u{13833}; + #\u{13834}; + #\u{13835}; + #\u{13836}; + #\u{13837}; + #\u{13838}; + #\u{13839}; + #\u{1383A}; + #\u{1383B}; + #\u{1383C}; + #\u{1383D}; + #\u{1383E}; + #\u{1383F}; + #\u{13840}; + #\u{13841}; + #\u{13842}; + #\u{13843}; + #\u{13844}; + #\u{13845}; + #\u{13846}; + #\u{13847}; + #\u{13848}; + #\u{13849}; + #\u{1384A}; + #\u{1384B}; + #\u{1384C}; + #\u{1384D}; + #\u{1384E}; + #\u{1384F}; + #\u{13850}; + #\u{13851}; + #\u{13852}; + #\u{13853}; + #\u{13854}; + #\u{13855}; + #\u{13856}; + #\u{13857}; + #\u{13858}; + #\u{13859}; + #\u{1385A}; + #\u{1385B}; + #\u{1385C}; + #\u{1385D}; + #\u{1385E}; + #\u{1385F}; + #\u{13860}; + #\u{13861}; + #\u{13862}; + #\u{13863}; + #\u{13864}; + #\u{13865}; + #\u{13866}; + #\u{13867}; + #\u{13868}; + #\u{13869}; + #\u{1386A}; + #\u{1386B}; + #\u{1386C}; + #\u{1386D}; + #\u{1386E}; + #\u{1386F}; + #\u{13870}; + #\u{13871}; + #\u{13872}; + #\u{13873}; + #\u{13874}; + #\u{13875}; + #\u{13876}; + #\u{13877}; + #\u{13878}; + #\u{13879}; + #\u{1387A}; + #\u{1387B}; + #\u{1387C}; + #\u{1387D}; + #\u{1387E}; + #\u{1387F}; + #\u{13880}; + #\u{13881}; + #\u{13882}; + #\u{13883}; + #\u{13884}; + #\u{13885}; + #\u{13886}; + #\u{13887}; + #\u{13888}; + #\u{13889}; + #\u{1388A}; + #\u{1388B}; + #\u{1388C}; + #\u{1388D}; + #\u{1388E}; + #\u{1388F}; + #\u{13890}; + #\u{13891}; + #\u{13892}; + #\u{13893}; + #\u{13894}; + #\u{13895}; + #\u{13896}; + #\u{13897}; + #\u{13898}; + #\u{13899}; + #\u{1389A}; + #\u{1389B}; + #\u{1389C}; + #\u{1389D}; + #\u{1389E}; + #\u{1389F}; + #\u{138A0}; + #\u{138A1}; + #\u{138A2}; + #\u{138A3}; + #\u{138A4}; + #\u{138A5}; + #\u{138A6}; + #\u{138A7}; + #\u{138A8}; + #\u{138A9}; + #\u{138AA}; + #\u{138AB}; + #\u{138AC}; + #\u{138AD}; + #\u{138AE}; + #\u{138AF}; + #\u{138B0}; + #\u{138B1}; + #\u{138B2}; + #\u{138B3}; + #\u{138B4}; + #\u{138B5}; + #\u{138B6}; + #\u{138B7}; + #\u{138B8}; + #\u{138B9}; + #\u{138BA}; + #\u{138BB}; + #\u{138BC}; + #\u{138BD}; + #\u{138BE}; + #\u{138BF}; + #\u{138C0}; + #\u{138C1}; + #\u{138C2}; + #\u{138C3}; + #\u{138C4}; + #\u{138C5}; + #\u{138C6}; + #\u{138C7}; + #\u{138C8}; + #\u{138C9}; + #\u{138CA}; + #\u{138CB}; + #\u{138CC}; + #\u{138CD}; + #\u{138CE}; + #\u{138CF}; + #\u{138D0}; + #\u{138D1}; + #\u{138D2}; + #\u{138D3}; + #\u{138D4}; + #\u{138D5}; + #\u{138D6}; + #\u{138D7}; + #\u{138D8}; + #\u{138D9}; + #\u{138DA}; + #\u{138DB}; + #\u{138DC}; + #\u{138DD}; + #\u{138DE}; + #\u{138DF}; + #\u{138E0}; + #\u{138E1}; + #\u{138E2}; + #\u{138E3}; + #\u{138E4}; + #\u{138E5}; + #\u{138E6}; + #\u{138E7}; + #\u{138E8}; + #\u{138E9}; + #\u{138EA}; + #\u{138EB}; + #\u{138EC}; + #\u{138ED}; + #\u{138EE}; + #\u{138EF}; + #\u{138F0}; + #\u{138F1}; + #\u{138F2}; + #\u{138F3}; + #\u{138F4}; + #\u{138F5}; + #\u{138F6}; + #\u{138F7}; + #\u{138F8}; + #\u{138F9}; + #\u{138FA}; + #\u{138FB}; + #\u{138FC}; + #\u{138FD}; + #\u{138FE}; + #\u{138FF}; + #\u{13900}; + #\u{13901}; + #\u{13902}; + #\u{13903}; + #\u{13904}; + #\u{13905}; + #\u{13906}; + #\u{13907}; + #\u{13908}; + #\u{13909}; + #\u{1390A}; + #\u{1390B}; + #\u{1390C}; + #\u{1390D}; + #\u{1390E}; + #\u{1390F}; + #\u{13910}; + #\u{13911}; + #\u{13912}; + #\u{13913}; + #\u{13914}; + #\u{13915}; + #\u{13916}; + #\u{13917}; + #\u{13918}; + #\u{13919}; + #\u{1391A}; + #\u{1391B}; + #\u{1391C}; + #\u{1391D}; + #\u{1391E}; + #\u{1391F}; + #\u{13920}; + #\u{13921}; + #\u{13922}; + #\u{13923}; + #\u{13924}; + #\u{13925}; + #\u{13926}; + #\u{13927}; + #\u{13928}; + #\u{13929}; + #\u{1392A}; + #\u{1392B}; + #\u{1392C}; + #\u{1392D}; + #\u{1392E}; + #\u{1392F}; + #\u{13930}; + #\u{13931}; + #\u{13932}; + #\u{13933}; + #\u{13934}; + #\u{13935}; + #\u{13936}; + #\u{13937}; + #\u{13938}; + #\u{13939}; + #\u{1393A}; + #\u{1393B}; + #\u{1393C}; + #\u{1393D}; + #\u{1393E}; + #\u{1393F}; + #\u{13940}; + #\u{13941}; + #\u{13942}; + #\u{13943}; + #\u{13944}; + #\u{13945}; + #\u{13946}; + #\u{13947}; + #\u{13948}; + #\u{13949}; + #\u{1394A}; + #\u{1394B}; + #\u{1394C}; + #\u{1394D}; + #\u{1394E}; + #\u{1394F}; + #\u{13950}; + #\u{13951}; + #\u{13952}; + #\u{13953}; + #\u{13954}; + #\u{13955}; + #\u{13956}; + #\u{13957}; + #\u{13958}; + #\u{13959}; + #\u{1395A}; + #\u{1395B}; + #\u{1395C}; + #\u{1395D}; + #\u{1395E}; + #\u{1395F}; + #\u{13960}; + #\u{13961}; + #\u{13962}; + #\u{13963}; + #\u{13964}; + #\u{13965}; + #\u{13966}; + #\u{13967}; + #\u{13968}; + #\u{13969}; + #\u{1396A}; + #\u{1396B}; + #\u{1396C}; + #\u{1396D}; + #\u{1396E}; + #\u{1396F}; + #\u{13970}; + #\u{13971}; + #\u{13972}; + #\u{13973}; + #\u{13974}; + #\u{13975}; + #\u{13976}; + #\u{13977}; + #\u{13978}; + #\u{13979}; + #\u{1397A}; + #\u{1397B}; + #\u{1397C}; + #\u{1397D}; + #\u{1397E}; + #\u{1397F}; + #\u{13980}; + #\u{13981}; + #\u{13982}; + #\u{13983}; + #\u{13984}; + #\u{13985}; + #\u{13986}; + #\u{13987}; + #\u{13988}; + #\u{13989}; + #\u{1398A}; + #\u{1398B}; + #\u{1398C}; + #\u{1398D}; + #\u{1398E}; + #\u{1398F}; + #\u{13990}; + #\u{13991}; + #\u{13992}; + #\u{13993}; + #\u{13994}; + #\u{13995}; + #\u{13996}; + #\u{13997}; + #\u{13998}; + #\u{13999}; + #\u{1399A}; + #\u{1399B}; + #\u{1399C}; + #\u{1399D}; + #\u{1399E}; + #\u{1399F}; + #\u{139A0}; + #\u{139A1}; + #\u{139A2}; + #\u{139A3}; + #\u{139A4}; + #\u{139A5}; + #\u{139A6}; + #\u{139A7}; + #\u{139A8}; + #\u{139A9}; + #\u{139AA}; + #\u{139AB}; + #\u{139AC}; + #\u{139AD}; + #\u{139AE}; + #\u{139AF}; + #\u{139B0}; + #\u{139B1}; + #\u{139B2}; + #\u{139B3}; + #\u{139B4}; + #\u{139B5}; + #\u{139B6}; + #\u{139B7}; + #\u{139B8}; + #\u{139B9}; + #\u{139BA}; + #\u{139BB}; + #\u{139BC}; + #\u{139BD}; + #\u{139BE}; + #\u{139BF}; + #\u{139C0}; + #\u{139C1}; + #\u{139C2}; + #\u{139C3}; + #\u{139C4}; + #\u{139C5}; + #\u{139C6}; + #\u{139C7}; + #\u{139C8}; + #\u{139C9}; + #\u{139CA}; + #\u{139CB}; + #\u{139CC}; + #\u{139CD}; + #\u{139CE}; + #\u{139CF}; + #\u{139D0}; + #\u{139D1}; + #\u{139D2}; + #\u{139D3}; + #\u{139D4}; + #\u{139D5}; + #\u{139D6}; + #\u{139D7}; + #\u{139D8}; + #\u{139D9}; + #\u{139DA}; + #\u{139DB}; + #\u{139DC}; + #\u{139DD}; + #\u{139DE}; + #\u{139DF}; + #\u{139E0}; + #\u{139E1}; + #\u{139E2}; + #\u{139E3}; + #\u{139E4}; + #\u{139E5}; + #\u{139E6}; + #\u{139E7}; + #\u{139E8}; + #\u{139E9}; + #\u{139EA}; + #\u{139EB}; + #\u{139EC}; + #\u{139ED}; + #\u{139EE}; + #\u{139EF}; + #\u{139F0}; + #\u{139F1}; + #\u{139F2}; + #\u{139F3}; + #\u{139F4}; + #\u{139F5}; + #\u{139F6}; + #\u{139F7}; + #\u{139F8}; + #\u{139F9}; + #\u{139FA}; + #\u{139FB}; + #\u{139FC}; + #\u{139FD}; + #\u{139FE}; + #\u{139FF}; + #\u{13A00}; + #\u{13A01}; + #\u{13A02}; + #\u{13A03}; + #\u{13A04}; + #\u{13A05}; + #\u{13A06}; + #\u{13A07}; + #\u{13A08}; + #\u{13A09}; + #\u{13A0A}; + #\u{13A0B}; + #\u{13A0C}; + #\u{13A0D}; + #\u{13A0E}; + #\u{13A0F}; + #\u{13A10}; + #\u{13A11}; + #\u{13A12}; + #\u{13A13}; + #\u{13A14}; + #\u{13A15}; + #\u{13A16}; + #\u{13A17}; + #\u{13A18}; + #\u{13A19}; + #\u{13A1A}; + #\u{13A1B}; + #\u{13A1C}; + #\u{13A1D}; + #\u{13A1E}; + #\u{13A1F}; + #\u{13A20}; + #\u{13A21}; + #\u{13A22}; + #\u{13A23}; + #\u{13A24}; + #\u{13A25}; + #\u{13A26}; + #\u{13A27}; + #\u{13A28}; + #\u{13A29}; + #\u{13A2A}; + #\u{13A2B}; + #\u{13A2C}; + #\u{13A2D}; + #\u{13A2E}; + #\u{13A2F}; + #\u{13A30}; + #\u{13A31}; + #\u{13A32}; + #\u{13A33}; + #\u{13A34}; + #\u{13A35}; + #\u{13A36}; + #\u{13A37}; + #\u{13A38}; + #\u{13A39}; + #\u{13A3A}; + #\u{13A3B}; + #\u{13A3C}; + #\u{13A3D}; + #\u{13A3E}; + #\u{13A3F}; + #\u{13A40}; + #\u{13A41}; + #\u{13A42}; + #\u{13A43}; + #\u{13A44}; + #\u{13A45}; + #\u{13A46}; + #\u{13A47}; + #\u{13A48}; + #\u{13A49}; + #\u{13A4A}; + #\u{13A4B}; + #\u{13A4C}; + #\u{13A4D}; + #\u{13A4E}; + #\u{13A4F}; + #\u{13A50}; + #\u{13A51}; + #\u{13A52}; + #\u{13A53}; + #\u{13A54}; + #\u{13A55}; + #\u{13A56}; + #\u{13A57}; + #\u{13A58}; + #\u{13A59}; + #\u{13A5A}; + #\u{13A5B}; + #\u{13A5C}; + #\u{13A5D}; + #\u{13A5E}; + #\u{13A5F}; + #\u{13A60}; + #\u{13A61}; + #\u{13A62}; + #\u{13A63}; + #\u{13A64}; + #\u{13A65}; + #\u{13A66}; + #\u{13A67}; + #\u{13A68}; + #\u{13A69}; + #\u{13A6A}; + #\u{13A6B}; + #\u{13A6C}; + #\u{13A6D}; + #\u{13A6E}; + #\u{13A6F}; + #\u{13A70}; + #\u{13A71}; + #\u{13A72}; + #\u{13A73}; + #\u{13A74}; + #\u{13A75}; + #\u{13A76}; + #\u{13A77}; + #\u{13A78}; + #\u{13A79}; + #\u{13A7A}; + #\u{13A7B}; + #\u{13A7C}; + #\u{13A7D}; + #\u{13A7E}; + #\u{13A7F}; + #\u{13A80}; + #\u{13A81}; + #\u{13A82}; + #\u{13A83}; + #\u{13A84}; + #\u{13A85}; + #\u{13A86}; + #\u{13A87}; + #\u{13A88}; + #\u{13A89}; + #\u{13A8A}; + #\u{13A8B}; + #\u{13A8C}; + #\u{13A8D}; + #\u{13A8E}; + #\u{13A8F}; + #\u{13A90}; + #\u{13A91}; + #\u{13A92}; + #\u{13A93}; + #\u{13A94}; + #\u{13A95}; + #\u{13A96}; + #\u{13A97}; + #\u{13A98}; + #\u{13A99}; + #\u{13A9A}; + #\u{13A9B}; + #\u{13A9C}; + #\u{13A9D}; + #\u{13A9E}; + #\u{13A9F}; + #\u{13AA0}; + #\u{13AA1}; + #\u{13AA2}; + #\u{13AA3}; + #\u{13AA4}; + #\u{13AA5}; + #\u{13AA6}; + #\u{13AA7}; + #\u{13AA8}; + #\u{13AA9}; + #\u{13AAA}; + #\u{13AAB}; + #\u{13AAC}; + #\u{13AAD}; + #\u{13AAE}; + #\u{13AAF}; + #\u{13AB0}; + #\u{13AB1}; + #\u{13AB2}; + #\u{13AB3}; + #\u{13AB4}; + #\u{13AB5}; + #\u{13AB6}; + #\u{13AB7}; + #\u{13AB8}; + #\u{13AB9}; + #\u{13ABA}; + #\u{13ABB}; + #\u{13ABC}; + #\u{13ABD}; + #\u{13ABE}; + #\u{13ABF}; + #\u{13AC0}; + #\u{13AC1}; + #\u{13AC2}; + #\u{13AC3}; + #\u{13AC4}; + #\u{13AC5}; + #\u{13AC6}; + #\u{13AC7}; + #\u{13AC8}; + #\u{13AC9}; + #\u{13ACA}; + #\u{13ACB}; + #\u{13ACC}; + #\u{13ACD}; + #\u{13ACE}; + #\u{13ACF}; + #\u{13AD0}; + #\u{13AD1}; + #\u{13AD2}; + #\u{13AD3}; + #\u{13AD4}; + #\u{13AD5}; + #\u{13AD6}; + #\u{13AD7}; + #\u{13AD8}; + #\u{13AD9}; + #\u{13ADA}; + #\u{13ADB}; + #\u{13ADC}; + #\u{13ADD}; + #\u{13ADE}; + #\u{13ADF}; + #\u{13AE0}; + #\u{13AE1}; + #\u{13AE2}; + #\u{13AE3}; + #\u{13AE4}; + #\u{13AE5}; + #\u{13AE6}; + #\u{13AE7}; + #\u{13AE8}; + #\u{13AE9}; + #\u{13AEA}; + #\u{13AEB}; + #\u{13AEC}; + #\u{13AED}; + #\u{13AEE}; + #\u{13AEF}; + #\u{13AF0}; + #\u{13AF1}; + #\u{13AF2}; + #\u{13AF3}; + #\u{13AF4}; + #\u{13AF5}; + #\u{13AF6}; + #\u{13AF7}; + #\u{13AF8}; + #\u{13AF9}; + #\u{13AFA}; + #\u{13AFB}; + #\u{13AFC}; + #\u{13AFD}; + #\u{13AFE}; + #\u{13AFF}; + #\u{13B00}; + #\u{13B01}; + #\u{13B02}; + #\u{13B03}; + #\u{13B04}; + #\u{13B05}; + #\u{13B06}; + #\u{13B07}; + #\u{13B08}; + #\u{13B09}; + #\u{13B0A}; + #\u{13B0B}; + #\u{13B0C}; + #\u{13B0D}; + #\u{13B0E}; + #\u{13B0F}; + #\u{13B10}; + #\u{13B11}; + #\u{13B12}; + #\u{13B13}; + #\u{13B14}; + #\u{13B15}; + #\u{13B16}; + #\u{13B17}; + #\u{13B18}; + #\u{13B19}; + #\u{13B1A}; + #\u{13B1B}; + #\u{13B1C}; + #\u{13B1D}; + #\u{13B1E}; + #\u{13B1F}; + #\u{13B20}; + #\u{13B21}; + #\u{13B22}; + #\u{13B23}; + #\u{13B24}; + #\u{13B25}; + #\u{13B26}; + #\u{13B27}; + #\u{13B28}; + #\u{13B29}; + #\u{13B2A}; + #\u{13B2B}; + #\u{13B2C}; + #\u{13B2D}; + #\u{13B2E}; + #\u{13B2F}; + #\u{13B30}; + #\u{13B31}; + #\u{13B32}; + #\u{13B33}; + #\u{13B34}; + #\u{13B35}; + #\u{13B36}; + #\u{13B37}; + #\u{13B38}; + #\u{13B39}; + #\u{13B3A}; + #\u{13B3B}; + #\u{13B3C}; + #\u{13B3D}; + #\u{13B3E}; + #\u{13B3F}; + #\u{13B40}; + #\u{13B41}; + #\u{13B42}; + #\u{13B43}; + #\u{13B44}; + #\u{13B45}; + #\u{13B46}; + #\u{13B47}; + #\u{13B48}; + #\u{13B49}; + #\u{13B4A}; + #\u{13B4B}; + #\u{13B4C}; + #\u{13B4D}; + #\u{13B4E}; + #\u{13B4F}; + #\u{13B50}; + #\u{13B51}; + #\u{13B52}; + #\u{13B53}; + #\u{13B54}; + #\u{13B55}; + #\u{13B56}; + #\u{13B57}; + #\u{13B58}; + #\u{13B59}; + #\u{13B5A}; + #\u{13B5B}; + #\u{13B5C}; + #\u{13B5D}; + #\u{13B5E}; + #\u{13B5F}; + #\u{13B60}; + #\u{13B61}; + #\u{13B62}; + #\u{13B63}; + #\u{13B64}; + #\u{13B65}; + #\u{13B66}; + #\u{13B67}; + #\u{13B68}; + #\u{13B69}; + #\u{13B6A}; + #\u{13B6B}; + #\u{13B6C}; + #\u{13B6D}; + #\u{13B6E}; + #\u{13B6F}; + #\u{13B70}; + #\u{13B71}; + #\u{13B72}; + #\u{13B73}; + #\u{13B74}; + #\u{13B75}; + #\u{13B76}; + #\u{13B77}; + #\u{13B78}; + #\u{13B79}; + #\u{13B7A}; + #\u{13B7B}; + #\u{13B7C}; + #\u{13B7D}; + #\u{13B7E}; + #\u{13B7F}; + #\u{13B80}; + #\u{13B81}; + #\u{13B82}; + #\u{13B83}; + #\u{13B84}; + #\u{13B85}; + #\u{13B86}; + #\u{13B87}; + #\u{13B88}; + #\u{13B89}; + #\u{13B8A}; + #\u{13B8B}; + #\u{13B8C}; + #\u{13B8D}; + #\u{13B8E}; + #\u{13B8F}; + #\u{13B90}; + #\u{13B91}; + #\u{13B92}; + #\u{13B93}; + #\u{13B94}; + #\u{13B95}; + #\u{13B96}; + #\u{13B97}; + #\u{13B98}; + #\u{13B99}; + #\u{13B9A}; + #\u{13B9B}; + #\u{13B9C}; + #\u{13B9D}; + #\u{13B9E}; + #\u{13B9F}; + #\u{13BA0}; + #\u{13BA1}; + #\u{13BA2}; + #\u{13BA3}; + #\u{13BA4}; + #\u{13BA5}; + #\u{13BA6}; + #\u{13BA7}; + #\u{13BA8}; + #\u{13BA9}; + #\u{13BAA}; + #\u{13BAB}; + #\u{13BAC}; + #\u{13BAD}; + #\u{13BAE}; + #\u{13BAF}; + #\u{13BB0}; + #\u{13BB1}; + #\u{13BB2}; + #\u{13BB3}; + #\u{13BB4}; + #\u{13BB5}; + #\u{13BB6}; + #\u{13BB7}; + #\u{13BB8}; + #\u{13BB9}; + #\u{13BBA}; + #\u{13BBB}; + #\u{13BBC}; + #\u{13BBD}; + #\u{13BBE}; + #\u{13BBF}; + #\u{13BC0}; + #\u{13BC1}; + #\u{13BC2}; + #\u{13BC3}; + #\u{13BC4}; + #\u{13BC5}; + #\u{13BC6}; + #\u{13BC7}; + #\u{13BC8}; + #\u{13BC9}; + #\u{13BCA}; + #\u{13BCB}; + #\u{13BCC}; + #\u{13BCD}; + #\u{13BCE}; + #\u{13BCF}; + #\u{13BD0}; + #\u{13BD1}; + #\u{13BD2}; + #\u{13BD3}; + #\u{13BD4}; + #\u{13BD5}; + #\u{13BD6}; + #\u{13BD7}; + #\u{13BD8}; + #\u{13BD9}; + #\u{13BDA}; + #\u{13BDB}; + #\u{13BDC}; + #\u{13BDD}; + #\u{13BDE}; + #\u{13BDF}; + #\u{13BE0}; + #\u{13BE1}; + #\u{13BE2}; + #\u{13BE3}; + #\u{13BE4}; + #\u{13BE5}; + #\u{13BE6}; + #\u{13BE7}; + #\u{13BE8}; + #\u{13BE9}; + #\u{13BEA}; + #\u{13BEB}; + #\u{13BEC}; + #\u{13BED}; + #\u{13BEE}; + #\u{13BEF}; + #\u{13BF0}; + #\u{13BF1}; + #\u{13BF2}; + #\u{13BF3}; + #\u{13BF4}; + #\u{13BF5}; + #\u{13BF6}; + #\u{13BF7}; + #\u{13BF8}; + #\u{13BF9}; + #\u{13BFA}; + #\u{13BFB}; + #\u{13BFC}; + #\u{13BFD}; + #\u{13BFE}; + #\u{13BFF}; + #\u{13C00}; + #\u{13C01}; + #\u{13C02}; + #\u{13C03}; + #\u{13C04}; + #\u{13C05}; + #\u{13C06}; + #\u{13C07}; + #\u{13C08}; + #\u{13C09}; + #\u{13C0A}; + #\u{13C0B}; + #\u{13C0C}; + #\u{13C0D}; + #\u{13C0E}; + #\u{13C0F}; + #\u{13C10}; + #\u{13C11}; + #\u{13C12}; + #\u{13C13}; + #\u{13C14}; + #\u{13C15}; + #\u{13C16}; + #\u{13C17}; + #\u{13C18}; + #\u{13C19}; + #\u{13C1A}; + #\u{13C1B}; + #\u{13C1C}; + #\u{13C1D}; + #\u{13C1E}; + #\u{13C1F}; + #\u{13C20}; + #\u{13C21}; + #\u{13C22}; + #\u{13C23}; + #\u{13C24}; + #\u{13C25}; + #\u{13C26}; + #\u{13C27}; + #\u{13C28}; + #\u{13C29}; + #\u{13C2A}; + #\u{13C2B}; + #\u{13C2C}; + #\u{13C2D}; + #\u{13C2E}; + #\u{13C2F}; + #\u{13C30}; + #\u{13C31}; + #\u{13C32}; + #\u{13C33}; + #\u{13C34}; + #\u{13C35}; + #\u{13C36}; + #\u{13C37}; + #\u{13C38}; + #\u{13C39}; + #\u{13C3A}; + #\u{13C3B}; + #\u{13C3C}; + #\u{13C3D}; + #\u{13C3E}; + #\u{13C3F}; + #\u{13C40}; + #\u{13C41}; + #\u{13C42}; + #\u{13C43}; + #\u{13C44}; + #\u{13C45}; + #\u{13C46}; + #\u{13C47}; + #\u{13C48}; + #\u{13C49}; + #\u{13C4A}; + #\u{13C4B}; + #\u{13C4C}; + #\u{13C4D}; + #\u{13C4E}; + #\u{13C4F}; + #\u{13C50}; + #\u{13C51}; + #\u{13C52}; + #\u{13C53}; + #\u{13C54}; + #\u{13C55}; + #\u{13C56}; + #\u{13C57}; + #\u{13C58}; + #\u{13C59}; + #\u{13C5A}; + #\u{13C5B}; + #\u{13C5C}; + #\u{13C5D}; + #\u{13C5E}; + #\u{13C5F}; + #\u{13C60}; + #\u{13C61}; + #\u{13C62}; + #\u{13C63}; + #\u{13C64}; + #\u{13C65}; + #\u{13C66}; + #\u{13C67}; + #\u{13C68}; + #\u{13C69}; + #\u{13C6A}; + #\u{13C6B}; + #\u{13C6C}; + #\u{13C6D}; + #\u{13C6E}; + #\u{13C6F}; + #\u{13C70}; + #\u{13C71}; + #\u{13C72}; + #\u{13C73}; + #\u{13C74}; + #\u{13C75}; + #\u{13C76}; + #\u{13C77}; + #\u{13C78}; + #\u{13C79}; + #\u{13C7A}; + #\u{13C7B}; + #\u{13C7C}; + #\u{13C7D}; + #\u{13C7E}; + #\u{13C7F}; + #\u{13C80}; + #\u{13C81}; + #\u{13C82}; + #\u{13C83}; + #\u{13C84}; + #\u{13C85}; + #\u{13C86}; + #\u{13C87}; + #\u{13C88}; + #\u{13C89}; + #\u{13C8A}; + #\u{13C8B}; + #\u{13C8C}; + #\u{13C8D}; + #\u{13C8E}; + #\u{13C8F}; + #\u{13C90}; + #\u{13C91}; + #\u{13C92}; + #\u{13C93}; + #\u{13C94}; + #\u{13C95}; + #\u{13C96}; + #\u{13C97}; + #\u{13C98}; + #\u{13C99}; + #\u{13C9A}; + #\u{13C9B}; + #\u{13C9C}; + #\u{13C9D}; + #\u{13C9E}; + #\u{13C9F}; + #\u{13CA0}; + #\u{13CA1}; + #\u{13CA2}; + #\u{13CA3}; + #\u{13CA4}; + #\u{13CA5}; + #\u{13CA6}; + #\u{13CA7}; + #\u{13CA8}; + #\u{13CA9}; + #\u{13CAA}; + #\u{13CAB}; + #\u{13CAC}; + #\u{13CAD}; + #\u{13CAE}; + #\u{13CAF}; + #\u{13CB0}; + #\u{13CB1}; + #\u{13CB2}; + #\u{13CB3}; + #\u{13CB4}; + #\u{13CB5}; + #\u{13CB6}; + #\u{13CB7}; + #\u{13CB8}; + #\u{13CB9}; + #\u{13CBA}; + #\u{13CBB}; + #\u{13CBC}; + #\u{13CBD}; + #\u{13CBE}; + #\u{13CBF}; + #\u{13CC0}; + #\u{13CC1}; + #\u{13CC2}; + #\u{13CC3}; + #\u{13CC4}; + #\u{13CC5}; + #\u{13CC6}; + #\u{13CC7}; + #\u{13CC8}; + #\u{13CC9}; + #\u{13CCA}; + #\u{13CCB}; + #\u{13CCC}; + #\u{13CCD}; + #\u{13CCE}; + #\u{13CCF}; + #\u{13CD0}; + #\u{13CD1}; + #\u{13CD2}; + #\u{13CD3}; + #\u{13CD4}; + #\u{13CD5}; + #\u{13CD6}; + #\u{13CD7}; + #\u{13CD8}; + #\u{13CD9}; + #\u{13CDA}; + #\u{13CDB}; + #\u{13CDC}; + #\u{13CDD}; + #\u{13CDE}; + #\u{13CDF}; + #\u{13CE0}; + #\u{13CE1}; + #\u{13CE2}; + #\u{13CE3}; + #\u{13CE4}; + #\u{13CE5}; + #\u{13CE6}; + #\u{13CE7}; + #\u{13CE8}; + #\u{13CE9}; + #\u{13CEA}; + #\u{13CEB}; + #\u{13CEC}; + #\u{13CED}; + #\u{13CEE}; + #\u{13CEF}; + #\u{13CF0}; + #\u{13CF1}; + #\u{13CF2}; + #\u{13CF3}; + #\u{13CF4}; + #\u{13CF5}; + #\u{13CF6}; + #\u{13CF7}; + #\u{13CF8}; + #\u{13CF9}; + #\u{13CFA}; + #\u{13CFB}; + #\u{13CFC}; + #\u{13CFD}; + #\u{13CFE}; + #\u{13CFF}; + #\u{13D00}; + #\u{13D01}; + #\u{13D02}; + #\u{13D03}; + #\u{13D04}; + #\u{13D05}; + #\u{13D06}; + #\u{13D07}; + #\u{13D08}; + #\u{13D09}; + #\u{13D0A}; + #\u{13D0B}; + #\u{13D0C}; + #\u{13D0D}; + #\u{13D0E}; + #\u{13D0F}; + #\u{13D10}; + #\u{13D11}; + #\u{13D12}; + #\u{13D13}; + #\u{13D14}; + #\u{13D15}; + #\u{13D16}; + #\u{13D17}; + #\u{13D18}; + #\u{13D19}; + #\u{13D1A}; + #\u{13D1B}; + #\u{13D1C}; + #\u{13D1D}; + #\u{13D1E}; + #\u{13D1F}; + #\u{13D20}; + #\u{13D21}; + #\u{13D22}; + #\u{13D23}; + #\u{13D24}; + #\u{13D25}; + #\u{13D26}; + #\u{13D27}; + #\u{13D28}; + #\u{13D29}; + #\u{13D2A}; + #\u{13D2B}; + #\u{13D2C}; + #\u{13D2D}; + #\u{13D2E}; + #\u{13D2F}; + #\u{13D30}; + #\u{13D31}; + #\u{13D32}; + #\u{13D33}; + #\u{13D34}; + #\u{13D35}; + #\u{13D36}; + #\u{13D37}; + #\u{13D38}; + #\u{13D39}; + #\u{13D3A}; + #\u{13D3B}; + #\u{13D3C}; + #\u{13D3D}; + #\u{13D3E}; + #\u{13D3F}; + #\u{13D40}; + #\u{13D41}; + #\u{13D42}; + #\u{13D43}; + #\u{13D44}; + #\u{13D45}; + #\u{13D46}; + #\u{13D47}; + #\u{13D48}; + #\u{13D49}; + #\u{13D4A}; + #\u{13D4B}; + #\u{13D4C}; + #\u{13D4D}; + #\u{13D4E}; + #\u{13D4F}; + #\u{13D50}; + #\u{13D51}; + #\u{13D52}; + #\u{13D53}; + #\u{13D54}; + #\u{13D55}; + #\u{13D56}; + #\u{13D57}; + #\u{13D58}; + #\u{13D59}; + #\u{13D5A}; + #\u{13D5B}; + #\u{13D5C}; + #\u{13D5D}; + #\u{13D5E}; + #\u{13D5F}; + #\u{13D60}; + #\u{13D61}; + #\u{13D62}; + #\u{13D63}; + #\u{13D64}; + #\u{13D65}; + #\u{13D66}; + #\u{13D67}; + #\u{13D68}; + #\u{13D69}; + #\u{13D6A}; + #\u{13D6B}; + #\u{13D6C}; + #\u{13D6D}; + #\u{13D6E}; + #\u{13D6F}; + #\u{13D70}; + #\u{13D71}; + #\u{13D72}; + #\u{13D73}; + #\u{13D74}; + #\u{13D75}; + #\u{13D76}; + #\u{13D77}; + #\u{13D78}; + #\u{13D79}; + #\u{13D7A}; + #\u{13D7B}; + #\u{13D7C}; + #\u{13D7D}; + #\u{13D7E}; + #\u{13D7F}; + #\u{13D80}; + #\u{13D81}; + #\u{13D82}; + #\u{13D83}; + #\u{13D84}; + #\u{13D85}; + #\u{13D86}; + #\u{13D87}; + #\u{13D88}; + #\u{13D89}; + #\u{13D8A}; + #\u{13D8B}; + #\u{13D8C}; + #\u{13D8D}; + #\u{13D8E}; + #\u{13D8F}; + #\u{13D90}; + #\u{13D91}; + #\u{13D92}; + #\u{13D93}; + #\u{13D94}; + #\u{13D95}; + #\u{13D96}; + #\u{13D97}; + #\u{13D98}; + #\u{13D99}; + #\u{13D9A}; + #\u{13D9B}; + #\u{13D9C}; + #\u{13D9D}; + #\u{13D9E}; + #\u{13D9F}; + #\u{13DA0}; + #\u{13DA1}; + #\u{13DA2}; + #\u{13DA3}; + #\u{13DA4}; + #\u{13DA5}; + #\u{13DA6}; + #\u{13DA7}; + #\u{13DA8}; + #\u{13DA9}; + #\u{13DAA}; + #\u{13DAB}; + #\u{13DAC}; + #\u{13DAD}; + #\u{13DAE}; + #\u{13DAF}; + #\u{13DB0}; + #\u{13DB1}; + #\u{13DB2}; + #\u{13DB3}; + #\u{13DB4}; + #\u{13DB5}; + #\u{13DB6}; + #\u{13DB7}; + #\u{13DB8}; + #\u{13DB9}; + #\u{13DBA}; + #\u{13DBB}; + #\u{13DBC}; + #\u{13DBD}; + #\u{13DBE}; + #\u{13DBF}; + #\u{13DC0}; + #\u{13DC1}; + #\u{13DC2}; + #\u{13DC3}; + #\u{13DC4}; + #\u{13DC5}; + #\u{13DC6}; + #\u{13DC7}; + #\u{13DC8}; + #\u{13DC9}; + #\u{13DCA}; + #\u{13DCB}; + #\u{13DCC}; + #\u{13DCD}; + #\u{13DCE}; + #\u{13DCF}; + #\u{13DD0}; + #\u{13DD1}; + #\u{13DD2}; + #\u{13DD3}; + #\u{13DD4}; + #\u{13DD5}; + #\u{13DD6}; + #\u{13DD7}; + #\u{13DD8}; + #\u{13DD9}; + #\u{13DDA}; + #\u{13DDB}; + #\u{13DDC}; + #\u{13DDD}; + #\u{13DDE}; + #\u{13DDF}; + #\u{13DE0}; + #\u{13DE1}; + #\u{13DE2}; + #\u{13DE3}; + #\u{13DE4}; + #\u{13DE5}; + #\u{13DE6}; + #\u{13DE7}; + #\u{13DE8}; + #\u{13DE9}; + #\u{13DEA}; + #\u{13DEB}; + #\u{13DEC}; + #\u{13DED}; + #\u{13DEE}; + #\u{13DEF}; + #\u{13DF0}; + #\u{13DF1}; + #\u{13DF2}; + #\u{13DF3}; + #\u{13DF4}; + #\u{13DF5}; + #\u{13DF6}; + #\u{13DF7}; + #\u{13DF8}; + #\u{13DF9}; + #\u{13DFA}; + #\u{13DFB}; + #\u{13DFC}; + #\u{13DFD}; + #\u{13DFE}; + #\u{13DFF}; + #\u{13E00}; + #\u{13E01}; + #\u{13E02}; + #\u{13E03}; + #\u{13E04}; + #\u{13E05}; + #\u{13E06}; + #\u{13E07}; + #\u{13E08}; + #\u{13E09}; + #\u{13E0A}; + #\u{13E0B}; + #\u{13E0C}; + #\u{13E0D}; + #\u{13E0E}; + #\u{13E0F}; + #\u{13E10}; + #\u{13E11}; + #\u{13E12}; + #\u{13E13}; + #\u{13E14}; + #\u{13E15}; + #\u{13E16}; + #\u{13E17}; + #\u{13E18}; + #\u{13E19}; + #\u{13E1A}; + #\u{13E1B}; + #\u{13E1C}; + #\u{13E1D}; + #\u{13E1E}; + #\u{13E1F}; + #\u{13E20}; + #\u{13E21}; + #\u{13E22}; + #\u{13E23}; + #\u{13E24}; + #\u{13E25}; + #\u{13E26}; + #\u{13E27}; + #\u{13E28}; + #\u{13E29}; + #\u{13E2A}; + #\u{13E2B}; + #\u{13E2C}; + #\u{13E2D}; + #\u{13E2E}; + #\u{13E2F}; + #\u{13E30}; + #\u{13E31}; + #\u{13E32}; + #\u{13E33}; + #\u{13E34}; + #\u{13E35}; + #\u{13E36}; + #\u{13E37}; + #\u{13E38}; + #\u{13E39}; + #\u{13E3A}; + #\u{13E3B}; + #\u{13E3C}; + #\u{13E3D}; + #\u{13E3E}; + #\u{13E3F}; + #\u{13E40}; + #\u{13E41}; + #\u{13E42}; + #\u{13E43}; + #\u{13E44}; + #\u{13E45}; + #\u{13E46}; + #\u{13E47}; + #\u{13E48}; + #\u{13E49}; + #\u{13E4A}; + #\u{13E4B}; + #\u{13E4C}; + #\u{13E4D}; + #\u{13E4E}; + #\u{13E4F}; + #\u{13E50}; + #\u{13E51}; + #\u{13E52}; + #\u{13E53}; + #\u{13E54}; + #\u{13E55}; + #\u{13E56}; + #\u{13E57}; + #\u{13E58}; + #\u{13E59}; + #\u{13E5A}; + #\u{13E5B}; + #\u{13E5C}; + #\u{13E5D}; + #\u{13E5E}; + #\u{13E5F}; + #\u{13E60}; + #\u{13E61}; + #\u{13E62}; + #\u{13E63}; + #\u{13E64}; + #\u{13E65}; + #\u{13E66}; + #\u{13E67}; + #\u{13E68}; + #\u{13E69}; + #\u{13E6A}; + #\u{13E6B}; + #\u{13E6C}; + #\u{13E6D}; + #\u{13E6E}; + #\u{13E6F}; + #\u{13E70}; + #\u{13E71}; + #\u{13E72}; + #\u{13E73}; + #\u{13E74}; + #\u{13E75}; + #\u{13E76}; + #\u{13E77}; + #\u{13E78}; + #\u{13E79}; + #\u{13E7A}; + #\u{13E7B}; + #\u{13E7C}; + #\u{13E7D}; + #\u{13E7E}; + #\u{13E7F}; + #\u{13E80}; + #\u{13E81}; + #\u{13E82}; + #\u{13E83}; + #\u{13E84}; + #\u{13E85}; + #\u{13E86}; + #\u{13E87}; + #\u{13E88}; + #\u{13E89}; + #\u{13E8A}; + #\u{13E8B}; + #\u{13E8C}; + #\u{13E8D}; + #\u{13E8E}; + #\u{13E8F}; + #\u{13E90}; + #\u{13E91}; + #\u{13E92}; + #\u{13E93}; + #\u{13E94}; + #\u{13E95}; + #\u{13E96}; + #\u{13E97}; + #\u{13E98}; + #\u{13E99}; + #\u{13E9A}; + #\u{13E9B}; + #\u{13E9C}; + #\u{13E9D}; + #\u{13E9E}; + #\u{13E9F}; + #\u{13EA0}; + #\u{13EA1}; + #\u{13EA2}; + #\u{13EA3}; + #\u{13EA4}; + #\u{13EA5}; + #\u{13EA6}; + #\u{13EA7}; + #\u{13EA8}; + #\u{13EA9}; + #\u{13EAA}; + #\u{13EAB}; + #\u{13EAC}; + #\u{13EAD}; + #\u{13EAE}; + #\u{13EAF}; + #\u{13EB0}; + #\u{13EB1}; + #\u{13EB2}; + #\u{13EB3}; + #\u{13EB4}; + #\u{13EB5}; + #\u{13EB6}; + #\u{13EB7}; + #\u{13EB8}; + #\u{13EB9}; + #\u{13EBA}; + #\u{13EBB}; + #\u{13EBC}; + #\u{13EBD}; + #\u{13EBE}; + #\u{13EBF}; + #\u{13EC0}; + #\u{13EC1}; + #\u{13EC2}; + #\u{13EC3}; + #\u{13EC4}; + #\u{13EC5}; + #\u{13EC6}; + #\u{13EC7}; + #\u{13EC8}; + #\u{13EC9}; + #\u{13ECA}; + #\u{13ECB}; + #\u{13ECC}; + #\u{13ECD}; + #\u{13ECE}; + #\u{13ECF}; + #\u{13ED0}; + #\u{13ED1}; + #\u{13ED2}; + #\u{13ED3}; + #\u{13ED4}; + #\u{13ED5}; + #\u{13ED6}; + #\u{13ED7}; + #\u{13ED8}; + #\u{13ED9}; + #\u{13EDA}; + #\u{13EDB}; + #\u{13EDC}; + #\u{13EDD}; + #\u{13EDE}; + #\u{13EDF}; + #\u{13EE0}; + #\u{13EE1}; + #\u{13EE2}; + #\u{13EE3}; + #\u{13EE4}; + #\u{13EE5}; + #\u{13EE6}; + #\u{13EE7}; + #\u{13EE8}; + #\u{13EE9}; + #\u{13EEA}; + #\u{13EEB}; + #\u{13EEC}; + #\u{13EED}; + #\u{13EEE}; + #\u{13EEF}; + #\u{13EF0}; + #\u{13EF1}; + #\u{13EF2}; + #\u{13EF3}; + #\u{13EF4}; + #\u{13EF5}; + #\u{13EF6}; + #\u{13EF7}; + #\u{13EF8}; + #\u{13EF9}; + #\u{13EFA}; + #\u{13EFB}; + #\u{13EFC}; + #\u{13EFD}; + #\u{13EFE}; + #\u{13EFF}; + #\u{13F00}; + #\u{13F01}; + #\u{13F02}; + #\u{13F03}; + #\u{13F04}; + #\u{13F05}; + #\u{13F06}; + #\u{13F07}; + #\u{13F08}; + #\u{13F09}; + #\u{13F0A}; + #\u{13F0B}; + #\u{13F0C}; + #\u{13F0D}; + #\u{13F0E}; + #\u{13F0F}; + #\u{13F10}; + #\u{13F11}; + #\u{13F12}; + #\u{13F13}; + #\u{13F14}; + #\u{13F15}; + #\u{13F16}; + #\u{13F17}; + #\u{13F18}; + #\u{13F19}; + #\u{13F1A}; + #\u{13F1B}; + #\u{13F1C}; + #\u{13F1D}; + #\u{13F1E}; + #\u{13F1F}; + #\u{13F20}; + #\u{13F21}; + #\u{13F22}; + #\u{13F23}; + #\u{13F24}; + #\u{13F25}; + #\u{13F26}; + #\u{13F27}; + #\u{13F28}; + #\u{13F29}; + #\u{13F2A}; + #\u{13F2B}; + #\u{13F2C}; + #\u{13F2D}; + #\u{13F2E}; + #\u{13F2F}; + #\u{13F30}; + #\u{13F31}; + #\u{13F32}; + #\u{13F33}; + #\u{13F34}; + #\u{13F35}; + #\u{13F36}; + #\u{13F37}; + #\u{13F38}; + #\u{13F39}; + #\u{13F3A}; + #\u{13F3B}; + #\u{13F3C}; + #\u{13F3D}; + #\u{13F3E}; + #\u{13F3F}; + #\u{13F40}; + #\u{13F41}; + #\u{13F42}; + #\u{13F43}; + #\u{13F44}; + #\u{13F45}; + #\u{13F46}; + #\u{13F47}; + #\u{13F48}; + #\u{13F49}; + #\u{13F4A}; + #\u{13F4B}; + #\u{13F4C}; + #\u{13F4D}; + #\u{13F4E}; + #\u{13F4F}; + #\u{13F50}; + #\u{13F51}; + #\u{13F52}; + #\u{13F53}; + #\u{13F54}; + #\u{13F55}; + #\u{13F56}; + #\u{13F57}; + #\u{13F58}; + #\u{13F59}; + #\u{13F5A}; + #\u{13F5B}; + #\u{13F5C}; + #\u{13F5D}; + #\u{13F5E}; + #\u{13F5F}; + #\u{13F60}; + #\u{13F61}; + #\u{13F62}; + #\u{13F63}; + #\u{13F64}; + #\u{13F65}; + #\u{13F66}; + #\u{13F67}; + #\u{13F68}; + #\u{13F69}; + #\u{13F6A}; + #\u{13F6B}; + #\u{13F6C}; + #\u{13F6D}; + #\u{13F6E}; + #\u{13F6F}; + #\u{13F70}; + #\u{13F71}; + #\u{13F72}; + #\u{13F73}; + #\u{13F74}; + #\u{13F75}; + #\u{13F76}; + #\u{13F77}; + #\u{13F78}; + #\u{13F79}; + #\u{13F7A}; + #\u{13F7B}; + #\u{13F7C}; + #\u{13F7D}; + #\u{13F7E}; + #\u{13F7F}; + #\u{13F80}; + #\u{13F81}; + #\u{13F82}; + #\u{13F83}; + #\u{13F84}; + #\u{13F85}; + #\u{13F86}; + #\u{13F87}; + #\u{13F88}; + #\u{13F89}; + #\u{13F8A}; + #\u{13F8B}; + #\u{13F8C}; + #\u{13F8D}; + #\u{13F8E}; + #\u{13F8F}; + #\u{13F90}; + #\u{13F91}; + #\u{13F92}; + #\u{13F93}; + #\u{13F94}; + #\u{13F95}; + #\u{13F96}; + #\u{13F97}; + #\u{13F98}; + #\u{13F99}; + #\u{13F9A}; + #\u{13F9B}; + #\u{13F9C}; + #\u{13F9D}; + #\u{13F9E}; + #\u{13F9F}; + #\u{13FA0}; + #\u{13FA1}; + #\u{13FA2}; + #\u{13FA3}; + #\u{13FA4}; + #\u{13FA5}; + #\u{13FA6}; + #\u{13FA7}; + #\u{13FA8}; + #\u{13FA9}; + #\u{13FAA}; + #\u{13FAB}; + #\u{13FAC}; + #\u{13FAD}; + #\u{13FAE}; + #\u{13FAF}; + #\u{13FB0}; + #\u{13FB1}; + #\u{13FB2}; + #\u{13FB3}; + #\u{13FB4}; + #\u{13FB5}; + #\u{13FB6}; + #\u{13FB7}; + #\u{13FB8}; + #\u{13FB9}; + #\u{13FBA}; + #\u{13FBB}; + #\u{13FBC}; + #\u{13FBD}; + #\u{13FBE}; + #\u{13FBF}; + #\u{13FC0}; + #\u{13FC1}; + #\u{13FC2}; + #\u{13FC3}; + #\u{13FC4}; + #\u{13FC5}; + #\u{13FC6}; + #\u{13FC7}; + #\u{13FC8}; + #\u{13FC9}; + #\u{13FCA}; + #\u{13FCB}; + #\u{13FCC}; + #\u{13FCD}; + #\u{13FCE}; + #\u{13FCF}; + #\u{13FD0}; + #\u{13FD1}; + #\u{13FD2}; + #\u{13FD3}; + #\u{13FD4}; + #\u{13FD5}; + #\u{13FD6}; + #\u{13FD7}; + #\u{13FD8}; + #\u{13FD9}; + #\u{13FDA}; + #\u{13FDB}; + #\u{13FDC}; + #\u{13FDD}; + #\u{13FDE}; + #\u{13FDF}; + #\u{13FE0}; + #\u{13FE1}; + #\u{13FE2}; + #\u{13FE3}; + #\u{13FE4}; + #\u{13FE5}; + #\u{13FE6}; + #\u{13FE7}; + #\u{13FE8}; + #\u{13FE9}; + #\u{13FEA}; + #\u{13FEB}; + #\u{13FEC}; + #\u{13FED}; + #\u{13FEE}; + #\u{13FEF}; + #\u{13FF0}; + #\u{13FF1}; + #\u{13FF2}; + #\u{13FF3}; + #\u{13FF4}; + #\u{13FF5}; + #\u{13FF6}; + #\u{13FF7}; + #\u{13FF8}; + #\u{13FF9}; + #\u{13FFA}; + #\u{13FFB}; + #\u{13FFC}; + #\u{13FFD}; + #\u{13FFE}; + #\u{13FFF}; + #\u{14000}; + #\u{14001}; + #\u{14002}; + #\u{14003}; + #\u{14004}; + #\u{14005}; + #\u{14006}; + #\u{14007}; + #\u{14008}; + #\u{14009}; + #\u{1400A}; + #\u{1400B}; + #\u{1400C}; + #\u{1400D}; + #\u{1400E}; + #\u{1400F}; + #\u{14010}; + #\u{14011}; + #\u{14012}; + #\u{14013}; + #\u{14014}; + #\u{14015}; + #\u{14016}; + #\u{14017}; + #\u{14018}; + #\u{14019}; + #\u{1401A}; + #\u{1401B}; + #\u{1401C}; + #\u{1401D}; + #\u{1401E}; + #\u{1401F}; + #\u{14020}; + #\u{14021}; + #\u{14022}; + #\u{14023}; + #\u{14024}; + #\u{14025}; + #\u{14026}; + #\u{14027}; + #\u{14028}; + #\u{14029}; + #\u{1402A}; + #\u{1402B}; + #\u{1402C}; + #\u{1402D}; + #\u{1402E}; + #\u{1402F}; + #\u{14030}; + #\u{14031}; + #\u{14032}; + #\u{14033}; + #\u{14034}; + #\u{14035}; + #\u{14036}; + #\u{14037}; + #\u{14038}; + #\u{14039}; + #\u{1403A}; + #\u{1403B}; + #\u{1403C}; + #\u{1403D}; + #\u{1403E}; + #\u{1403F}; + #\u{14040}; + #\u{14041}; + #\u{14042}; + #\u{14043}; + #\u{14044}; + #\u{14045}; + #\u{14046}; + #\u{14047}; + #\u{14048}; + #\u{14049}; + #\u{1404A}; + #\u{1404B}; + #\u{1404C}; + #\u{1404D}; + #\u{1404E}; + #\u{1404F}; + #\u{14050}; + #\u{14051}; + #\u{14052}; + #\u{14053}; + #\u{14054}; + #\u{14055}; + #\u{14056}; + #\u{14057}; + #\u{14058}; + #\u{14059}; + #\u{1405A}; + #\u{1405B}; + #\u{1405C}; + #\u{1405D}; + #\u{1405E}; + #\u{1405F}; + #\u{14060}; + #\u{14061}; + #\u{14062}; + #\u{14063}; + #\u{14064}; + #\u{14065}; + #\u{14066}; + #\u{14067}; + #\u{14068}; + #\u{14069}; + #\u{1406A}; + #\u{1406B}; + #\u{1406C}; + #\u{1406D}; + #\u{1406E}; + #\u{1406F}; + #\u{14070}; + #\u{14071}; + #\u{14072}; + #\u{14073}; + #\u{14074}; + #\u{14075}; + #\u{14076}; + #\u{14077}; + #\u{14078}; + #\u{14079}; + #\u{1407A}; + #\u{1407B}; + #\u{1407C}; + #\u{1407D}; + #\u{1407E}; + #\u{1407F}; + #\u{14080}; + #\u{14081}; + #\u{14082}; + #\u{14083}; + #\u{14084}; + #\u{14085}; + #\u{14086}; + #\u{14087}; + #\u{14088}; + #\u{14089}; + #\u{1408A}; + #\u{1408B}; + #\u{1408C}; + #\u{1408D}; + #\u{1408E}; + #\u{1408F}; + #\u{14090}; + #\u{14091}; + #\u{14092}; + #\u{14093}; + #\u{14094}; + #\u{14095}; + #\u{14096}; + #\u{14097}; + #\u{14098}; + #\u{14099}; + #\u{1409A}; + #\u{1409B}; + #\u{1409C}; + #\u{1409D}; + #\u{1409E}; + #\u{1409F}; + #\u{140A0}; + #\u{140A1}; + #\u{140A2}; + #\u{140A3}; + #\u{140A4}; + #\u{140A5}; + #\u{140A6}; + #\u{140A7}; + #\u{140A8}; + #\u{140A9}; + #\u{140AA}; + #\u{140AB}; + #\u{140AC}; + #\u{140AD}; + #\u{140AE}; + #\u{140AF}; + #\u{140B0}; + #\u{140B1}; + #\u{140B2}; + #\u{140B3}; + #\u{140B4}; + #\u{140B5}; + #\u{140B6}; + #\u{140B7}; + #\u{140B8}; + #\u{140B9}; + #\u{140BA}; + #\u{140BB}; + #\u{140BC}; + #\u{140BD}; + #\u{140BE}; + #\u{140BF}; + #\u{140C0}; + #\u{140C1}; + #\u{140C2}; + #\u{140C3}; + #\u{140C4}; + #\u{140C5}; + #\u{140C6}; + #\u{140C7}; + #\u{140C8}; + #\u{140C9}; + #\u{140CA}; + #\u{140CB}; + #\u{140CC}; + #\u{140CD}; + #\u{140CE}; + #\u{140CF}; + #\u{140D0}; + #\u{140D1}; + #\u{140D2}; + #\u{140D3}; + #\u{140D4}; + #\u{140D5}; + #\u{140D6}; + #\u{140D7}; + #\u{140D8}; + #\u{140D9}; + #\u{140DA}; + #\u{140DB}; + #\u{140DC}; + #\u{140DD}; + #\u{140DE}; + #\u{140DF}; + #\u{140E0}; + #\u{140E1}; + #\u{140E2}; + #\u{140E3}; + #\u{140E4}; + #\u{140E5}; + #\u{140E6}; + #\u{140E7}; + #\u{140E8}; + #\u{140E9}; + #\u{140EA}; + #\u{140EB}; + #\u{140EC}; + #\u{140ED}; + #\u{140EE}; + #\u{140EF}; + #\u{140F0}; + #\u{140F1}; + #\u{140F2}; + #\u{140F3}; + #\u{140F4}; + #\u{140F5}; + #\u{140F6}; + #\u{140F7}; + #\u{140F8}; + #\u{140F9}; + #\u{140FA}; + #\u{140FB}; + #\u{140FC}; + #\u{140FD}; + #\u{140FE}; + #\u{140FF}; + #\u{14100}; + #\u{14101}; + #\u{14102}; + #\u{14103}; + #\u{14104}; + #\u{14105}; + #\u{14106}; + #\u{14107}; + #\u{14108}; + #\u{14109}; + #\u{1410A}; + #\u{1410B}; + #\u{1410C}; + #\u{1410D}; + #\u{1410E}; + #\u{1410F}; + #\u{14110}; + #\u{14111}; + #\u{14112}; + #\u{14113}; + #\u{14114}; + #\u{14115}; + #\u{14116}; + #\u{14117}; + #\u{14118}; + #\u{14119}; + #\u{1411A}; + #\u{1411B}; + #\u{1411C}; + #\u{1411D}; + #\u{1411E}; + #\u{1411F}; + #\u{14120}; + #\u{14121}; + #\u{14122}; + #\u{14123}; + #\u{14124}; + #\u{14125}; + #\u{14126}; + #\u{14127}; + #\u{14128}; + #\u{14129}; + #\u{1412A}; + #\u{1412B}; + #\u{1412C}; + #\u{1412D}; + #\u{1412E}; + #\u{1412F}; + #\u{14130}; + #\u{14131}; + #\u{14132}; + #\u{14133}; + #\u{14134}; + #\u{14135}; + #\u{14136}; + #\u{14137}; + #\u{14138}; + #\u{14139}; + #\u{1413A}; + #\u{1413B}; + #\u{1413C}; + #\u{1413D}; + #\u{1413E}; + #\u{1413F}; + #\u{14140}; + #\u{14141}; + #\u{14142}; + #\u{14143}; + #\u{14144}; + #\u{14145}; + #\u{14146}; + #\u{14147}; + #\u{14148}; + #\u{14149}; + #\u{1414A}; + #\u{1414B}; + #\u{1414C}; + #\u{1414D}; + #\u{1414E}; + #\u{1414F}; + #\u{14150}; + #\u{14151}; + #\u{14152}; + #\u{14153}; + #\u{14154}; + #\u{14155}; + #\u{14156}; + #\u{14157}; + #\u{14158}; + #\u{14159}; + #\u{1415A}; + #\u{1415B}; + #\u{1415C}; + #\u{1415D}; + #\u{1415E}; + #\u{1415F}; + #\u{14160}; + #\u{14161}; + #\u{14162}; + #\u{14163}; + #\u{14164}; + #\u{14165}; + #\u{14166}; + #\u{14167}; + #\u{14168}; + #\u{14169}; + #\u{1416A}; + #\u{1416B}; + #\u{1416C}; + #\u{1416D}; + #\u{1416E}; + #\u{1416F}; + #\u{14170}; + #\u{14171}; + #\u{14172}; + #\u{14173}; + #\u{14174}; + #\u{14175}; + #\u{14176}; + #\u{14177}; + #\u{14178}; + #\u{14179}; + #\u{1417A}; + #\u{1417B}; + #\u{1417C}; + #\u{1417D}; + #\u{1417E}; + #\u{1417F}; + #\u{14180}; + #\u{14181}; + #\u{14182}; + #\u{14183}; + #\u{14184}; + #\u{14185}; + #\u{14186}; + #\u{14187}; + #\u{14188}; + #\u{14189}; + #\u{1418A}; + #\u{1418B}; + #\u{1418C}; + #\u{1418D}; + #\u{1418E}; + #\u{1418F}; + #\u{14190}; + #\u{14191}; + #\u{14192}; + #\u{14193}; + #\u{14194}; + #\u{14195}; + #\u{14196}; + #\u{14197}; + #\u{14198}; + #\u{14199}; + #\u{1419A}; + #\u{1419B}; + #\u{1419C}; + #\u{1419D}; + #\u{1419E}; + #\u{1419F}; + #\u{141A0}; + #\u{141A1}; + #\u{141A2}; + #\u{141A3}; + #\u{141A4}; + #\u{141A5}; + #\u{141A6}; + #\u{141A7}; + #\u{141A8}; + #\u{141A9}; + #\u{141AA}; + #\u{141AB}; + #\u{141AC}; + #\u{141AD}; + #\u{141AE}; + #\u{141AF}; + #\u{141B0}; + #\u{141B1}; + #\u{141B2}; + #\u{141B3}; + #\u{141B4}; + #\u{141B5}; + #\u{141B6}; + #\u{141B7}; + #\u{141B8}; + #\u{141B9}; + #\u{141BA}; + #\u{141BB}; + #\u{141BC}; + #\u{141BD}; + #\u{141BE}; + #\u{141BF}; + #\u{141C0}; + #\u{141C1}; + #\u{141C2}; + #\u{141C3}; + #\u{141C4}; + #\u{141C5}; + #\u{141C6}; + #\u{141C7}; + #\u{141C8}; + #\u{141C9}; + #\u{141CA}; + #\u{141CB}; + #\u{141CC}; + #\u{141CD}; + #\u{141CE}; + #\u{141CF}; + #\u{141D0}; + #\u{141D1}; + #\u{141D2}; + #\u{141D3}; + #\u{141D4}; + #\u{141D5}; + #\u{141D6}; + #\u{141D7}; + #\u{141D8}; + #\u{141D9}; + #\u{141DA}; + #\u{141DB}; + #\u{141DC}; + #\u{141DD}; + #\u{141DE}; + #\u{141DF}; + #\u{141E0}; + #\u{141E1}; + #\u{141E2}; + #\u{141E3}; + #\u{141E4}; + #\u{141E5}; + #\u{141E6}; + #\u{141E7}; + #\u{141E8}; + #\u{141E9}; + #\u{141EA}; + #\u{141EB}; + #\u{141EC}; + #\u{141ED}; + #\u{141EE}; + #\u{141EF}; + #\u{141F0}; + #\u{141F1}; + #\u{141F2}; + #\u{141F3}; + #\u{141F4}; + #\u{141F5}; + #\u{141F6}; + #\u{141F7}; + #\u{141F8}; + #\u{141F9}; + #\u{141FA}; + #\u{141FB}; + #\u{141FC}; + #\u{141FD}; + #\u{141FE}; + #\u{141FF}; + #\u{14200}; + #\u{14201}; + #\u{14202}; + #\u{14203}; + #\u{14204}; + #\u{14205}; + #\u{14206}; + #\u{14207}; + #\u{14208}; + #\u{14209}; + #\u{1420A}; + #\u{1420B}; + #\u{1420C}; + #\u{1420D}; + #\u{1420E}; + #\u{1420F}; + #\u{14210}; + #\u{14211}; + #\u{14212}; + #\u{14213}; + #\u{14214}; + #\u{14215}; + #\u{14216}; + #\u{14217}; + #\u{14218}; + #\u{14219}; + #\u{1421A}; + #\u{1421B}; + #\u{1421C}; + #\u{1421D}; + #\u{1421E}; + #\u{1421F}; + #\u{14220}; + #\u{14221}; + #\u{14222}; + #\u{14223}; + #\u{14224}; + #\u{14225}; + #\u{14226}; + #\u{14227}; + #\u{14228}; + #\u{14229}; + #\u{1422A}; + #\u{1422B}; + #\u{1422C}; + #\u{1422D}; + #\u{1422E}; + #\u{1422F}; + #\u{14230}; + #\u{14231}; + #\u{14232}; + #\u{14233}; + #\u{14234}; + #\u{14235}; + #\u{14236}; + #\u{14237}; + #\u{14238}; + #\u{14239}; + #\u{1423A}; + #\u{1423B}; + #\u{1423C}; + #\u{1423D}; + #\u{1423E}; + #\u{1423F}; + #\u{14240}; + #\u{14241}; + #\u{14242}; + #\u{14243}; + #\u{14244}; + #\u{14245}; + #\u{14246}; + #\u{14247}; + #\u{14248}; + #\u{14249}; + #\u{1424A}; + #\u{1424B}; + #\u{1424C}; + #\u{1424D}; + #\u{1424E}; + #\u{1424F}; + #\u{14250}; + #\u{14251}; + #\u{14252}; + #\u{14253}; + #\u{14254}; + #\u{14255}; + #\u{14256}; + #\u{14257}; + #\u{14258}; + #\u{14259}; + #\u{1425A}; + #\u{1425B}; + #\u{1425C}; + #\u{1425D}; + #\u{1425E}; + #\u{1425F}; + #\u{14260}; + #\u{14261}; + #\u{14262}; + #\u{14263}; + #\u{14264}; + #\u{14265}; + #\u{14266}; + #\u{14267}; + #\u{14268}; + #\u{14269}; + #\u{1426A}; + #\u{1426B}; + #\u{1426C}; + #\u{1426D}; + #\u{1426E}; + #\u{1426F}; + #\u{14270}; + #\u{14271}; + #\u{14272}; + #\u{14273}; + #\u{14274}; + #\u{14275}; + #\u{14276}; + #\u{14277}; + #\u{14278}; + #\u{14279}; + #\u{1427A}; + #\u{1427B}; + #\u{1427C}; + #\u{1427D}; + #\u{1427E}; + #\u{1427F}; + #\u{14280}; + #\u{14281}; + #\u{14282}; + #\u{14283}; + #\u{14284}; + #\u{14285}; + #\u{14286}; + #\u{14287}; + #\u{14288}; + #\u{14289}; + #\u{1428A}; + #\u{1428B}; + #\u{1428C}; + #\u{1428D}; + #\u{1428E}; + #\u{1428F}; + #\u{14290}; + #\u{14291}; + #\u{14292}; + #\u{14293}; + #\u{14294}; + #\u{14295}; + #\u{14296}; + #\u{14297}; + #\u{14298}; + #\u{14299}; + #\u{1429A}; + #\u{1429B}; + #\u{1429C}; + #\u{1429D}; + #\u{1429E}; + #\u{1429F}; + #\u{142A0}; + #\u{142A1}; + #\u{142A2}; + #\u{142A3}; + #\u{142A4}; + #\u{142A5}; + #\u{142A6}; + #\u{142A7}; + #\u{142A8}; + #\u{142A9}; + #\u{142AA}; + #\u{142AB}; + #\u{142AC}; + #\u{142AD}; + #\u{142AE}; + #\u{142AF}; + #\u{142B0}; + #\u{142B1}; + #\u{142B2}; + #\u{142B3}; + #\u{142B4}; + #\u{142B5}; + #\u{142B6}; + #\u{142B7}; + #\u{142B8}; + #\u{142B9}; + #\u{142BA}; + #\u{142BB}; + #\u{142BC}; + #\u{142BD}; + #\u{142BE}; + #\u{142BF}; + #\u{142C0}; + #\u{142C1}; + #\u{142C2}; + #\u{142C3}; + #\u{142C4}; + #\u{142C5}; + #\u{142C6}; + #\u{142C7}; + #\u{142C8}; + #\u{142C9}; + #\u{142CA}; + #\u{142CB}; + #\u{142CC}; + #\u{142CD}; + #\u{142CE}; + #\u{142CF}; + #\u{142D0}; + #\u{142D1}; + #\u{142D2}; + #\u{142D3}; + #\u{142D4}; + #\u{142D5}; + #\u{142D6}; + #\u{142D7}; + #\u{142D8}; + #\u{142D9}; + #\u{142DA}; + #\u{142DB}; + #\u{142DC}; + #\u{142DD}; + #\u{142DE}; + #\u{142DF}; + #\u{142E0}; + #\u{142E1}; + #\u{142E2}; + #\u{142E3}; + #\u{142E4}; + #\u{142E5}; + #\u{142E6}; + #\u{142E7}; + #\u{142E8}; + #\u{142E9}; + #\u{142EA}; + #\u{142EB}; + #\u{142EC}; + #\u{142ED}; + #\u{142EE}; + #\u{142EF}; + #\u{142F0}; + #\u{142F1}; + #\u{142F2}; + #\u{142F3}; + #\u{142F4}; + #\u{142F5}; + #\u{142F6}; + #\u{142F7}; + #\u{142F8}; + #\u{142F9}; + #\u{142FA}; + #\u{142FB}; + #\u{142FC}; + #\u{142FD}; + #\u{142FE}; + #\u{142FF}; + #\u{14300}; + #\u{14301}; + #\u{14302}; + #\u{14303}; + #\u{14304}; + #\u{14305}; + #\u{14306}; + #\u{14307}; + #\u{14308}; + #\u{14309}; + #\u{1430A}; + #\u{1430B}; + #\u{1430C}; + #\u{1430D}; + #\u{1430E}; + #\u{1430F}; + #\u{14310}; + #\u{14311}; + #\u{14312}; + #\u{14313}; + #\u{14314}; + #\u{14315}; + #\u{14316}; + #\u{14317}; + #\u{14318}; + #\u{14319}; + #\u{1431A}; + #\u{1431B}; + #\u{1431C}; + #\u{1431D}; + #\u{1431E}; + #\u{1431F}; + #\u{14320}; + #\u{14321}; + #\u{14322}; + #\u{14323}; + #\u{14324}; + #\u{14325}; + #\u{14326}; + #\u{14327}; + #\u{14328}; + #\u{14329}; + #\u{1432A}; + #\u{1432B}; + #\u{1432C}; + #\u{1432D}; + #\u{1432E}; + #\u{1432F}; + #\u{14330}; + #\u{14331}; + #\u{14332}; + #\u{14333}; + #\u{14334}; + #\u{14335}; + #\u{14336}; + #\u{14337}; + #\u{14338}; + #\u{14339}; + #\u{1433A}; + #\u{1433B}; + #\u{1433C}; + #\u{1433D}; + #\u{1433E}; + #\u{1433F}; + #\u{14340}; + #\u{14341}; + #\u{14342}; + #\u{14343}; + #\u{14344}; + #\u{14345}; + #\u{14346}; + #\u{14347}; + #\u{14348}; + #\u{14349}; + #\u{1434A}; + #\u{1434B}; + #\u{1434C}; + #\u{1434D}; + #\u{1434E}; + #\u{1434F}; + #\u{14350}; + #\u{14351}; + #\u{14352}; + #\u{14353}; + #\u{14354}; + #\u{14355}; + #\u{14356}; + #\u{14357}; + #\u{14358}; + #\u{14359}; + #\u{1435A}; + #\u{1435B}; + #\u{1435C}; + #\u{1435D}; + #\u{1435E}; + #\u{1435F}; + #\u{14360}; + #\u{14361}; + #\u{14362}; + #\u{14363}; + #\u{14364}; + #\u{14365}; + #\u{14366}; + #\u{14367}; + #\u{14368}; + #\u{14369}; + #\u{1436A}; + #\u{1436B}; + #\u{1436C}; + #\u{1436D}; + #\u{1436E}; + #\u{1436F}; + #\u{14370}; + #\u{14371}; + #\u{14372}; + #\u{14373}; + #\u{14374}; + #\u{14375}; + #\u{14376}; + #\u{14377}; + #\u{14378}; + #\u{14379}; + #\u{1437A}; + #\u{1437B}; + #\u{1437C}; + #\u{1437D}; + #\u{1437E}; + #\u{1437F}; + #\u{14380}; + #\u{14381}; + #\u{14382}; + #\u{14383}; + #\u{14384}; + #\u{14385}; + #\u{14386}; + #\u{14387}; + #\u{14388}; + #\u{14389}; + #\u{1438A}; + #\u{1438B}; + #\u{1438C}; + #\u{1438D}; + #\u{1438E}; + #\u{1438F}; + #\u{14390}; + #\u{14391}; + #\u{14392}; + #\u{14393}; + #\u{14394}; + #\u{14395}; + #\u{14396}; + #\u{14397}; + #\u{14398}; + #\u{14399}; + #\u{1439A}; + #\u{1439B}; + #\u{1439C}; + #\u{1439D}; + #\u{1439E}; + #\u{1439F}; + #\u{143A0}; + #\u{143A1}; + #\u{143A2}; + #\u{143A3}; + #\u{143A4}; + #\u{143A5}; + #\u{143A6}; + #\u{143A7}; + #\u{143A8}; + #\u{143A9}; + #\u{143AA}; + #\u{143AB}; + #\u{143AC}; + #\u{143AD}; + #\u{143AE}; + #\u{143AF}; + #\u{143B0}; + #\u{143B1}; + #\u{143B2}; + #\u{143B3}; + #\u{143B4}; + #\u{143B5}; + #\u{143B6}; + #\u{143B7}; + #\u{143B8}; + #\u{143B9}; + #\u{143BA}; + #\u{143BB}; + #\u{143BC}; + #\u{143BD}; + #\u{143BE}; + #\u{143BF}; + #\u{143C0}; + #\u{143C1}; + #\u{143C2}; + #\u{143C3}; + #\u{143C4}; + #\u{143C5}; + #\u{143C6}; + #\u{143C7}; + #\u{143C8}; + #\u{143C9}; + #\u{143CA}; + #\u{143CB}; + #\u{143CC}; + #\u{143CD}; + #\u{143CE}; + #\u{143CF}; + #\u{143D0}; + #\u{143D1}; + #\u{143D2}; + #\u{143D3}; + #\u{143D4}; + #\u{143D5}; + #\u{143D6}; + #\u{143D7}; + #\u{143D8}; + #\u{143D9}; + #\u{143DA}; + #\u{143DB}; + #\u{143DC}; + #\u{143DD}; + #\u{143DE}; + #\u{143DF}; + #\u{143E0}; + #\u{143E1}; + #\u{143E2}; + #\u{143E3}; + #\u{143E4}; + #\u{143E5}; + #\u{143E6}; + #\u{143E7}; + #\u{143E8}; + #\u{143E9}; + #\u{143EA}; + #\u{143EB}; + #\u{143EC}; + #\u{143ED}; + #\u{143EE}; + #\u{143EF}; + #\u{143F0}; + #\u{143F1}; + #\u{143F2}; + #\u{143F3}; + #\u{143F4}; + #\u{143F5}; + #\u{143F6}; + #\u{143F7}; + #\u{143F8}; + #\u{143F9}; + #\u{143FA}; + #\u{16100}; + #\u{16101}; + #\u{16102}; + #\u{16103}; + #\u{16104}; + #\u{16105}; + #\u{16106}; + #\u{16107}; + #\u{16108}; + #\u{16109}; + #\u{1610A}; + #\u{1610B}; + #\u{1610C}; + #\u{1610D}; + #\u{1610E}; + #\u{1610F}; + #\u{16110}; + #\u{16111}; + #\u{16112}; + #\u{16113}; + #\u{16114}; + #\u{16115}; + #\u{16116}; + #\u{16117}; + #\u{16118}; + #\u{16119}; + #\u{1611A}; + #\u{1611B}; + #\u{1611C}; + #\u{1611D}; + #\u{16D40}; + #\u{16D41}; + #\u{16D42}; + #\u{16D43}; + #\u{16D44}; + #\u{16D45}; + #\u{16D46}; + #\u{16D47}; + #\u{16D48}; + #\u{16D49}; + #\u{16D4A}; + #\u{16D4B}; + #\u{16D4C}; + #\u{16D4D}; + #\u{16D4E}; + #\u{16D4F}; + #\u{16D50}; + #\u{16D51}; + #\u{16D52}; + #\u{16D53}; + #\u{16D54}; + #\u{16D55}; + #\u{16D56}; + #\u{16D57}; + #\u{16D58}; + #\u{16D59}; + #\u{16D5A}; + #\u{16D5B}; + #\u{16D5C}; + #\u{16D5D}; + #\u{16D5E}; + #\u{16D5F}; + #\u{16D60}; + #\u{16D61}; + #\u{16D62}; + #\u{16D63}; + #\u{16D64}; + #\u{16D65}; + #\u{16D66}; + #\u{16D67}; + #\u{16D68}; + #\u{16D69}; + #\u{16D6A}; + #\u{16D6B}; + #\u{16D6C}; + #\u{18CFF}; + #\u{1E5D0}; + #\u{1E5D1}; + #\u{1E5D2}; + #\u{1E5D3}; + #\u{1E5D4}; + #\u{1E5D5}; + #\u{1E5D6}; + #\u{1E5D7}; + #\u{1E5D8}; + #\u{1E5D9}; + #\u{1E5DA}; + #\u{1E5DB}; + #\u{1E5DC}; + #\u{1E5DD}; + #\u{1E5DE}; + #\u{1E5DF}; + #\u{1E5E0}; + #\u{1E5E1}; + #\u{1E5E2}; + #\u{1E5E3}; + #\u{1E5E4}; + #\u{1E5E5}; + #\u{1E5E6}; + #\u{1E5E7}; + #\u{1E5E8}; + #\u{1E5E9}; + #\u{1E5EA}; + #\u{1E5EB}; + #\u{1E5EC}; + #\u{1E5ED}; + #\u{1E5F0}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0-class.js new file mode 100644 index 000000000..4a5d63a7d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0-class.js @@ -0,0 +1,4318 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v16.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #Ᲊ; + #ᲊ; + #Ɤ; + #Ꟍ; + #ꟍ; + #Ꟛ; + #ꟛ; + #Ƛ; + #𐗀; + #𐗁; + #𐗂; + #𐗃; + #𐗄; + #𐗅; + #𐗆; + #𐗇; + #𐗈; + #𐗉; + #𐗊; + #𐗋; + #𐗌; + #𐗍; + #𐗎; + #𐗏; + #𐗐; + #𐗑; + #𐗒; + #𐗓; + #𐗔; + #𐗕; + #𐗖; + #𐗗; + #𐗘; + #𐗙; + #𐗚; + #𐗛; + #𐗜; + #𐗝; + #𐗞; + #𐗟; + #𐗠; + #𐗡; + #𐗢; + #𐗣; + #𐗤; + #𐗥; + #𐗦; + #𐗧; + #𐗨; + #𐗩; + #𐗪; + #𐗫; + #𐗬; + #𐗭; + #𐗮; + #𐗯; + #𐗰; + #𐗱; + #𐗲; + #𐗳; + #𐵊; + #𐵋; + #𐵌; + #𐵍; + #𐵎; + #𐵏; + #𐵐; + #𐵑; + #𐵒; + #𐵓; + #𐵔; + #𐵕; + #𐵖; + #𐵗; + #𐵘; + #𐵙; + #𐵚; + #𐵛; + #𐵜; + #𐵝; + #𐵞; + #𐵟; + #𐵠; + #𐵡; + #𐵢; + #𐵣; + #𐵤; + #𐵥; + #𐵯; + #𐵰; + #𐵱; + #𐵲; + #𐵳; + #𐵴; + #𐵵; + #𐵶; + #𐵷; + #𐵸; + #𐵹; + #𐵺; + #𐵻; + #𐵼; + #𐵽; + #𐵾; + #𐵿; + #𐶀; + #𐶁; + #𐶂; + #𐶃; + #𐶄; + #𐶅; + #𐻂; + #𐻃; + #𐻄; + #𑎀; + #𑎁; + #𑎂; + #𑎃; + #𑎄; + #𑎅; + #𑎆; + #𑎇; + #𑎈; + #𑎉; + #𑎋; + #𑎎; + #𑎐; + #𑎑; + #𑎒; + #𑎓; + #𑎔; + #𑎕; + #𑎖; + #𑎗; + #𑎘; + #𑎙; + #𑎚; + #𑎛; + #𑎜; + #𑎝; + #𑎞; + #𑎟; + #𑎠; + #𑎡; + #𑎢; + #𑎣; + #𑎤; + #𑎥; + #𑎦; + #𑎧; + #𑎨; + #𑎩; + #𑎪; + #𑎫; + #𑎬; + #𑎭; + #𑎮; + #𑎯; + #𑎰; + #𑎱; + #𑎲; + #𑎳; + #𑎴; + #𑎵; + #𑎷; + #𑏑; + #𑏓; + #𑯀; + #𑯁; + #𑯂; + #𑯃; + #𑯄; + #𑯅; + #𑯆; + #𑯇; + #𑯈; + #𑯉; + #𑯊; + #𑯋; + #𑯌; + #𑯍; + #𑯎; + #𑯏; + #𑯐; + #𑯑; + #𑯒; + #𑯓; + #𑯔; + #𑯕; + #𑯖; + #𑯗; + #𑯘; + #𑯙; + #𑯚; + #𑯛; + #𑯜; + #𑯝; + #𑯞; + #𑯟; + #𑯠; + #𓑠; + #𓑡; + #𓑢; + #𓑣; + #𓑤; + #𓑥; + #𓑦; + #𓑧; + #𓑨; + #𓑩; + #𓑪; + #𓑫; + #𓑬; + #𓑭; + #𓑮; + #𓑯; + #𓑰; + #𓑱; + #𓑲; + #𓑳; + #𓑴; + #𓑵; + #𓑶; + #𓑷; + #𓑸; + #𓑹; + #𓑺; + #𓑻; + #𓑼; + #𓑽; + #𓑾; + #𓑿; + #𓒀; + #𓒁; + #𓒂; + #𓒃; + #𓒄; + #𓒅; + #𓒆; + #𓒇; + #𓒈; + #𓒉; + #𓒊; + #𓒋; + #𓒌; + #𓒍; + #𓒎; + #𓒏; + #𓒐; + #𓒑; + #𓒒; + #𓒓; + #𓒔; + #𓒕; + #𓒖; + #𓒗; + #𓒘; + #𓒙; + #𓒚; + #𓒛; + #𓒜; + #𓒝; + #𓒞; + #𓒟; + #𓒠; + #𓒡; + #𓒢; + #𓒣; + #𓒤; + #𓒥; + #𓒦; + #𓒧; + #𓒨; + #𓒩; + #𓒪; + #𓒫; + #𓒬; + #𓒭; + #𓒮; + #𓒯; + #𓒰; + #𓒱; + #𓒲; + #𓒳; + #𓒴; + #𓒵; + #𓒶; + #𓒷; + #𓒸; + #𓒹; + #𓒺; + #𓒻; + #𓒼; + #𓒽; + #𓒾; + #𓒿; + #𓓀; + #𓓁; + #𓓂; + #𓓃; + #𓓄; + #𓓅; + #𓓆; + #𓓇; + #𓓈; + #𓓉; + #𓓊; + #𓓋; + #𓓌; + #𓓍; + #𓓎; + #𓓏; + #𓓐; + #𓓑; + #𓓒; + #𓓓; + #𓓔; + #𓓕; + #𓓖; + #𓓗; + #𓓘; + #𓓙; + #𓓚; + #𓓛; + #𓓜; + #𓓝; + #𓓞; + #𓓟; + #𓓠; + #𓓡; + #𓓢; + #𓓣; + #𓓤; + #𓓥; + #𓓦; + #𓓧; + #𓓨; + #𓓩; + #𓓪; + #𓓫; + #𓓬; + #𓓭; + #𓓮; + #𓓯; + #𓓰; + #𓓱; + #𓓲; + #𓓳; + #𓓴; + #𓓵; + #𓓶; + #𓓷; + #𓓸; + #𓓹; + #𓓺; + #𓓻; + #𓓼; + #𓓽; + #𓓾; + #𓓿; + #𓔀; + #𓔁; + #𓔂; + #𓔃; + #𓔄; + #𓔅; + #𓔆; + #𓔇; + #𓔈; + #𓔉; + #𓔊; + #𓔋; + #𓔌; + #𓔍; + #𓔎; + #𓔏; + #𓔐; + #𓔑; + #𓔒; + #𓔓; + #𓔔; + #𓔕; + #𓔖; + #𓔗; + #𓔘; + #𓔙; + #𓔚; + #𓔛; + #𓔜; + #𓔝; + #𓔞; + #𓔟; + #𓔠; + #𓔡; + #𓔢; + #𓔣; + #𓔤; + #𓔥; + #𓔦; + #𓔧; + #𓔨; + #𓔩; + #𓔪; + #𓔫; + #𓔬; + #𓔭; + #𓔮; + #𓔯; + #𓔰; + #𓔱; + #𓔲; + #𓔳; + #𓔴; + #𓔵; + #𓔶; + #𓔷; + #𓔸; + #𓔹; + #𓔺; + #𓔻; + #𓔼; + #𓔽; + #𓔾; + #𓔿; + #𓕀; + #𓕁; + #𓕂; + #𓕃; + #𓕄; + #𓕅; + #𓕆; + #𓕇; + #𓕈; + #𓕉; + #𓕊; + #𓕋; + #𓕌; + #𓕍; + #𓕎; + #𓕏; + #𓕐; + #𓕑; + #𓕒; + #𓕓; + #𓕔; + #𓕕; + #𓕖; + #𓕗; + #𓕘; + #𓕙; + #𓕚; + #𓕛; + #𓕜; + #𓕝; + #𓕞; + #𓕟; + #𓕠; + #𓕡; + #𓕢; + #𓕣; + #𓕤; + #𓕥; + #𓕦; + #𓕧; + #𓕨; + #𓕩; + #𓕪; + #𓕫; + #𓕬; + #𓕭; + #𓕮; + #𓕯; + #𓕰; + #𓕱; + #𓕲; + #𓕳; + #𓕴; + #𓕵; + #𓕶; + #𓕷; + #𓕸; + #𓕹; + #𓕺; + #𓕻; + #𓕼; + #𓕽; + #𓕾; + #𓕿; + #𓖀; + #𓖁; + #𓖂; + #𓖃; + #𓖄; + #𓖅; + #𓖆; + #𓖇; + #𓖈; + #𓖉; + #𓖊; + #𓖋; + #𓖌; + #𓖍; + #𓖎; + #𓖏; + #𓖐; + #𓖑; + #𓖒; + #𓖓; + #𓖔; + #𓖕; + #𓖖; + #𓖗; + #𓖘; + #𓖙; + #𓖚; + #𓖛; + #𓖜; + #𓖝; + #𓖞; + #𓖟; + #𓖠; + #𓖡; + #𓖢; + #𓖣; + #𓖤; + #𓖥; + #𓖦; + #𓖧; + #𓖨; + #𓖩; + #𓖪; + #𓖫; + #𓖬; + #𓖭; + #𓖮; + #𓖯; + #𓖰; + #𓖱; + #𓖲; + #𓖳; + #𓖴; + #𓖵; + #𓖶; + #𓖷; + #𓖸; + #𓖹; + #𓖺; + #𓖻; + #𓖼; + #𓖽; + #𓖾; + #𓖿; + #𓗀; + #𓗁; + #𓗂; + #𓗃; + #𓗄; + #𓗅; + #𓗆; + #𓗇; + #𓗈; + #𓗉; + #𓗊; + #𓗋; + #𓗌; + #𓗍; + #𓗎; + #𓗏; + #𓗐; + #𓗑; + #𓗒; + #𓗓; + #𓗔; + #𓗕; + #𓗖; + #𓗗; + #𓗘; + #𓗙; + #𓗚; + #𓗛; + #𓗜; + #𓗝; + #𓗞; + #𓗟; + #𓗠; + #𓗡; + #𓗢; + #𓗣; + #𓗤; + #𓗥; + #𓗦; + #𓗧; + #𓗨; + #𓗩; + #𓗪; + #𓗫; + #𓗬; + #𓗭; + #𓗮; + #𓗯; + #𓗰; + #𓗱; + #𓗲; + #𓗳; + #𓗴; + #𓗵; + #𓗶; + #𓗷; + #𓗸; + #𓗹; + #𓗺; + #𓗻; + #𓗼; + #𓗽; + #𓗾; + #𓗿; + #𓘀; + #𓘁; + #𓘂; + #𓘃; + #𓘄; + #𓘅; + #𓘆; + #𓘇; + #𓘈; + #𓘉; + #𓘊; + #𓘋; + #𓘌; + #𓘍; + #𓘎; + #𓘏; + #𓘐; + #𓘑; + #𓘒; + #𓘓; + #𓘔; + #𓘕; + #𓘖; + #𓘗; + #𓘘; + #𓘙; + #𓘚; + #𓘛; + #𓘜; + #𓘝; + #𓘞; + #𓘟; + #𓘠; + #𓘡; + #𓘢; + #𓘣; + #𓘤; + #𓘥; + #𓘦; + #𓘧; + #𓘨; + #𓘩; + #𓘪; + #𓘫; + #𓘬; + #𓘭; + #𓘮; + #𓘯; + #𓘰; + #𓘱; + #𓘲; + #𓘳; + #𓘴; + #𓘵; + #𓘶; + #𓘷; + #𓘸; + #𓘹; + #𓘺; + #𓘻; + #𓘼; + #𓘽; + #𓘾; + #𓘿; + #𓙀; + #𓙁; + #𓙂; + #𓙃; + #𓙄; + #𓙅; + #𓙆; + #𓙇; + #𓙈; + #𓙉; + #𓙊; + #𓙋; + #𓙌; + #𓙍; + #𓙎; + #𓙏; + #𓙐; + #𓙑; + #𓙒; + #𓙓; + #𓙔; + #𓙕; + #𓙖; + #𓙗; + #𓙘; + #𓙙; + #𓙚; + #𓙛; + #𓙜; + #𓙝; + #𓙞; + #𓙟; + #𓙠; + #𓙡; + #𓙢; + #𓙣; + #𓙤; + #𓙥; + #𓙦; + #𓙧; + #𓙨; + #𓙩; + #𓙪; + #𓙫; + #𓙬; + #𓙭; + #𓙮; + #𓙯; + #𓙰; + #𓙱; + #𓙲; + #𓙳; + #𓙴; + #𓙵; + #𓙶; + #𓙷; + #𓙸; + #𓙹; + #𓙺; + #𓙻; + #𓙼; + #𓙽; + #𓙾; + #𓙿; + #𓚀; + #𓚁; + #𓚂; + #𓚃; + #𓚄; + #𓚅; + #𓚆; + #𓚇; + #𓚈; + #𓚉; + #𓚊; + #𓚋; + #𓚌; + #𓚍; + #𓚎; + #𓚏; + #𓚐; + #𓚑; + #𓚒; + #𓚓; + #𓚔; + #𓚕; + #𓚖; + #𓚗; + #𓚘; + #𓚙; + #𓚚; + #𓚛; + #𓚜; + #𓚝; + #𓚞; + #𓚟; + #𓚠; + #𓚡; + #𓚢; + #𓚣; + #𓚤; + #𓚥; + #𓚦; + #𓚧; + #𓚨; + #𓚩; + #𓚪; + #𓚫; + #𓚬; + #𓚭; + #𓚮; + #𓚯; + #𓚰; + #𓚱; + #𓚲; + #𓚳; + #𓚴; + #𓚵; + #𓚶; + #𓚷; + #𓚸; + #𓚹; + #𓚺; + #𓚻; + #𓚼; + #𓚽; + #𓚾; + #𓚿; + #𓛀; + #𓛁; + #𓛂; + #𓛃; + #𓛄; + #𓛅; + #𓛆; + #𓛇; + #𓛈; + #𓛉; + #𓛊; + #𓛋; + #𓛌; + #𓛍; + #𓛎; + #𓛏; + #𓛐; + #𓛑; + #𓛒; + #𓛓; + #𓛔; + #𓛕; + #𓛖; + #𓛗; + #𓛘; + #𓛙; + #𓛚; + #𓛛; + #𓛜; + #𓛝; + #𓛞; + #𓛟; + #𓛠; + #𓛡; + #𓛢; + #𓛣; + #𓛤; + #𓛥; + #𓛦; + #𓛧; + #𓛨; + #𓛩; + #𓛪; + #𓛫; + #𓛬; + #𓛭; + #𓛮; + #𓛯; + #𓛰; + #𓛱; + #𓛲; + #𓛳; + #𓛴; + #𓛵; + #𓛶; + #𓛷; + #𓛸; + #𓛹; + #𓛺; + #𓛻; + #𓛼; + #𓛽; + #𓛾; + #𓛿; + #𓜀; + #𓜁; + #𓜂; + #𓜃; + #𓜄; + #𓜅; + #𓜆; + #𓜇; + #𓜈; + #𓜉; + #𓜊; + #𓜋; + #𓜌; + #𓜍; + #𓜎; + #𓜏; + #𓜐; + #𓜑; + #𓜒; + #𓜓; + #𓜔; + #𓜕; + #𓜖; + #𓜗; + #𓜘; + #𓜙; + #𓜚; + #𓜛; + #𓜜; + #𓜝; + #𓜞; + #𓜟; + #𓜠; + #𓜡; + #𓜢; + #𓜣; + #𓜤; + #𓜥; + #𓜦; + #𓜧; + #𓜨; + #𓜩; + #𓜪; + #𓜫; + #𓜬; + #𓜭; + #𓜮; + #𓜯; + #𓜰; + #𓜱; + #𓜲; + #𓜳; + #𓜴; + #𓜵; + #𓜶; + #𓜷; + #𓜸; + #𓜹; + #𓜺; + #𓜻; + #𓜼; + #𓜽; + #𓜾; + #𓜿; + #𓝀; + #𓝁; + #𓝂; + #𓝃; + #𓝄; + #𓝅; + #𓝆; + #𓝇; + #𓝈; + #𓝉; + #𓝊; + #𓝋; + #𓝌; + #𓝍; + #𓝎; + #𓝏; + #𓝐; + #𓝑; + #𓝒; + #𓝓; + #𓝔; + #𓝕; + #𓝖; + #𓝗; + #𓝘; + #𓝙; + #𓝚; + #𓝛; + #𓝜; + #𓝝; + #𓝞; + #𓝟; + #𓝠; + #𓝡; + #𓝢; + #𓝣; + #𓝤; + #𓝥; + #𓝦; + #𓝧; + #𓝨; + #𓝩; + #𓝪; + #𓝫; + #𓝬; + #𓝭; + #𓝮; + #𓝯; + #𓝰; + #𓝱; + #𓝲; + #𓝳; + #𓝴; + #𓝵; + #𓝶; + #𓝷; + #𓝸; + #𓝹; + #𓝺; + #𓝻; + #𓝼; + #𓝽; + #𓝾; + #𓝿; + #𓞀; + #𓞁; + #𓞂; + #𓞃; + #𓞄; + #𓞅; + #𓞆; + #𓞇; + #𓞈; + #𓞉; + #𓞊; + #𓞋; + #𓞌; + #𓞍; + #𓞎; + #𓞏; + #𓞐; + #𓞑; + #𓞒; + #𓞓; + #𓞔; + #𓞕; + #𓞖; + #𓞗; + #𓞘; + #𓞙; + #𓞚; + #𓞛; + #𓞜; + #𓞝; + #𓞞; + #𓞟; + #𓞠; + #𓞡; + #𓞢; + #𓞣; + #𓞤; + #𓞥; + #𓞦; + #𓞧; + #𓞨; + #𓞩; + #𓞪; + #𓞫; + #𓞬; + #𓞭; + #𓞮; + #𓞯; + #𓞰; + #𓞱; + #𓞲; + #𓞳; + #𓞴; + #𓞵; + #𓞶; + #𓞷; + #𓞸; + #𓞹; + #𓞺; + #𓞻; + #𓞼; + #𓞽; + #𓞾; + #𓞿; + #𓟀; + #𓟁; + #𓟂; + #𓟃; + #𓟄; + #𓟅; + #𓟆; + #𓟇; + #𓟈; + #𓟉; + #𓟊; + #𓟋; + #𓟌; + #𓟍; + #𓟎; + #𓟏; + #𓟐; + #𓟑; + #𓟒; + #𓟓; + #𓟔; + #𓟕; + #𓟖; + #𓟗; + #𓟘; + #𓟙; + #𓟚; + #𓟛; + #𓟜; + #𓟝; + #𓟞; + #𓟟; + #𓟠; + #𓟡; + #𓟢; + #𓟣; + #𓟤; + #𓟥; + #𓟦; + #𓟧; + #𓟨; + #𓟩; + #𓟪; + #𓟫; + #𓟬; + #𓟭; + #𓟮; + #𓟯; + #𓟰; + #𓟱; + #𓟲; + #𓟳; + #𓟴; + #𓟵; + #𓟶; + #𓟷; + #𓟸; + #𓟹; + #𓟺; + #𓟻; + #𓟼; + #𓟽; + #𓟾; + #𓟿; + #𓠀; + #𓠁; + #𓠂; + #𓠃; + #𓠄; + #𓠅; + #𓠆; + #𓠇; + #𓠈; + #𓠉; + #𓠊; + #𓠋; + #𓠌; + #𓠍; + #𓠎; + #𓠏; + #𓠐; + #𓠑; + #𓠒; + #𓠓; + #𓠔; + #𓠕; + #𓠖; + #𓠗; + #𓠘; + #𓠙; + #𓠚; + #𓠛; + #𓠜; + #𓠝; + #𓠞; + #𓠟; + #𓠠; + #𓠡; + #𓠢; + #𓠣; + #𓠤; + #𓠥; + #𓠦; + #𓠧; + #𓠨; + #𓠩; + #𓠪; + #𓠫; + #𓠬; + #𓠭; + #𓠮; + #𓠯; + #𓠰; + #𓠱; + #𓠲; + #𓠳; + #𓠴; + #𓠵; + #𓠶; + #𓠷; + #𓠸; + #𓠹; + #𓠺; + #𓠻; + #𓠼; + #𓠽; + #𓠾; + #𓠿; + #𓡀; + #𓡁; + #𓡂; + #𓡃; + #𓡄; + #𓡅; + #𓡆; + #𓡇; + #𓡈; + #𓡉; + #𓡊; + #𓡋; + #𓡌; + #𓡍; + #𓡎; + #𓡏; + #𓡐; + #𓡑; + #𓡒; + #𓡓; + #𓡔; + #𓡕; + #𓡖; + #𓡗; + #𓡘; + #𓡙; + #𓡚; + #𓡛; + #𓡜; + #𓡝; + #𓡞; + #𓡟; + #𓡠; + #𓡡; + #𓡢; + #𓡣; + #𓡤; + #𓡥; + #𓡦; + #𓡧; + #𓡨; + #𓡩; + #𓡪; + #𓡫; + #𓡬; + #𓡭; + #𓡮; + #𓡯; + #𓡰; + #𓡱; + #𓡲; + #𓡳; + #𓡴; + #𓡵; + #𓡶; + #𓡷; + #𓡸; + #𓡹; + #𓡺; + #𓡻; + #𓡼; + #𓡽; + #𓡾; + #𓡿; + #𓢀; + #𓢁; + #𓢂; + #𓢃; + #𓢄; + #𓢅; + #𓢆; + #𓢇; + #𓢈; + #𓢉; + #𓢊; + #𓢋; + #𓢌; + #𓢍; + #𓢎; + #𓢏; + #𓢐; + #𓢑; + #𓢒; + #𓢓; + #𓢔; + #𓢕; + #𓢖; + #𓢗; + #𓢘; + #𓢙; + #𓢚; + #𓢛; + #𓢜; + #𓢝; + #𓢞; + #𓢟; + #𓢠; + #𓢡; + #𓢢; + #𓢣; + #𓢤; + #𓢥; + #𓢦; + #𓢧; + #𓢨; + #𓢩; + #𓢪; + #𓢫; + #𓢬; + #𓢭; + #𓢮; + #𓢯; + #𓢰; + #𓢱; + #𓢲; + #𓢳; + #𓢴; + #𓢵; + #𓢶; + #𓢷; + #𓢸; + #𓢹; + #𓢺; + #𓢻; + #𓢼; + #𓢽; + #𓢾; + #𓢿; + #𓣀; + #𓣁; + #𓣂; + #𓣃; + #𓣄; + #𓣅; + #𓣆; + #𓣇; + #𓣈; + #𓣉; + #𓣊; + #𓣋; + #𓣌; + #𓣍; + #𓣎; + #𓣏; + #𓣐; + #𓣑; + #𓣒; + #𓣓; + #𓣔; + #𓣕; + #𓣖; + #𓣗; + #𓣘; + #𓣙; + #𓣚; + #𓣛; + #𓣜; + #𓣝; + #𓣞; + #𓣟; + #𓣠; + #𓣡; + #𓣢; + #𓣣; + #𓣤; + #𓣥; + #𓣦; + #𓣧; + #𓣨; + #𓣩; + #𓣪; + #𓣫; + #𓣬; + #𓣭; + #𓣮; + #𓣯; + #𓣰; + #𓣱; + #𓣲; + #𓣳; + #𓣴; + #𓣵; + #𓣶; + #𓣷; + #𓣸; + #𓣹; + #𓣺; + #𓣻; + #𓣼; + #𓣽; + #𓣾; + #𓣿; + #𓤀; + #𓤁; + #𓤂; + #𓤃; + #𓤄; + #𓤅; + #𓤆; + #𓤇; + #𓤈; + #𓤉; + #𓤊; + #𓤋; + #𓤌; + #𓤍; + #𓤎; + #𓤏; + #𓤐; + #𓤑; + #𓤒; + #𓤓; + #𓤔; + #𓤕; + #𓤖; + #𓤗; + #𓤘; + #𓤙; + #𓤚; + #𓤛; + #𓤜; + #𓤝; + #𓤞; + #𓤟; + #𓤠; + #𓤡; + #𓤢; + #𓤣; + #𓤤; + #𓤥; + #𓤦; + #𓤧; + #𓤨; + #𓤩; + #𓤪; + #𓤫; + #𓤬; + #𓤭; + #𓤮; + #𓤯; + #𓤰; + #𓤱; + #𓤲; + #𓤳; + #𓤴; + #𓤵; + #𓤶; + #𓤷; + #𓤸; + #𓤹; + #𓤺; + #𓤻; + #𓤼; + #𓤽; + #𓤾; + #𓤿; + #𓥀; + #𓥁; + #𓥂; + #𓥃; + #𓥄; + #𓥅; + #𓥆; + #𓥇; + #𓥈; + #𓥉; + #𓥊; + #𓥋; + #𓥌; + #𓥍; + #𓥎; + #𓥏; + #𓥐; + #𓥑; + #𓥒; + #𓥓; + #𓥔; + #𓥕; + #𓥖; + #𓥗; + #𓥘; + #𓥙; + #𓥚; + #𓥛; + #𓥜; + #𓥝; + #𓥞; + #𓥟; + #𓥠; + #𓥡; + #𓥢; + #𓥣; + #𓥤; + #𓥥; + #𓥦; + #𓥧; + #𓥨; + #𓥩; + #𓥪; + #𓥫; + #𓥬; + #𓥭; + #𓥮; + #𓥯; + #𓥰; + #𓥱; + #𓥲; + #𓥳; + #𓥴; + #𓥵; + #𓥶; + #𓥷; + #𓥸; + #𓥹; + #𓥺; + #𓥻; + #𓥼; + #𓥽; + #𓥾; + #𓥿; + #𓦀; + #𓦁; + #𓦂; + #𓦃; + #𓦄; + #𓦅; + #𓦆; + #𓦇; + #𓦈; + #𓦉; + #𓦊; + #𓦋; + #𓦌; + #𓦍; + #𓦎; + #𓦏; + #𓦐; + #𓦑; + #𓦒; + #𓦓; + #𓦔; + #𓦕; + #𓦖; + #𓦗; + #𓦘; + #𓦙; + #𓦚; + #𓦛; + #𓦜; + #𓦝; + #𓦞; + #𓦟; + #𓦠; + #𓦡; + #𓦢; + #𓦣; + #𓦤; + #𓦥; + #𓦦; + #𓦧; + #𓦨; + #𓦩; + #𓦪; + #𓦫; + #𓦬; + #𓦭; + #𓦮; + #𓦯; + #𓦰; + #𓦱; + #𓦲; + #𓦳; + #𓦴; + #𓦵; + #𓦶; + #𓦷; + #𓦸; + #𓦹; + #𓦺; + #𓦻; + #𓦼; + #𓦽; + #𓦾; + #𓦿; + #𓧀; + #𓧁; + #𓧂; + #𓧃; + #𓧄; + #𓧅; + #𓧆; + #𓧇; + #𓧈; + #𓧉; + #𓧊; + #𓧋; + #𓧌; + #𓧍; + #𓧎; + #𓧏; + #𓧐; + #𓧑; + #𓧒; + #𓧓; + #𓧔; + #𓧕; + #𓧖; + #𓧗; + #𓧘; + #𓧙; + #𓧚; + #𓧛; + #𓧜; + #𓧝; + #𓧞; + #𓧟; + #𓧠; + #𓧡; + #𓧢; + #𓧣; + #𓧤; + #𓧥; + #𓧦; + #𓧧; + #𓧨; + #𓧩; + #𓧪; + #𓧫; + #𓧬; + #𓧭; + #𓧮; + #𓧯; + #𓧰; + #𓧱; + #𓧲; + #𓧳; + #𓧴; + #𓧵; + #𓧶; + #𓧷; + #𓧸; + #𓧹; + #𓧺; + #𓧻; + #𓧼; + #𓧽; + #𓧾; + #𓧿; + #𓨀; + #𓨁; + #𓨂; + #𓨃; + #𓨄; + #𓨅; + #𓨆; + #𓨇; + #𓨈; + #𓨉; + #𓨊; + #𓨋; + #𓨌; + #𓨍; + #𓨎; + #𓨏; + #𓨐; + #𓨑; + #𓨒; + #𓨓; + #𓨔; + #𓨕; + #𓨖; + #𓨗; + #𓨘; + #𓨙; + #𓨚; + #𓨛; + #𓨜; + #𓨝; + #𓨞; + #𓨟; + #𓨠; + #𓨡; + #𓨢; + #𓨣; + #𓨤; + #𓨥; + #𓨦; + #𓨧; + #𓨨; + #𓨩; + #𓨪; + #𓨫; + #𓨬; + #𓨭; + #𓨮; + #𓨯; + #𓨰; + #𓨱; + #𓨲; + #𓨳; + #𓨴; + #𓨵; + #𓨶; + #𓨷; + #𓨸; + #𓨹; + #𓨺; + #𓨻; + #𓨼; + #𓨽; + #𓨾; + #𓨿; + #𓩀; + #𓩁; + #𓩂; + #𓩃; + #𓩄; + #𓩅; + #𓩆; + #𓩇; + #𓩈; + #𓩉; + #𓩊; + #𓩋; + #𓩌; + #𓩍; + #𓩎; + #𓩏; + #𓩐; + #𓩑; + #𓩒; + #𓩓; + #𓩔; + #𓩕; + #𓩖; + #𓩗; + #𓩘; + #𓩙; + #𓩚; + #𓩛; + #𓩜; + #𓩝; + #𓩞; + #𓩟; + #𓩠; + #𓩡; + #𓩢; + #𓩣; + #𓩤; + #𓩥; + #𓩦; + #𓩧; + #𓩨; + #𓩩; + #𓩪; + #𓩫; + #𓩬; + #𓩭; + #𓩮; + #𓩯; + #𓩰; + #𓩱; + #𓩲; + #𓩳; + #𓩴; + #𓩵; + #𓩶; + #𓩷; + #𓩸; + #𓩹; + #𓩺; + #𓩻; + #𓩼; + #𓩽; + #𓩾; + #𓩿; + #𓪀; + #𓪁; + #𓪂; + #𓪃; + #𓪄; + #𓪅; + #𓪆; + #𓪇; + #𓪈; + #𓪉; + #𓪊; + #𓪋; + #𓪌; + #𓪍; + #𓪎; + #𓪏; + #𓪐; + #𓪑; + #𓪒; + #𓪓; + #𓪔; + #𓪕; + #𓪖; + #𓪗; + #𓪘; + #𓪙; + #𓪚; + #𓪛; + #𓪜; + #𓪝; + #𓪞; + #𓪟; + #𓪠; + #𓪡; + #𓪢; + #𓪣; + #𓪤; + #𓪥; + #𓪦; + #𓪧; + #𓪨; + #𓪩; + #𓪪; + #𓪫; + #𓪬; + #𓪭; + #𓪮; + #𓪯; + #𓪰; + #𓪱; + #𓪲; + #𓪳; + #𓪴; + #𓪵; + #𓪶; + #𓪷; + #𓪸; + #𓪹; + #𓪺; + #𓪻; + #𓪼; + #𓪽; + #𓪾; + #𓪿; + #𓫀; + #𓫁; + #𓫂; + #𓫃; + #𓫄; + #𓫅; + #𓫆; + #𓫇; + #𓫈; + #𓫉; + #𓫊; + #𓫋; + #𓫌; + #𓫍; + #𓫎; + #𓫏; + #𓫐; + #𓫑; + #𓫒; + #𓫓; + #𓫔; + #𓫕; + #𓫖; + #𓫗; + #𓫘; + #𓫙; + #𓫚; + #𓫛; + #𓫜; + #𓫝; + #𓫞; + #𓫟; + #𓫠; + #𓫡; + #𓫢; + #𓫣; + #𓫤; + #𓫥; + #𓫦; + #𓫧; + #𓫨; + #𓫩; + #𓫪; + #𓫫; + #𓫬; + #𓫭; + #𓫮; + #𓫯; + #𓫰; + #𓫱; + #𓫲; + #𓫳; + #𓫴; + #𓫵; + #𓫶; + #𓫷; + #𓫸; + #𓫹; + #𓫺; + #𓫻; + #𓫼; + #𓫽; + #𓫾; + #𓫿; + #𓬀; + #𓬁; + #𓬂; + #𓬃; + #𓬄; + #𓬅; + #𓬆; + #𓬇; + #𓬈; + #𓬉; + #𓬊; + #𓬋; + #𓬌; + #𓬍; + #𓬎; + #𓬏; + #𓬐; + #𓬑; + #𓬒; + #𓬓; + #𓬔; + #𓬕; + #𓬖; + #𓬗; + #𓬘; + #𓬙; + #𓬚; + #𓬛; + #𓬜; + #𓬝; + #𓬞; + #𓬟; + #𓬠; + #𓬡; + #𓬢; + #𓬣; + #𓬤; + #𓬥; + #𓬦; + #𓬧; + #𓬨; + #𓬩; + #𓬪; + #𓬫; + #𓬬; + #𓬭; + #𓬮; + #𓬯; + #𓬰; + #𓬱; + #𓬲; + #𓬳; + #𓬴; + #𓬵; + #𓬶; + #𓬷; + #𓬸; + #𓬹; + #𓬺; + #𓬻; + #𓬼; + #𓬽; + #𓬾; + #𓬿; + #𓭀; + #𓭁; + #𓭂; + #𓭃; + #𓭄; + #𓭅; + #𓭆; + #𓭇; + #𓭈; + #𓭉; + #𓭊; + #𓭋; + #𓭌; + #𓭍; + #𓭎; + #𓭏; + #𓭐; + #𓭑; + #𓭒; + #𓭓; + #𓭔; + #𓭕; + #𓭖; + #𓭗; + #𓭘; + #𓭙; + #𓭚; + #𓭛; + #𓭜; + #𓭝; + #𓭞; + #𓭟; + #𓭠; + #𓭡; + #𓭢; + #𓭣; + #𓭤; + #𓭥; + #𓭦; + #𓭧; + #𓭨; + #𓭩; + #𓭪; + #𓭫; + #𓭬; + #𓭭; + #𓭮; + #𓭯; + #𓭰; + #𓭱; + #𓭲; + #𓭳; + #𓭴; + #𓭵; + #𓭶; + #𓭷; + #𓭸; + #𓭹; + #𓭺; + #𓭻; + #𓭼; + #𓭽; + #𓭾; + #𓭿; + #𓮀; + #𓮁; + #𓮂; + #𓮃; + #𓮄; + #𓮅; + #𓮆; + #𓮇; + #𓮈; + #𓮉; + #𓮊; + #𓮋; + #𓮌; + #𓮍; + #𓮎; + #𓮏; + #𓮐; + #𓮑; + #𓮒; + #𓮓; + #𓮔; + #𓮕; + #𓮖; + #𓮗; + #𓮘; + #𓮙; + #𓮚; + #𓮛; + #𓮜; + #𓮝; + #𓮞; + #𓮟; + #𓮠; + #𓮡; + #𓮢; + #𓮣; + #𓮤; + #𓮥; + #𓮦; + #𓮧; + #𓮨; + #𓮩; + #𓮪; + #𓮫; + #𓮬; + #𓮭; + #𓮮; + #𓮯; + #𓮰; + #𓮱; + #𓮲; + #𓮳; + #𓮴; + #𓮵; + #𓮶; + #𓮷; + #𓮸; + #𓮹; + #𓮺; + #𓮻; + #𓮼; + #𓮽; + #𓮾; + #𓮿; + #𓯀; + #𓯁; + #𓯂; + #𓯃; + #𓯄; + #𓯅; + #𓯆; + #𓯇; + #𓯈; + #𓯉; + #𓯊; + #𓯋; + #𓯌; + #𓯍; + #𓯎; + #𓯏; + #𓯐; + #𓯑; + #𓯒; + #𓯓; + #𓯔; + #𓯕; + #𓯖; + #𓯗; + #𓯘; + #𓯙; + #𓯚; + #𓯛; + #𓯜; + #𓯝; + #𓯞; + #𓯟; + #𓯠; + #𓯡; + #𓯢; + #𓯣; + #𓯤; + #𓯥; + #𓯦; + #𓯧; + #𓯨; + #𓯩; + #𓯪; + #𓯫; + #𓯬; + #𓯭; + #𓯮; + #𓯯; + #𓯰; + #𓯱; + #𓯲; + #𓯳; + #𓯴; + #𓯵; + #𓯶; + #𓯷; + #𓯸; + #𓯹; + #𓯺; + #𓯻; + #𓯼; + #𓯽; + #𓯾; + #𓯿; + #𓰀; + #𓰁; + #𓰂; + #𓰃; + #𓰄; + #𓰅; + #𓰆; + #𓰇; + #𓰈; + #𓰉; + #𓰊; + #𓰋; + #𓰌; + #𓰍; + #𓰎; + #𓰏; + #𓰐; + #𓰑; + #𓰒; + #𓰓; + #𓰔; + #𓰕; + #𓰖; + #𓰗; + #𓰘; + #𓰙; + #𓰚; + #𓰛; + #𓰜; + #𓰝; + #𓰞; + #𓰟; + #𓰠; + #𓰡; + #𓰢; + #𓰣; + #𓰤; + #𓰥; + #𓰦; + #𓰧; + #𓰨; + #𓰩; + #𓰪; + #𓰫; + #𓰬; + #𓰭; + #𓰮; + #𓰯; + #𓰰; + #𓰱; + #𓰲; + #𓰳; + #𓰴; + #𓰵; + #𓰶; + #𓰷; + #𓰸; + #𓰹; + #𓰺; + #𓰻; + #𓰼; + #𓰽; + #𓰾; + #𓰿; + #𓱀; + #𓱁; + #𓱂; + #𓱃; + #𓱄; + #𓱅; + #𓱆; + #𓱇; + #𓱈; + #𓱉; + #𓱊; + #𓱋; + #𓱌; + #𓱍; + #𓱎; + #𓱏; + #𓱐; + #𓱑; + #𓱒; + #𓱓; + #𓱔; + #𓱕; + #𓱖; + #𓱗; + #𓱘; + #𓱙; + #𓱚; + #𓱛; + #𓱜; + #𓱝; + #𓱞; + #𓱟; + #𓱠; + #𓱡; + #𓱢; + #𓱣; + #𓱤; + #𓱥; + #𓱦; + #𓱧; + #𓱨; + #𓱩; + #𓱪; + #𓱫; + #𓱬; + #𓱭; + #𓱮; + #𓱯; + #𓱰; + #𓱱; + #𓱲; + #𓱳; + #𓱴; + #𓱵; + #𓱶; + #𓱷; + #𓱸; + #𓱹; + #𓱺; + #𓱻; + #𓱼; + #𓱽; + #𓱾; + #𓱿; + #𓲀; + #𓲁; + #𓲂; + #𓲃; + #𓲄; + #𓲅; + #𓲆; + #𓲇; + #𓲈; + #𓲉; + #𓲊; + #𓲋; + #𓲌; + #𓲍; + #𓲎; + #𓲏; + #𓲐; + #𓲑; + #𓲒; + #𓲓; + #𓲔; + #𓲕; + #𓲖; + #𓲗; + #𓲘; + #𓲙; + #𓲚; + #𓲛; + #𓲜; + #𓲝; + #𓲞; + #𓲟; + #𓲠; + #𓲡; + #𓲢; + #𓲣; + #𓲤; + #𓲥; + #𓲦; + #𓲧; + #𓲨; + #𓲩; + #𓲪; + #𓲫; + #𓲬; + #𓲭; + #𓲮; + #𓲯; + #𓲰; + #𓲱; + #𓲲; + #𓲳; + #𓲴; + #𓲵; + #𓲶; + #𓲷; + #𓲸; + #𓲹; + #𓲺; + #𓲻; + #𓲼; + #𓲽; + #𓲾; + #𓲿; + #𓳀; + #𓳁; + #𓳂; + #𓳃; + #𓳄; + #𓳅; + #𓳆; + #𓳇; + #𓳈; + #𓳉; + #𓳊; + #𓳋; + #𓳌; + #𓳍; + #𓳎; + #𓳏; + #𓳐; + #𓳑; + #𓳒; + #𓳓; + #𓳔; + #𓳕; + #𓳖; + #𓳗; + #𓳘; + #𓳙; + #𓳚; + #𓳛; + #𓳜; + #𓳝; + #𓳞; + #𓳟; + #𓳠; + #𓳡; + #𓳢; + #𓳣; + #𓳤; + #𓳥; + #𓳦; + #𓳧; + #𓳨; + #𓳩; + #𓳪; + #𓳫; + #𓳬; + #𓳭; + #𓳮; + #𓳯; + #𓳰; + #𓳱; + #𓳲; + #𓳳; + #𓳴; + #𓳵; + #𓳶; + #𓳷; + #𓳸; + #𓳹; + #𓳺; + #𓳻; + #𓳼; + #𓳽; + #𓳾; + #𓳿; + #𓴀; + #𓴁; + #𓴂; + #𓴃; + #𓴄; + #𓴅; + #𓴆; + #𓴇; + #𓴈; + #𓴉; + #𓴊; + #𓴋; + #𓴌; + #𓴍; + #𓴎; + #𓴏; + #𓴐; + #𓴑; + #𓴒; + #𓴓; + #𓴔; + #𓴕; + #𓴖; + #𓴗; + #𓴘; + #𓴙; + #𓴚; + #𓴛; + #𓴜; + #𓴝; + #𓴞; + #𓴟; + #𓴠; + #𓴡; + #𓴢; + #𓴣; + #𓴤; + #𓴥; + #𓴦; + #𓴧; + #𓴨; + #𓴩; + #𓴪; + #𓴫; + #𓴬; + #𓴭; + #𓴮; + #𓴯; + #𓴰; + #𓴱; + #𓴲; + #𓴳; + #𓴴; + #𓴵; + #𓴶; + #𓴷; + #𓴸; + #𓴹; + #𓴺; + #𓴻; + #𓴼; + #𓴽; + #𓴾; + #𓴿; + #𓵀; + #𓵁; + #𓵂; + #𓵃; + #𓵄; + #𓵅; + #𓵆; + #𓵇; + #𓵈; + #𓵉; + #𓵊; + #𓵋; + #𓵌; + #𓵍; + #𓵎; + #𓵏; + #𓵐; + #𓵑; + #𓵒; + #𓵓; + #𓵔; + #𓵕; + #𓵖; + #𓵗; + #𓵘; + #𓵙; + #𓵚; + #𓵛; + #𓵜; + #𓵝; + #𓵞; + #𓵟; + #𓵠; + #𓵡; + #𓵢; + #𓵣; + #𓵤; + #𓵥; + #𓵦; + #𓵧; + #𓵨; + #𓵩; + #𓵪; + #𓵫; + #𓵬; + #𓵭; + #𓵮; + #𓵯; + #𓵰; + #𓵱; + #𓵲; + #𓵳; + #𓵴; + #𓵵; + #𓵶; + #𓵷; + #𓵸; + #𓵹; + #𓵺; + #𓵻; + #𓵼; + #𓵽; + #𓵾; + #𓵿; + #𓶀; + #𓶁; + #𓶂; + #𓶃; + #𓶄; + #𓶅; + #𓶆; + #𓶇; + #𓶈; + #𓶉; + #𓶊; + #𓶋; + #𓶌; + #𓶍; + #𓶎; + #𓶏; + #𓶐; + #𓶑; + #𓶒; + #𓶓; + #𓶔; + #𓶕; + #𓶖; + #𓶗; + #𓶘; + #𓶙; + #𓶚; + #𓶛; + #𓶜; + #𓶝; + #𓶞; + #𓶟; + #𓶠; + #𓶡; + #𓶢; + #𓶣; + #𓶤; + #𓶥; + #𓶦; + #𓶧; + #𓶨; + #𓶩; + #𓶪; + #𓶫; + #𓶬; + #𓶭; + #𓶮; + #𓶯; + #𓶰; + #𓶱; + #𓶲; + #𓶳; + #𓶴; + #𓶵; + #𓶶; + #𓶷; + #𓶸; + #𓶹; + #𓶺; + #𓶻; + #𓶼; + #𓶽; + #𓶾; + #𓶿; + #𓷀; + #𓷁; + #𓷂; + #𓷃; + #𓷄; + #𓷅; + #𓷆; + #𓷇; + #𓷈; + #𓷉; + #𓷊; + #𓷋; + #𓷌; + #𓷍; + #𓷎; + #𓷏; + #𓷐; + #𓷑; + #𓷒; + #𓷓; + #𓷔; + #𓷕; + #𓷖; + #𓷗; + #𓷘; + #𓷙; + #𓷚; + #𓷛; + #𓷜; + #𓷝; + #𓷞; + #𓷟; + #𓷠; + #𓷡; + #𓷢; + #𓷣; + #𓷤; + #𓷥; + #𓷦; + #𓷧; + #𓷨; + #𓷩; + #𓷪; + #𓷫; + #𓷬; + #𓷭; + #𓷮; + #𓷯; + #𓷰; + #𓷱; + #𓷲; + #𓷳; + #𓷴; + #𓷵; + #𓷶; + #𓷷; + #𓷸; + #𓷹; + #𓷺; + #𓷻; + #𓷼; + #𓷽; + #𓷾; + #𓷿; + #𓸀; + #𓸁; + #𓸂; + #𓸃; + #𓸄; + #𓸅; + #𓸆; + #𓸇; + #𓸈; + #𓸉; + #𓸊; + #𓸋; + #𓸌; + #𓸍; + #𓸎; + #𓸏; + #𓸐; + #𓸑; + #𓸒; + #𓸓; + #𓸔; + #𓸕; + #𓸖; + #𓸗; + #𓸘; + #𓸙; + #𓸚; + #𓸛; + #𓸜; + #𓸝; + #𓸞; + #𓸟; + #𓸠; + #𓸡; + #𓸢; + #𓸣; + #𓸤; + #𓸥; + #𓸦; + #𓸧; + #𓸨; + #𓸩; + #𓸪; + #𓸫; + #𓸬; + #𓸭; + #𓸮; + #𓸯; + #𓸰; + #𓸱; + #𓸲; + #𓸳; + #𓸴; + #𓸵; + #𓸶; + #𓸷; + #𓸸; + #𓸹; + #𓸺; + #𓸻; + #𓸼; + #𓸽; + #𓸾; + #𓸿; + #𓹀; + #𓹁; + #𓹂; + #𓹃; + #𓹄; + #𓹅; + #𓹆; + #𓹇; + #𓹈; + #𓹉; + #𓹊; + #𓹋; + #𓹌; + #𓹍; + #𓹎; + #𓹏; + #𓹐; + #𓹑; + #𓹒; + #𓹓; + #𓹔; + #𓹕; + #𓹖; + #𓹗; + #𓹘; + #𓹙; + #𓹚; + #𓹛; + #𓹜; + #𓹝; + #𓹞; + #𓹟; + #𓹠; + #𓹡; + #𓹢; + #𓹣; + #𓹤; + #𓹥; + #𓹦; + #𓹧; + #𓹨; + #𓹩; + #𓹪; + #𓹫; + #𓹬; + #𓹭; + #𓹮; + #𓹯; + #𓹰; + #𓹱; + #𓹲; + #𓹳; + #𓹴; + #𓹵; + #𓹶; + #𓹷; + #𓹸; + #𓹹; + #𓹺; + #𓹻; + #𓹼; + #𓹽; + #𓹾; + #𓹿; + #𓺀; + #𓺁; + #𓺂; + #𓺃; + #𓺄; + #𓺅; + #𓺆; + #𓺇; + #𓺈; + #𓺉; + #𓺊; + #𓺋; + #𓺌; + #𓺍; + #𓺎; + #𓺏; + #𓺐; + #𓺑; + #𓺒; + #𓺓; + #𓺔; + #𓺕; + #𓺖; + #𓺗; + #𓺘; + #𓺙; + #𓺚; + #𓺛; + #𓺜; + #𓺝; + #𓺞; + #𓺟; + #𓺠; + #𓺡; + #𓺢; + #𓺣; + #𓺤; + #𓺥; + #𓺦; + #𓺧; + #𓺨; + #𓺩; + #𓺪; + #𓺫; + #𓺬; + #𓺭; + #𓺮; + #𓺯; + #𓺰; + #𓺱; + #𓺲; + #𓺳; + #𓺴; + #𓺵; + #𓺶; + #𓺷; + #𓺸; + #𓺹; + #𓺺; + #𓺻; + #𓺼; + #𓺽; + #𓺾; + #𓺿; + #𓻀; + #𓻁; + #𓻂; + #𓻃; + #𓻄; + #𓻅; + #𓻆; + #𓻇; + #𓻈; + #𓻉; + #𓻊; + #𓻋; + #𓻌; + #𓻍; + #𓻎; + #𓻏; + #𓻐; + #𓻑; + #𓻒; + #𓻓; + #𓻔; + #𓻕; + #𓻖; + #𓻗; + #𓻘; + #𓻙; + #𓻚; + #𓻛; + #𓻜; + #𓻝; + #𓻞; + #𓻟; + #𓻠; + #𓻡; + #𓻢; + #𓻣; + #𓻤; + #𓻥; + #𓻦; + #𓻧; + #𓻨; + #𓻩; + #𓻪; + #𓻫; + #𓻬; + #𓻭; + #𓻮; + #𓻯; + #𓻰; + #𓻱; + #𓻲; + #𓻳; + #𓻴; + #𓻵; + #𓻶; + #𓻷; + #𓻸; + #𓻹; + #𓻺; + #𓻻; + #𓻼; + #𓻽; + #𓻾; + #𓻿; + #𓼀; + #𓼁; + #𓼂; + #𓼃; + #𓼄; + #𓼅; + #𓼆; + #𓼇; + #𓼈; + #𓼉; + #𓼊; + #𓼋; + #𓼌; + #𓼍; + #𓼎; + #𓼏; + #𓼐; + #𓼑; + #𓼒; + #𓼓; + #𓼔; + #𓼕; + #𓼖; + #𓼗; + #𓼘; + #𓼙; + #𓼚; + #𓼛; + #𓼜; + #𓼝; + #𓼞; + #𓼟; + #𓼠; + #𓼡; + #𓼢; + #𓼣; + #𓼤; + #𓼥; + #𓼦; + #𓼧; + #𓼨; + #𓼩; + #𓼪; + #𓼫; + #𓼬; + #𓼭; + #𓼮; + #𓼯; + #𓼰; + #𓼱; + #𓼲; + #𓼳; + #𓼴; + #𓼵; + #𓼶; + #𓼷; + #𓼸; + #𓼹; + #𓼺; + #𓼻; + #𓼼; + #𓼽; + #𓼾; + #𓼿; + #𓽀; + #𓽁; + #𓽂; + #𓽃; + #𓽄; + #𓽅; + #𓽆; + #𓽇; + #𓽈; + #𓽉; + #𓽊; + #𓽋; + #𓽌; + #𓽍; + #𓽎; + #𓽏; + #𓽐; + #𓽑; + #𓽒; + #𓽓; + #𓽔; + #𓽕; + #𓽖; + #𓽗; + #𓽘; + #𓽙; + #𓽚; + #𓽛; + #𓽜; + #𓽝; + #𓽞; + #𓽟; + #𓽠; + #𓽡; + #𓽢; + #𓽣; + #𓽤; + #𓽥; + #𓽦; + #𓽧; + #𓽨; + #𓽩; + #𓽪; + #𓽫; + #𓽬; + #𓽭; + #𓽮; + #𓽯; + #𓽰; + #𓽱; + #𓽲; + #𓽳; + #𓽴; + #𓽵; + #𓽶; + #𓽷; + #𓽸; + #𓽹; + #𓽺; + #𓽻; + #𓽼; + #𓽽; + #𓽾; + #𓽿; + #𓾀; + #𓾁; + #𓾂; + #𓾃; + #𓾄; + #𓾅; + #𓾆; + #𓾇; + #𓾈; + #𓾉; + #𓾊; + #𓾋; + #𓾌; + #𓾍; + #𓾎; + #𓾏; + #𓾐; + #𓾑; + #𓾒; + #𓾓; + #𓾔; + #𓾕; + #𓾖; + #𓾗; + #𓾘; + #𓾙; + #𓾚; + #𓾛; + #𓾜; + #𓾝; + #𓾞; + #𓾟; + #𓾠; + #𓾡; + #𓾢; + #𓾣; + #𓾤; + #𓾥; + #𓾦; + #𓾧; + #𓾨; + #𓾩; + #𓾪; + #𓾫; + #𓾬; + #𓾭; + #𓾮; + #𓾯; + #𓾰; + #𓾱; + #𓾲; + #𓾳; + #𓾴; + #𓾵; + #𓾶; + #𓾷; + #𓾸; + #𓾹; + #𓾺; + #𓾻; + #𓾼; + #𓾽; + #𓾾; + #𓾿; + #𓿀; + #𓿁; + #𓿂; + #𓿃; + #𓿄; + #𓿅; + #𓿆; + #𓿇; + #𓿈; + #𓿉; + #𓿊; + #𓿋; + #𓿌; + #𓿍; + #𓿎; + #𓿏; + #𓿐; + #𓿑; + #𓿒; + #𓿓; + #𓿔; + #𓿕; + #𓿖; + #𓿗; + #𓿘; + #𓿙; + #𓿚; + #𓿛; + #𓿜; + #𓿝; + #𓿞; + #𓿟; + #𓿠; + #𓿡; + #𓿢; + #𓿣; + #𓿤; + #𓿥; + #𓿦; + #𓿧; + #𓿨; + #𓿩; + #𓿪; + #𓿫; + #𓿬; + #𓿭; + #𓿮; + #𓿯; + #𓿰; + #𓿱; + #𓿲; + #𓿳; + #𓿴; + #𓿵; + #𓿶; + #𓿷; + #𓿸; + #𓿹; + #𓿺; + #𓿻; + #𓿼; + #𓿽; + #𓿾; + #𓿿; + #𔀀; + #𔀁; + #𔀂; + #𔀃; + #𔀄; + #𔀅; + #𔀆; + #𔀇; + #𔀈; + #𔀉; + #𔀊; + #𔀋; + #𔀌; + #𔀍; + #𔀎; + #𔀏; + #𔀐; + #𔀑; + #𔀒; + #𔀓; + #𔀔; + #𔀕; + #𔀖; + #𔀗; + #𔀘; + #𔀙; + #𔀚; + #𔀛; + #𔀜; + #𔀝; + #𔀞; + #𔀟; + #𔀠; + #𔀡; + #𔀢; + #𔀣; + #𔀤; + #𔀥; + #𔀦; + #𔀧; + #𔀨; + #𔀩; + #𔀪; + #𔀫; + #𔀬; + #𔀭; + #𔀮; + #𔀯; + #𔀰; + #𔀱; + #𔀲; + #𔀳; + #𔀴; + #𔀵; + #𔀶; + #𔀷; + #𔀸; + #𔀹; + #𔀺; + #𔀻; + #𔀼; + #𔀽; + #𔀾; + #𔀿; + #𔁀; + #𔁁; + #𔁂; + #𔁃; + #𔁄; + #𔁅; + #𔁆; + #𔁇; + #𔁈; + #𔁉; + #𔁊; + #𔁋; + #𔁌; + #𔁍; + #𔁎; + #𔁏; + #𔁐; + #𔁑; + #𔁒; + #𔁓; + #𔁔; + #𔁕; + #𔁖; + #𔁗; + #𔁘; + #𔁙; + #𔁚; + #𔁛; + #𔁜; + #𔁝; + #𔁞; + #𔁟; + #𔁠; + #𔁡; + #𔁢; + #𔁣; + #𔁤; + #𔁥; + #𔁦; + #𔁧; + #𔁨; + #𔁩; + #𔁪; + #𔁫; + #𔁬; + #𔁭; + #𔁮; + #𔁯; + #𔁰; + #𔁱; + #𔁲; + #𔁳; + #𔁴; + #𔁵; + #𔁶; + #𔁷; + #𔁸; + #𔁹; + #𔁺; + #𔁻; + #𔁼; + #𔁽; + #𔁾; + #𔁿; + #𔂀; + #𔂁; + #𔂂; + #𔂃; + #𔂄; + #𔂅; + #𔂆; + #𔂇; + #𔂈; + #𔂉; + #𔂊; + #𔂋; + #𔂌; + #𔂍; + #𔂎; + #𔂏; + #𔂐; + #𔂑; + #𔂒; + #𔂓; + #𔂔; + #𔂕; + #𔂖; + #𔂗; + #𔂘; + #𔂙; + #𔂚; + #𔂛; + #𔂜; + #𔂝; + #𔂞; + #𔂟; + #𔂠; + #𔂡; + #𔂢; + #𔂣; + #𔂤; + #𔂥; + #𔂦; + #𔂧; + #𔂨; + #𔂩; + #𔂪; + #𔂫; + #𔂬; + #𔂭; + #𔂮; + #𔂯; + #𔂰; + #𔂱; + #𔂲; + #𔂳; + #𔂴; + #𔂵; + #𔂶; + #𔂷; + #𔂸; + #𔂹; + #𔂺; + #𔂻; + #𔂼; + #𔂽; + #𔂾; + #𔂿; + #𔃀; + #𔃁; + #𔃂; + #𔃃; + #𔃄; + #𔃅; + #𔃆; + #𔃇; + #𔃈; + #𔃉; + #𔃊; + #𔃋; + #𔃌; + #𔃍; + #𔃎; + #𔃏; + #𔃐; + #𔃑; + #𔃒; + #𔃓; + #𔃔; + #𔃕; + #𔃖; + #𔃗; + #𔃘; + #𔃙; + #𔃚; + #𔃛; + #𔃜; + #𔃝; + #𔃞; + #𔃟; + #𔃠; + #𔃡; + #𔃢; + #𔃣; + #𔃤; + #𔃥; + #𔃦; + #𔃧; + #𔃨; + #𔃩; + #𔃪; + #𔃫; + #𔃬; + #𔃭; + #𔃮; + #𔃯; + #𔃰; + #𔃱; + #𔃲; + #𔃳; + #𔃴; + #𔃵; + #𔃶; + #𔃷; + #𔃸; + #𔃹; + #𔃺; + #𔃻; + #𔃼; + #𔃽; + #𔃾; + #𔃿; + #𔄀; + #𔄁; + #𔄂; + #𔄃; + #𔄄; + #𔄅; + #𔄆; + #𔄇; + #𔄈; + #𔄉; + #𔄊; + #𔄋; + #𔄌; + #𔄍; + #𔄎; + #𔄏; + #𔄐; + #𔄑; + #𔄒; + #𔄓; + #𔄔; + #𔄕; + #𔄖; + #𔄗; + #𔄘; + #𔄙; + #𔄚; + #𔄛; + #𔄜; + #𔄝; + #𔄞; + #𔄟; + #𔄠; + #𔄡; + #𔄢; + #𔄣; + #𔄤; + #𔄥; + #𔄦; + #𔄧; + #𔄨; + #𔄩; + #𔄪; + #𔄫; + #𔄬; + #𔄭; + #𔄮; + #𔄯; + #𔄰; + #𔄱; + #𔄲; + #𔄳; + #𔄴; + #𔄵; + #𔄶; + #𔄷; + #𔄸; + #𔄹; + #𔄺; + #𔄻; + #𔄼; + #𔄽; + #𔄾; + #𔄿; + #𔅀; + #𔅁; + #𔅂; + #𔅃; + #𔅄; + #𔅅; + #𔅆; + #𔅇; + #𔅈; + #𔅉; + #𔅊; + #𔅋; + #𔅌; + #𔅍; + #𔅎; + #𔅏; + #𔅐; + #𔅑; + #𔅒; + #𔅓; + #𔅔; + #𔅕; + #𔅖; + #𔅗; + #𔅘; + #𔅙; + #𔅚; + #𔅛; + #𔅜; + #𔅝; + #𔅞; + #𔅟; + #𔅠; + #𔅡; + #𔅢; + #𔅣; + #𔅤; + #𔅥; + #𔅦; + #𔅧; + #𔅨; + #𔅩; + #𔅪; + #𔅫; + #𔅬; + #𔅭; + #𔅮; + #𔅯; + #𔅰; + #𔅱; + #𔅲; + #𔅳; + #𔅴; + #𔅵; + #𔅶; + #𔅷; + #𔅸; + #𔅹; + #𔅺; + #𔅻; + #𔅼; + #𔅽; + #𔅾; + #𔅿; + #𔆀; + #𔆁; + #𔆂; + #𔆃; + #𔆄; + #𔆅; + #𔆆; + #𔆇; + #𔆈; + #𔆉; + #𔆊; + #𔆋; + #𔆌; + #𔆍; + #𔆎; + #𔆏; + #𔆐; + #𔆑; + #𔆒; + #𔆓; + #𔆔; + #𔆕; + #𔆖; + #𔆗; + #𔆘; + #𔆙; + #𔆚; + #𔆛; + #𔆜; + #𔆝; + #𔆞; + #𔆟; + #𔆠; + #𔆡; + #𔆢; + #𔆣; + #𔆤; + #𔆥; + #𔆦; + #𔆧; + #𔆨; + #𔆩; + #𔆪; + #𔆫; + #𔆬; + #𔆭; + #𔆮; + #𔆯; + #𔆰; + #𔆱; + #𔆲; + #𔆳; + #𔆴; + #𔆵; + #𔆶; + #𔆷; + #𔆸; + #𔆹; + #𔆺; + #𔆻; + #𔆼; + #𔆽; + #𔆾; + #𔆿; + #𔇀; + #𔇁; + #𔇂; + #𔇃; + #𔇄; + #𔇅; + #𔇆; + #𔇇; + #𔇈; + #𔇉; + #𔇊; + #𔇋; + #𔇌; + #𔇍; + #𔇎; + #𔇏; + #𔇐; + #𔇑; + #𔇒; + #𔇓; + #𔇔; + #𔇕; + #𔇖; + #𔇗; + #𔇘; + #𔇙; + #𔇚; + #𔇛; + #𔇜; + #𔇝; + #𔇞; + #𔇟; + #𔇠; + #𔇡; + #𔇢; + #𔇣; + #𔇤; + #𔇥; + #𔇦; + #𔇧; + #𔇨; + #𔇩; + #𔇪; + #𔇫; + #𔇬; + #𔇭; + #𔇮; + #𔇯; + #𔇰; + #𔇱; + #𔇲; + #𔇳; + #𔇴; + #𔇵; + #𔇶; + #𔇷; + #𔇸; + #𔇹; + #𔇺; + #𔇻; + #𔇼; + #𔇽; + #𔇾; + #𔇿; + #𔈀; + #𔈁; + #𔈂; + #𔈃; + #𔈄; + #𔈅; + #𔈆; + #𔈇; + #𔈈; + #𔈉; + #𔈊; + #𔈋; + #𔈌; + #𔈍; + #𔈎; + #𔈏; + #𔈐; + #𔈑; + #𔈒; + #𔈓; + #𔈔; + #𔈕; + #𔈖; + #𔈗; + #𔈘; + #𔈙; + #𔈚; + #𔈛; + #𔈜; + #𔈝; + #𔈞; + #𔈟; + #𔈠; + #𔈡; + #𔈢; + #𔈣; + #𔈤; + #𔈥; + #𔈦; + #𔈧; + #𔈨; + #𔈩; + #𔈪; + #𔈫; + #𔈬; + #𔈭; + #𔈮; + #𔈯; + #𔈰; + #𔈱; + #𔈲; + #𔈳; + #𔈴; + #𔈵; + #𔈶; + #𔈷; + #𔈸; + #𔈹; + #𔈺; + #𔈻; + #𔈼; + #𔈽; + #𔈾; + #𔈿; + #𔉀; + #𔉁; + #𔉂; + #𔉃; + #𔉄; + #𔉅; + #𔉆; + #𔉇; + #𔉈; + #𔉉; + #𔉊; + #𔉋; + #𔉌; + #𔉍; + #𔉎; + #𔉏; + #𔉐; + #𔉑; + #𔉒; + #𔉓; + #𔉔; + #𔉕; + #𔉖; + #𔉗; + #𔉘; + #𔉙; + #𔉚; + #𔉛; + #𔉜; + #𔉝; + #𔉞; + #𔉟; + #𔉠; + #𔉡; + #𔉢; + #𔉣; + #𔉤; + #𔉥; + #𔉦; + #𔉧; + #𔉨; + #𔉩; + #𔉪; + #𔉫; + #𔉬; + #𔉭; + #𔉮; + #𔉯; + #𔉰; + #𔉱; + #𔉲; + #𔉳; + #𔉴; + #𔉵; + #𔉶; + #𔉷; + #𔉸; + #𔉹; + #𔉺; + #𔉻; + #𔉼; + #𔉽; + #𔉾; + #𔉿; + #𔊀; + #𔊁; + #𔊂; + #𔊃; + #𔊄; + #𔊅; + #𔊆; + #𔊇; + #𔊈; + #𔊉; + #𔊊; + #𔊋; + #𔊌; + #𔊍; + #𔊎; + #𔊏; + #𔊐; + #𔊑; + #𔊒; + #𔊓; + #𔊔; + #𔊕; + #𔊖; + #𔊗; + #𔊘; + #𔊙; + #𔊚; + #𔊛; + #𔊜; + #𔊝; + #𔊞; + #𔊟; + #𔊠; + #𔊡; + #𔊢; + #𔊣; + #𔊤; + #𔊥; + #𔊦; + #𔊧; + #𔊨; + #𔊩; + #𔊪; + #𔊫; + #𔊬; + #𔊭; + #𔊮; + #𔊯; + #𔊰; + #𔊱; + #𔊲; + #𔊳; + #𔊴; + #𔊵; + #𔊶; + #𔊷; + #𔊸; + #𔊹; + #𔊺; + #𔊻; + #𔊼; + #𔊽; + #𔊾; + #𔊿; + #𔋀; + #𔋁; + #𔋂; + #𔋃; + #𔋄; + #𔋅; + #𔋆; + #𔋇; + #𔋈; + #𔋉; + #𔋊; + #𔋋; + #𔋌; + #𔋍; + #𔋎; + #𔋏; + #𔋐; + #𔋑; + #𔋒; + #𔋓; + #𔋔; + #𔋕; + #𔋖; + #𔋗; + #𔋘; + #𔋙; + #𔋚; + #𔋛; + #𔋜; + #𔋝; + #𔋞; + #𔋟; + #𔋠; + #𔋡; + #𔋢; + #𔋣; + #𔋤; + #𔋥; + #𔋦; + #𔋧; + #𔋨; + #𔋩; + #𔋪; + #𔋫; + #𔋬; + #𔋭; + #𔋮; + #𔋯; + #𔋰; + #𔋱; + #𔋲; + #𔋳; + #𔋴; + #𔋵; + #𔋶; + #𔋷; + #𔋸; + #𔋹; + #𔋺; + #𔋻; + #𔋼; + #𔋽; + #𔋾; + #𔋿; + #𔌀; + #𔌁; + #𔌂; + #𔌃; + #𔌄; + #𔌅; + #𔌆; + #𔌇; + #𔌈; + #𔌉; + #𔌊; + #𔌋; + #𔌌; + #𔌍; + #𔌎; + #𔌏; + #𔌐; + #𔌑; + #𔌒; + #𔌓; + #𔌔; + #𔌕; + #𔌖; + #𔌗; + #𔌘; + #𔌙; + #𔌚; + #𔌛; + #𔌜; + #𔌝; + #𔌞; + #𔌟; + #𔌠; + #𔌡; + #𔌢; + #𔌣; + #𔌤; + #𔌥; + #𔌦; + #𔌧; + #𔌨; + #𔌩; + #𔌪; + #𔌫; + #𔌬; + #𔌭; + #𔌮; + #𔌯; + #𔌰; + #𔌱; + #𔌲; + #𔌳; + #𔌴; + #𔌵; + #𔌶; + #𔌷; + #𔌸; + #𔌹; + #𔌺; + #𔌻; + #𔌼; + #𔌽; + #𔌾; + #𔌿; + #𔍀; + #𔍁; + #𔍂; + #𔍃; + #𔍄; + #𔍅; + #𔍆; + #𔍇; + #𔍈; + #𔍉; + #𔍊; + #𔍋; + #𔍌; + #𔍍; + #𔍎; + #𔍏; + #𔍐; + #𔍑; + #𔍒; + #𔍓; + #𔍔; + #𔍕; + #𔍖; + #𔍗; + #𔍘; + #𔍙; + #𔍚; + #𔍛; + #𔍜; + #𔍝; + #𔍞; + #𔍟; + #𔍠; + #𔍡; + #𔍢; + #𔍣; + #𔍤; + #𔍥; + #𔍦; + #𔍧; + #𔍨; + #𔍩; + #𔍪; + #𔍫; + #𔍬; + #𔍭; + #𔍮; + #𔍯; + #𔍰; + #𔍱; + #𔍲; + #𔍳; + #𔍴; + #𔍵; + #𔍶; + #𔍷; + #𔍸; + #𔍹; + #𔍺; + #𔍻; + #𔍼; + #𔍽; + #𔍾; + #𔍿; + #𔎀; + #𔎁; + #𔎂; + #𔎃; + #𔎄; + #𔎅; + #𔎆; + #𔎇; + #𔎈; + #𔎉; + #𔎊; + #𔎋; + #𔎌; + #𔎍; + #𔎎; + #𔎏; + #𔎐; + #𔎑; + #𔎒; + #𔎓; + #𔎔; + #𔎕; + #𔎖; + #𔎗; + #𔎘; + #𔎙; + #𔎚; + #𔎛; + #𔎜; + #𔎝; + #𔎞; + #𔎟; + #𔎠; + #𔎡; + #𔎢; + #𔎣; + #𔎤; + #𔎥; + #𔎦; + #𔎧; + #𔎨; + #𔎩; + #𔎪; + #𔎫; + #𔎬; + #𔎭; + #𔎮; + #𔎯; + #𔎰; + #𔎱; + #𔎲; + #𔎳; + #𔎴; + #𔎵; + #𔎶; + #𔎷; + #𔎸; + #𔎹; + #𔎺; + #𔎻; + #𔎼; + #𔎽; + #𔎾; + #𔎿; + #𔏀; + #𔏁; + #𔏂; + #𔏃; + #𔏄; + #𔏅; + #𔏆; + #𔏇; + #𔏈; + #𔏉; + #𔏊; + #𔏋; + #𔏌; + #𔏍; + #𔏎; + #𔏏; + #𔏐; + #𔏑; + #𔏒; + #𔏓; + #𔏔; + #𔏕; + #𔏖; + #𔏗; + #𔏘; + #𔏙; + #𔏚; + #𔏛; + #𔏜; + #𔏝; + #𔏞; + #𔏟; + #𔏠; + #𔏡; + #𔏢; + #𔏣; + #𔏤; + #𔏥; + #𔏦; + #𔏧; + #𔏨; + #𔏩; + #𔏪; + #𔏫; + #𔏬; + #𔏭; + #𔏮; + #𔏯; + #𔏰; + #𔏱; + #𔏲; + #𔏳; + #𔏴; + #𔏵; + #𔏶; + #𔏷; + #𔏸; + #𔏹; + #𔏺; + #𖄀; + #𖄁; + #𖄂; + #𖄃; + #𖄄; + #𖄅; + #𖄆; + #𖄇; + #𖄈; + #𖄉; + #𖄊; + #𖄋; + #𖄌; + #𖄍; + #𖄎; + #𖄏; + #𖄐; + #𖄑; + #𖄒; + #𖄓; + #𖄔; + #𖄕; + #𖄖; + #𖄗; + #𖄘; + #𖄙; + #𖄚; + #𖄛; + #𖄜; + #𖄝; + #𖵀; + #𖵁; + #𖵂; + #𖵃; + #𖵄; + #𖵅; + #𖵆; + #𖵇; + #𖵈; + #𖵉; + #𖵊; + #𖵋; + #𖵌; + #𖵍; + #𖵎; + #𖵏; + #𖵐; + #𖵑; + #𖵒; + #𖵓; + #𖵔; + #𖵕; + #𖵖; + #𖵗; + #𖵘; + #𖵙; + #𖵚; + #𖵛; + #𖵜; + #𖵝; + #𖵞; + #𖵟; + #𖵠; + #𖵡; + #𖵢; + #𖵣; + #𖵤; + #𖵥; + #𖵦; + #𖵧; + #𖵨; + #𖵩; + #𖵪; + #𖵫; + #𖵬; + #𘳿; + #𞗐; + #𞗑; + #𞗒; + #𞗓; + #𞗔; + #𞗕; + #𞗖; + #𞗗; + #𞗘; + #𞗙; + #𞗚; + #𞗛; + #𞗜; + #𞗝; + #𞗞; + #𞗟; + #𞗠; + #𞗡; + #𞗢; + #𞗣; + #𞗤; + #𞗥; + #𞗦; + #𞗧; + #𞗨; + #𞗩; + #𞗪; + #𞗫; + #𞗬; + #𞗭; + #𞗰; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0-escaped.js new file mode 100644 index 000000000..9dd44e149 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0-escaped.js @@ -0,0 +1,4317 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v16.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u1C89; +var \u1C8A; +var \uA7CB; +var \uA7CC; +var \uA7CD; +var \uA7DA; +var \uA7DB; +var \uA7DC; +var \u{105C0}; +var \u{105C1}; +var \u{105C2}; +var \u{105C3}; +var \u{105C4}; +var \u{105C5}; +var \u{105C6}; +var \u{105C7}; +var \u{105C8}; +var \u{105C9}; +var \u{105CA}; +var \u{105CB}; +var \u{105CC}; +var \u{105CD}; +var \u{105CE}; +var \u{105CF}; +var \u{105D0}; +var \u{105D1}; +var \u{105D2}; +var \u{105D3}; +var \u{105D4}; +var \u{105D5}; +var \u{105D6}; +var \u{105D7}; +var \u{105D8}; +var \u{105D9}; +var \u{105DA}; +var \u{105DB}; +var \u{105DC}; +var \u{105DD}; +var \u{105DE}; +var \u{105DF}; +var \u{105E0}; +var \u{105E1}; +var \u{105E2}; +var \u{105E3}; +var \u{105E4}; +var \u{105E5}; +var \u{105E6}; +var \u{105E7}; +var \u{105E8}; +var \u{105E9}; +var \u{105EA}; +var \u{105EB}; +var \u{105EC}; +var \u{105ED}; +var \u{105EE}; +var \u{105EF}; +var \u{105F0}; +var \u{105F1}; +var \u{105F2}; +var \u{105F3}; +var \u{10D4A}; +var \u{10D4B}; +var \u{10D4C}; +var \u{10D4D}; +var \u{10D4E}; +var \u{10D4F}; +var \u{10D50}; +var \u{10D51}; +var \u{10D52}; +var \u{10D53}; +var \u{10D54}; +var \u{10D55}; +var \u{10D56}; +var \u{10D57}; +var \u{10D58}; +var \u{10D59}; +var \u{10D5A}; +var \u{10D5B}; +var \u{10D5C}; +var \u{10D5D}; +var \u{10D5E}; +var \u{10D5F}; +var \u{10D60}; +var \u{10D61}; +var \u{10D62}; +var \u{10D63}; +var \u{10D64}; +var \u{10D65}; +var \u{10D6F}; +var \u{10D70}; +var \u{10D71}; +var \u{10D72}; +var \u{10D73}; +var \u{10D74}; +var \u{10D75}; +var \u{10D76}; +var \u{10D77}; +var \u{10D78}; +var \u{10D79}; +var \u{10D7A}; +var \u{10D7B}; +var \u{10D7C}; +var \u{10D7D}; +var \u{10D7E}; +var \u{10D7F}; +var \u{10D80}; +var \u{10D81}; +var \u{10D82}; +var \u{10D83}; +var \u{10D84}; +var \u{10D85}; +var \u{10EC2}; +var \u{10EC3}; +var \u{10EC4}; +var \u{11380}; +var \u{11381}; +var \u{11382}; +var \u{11383}; +var \u{11384}; +var \u{11385}; +var \u{11386}; +var \u{11387}; +var \u{11388}; +var \u{11389}; +var \u{1138B}; +var \u{1138E}; +var \u{11390}; +var \u{11391}; +var \u{11392}; +var \u{11393}; +var \u{11394}; +var \u{11395}; +var \u{11396}; +var \u{11397}; +var \u{11398}; +var \u{11399}; +var \u{1139A}; +var \u{1139B}; +var \u{1139C}; +var \u{1139D}; +var \u{1139E}; +var \u{1139F}; +var \u{113A0}; +var \u{113A1}; +var \u{113A2}; +var \u{113A3}; +var \u{113A4}; +var \u{113A5}; +var \u{113A6}; +var \u{113A7}; +var \u{113A8}; +var \u{113A9}; +var \u{113AA}; +var \u{113AB}; +var \u{113AC}; +var \u{113AD}; +var \u{113AE}; +var \u{113AF}; +var \u{113B0}; +var \u{113B1}; +var \u{113B2}; +var \u{113B3}; +var \u{113B4}; +var \u{113B5}; +var \u{113B7}; +var \u{113D1}; +var \u{113D3}; +var \u{11BC0}; +var \u{11BC1}; +var \u{11BC2}; +var \u{11BC3}; +var \u{11BC4}; +var \u{11BC5}; +var \u{11BC6}; +var \u{11BC7}; +var \u{11BC8}; +var \u{11BC9}; +var \u{11BCA}; +var \u{11BCB}; +var \u{11BCC}; +var \u{11BCD}; +var \u{11BCE}; +var \u{11BCF}; +var \u{11BD0}; +var \u{11BD1}; +var \u{11BD2}; +var \u{11BD3}; +var \u{11BD4}; +var \u{11BD5}; +var \u{11BD6}; +var \u{11BD7}; +var \u{11BD8}; +var \u{11BD9}; +var \u{11BDA}; +var \u{11BDB}; +var \u{11BDC}; +var \u{11BDD}; +var \u{11BDE}; +var \u{11BDF}; +var \u{11BE0}; +var \u{13460}; +var \u{13461}; +var \u{13462}; +var \u{13463}; +var \u{13464}; +var \u{13465}; +var \u{13466}; +var \u{13467}; +var \u{13468}; +var \u{13469}; +var \u{1346A}; +var \u{1346B}; +var \u{1346C}; +var \u{1346D}; +var \u{1346E}; +var \u{1346F}; +var \u{13470}; +var \u{13471}; +var \u{13472}; +var \u{13473}; +var \u{13474}; +var \u{13475}; +var \u{13476}; +var \u{13477}; +var \u{13478}; +var \u{13479}; +var \u{1347A}; +var \u{1347B}; +var \u{1347C}; +var \u{1347D}; +var \u{1347E}; +var \u{1347F}; +var \u{13480}; +var \u{13481}; +var \u{13482}; +var \u{13483}; +var \u{13484}; +var \u{13485}; +var \u{13486}; +var \u{13487}; +var \u{13488}; +var \u{13489}; +var \u{1348A}; +var \u{1348B}; +var \u{1348C}; +var \u{1348D}; +var \u{1348E}; +var \u{1348F}; +var \u{13490}; +var \u{13491}; +var \u{13492}; +var \u{13493}; +var \u{13494}; +var \u{13495}; +var \u{13496}; +var \u{13497}; +var \u{13498}; +var \u{13499}; +var \u{1349A}; +var \u{1349B}; +var \u{1349C}; +var \u{1349D}; +var \u{1349E}; +var \u{1349F}; +var \u{134A0}; +var \u{134A1}; +var \u{134A2}; +var \u{134A3}; +var \u{134A4}; +var \u{134A5}; +var \u{134A6}; +var \u{134A7}; +var \u{134A8}; +var \u{134A9}; +var \u{134AA}; +var \u{134AB}; +var \u{134AC}; +var \u{134AD}; +var \u{134AE}; +var \u{134AF}; +var \u{134B0}; +var \u{134B1}; +var \u{134B2}; +var \u{134B3}; +var \u{134B4}; +var \u{134B5}; +var \u{134B6}; +var \u{134B7}; +var \u{134B8}; +var \u{134B9}; +var \u{134BA}; +var \u{134BB}; +var \u{134BC}; +var \u{134BD}; +var \u{134BE}; +var \u{134BF}; +var \u{134C0}; +var \u{134C1}; +var \u{134C2}; +var \u{134C3}; +var \u{134C4}; +var \u{134C5}; +var \u{134C6}; +var \u{134C7}; +var \u{134C8}; +var \u{134C9}; +var \u{134CA}; +var \u{134CB}; +var \u{134CC}; +var \u{134CD}; +var \u{134CE}; +var \u{134CF}; +var \u{134D0}; +var \u{134D1}; +var \u{134D2}; +var \u{134D3}; +var \u{134D4}; +var \u{134D5}; +var \u{134D6}; +var \u{134D7}; +var \u{134D8}; +var \u{134D9}; +var \u{134DA}; +var \u{134DB}; +var \u{134DC}; +var \u{134DD}; +var \u{134DE}; +var \u{134DF}; +var \u{134E0}; +var \u{134E1}; +var \u{134E2}; +var \u{134E3}; +var \u{134E4}; +var \u{134E5}; +var \u{134E6}; +var \u{134E7}; +var \u{134E8}; +var \u{134E9}; +var \u{134EA}; +var \u{134EB}; +var \u{134EC}; +var \u{134ED}; +var \u{134EE}; +var \u{134EF}; +var \u{134F0}; +var \u{134F1}; +var \u{134F2}; +var \u{134F3}; +var \u{134F4}; +var \u{134F5}; +var \u{134F6}; +var \u{134F7}; +var \u{134F8}; +var \u{134F9}; +var \u{134FA}; +var \u{134FB}; +var \u{134FC}; +var \u{134FD}; +var \u{134FE}; +var \u{134FF}; +var \u{13500}; +var \u{13501}; +var \u{13502}; +var \u{13503}; +var \u{13504}; +var \u{13505}; +var \u{13506}; +var \u{13507}; +var \u{13508}; +var \u{13509}; +var \u{1350A}; +var \u{1350B}; +var \u{1350C}; +var \u{1350D}; +var \u{1350E}; +var \u{1350F}; +var \u{13510}; +var \u{13511}; +var \u{13512}; +var \u{13513}; +var \u{13514}; +var \u{13515}; +var \u{13516}; +var \u{13517}; +var \u{13518}; +var \u{13519}; +var \u{1351A}; +var \u{1351B}; +var \u{1351C}; +var \u{1351D}; +var \u{1351E}; +var \u{1351F}; +var \u{13520}; +var \u{13521}; +var \u{13522}; +var \u{13523}; +var \u{13524}; +var \u{13525}; +var \u{13526}; +var \u{13527}; +var \u{13528}; +var \u{13529}; +var \u{1352A}; +var \u{1352B}; +var \u{1352C}; +var \u{1352D}; +var \u{1352E}; +var \u{1352F}; +var \u{13530}; +var \u{13531}; +var \u{13532}; +var \u{13533}; +var \u{13534}; +var \u{13535}; +var \u{13536}; +var \u{13537}; +var \u{13538}; +var \u{13539}; +var \u{1353A}; +var \u{1353B}; +var \u{1353C}; +var \u{1353D}; +var \u{1353E}; +var \u{1353F}; +var \u{13540}; +var \u{13541}; +var \u{13542}; +var \u{13543}; +var \u{13544}; +var \u{13545}; +var \u{13546}; +var \u{13547}; +var \u{13548}; +var \u{13549}; +var \u{1354A}; +var \u{1354B}; +var \u{1354C}; +var \u{1354D}; +var \u{1354E}; +var \u{1354F}; +var \u{13550}; +var \u{13551}; +var \u{13552}; +var \u{13553}; +var \u{13554}; +var \u{13555}; +var \u{13556}; +var \u{13557}; +var \u{13558}; +var \u{13559}; +var \u{1355A}; +var \u{1355B}; +var \u{1355C}; +var \u{1355D}; +var \u{1355E}; +var \u{1355F}; +var \u{13560}; +var \u{13561}; +var \u{13562}; +var \u{13563}; +var \u{13564}; +var \u{13565}; +var \u{13566}; +var \u{13567}; +var \u{13568}; +var \u{13569}; +var \u{1356A}; +var \u{1356B}; +var \u{1356C}; +var \u{1356D}; +var \u{1356E}; +var \u{1356F}; +var \u{13570}; +var \u{13571}; +var \u{13572}; +var \u{13573}; +var \u{13574}; +var \u{13575}; +var \u{13576}; +var \u{13577}; +var \u{13578}; +var \u{13579}; +var \u{1357A}; +var \u{1357B}; +var \u{1357C}; +var \u{1357D}; +var \u{1357E}; +var \u{1357F}; +var \u{13580}; +var \u{13581}; +var \u{13582}; +var \u{13583}; +var \u{13584}; +var \u{13585}; +var \u{13586}; +var \u{13587}; +var \u{13588}; +var \u{13589}; +var \u{1358A}; +var \u{1358B}; +var \u{1358C}; +var \u{1358D}; +var \u{1358E}; +var \u{1358F}; +var \u{13590}; +var \u{13591}; +var \u{13592}; +var \u{13593}; +var \u{13594}; +var \u{13595}; +var \u{13596}; +var \u{13597}; +var \u{13598}; +var \u{13599}; +var \u{1359A}; +var \u{1359B}; +var \u{1359C}; +var \u{1359D}; +var \u{1359E}; +var \u{1359F}; +var \u{135A0}; +var \u{135A1}; +var \u{135A2}; +var \u{135A3}; +var \u{135A4}; +var \u{135A5}; +var \u{135A6}; +var \u{135A7}; +var \u{135A8}; +var \u{135A9}; +var \u{135AA}; +var \u{135AB}; +var \u{135AC}; +var \u{135AD}; +var \u{135AE}; +var \u{135AF}; +var \u{135B0}; +var \u{135B1}; +var \u{135B2}; +var \u{135B3}; +var \u{135B4}; +var \u{135B5}; +var \u{135B6}; +var \u{135B7}; +var \u{135B8}; +var \u{135B9}; +var \u{135BA}; +var \u{135BB}; +var \u{135BC}; +var \u{135BD}; +var \u{135BE}; +var \u{135BF}; +var \u{135C0}; +var \u{135C1}; +var \u{135C2}; +var \u{135C3}; +var \u{135C4}; +var \u{135C5}; +var \u{135C6}; +var \u{135C7}; +var \u{135C8}; +var \u{135C9}; +var \u{135CA}; +var \u{135CB}; +var \u{135CC}; +var \u{135CD}; +var \u{135CE}; +var \u{135CF}; +var \u{135D0}; +var \u{135D1}; +var \u{135D2}; +var \u{135D3}; +var \u{135D4}; +var \u{135D5}; +var \u{135D6}; +var \u{135D7}; +var \u{135D8}; +var \u{135D9}; +var \u{135DA}; +var \u{135DB}; +var \u{135DC}; +var \u{135DD}; +var \u{135DE}; +var \u{135DF}; +var \u{135E0}; +var \u{135E1}; +var \u{135E2}; +var \u{135E3}; +var \u{135E4}; +var \u{135E5}; +var \u{135E6}; +var \u{135E7}; +var \u{135E8}; +var \u{135E9}; +var \u{135EA}; +var \u{135EB}; +var \u{135EC}; +var \u{135ED}; +var \u{135EE}; +var \u{135EF}; +var \u{135F0}; +var \u{135F1}; +var \u{135F2}; +var \u{135F3}; +var \u{135F4}; +var \u{135F5}; +var \u{135F6}; +var \u{135F7}; +var \u{135F8}; +var \u{135F9}; +var \u{135FA}; +var \u{135FB}; +var \u{135FC}; +var \u{135FD}; +var \u{135FE}; +var \u{135FF}; +var \u{13600}; +var \u{13601}; +var \u{13602}; +var \u{13603}; +var \u{13604}; +var \u{13605}; +var \u{13606}; +var \u{13607}; +var \u{13608}; +var \u{13609}; +var \u{1360A}; +var \u{1360B}; +var \u{1360C}; +var \u{1360D}; +var \u{1360E}; +var \u{1360F}; +var \u{13610}; +var \u{13611}; +var \u{13612}; +var \u{13613}; +var \u{13614}; +var \u{13615}; +var \u{13616}; +var \u{13617}; +var \u{13618}; +var \u{13619}; +var \u{1361A}; +var \u{1361B}; +var \u{1361C}; +var \u{1361D}; +var \u{1361E}; +var \u{1361F}; +var \u{13620}; +var \u{13621}; +var \u{13622}; +var \u{13623}; +var \u{13624}; +var \u{13625}; +var \u{13626}; +var \u{13627}; +var \u{13628}; +var \u{13629}; +var \u{1362A}; +var \u{1362B}; +var \u{1362C}; +var \u{1362D}; +var \u{1362E}; +var \u{1362F}; +var \u{13630}; +var \u{13631}; +var \u{13632}; +var \u{13633}; +var \u{13634}; +var \u{13635}; +var \u{13636}; +var \u{13637}; +var \u{13638}; +var \u{13639}; +var \u{1363A}; +var \u{1363B}; +var \u{1363C}; +var \u{1363D}; +var \u{1363E}; +var \u{1363F}; +var \u{13640}; +var \u{13641}; +var \u{13642}; +var \u{13643}; +var \u{13644}; +var \u{13645}; +var \u{13646}; +var \u{13647}; +var \u{13648}; +var \u{13649}; +var \u{1364A}; +var \u{1364B}; +var \u{1364C}; +var \u{1364D}; +var \u{1364E}; +var \u{1364F}; +var \u{13650}; +var \u{13651}; +var \u{13652}; +var \u{13653}; +var \u{13654}; +var \u{13655}; +var \u{13656}; +var \u{13657}; +var \u{13658}; +var \u{13659}; +var \u{1365A}; +var \u{1365B}; +var \u{1365C}; +var \u{1365D}; +var \u{1365E}; +var \u{1365F}; +var \u{13660}; +var \u{13661}; +var \u{13662}; +var \u{13663}; +var \u{13664}; +var \u{13665}; +var \u{13666}; +var \u{13667}; +var \u{13668}; +var \u{13669}; +var \u{1366A}; +var \u{1366B}; +var \u{1366C}; +var \u{1366D}; +var \u{1366E}; +var \u{1366F}; +var \u{13670}; +var \u{13671}; +var \u{13672}; +var \u{13673}; +var \u{13674}; +var \u{13675}; +var \u{13676}; +var \u{13677}; +var \u{13678}; +var \u{13679}; +var \u{1367A}; +var \u{1367B}; +var \u{1367C}; +var \u{1367D}; +var \u{1367E}; +var \u{1367F}; +var \u{13680}; +var \u{13681}; +var \u{13682}; +var \u{13683}; +var \u{13684}; +var \u{13685}; +var \u{13686}; +var \u{13687}; +var \u{13688}; +var \u{13689}; +var \u{1368A}; +var \u{1368B}; +var \u{1368C}; +var \u{1368D}; +var \u{1368E}; +var \u{1368F}; +var \u{13690}; +var \u{13691}; +var \u{13692}; +var \u{13693}; +var \u{13694}; +var \u{13695}; +var \u{13696}; +var \u{13697}; +var \u{13698}; +var \u{13699}; +var \u{1369A}; +var \u{1369B}; +var \u{1369C}; +var \u{1369D}; +var \u{1369E}; +var \u{1369F}; +var \u{136A0}; +var \u{136A1}; +var \u{136A2}; +var \u{136A3}; +var \u{136A4}; +var \u{136A5}; +var \u{136A6}; +var \u{136A7}; +var \u{136A8}; +var \u{136A9}; +var \u{136AA}; +var \u{136AB}; +var \u{136AC}; +var \u{136AD}; +var \u{136AE}; +var \u{136AF}; +var \u{136B0}; +var \u{136B1}; +var \u{136B2}; +var \u{136B3}; +var \u{136B4}; +var \u{136B5}; +var \u{136B6}; +var \u{136B7}; +var \u{136B8}; +var \u{136B9}; +var \u{136BA}; +var \u{136BB}; +var \u{136BC}; +var \u{136BD}; +var \u{136BE}; +var \u{136BF}; +var \u{136C0}; +var \u{136C1}; +var \u{136C2}; +var \u{136C3}; +var \u{136C4}; +var \u{136C5}; +var \u{136C6}; +var \u{136C7}; +var \u{136C8}; +var \u{136C9}; +var \u{136CA}; +var \u{136CB}; +var \u{136CC}; +var \u{136CD}; +var \u{136CE}; +var \u{136CF}; +var \u{136D0}; +var \u{136D1}; +var \u{136D2}; +var \u{136D3}; +var \u{136D4}; +var \u{136D5}; +var \u{136D6}; +var \u{136D7}; +var \u{136D8}; +var \u{136D9}; +var \u{136DA}; +var \u{136DB}; +var \u{136DC}; +var \u{136DD}; +var \u{136DE}; +var \u{136DF}; +var \u{136E0}; +var \u{136E1}; +var \u{136E2}; +var \u{136E3}; +var \u{136E4}; +var \u{136E5}; +var \u{136E6}; +var \u{136E7}; +var \u{136E8}; +var \u{136E9}; +var \u{136EA}; +var \u{136EB}; +var \u{136EC}; +var \u{136ED}; +var \u{136EE}; +var \u{136EF}; +var \u{136F0}; +var \u{136F1}; +var \u{136F2}; +var \u{136F3}; +var \u{136F4}; +var \u{136F5}; +var \u{136F6}; +var \u{136F7}; +var \u{136F8}; +var \u{136F9}; +var \u{136FA}; +var \u{136FB}; +var \u{136FC}; +var \u{136FD}; +var \u{136FE}; +var \u{136FF}; +var \u{13700}; +var \u{13701}; +var \u{13702}; +var \u{13703}; +var \u{13704}; +var \u{13705}; +var \u{13706}; +var \u{13707}; +var \u{13708}; +var \u{13709}; +var \u{1370A}; +var \u{1370B}; +var \u{1370C}; +var \u{1370D}; +var \u{1370E}; +var \u{1370F}; +var \u{13710}; +var \u{13711}; +var \u{13712}; +var \u{13713}; +var \u{13714}; +var \u{13715}; +var \u{13716}; +var \u{13717}; +var \u{13718}; +var \u{13719}; +var \u{1371A}; +var \u{1371B}; +var \u{1371C}; +var \u{1371D}; +var \u{1371E}; +var \u{1371F}; +var \u{13720}; +var \u{13721}; +var \u{13722}; +var \u{13723}; +var \u{13724}; +var \u{13725}; +var \u{13726}; +var \u{13727}; +var \u{13728}; +var \u{13729}; +var \u{1372A}; +var \u{1372B}; +var \u{1372C}; +var \u{1372D}; +var \u{1372E}; +var \u{1372F}; +var \u{13730}; +var \u{13731}; +var \u{13732}; +var \u{13733}; +var \u{13734}; +var \u{13735}; +var \u{13736}; +var \u{13737}; +var \u{13738}; +var \u{13739}; +var \u{1373A}; +var \u{1373B}; +var \u{1373C}; +var \u{1373D}; +var \u{1373E}; +var \u{1373F}; +var \u{13740}; +var \u{13741}; +var \u{13742}; +var \u{13743}; +var \u{13744}; +var \u{13745}; +var \u{13746}; +var \u{13747}; +var \u{13748}; +var \u{13749}; +var \u{1374A}; +var \u{1374B}; +var \u{1374C}; +var \u{1374D}; +var \u{1374E}; +var \u{1374F}; +var \u{13750}; +var \u{13751}; +var \u{13752}; +var \u{13753}; +var \u{13754}; +var \u{13755}; +var \u{13756}; +var \u{13757}; +var \u{13758}; +var \u{13759}; +var \u{1375A}; +var \u{1375B}; +var \u{1375C}; +var \u{1375D}; +var \u{1375E}; +var \u{1375F}; +var \u{13760}; +var \u{13761}; +var \u{13762}; +var \u{13763}; +var \u{13764}; +var \u{13765}; +var \u{13766}; +var \u{13767}; +var \u{13768}; +var \u{13769}; +var \u{1376A}; +var \u{1376B}; +var \u{1376C}; +var \u{1376D}; +var \u{1376E}; +var \u{1376F}; +var \u{13770}; +var \u{13771}; +var \u{13772}; +var \u{13773}; +var \u{13774}; +var \u{13775}; +var \u{13776}; +var \u{13777}; +var \u{13778}; +var \u{13779}; +var \u{1377A}; +var \u{1377B}; +var \u{1377C}; +var \u{1377D}; +var \u{1377E}; +var \u{1377F}; +var \u{13780}; +var \u{13781}; +var \u{13782}; +var \u{13783}; +var \u{13784}; +var \u{13785}; +var \u{13786}; +var \u{13787}; +var \u{13788}; +var \u{13789}; +var \u{1378A}; +var \u{1378B}; +var \u{1378C}; +var \u{1378D}; +var \u{1378E}; +var \u{1378F}; +var \u{13790}; +var \u{13791}; +var \u{13792}; +var \u{13793}; +var \u{13794}; +var \u{13795}; +var \u{13796}; +var \u{13797}; +var \u{13798}; +var \u{13799}; +var \u{1379A}; +var \u{1379B}; +var \u{1379C}; +var \u{1379D}; +var \u{1379E}; +var \u{1379F}; +var \u{137A0}; +var \u{137A1}; +var \u{137A2}; +var \u{137A3}; +var \u{137A4}; +var \u{137A5}; +var \u{137A6}; +var \u{137A7}; +var \u{137A8}; +var \u{137A9}; +var \u{137AA}; +var \u{137AB}; +var \u{137AC}; +var \u{137AD}; +var \u{137AE}; +var \u{137AF}; +var \u{137B0}; +var \u{137B1}; +var \u{137B2}; +var \u{137B3}; +var \u{137B4}; +var \u{137B5}; +var \u{137B6}; +var \u{137B7}; +var \u{137B8}; +var \u{137B9}; +var \u{137BA}; +var \u{137BB}; +var \u{137BC}; +var \u{137BD}; +var \u{137BE}; +var \u{137BF}; +var \u{137C0}; +var \u{137C1}; +var \u{137C2}; +var \u{137C3}; +var \u{137C4}; +var \u{137C5}; +var \u{137C6}; +var \u{137C7}; +var \u{137C8}; +var \u{137C9}; +var \u{137CA}; +var \u{137CB}; +var \u{137CC}; +var \u{137CD}; +var \u{137CE}; +var \u{137CF}; +var \u{137D0}; +var \u{137D1}; +var \u{137D2}; +var \u{137D3}; +var \u{137D4}; +var \u{137D5}; +var \u{137D6}; +var \u{137D7}; +var \u{137D8}; +var \u{137D9}; +var \u{137DA}; +var \u{137DB}; +var \u{137DC}; +var \u{137DD}; +var \u{137DE}; +var \u{137DF}; +var \u{137E0}; +var \u{137E1}; +var \u{137E2}; +var \u{137E3}; +var \u{137E4}; +var \u{137E5}; +var \u{137E6}; +var \u{137E7}; +var \u{137E8}; +var \u{137E9}; +var \u{137EA}; +var \u{137EB}; +var \u{137EC}; +var \u{137ED}; +var \u{137EE}; +var \u{137EF}; +var \u{137F0}; +var \u{137F1}; +var \u{137F2}; +var \u{137F3}; +var \u{137F4}; +var \u{137F5}; +var \u{137F6}; +var \u{137F7}; +var \u{137F8}; +var \u{137F9}; +var \u{137FA}; +var \u{137FB}; +var \u{137FC}; +var \u{137FD}; +var \u{137FE}; +var \u{137FF}; +var \u{13800}; +var \u{13801}; +var \u{13802}; +var \u{13803}; +var \u{13804}; +var \u{13805}; +var \u{13806}; +var \u{13807}; +var \u{13808}; +var \u{13809}; +var \u{1380A}; +var \u{1380B}; +var \u{1380C}; +var \u{1380D}; +var \u{1380E}; +var \u{1380F}; +var \u{13810}; +var \u{13811}; +var \u{13812}; +var \u{13813}; +var \u{13814}; +var \u{13815}; +var \u{13816}; +var \u{13817}; +var \u{13818}; +var \u{13819}; +var \u{1381A}; +var \u{1381B}; +var \u{1381C}; +var \u{1381D}; +var \u{1381E}; +var \u{1381F}; +var \u{13820}; +var \u{13821}; +var \u{13822}; +var \u{13823}; +var \u{13824}; +var \u{13825}; +var \u{13826}; +var \u{13827}; +var \u{13828}; +var \u{13829}; +var \u{1382A}; +var \u{1382B}; +var \u{1382C}; +var \u{1382D}; +var \u{1382E}; +var \u{1382F}; +var \u{13830}; +var \u{13831}; +var \u{13832}; +var \u{13833}; +var \u{13834}; +var \u{13835}; +var \u{13836}; +var \u{13837}; +var \u{13838}; +var \u{13839}; +var \u{1383A}; +var \u{1383B}; +var \u{1383C}; +var \u{1383D}; +var \u{1383E}; +var \u{1383F}; +var \u{13840}; +var \u{13841}; +var \u{13842}; +var \u{13843}; +var \u{13844}; +var \u{13845}; +var \u{13846}; +var \u{13847}; +var \u{13848}; +var \u{13849}; +var \u{1384A}; +var \u{1384B}; +var \u{1384C}; +var \u{1384D}; +var \u{1384E}; +var \u{1384F}; +var \u{13850}; +var \u{13851}; +var \u{13852}; +var \u{13853}; +var \u{13854}; +var \u{13855}; +var \u{13856}; +var \u{13857}; +var \u{13858}; +var \u{13859}; +var \u{1385A}; +var \u{1385B}; +var \u{1385C}; +var \u{1385D}; +var \u{1385E}; +var \u{1385F}; +var \u{13860}; +var \u{13861}; +var \u{13862}; +var \u{13863}; +var \u{13864}; +var \u{13865}; +var \u{13866}; +var \u{13867}; +var \u{13868}; +var \u{13869}; +var \u{1386A}; +var \u{1386B}; +var \u{1386C}; +var \u{1386D}; +var \u{1386E}; +var \u{1386F}; +var \u{13870}; +var \u{13871}; +var \u{13872}; +var \u{13873}; +var \u{13874}; +var \u{13875}; +var \u{13876}; +var \u{13877}; +var \u{13878}; +var \u{13879}; +var \u{1387A}; +var \u{1387B}; +var \u{1387C}; +var \u{1387D}; +var \u{1387E}; +var \u{1387F}; +var \u{13880}; +var \u{13881}; +var \u{13882}; +var \u{13883}; +var \u{13884}; +var \u{13885}; +var \u{13886}; +var \u{13887}; +var \u{13888}; +var \u{13889}; +var \u{1388A}; +var \u{1388B}; +var \u{1388C}; +var \u{1388D}; +var \u{1388E}; +var \u{1388F}; +var \u{13890}; +var \u{13891}; +var \u{13892}; +var \u{13893}; +var \u{13894}; +var \u{13895}; +var \u{13896}; +var \u{13897}; +var \u{13898}; +var \u{13899}; +var \u{1389A}; +var \u{1389B}; +var \u{1389C}; +var \u{1389D}; +var \u{1389E}; +var \u{1389F}; +var \u{138A0}; +var \u{138A1}; +var \u{138A2}; +var \u{138A3}; +var \u{138A4}; +var \u{138A5}; +var \u{138A6}; +var \u{138A7}; +var \u{138A8}; +var \u{138A9}; +var \u{138AA}; +var \u{138AB}; +var \u{138AC}; +var \u{138AD}; +var \u{138AE}; +var \u{138AF}; +var \u{138B0}; +var \u{138B1}; +var \u{138B2}; +var \u{138B3}; +var \u{138B4}; +var \u{138B5}; +var \u{138B6}; +var \u{138B7}; +var \u{138B8}; +var \u{138B9}; +var \u{138BA}; +var \u{138BB}; +var \u{138BC}; +var \u{138BD}; +var \u{138BE}; +var \u{138BF}; +var \u{138C0}; +var \u{138C1}; +var \u{138C2}; +var \u{138C3}; +var \u{138C4}; +var \u{138C5}; +var \u{138C6}; +var \u{138C7}; +var \u{138C8}; +var \u{138C9}; +var \u{138CA}; +var \u{138CB}; +var \u{138CC}; +var \u{138CD}; +var \u{138CE}; +var \u{138CF}; +var \u{138D0}; +var \u{138D1}; +var \u{138D2}; +var \u{138D3}; +var \u{138D4}; +var \u{138D5}; +var \u{138D6}; +var \u{138D7}; +var \u{138D8}; +var \u{138D9}; +var \u{138DA}; +var \u{138DB}; +var \u{138DC}; +var \u{138DD}; +var \u{138DE}; +var \u{138DF}; +var \u{138E0}; +var \u{138E1}; +var \u{138E2}; +var \u{138E3}; +var \u{138E4}; +var \u{138E5}; +var \u{138E6}; +var \u{138E7}; +var \u{138E8}; +var \u{138E9}; +var \u{138EA}; +var \u{138EB}; +var \u{138EC}; +var \u{138ED}; +var \u{138EE}; +var \u{138EF}; +var \u{138F0}; +var \u{138F1}; +var \u{138F2}; +var \u{138F3}; +var \u{138F4}; +var \u{138F5}; +var \u{138F6}; +var \u{138F7}; +var \u{138F8}; +var \u{138F9}; +var \u{138FA}; +var \u{138FB}; +var \u{138FC}; +var \u{138FD}; +var \u{138FE}; +var \u{138FF}; +var \u{13900}; +var \u{13901}; +var \u{13902}; +var \u{13903}; +var \u{13904}; +var \u{13905}; +var \u{13906}; +var \u{13907}; +var \u{13908}; +var \u{13909}; +var \u{1390A}; +var \u{1390B}; +var \u{1390C}; +var \u{1390D}; +var \u{1390E}; +var \u{1390F}; +var \u{13910}; +var \u{13911}; +var \u{13912}; +var \u{13913}; +var \u{13914}; +var \u{13915}; +var \u{13916}; +var \u{13917}; +var \u{13918}; +var \u{13919}; +var \u{1391A}; +var \u{1391B}; +var \u{1391C}; +var \u{1391D}; +var \u{1391E}; +var \u{1391F}; +var \u{13920}; +var \u{13921}; +var \u{13922}; +var \u{13923}; +var \u{13924}; +var \u{13925}; +var \u{13926}; +var \u{13927}; +var \u{13928}; +var \u{13929}; +var \u{1392A}; +var \u{1392B}; +var \u{1392C}; +var \u{1392D}; +var \u{1392E}; +var \u{1392F}; +var \u{13930}; +var \u{13931}; +var \u{13932}; +var \u{13933}; +var \u{13934}; +var \u{13935}; +var \u{13936}; +var \u{13937}; +var \u{13938}; +var \u{13939}; +var \u{1393A}; +var \u{1393B}; +var \u{1393C}; +var \u{1393D}; +var \u{1393E}; +var \u{1393F}; +var \u{13940}; +var \u{13941}; +var \u{13942}; +var \u{13943}; +var \u{13944}; +var \u{13945}; +var \u{13946}; +var \u{13947}; +var \u{13948}; +var \u{13949}; +var \u{1394A}; +var \u{1394B}; +var \u{1394C}; +var \u{1394D}; +var \u{1394E}; +var \u{1394F}; +var \u{13950}; +var \u{13951}; +var \u{13952}; +var \u{13953}; +var \u{13954}; +var \u{13955}; +var \u{13956}; +var \u{13957}; +var \u{13958}; +var \u{13959}; +var \u{1395A}; +var \u{1395B}; +var \u{1395C}; +var \u{1395D}; +var \u{1395E}; +var \u{1395F}; +var \u{13960}; +var \u{13961}; +var \u{13962}; +var \u{13963}; +var \u{13964}; +var \u{13965}; +var \u{13966}; +var \u{13967}; +var \u{13968}; +var \u{13969}; +var \u{1396A}; +var \u{1396B}; +var \u{1396C}; +var \u{1396D}; +var \u{1396E}; +var \u{1396F}; +var \u{13970}; +var \u{13971}; +var \u{13972}; +var \u{13973}; +var \u{13974}; +var \u{13975}; +var \u{13976}; +var \u{13977}; +var \u{13978}; +var \u{13979}; +var \u{1397A}; +var \u{1397B}; +var \u{1397C}; +var \u{1397D}; +var \u{1397E}; +var \u{1397F}; +var \u{13980}; +var \u{13981}; +var \u{13982}; +var \u{13983}; +var \u{13984}; +var \u{13985}; +var \u{13986}; +var \u{13987}; +var \u{13988}; +var \u{13989}; +var \u{1398A}; +var \u{1398B}; +var \u{1398C}; +var \u{1398D}; +var \u{1398E}; +var \u{1398F}; +var \u{13990}; +var \u{13991}; +var \u{13992}; +var \u{13993}; +var \u{13994}; +var \u{13995}; +var \u{13996}; +var \u{13997}; +var \u{13998}; +var \u{13999}; +var \u{1399A}; +var \u{1399B}; +var \u{1399C}; +var \u{1399D}; +var \u{1399E}; +var \u{1399F}; +var \u{139A0}; +var \u{139A1}; +var \u{139A2}; +var \u{139A3}; +var \u{139A4}; +var \u{139A5}; +var \u{139A6}; +var \u{139A7}; +var \u{139A8}; +var \u{139A9}; +var \u{139AA}; +var \u{139AB}; +var \u{139AC}; +var \u{139AD}; +var \u{139AE}; +var \u{139AF}; +var \u{139B0}; +var \u{139B1}; +var \u{139B2}; +var \u{139B3}; +var \u{139B4}; +var \u{139B5}; +var \u{139B6}; +var \u{139B7}; +var \u{139B8}; +var \u{139B9}; +var \u{139BA}; +var \u{139BB}; +var \u{139BC}; +var \u{139BD}; +var \u{139BE}; +var \u{139BF}; +var \u{139C0}; +var \u{139C1}; +var \u{139C2}; +var \u{139C3}; +var \u{139C4}; +var \u{139C5}; +var \u{139C6}; +var \u{139C7}; +var \u{139C8}; +var \u{139C9}; +var \u{139CA}; +var \u{139CB}; +var \u{139CC}; +var \u{139CD}; +var \u{139CE}; +var \u{139CF}; +var \u{139D0}; +var \u{139D1}; +var \u{139D2}; +var \u{139D3}; +var \u{139D4}; +var \u{139D5}; +var \u{139D6}; +var \u{139D7}; +var \u{139D8}; +var \u{139D9}; +var \u{139DA}; +var \u{139DB}; +var \u{139DC}; +var \u{139DD}; +var \u{139DE}; +var \u{139DF}; +var \u{139E0}; +var \u{139E1}; +var \u{139E2}; +var \u{139E3}; +var \u{139E4}; +var \u{139E5}; +var \u{139E6}; +var \u{139E7}; +var \u{139E8}; +var \u{139E9}; +var \u{139EA}; +var \u{139EB}; +var \u{139EC}; +var \u{139ED}; +var \u{139EE}; +var \u{139EF}; +var \u{139F0}; +var \u{139F1}; +var \u{139F2}; +var \u{139F3}; +var \u{139F4}; +var \u{139F5}; +var \u{139F6}; +var \u{139F7}; +var \u{139F8}; +var \u{139F9}; +var \u{139FA}; +var \u{139FB}; +var \u{139FC}; +var \u{139FD}; +var \u{139FE}; +var \u{139FF}; +var \u{13A00}; +var \u{13A01}; +var \u{13A02}; +var \u{13A03}; +var \u{13A04}; +var \u{13A05}; +var \u{13A06}; +var \u{13A07}; +var \u{13A08}; +var \u{13A09}; +var \u{13A0A}; +var \u{13A0B}; +var \u{13A0C}; +var \u{13A0D}; +var \u{13A0E}; +var \u{13A0F}; +var \u{13A10}; +var \u{13A11}; +var \u{13A12}; +var \u{13A13}; +var \u{13A14}; +var \u{13A15}; +var \u{13A16}; +var \u{13A17}; +var \u{13A18}; +var \u{13A19}; +var \u{13A1A}; +var \u{13A1B}; +var \u{13A1C}; +var \u{13A1D}; +var \u{13A1E}; +var \u{13A1F}; +var \u{13A20}; +var \u{13A21}; +var \u{13A22}; +var \u{13A23}; +var \u{13A24}; +var \u{13A25}; +var \u{13A26}; +var \u{13A27}; +var \u{13A28}; +var \u{13A29}; +var \u{13A2A}; +var \u{13A2B}; +var \u{13A2C}; +var \u{13A2D}; +var \u{13A2E}; +var \u{13A2F}; +var \u{13A30}; +var \u{13A31}; +var \u{13A32}; +var \u{13A33}; +var \u{13A34}; +var \u{13A35}; +var \u{13A36}; +var \u{13A37}; +var \u{13A38}; +var \u{13A39}; +var \u{13A3A}; +var \u{13A3B}; +var \u{13A3C}; +var \u{13A3D}; +var \u{13A3E}; +var \u{13A3F}; +var \u{13A40}; +var \u{13A41}; +var \u{13A42}; +var \u{13A43}; +var \u{13A44}; +var \u{13A45}; +var \u{13A46}; +var \u{13A47}; +var \u{13A48}; +var \u{13A49}; +var \u{13A4A}; +var \u{13A4B}; +var \u{13A4C}; +var \u{13A4D}; +var \u{13A4E}; +var \u{13A4F}; +var \u{13A50}; +var \u{13A51}; +var \u{13A52}; +var \u{13A53}; +var \u{13A54}; +var \u{13A55}; +var \u{13A56}; +var \u{13A57}; +var \u{13A58}; +var \u{13A59}; +var \u{13A5A}; +var \u{13A5B}; +var \u{13A5C}; +var \u{13A5D}; +var \u{13A5E}; +var \u{13A5F}; +var \u{13A60}; +var \u{13A61}; +var \u{13A62}; +var \u{13A63}; +var \u{13A64}; +var \u{13A65}; +var \u{13A66}; +var \u{13A67}; +var \u{13A68}; +var \u{13A69}; +var \u{13A6A}; +var \u{13A6B}; +var \u{13A6C}; +var \u{13A6D}; +var \u{13A6E}; +var \u{13A6F}; +var \u{13A70}; +var \u{13A71}; +var \u{13A72}; +var \u{13A73}; +var \u{13A74}; +var \u{13A75}; +var \u{13A76}; +var \u{13A77}; +var \u{13A78}; +var \u{13A79}; +var \u{13A7A}; +var \u{13A7B}; +var \u{13A7C}; +var \u{13A7D}; +var \u{13A7E}; +var \u{13A7F}; +var \u{13A80}; +var \u{13A81}; +var \u{13A82}; +var \u{13A83}; +var \u{13A84}; +var \u{13A85}; +var \u{13A86}; +var \u{13A87}; +var \u{13A88}; +var \u{13A89}; +var \u{13A8A}; +var \u{13A8B}; +var \u{13A8C}; +var \u{13A8D}; +var \u{13A8E}; +var \u{13A8F}; +var \u{13A90}; +var \u{13A91}; +var \u{13A92}; +var \u{13A93}; +var \u{13A94}; +var \u{13A95}; +var \u{13A96}; +var \u{13A97}; +var \u{13A98}; +var \u{13A99}; +var \u{13A9A}; +var \u{13A9B}; +var \u{13A9C}; +var \u{13A9D}; +var \u{13A9E}; +var \u{13A9F}; +var \u{13AA0}; +var \u{13AA1}; +var \u{13AA2}; +var \u{13AA3}; +var \u{13AA4}; +var \u{13AA5}; +var \u{13AA6}; +var \u{13AA7}; +var \u{13AA8}; +var \u{13AA9}; +var \u{13AAA}; +var \u{13AAB}; +var \u{13AAC}; +var \u{13AAD}; +var \u{13AAE}; +var \u{13AAF}; +var \u{13AB0}; +var \u{13AB1}; +var \u{13AB2}; +var \u{13AB3}; +var \u{13AB4}; +var \u{13AB5}; +var \u{13AB6}; +var \u{13AB7}; +var \u{13AB8}; +var \u{13AB9}; +var \u{13ABA}; +var \u{13ABB}; +var \u{13ABC}; +var \u{13ABD}; +var \u{13ABE}; +var \u{13ABF}; +var \u{13AC0}; +var \u{13AC1}; +var \u{13AC2}; +var \u{13AC3}; +var \u{13AC4}; +var \u{13AC5}; +var \u{13AC6}; +var \u{13AC7}; +var \u{13AC8}; +var \u{13AC9}; +var \u{13ACA}; +var \u{13ACB}; +var \u{13ACC}; +var \u{13ACD}; +var \u{13ACE}; +var \u{13ACF}; +var \u{13AD0}; +var \u{13AD1}; +var \u{13AD2}; +var \u{13AD3}; +var \u{13AD4}; +var \u{13AD5}; +var \u{13AD6}; +var \u{13AD7}; +var \u{13AD8}; +var \u{13AD9}; +var \u{13ADA}; +var \u{13ADB}; +var \u{13ADC}; +var \u{13ADD}; +var \u{13ADE}; +var \u{13ADF}; +var \u{13AE0}; +var \u{13AE1}; +var \u{13AE2}; +var \u{13AE3}; +var \u{13AE4}; +var \u{13AE5}; +var \u{13AE6}; +var \u{13AE7}; +var \u{13AE8}; +var \u{13AE9}; +var \u{13AEA}; +var \u{13AEB}; +var \u{13AEC}; +var \u{13AED}; +var \u{13AEE}; +var \u{13AEF}; +var \u{13AF0}; +var \u{13AF1}; +var \u{13AF2}; +var \u{13AF3}; +var \u{13AF4}; +var \u{13AF5}; +var \u{13AF6}; +var \u{13AF7}; +var \u{13AF8}; +var \u{13AF9}; +var \u{13AFA}; +var \u{13AFB}; +var \u{13AFC}; +var \u{13AFD}; +var \u{13AFE}; +var \u{13AFF}; +var \u{13B00}; +var \u{13B01}; +var \u{13B02}; +var \u{13B03}; +var \u{13B04}; +var \u{13B05}; +var \u{13B06}; +var \u{13B07}; +var \u{13B08}; +var \u{13B09}; +var \u{13B0A}; +var \u{13B0B}; +var \u{13B0C}; +var \u{13B0D}; +var \u{13B0E}; +var \u{13B0F}; +var \u{13B10}; +var \u{13B11}; +var \u{13B12}; +var \u{13B13}; +var \u{13B14}; +var \u{13B15}; +var \u{13B16}; +var \u{13B17}; +var \u{13B18}; +var \u{13B19}; +var \u{13B1A}; +var \u{13B1B}; +var \u{13B1C}; +var \u{13B1D}; +var \u{13B1E}; +var \u{13B1F}; +var \u{13B20}; +var \u{13B21}; +var \u{13B22}; +var \u{13B23}; +var \u{13B24}; +var \u{13B25}; +var \u{13B26}; +var \u{13B27}; +var \u{13B28}; +var \u{13B29}; +var \u{13B2A}; +var \u{13B2B}; +var \u{13B2C}; +var \u{13B2D}; +var \u{13B2E}; +var \u{13B2F}; +var \u{13B30}; +var \u{13B31}; +var \u{13B32}; +var \u{13B33}; +var \u{13B34}; +var \u{13B35}; +var \u{13B36}; +var \u{13B37}; +var \u{13B38}; +var \u{13B39}; +var \u{13B3A}; +var \u{13B3B}; +var \u{13B3C}; +var \u{13B3D}; +var \u{13B3E}; +var \u{13B3F}; +var \u{13B40}; +var \u{13B41}; +var \u{13B42}; +var \u{13B43}; +var \u{13B44}; +var \u{13B45}; +var \u{13B46}; +var \u{13B47}; +var \u{13B48}; +var \u{13B49}; +var \u{13B4A}; +var \u{13B4B}; +var \u{13B4C}; +var \u{13B4D}; +var \u{13B4E}; +var \u{13B4F}; +var \u{13B50}; +var \u{13B51}; +var \u{13B52}; +var \u{13B53}; +var \u{13B54}; +var \u{13B55}; +var \u{13B56}; +var \u{13B57}; +var \u{13B58}; +var \u{13B59}; +var \u{13B5A}; +var \u{13B5B}; +var \u{13B5C}; +var \u{13B5D}; +var \u{13B5E}; +var \u{13B5F}; +var \u{13B60}; +var \u{13B61}; +var \u{13B62}; +var \u{13B63}; +var \u{13B64}; +var \u{13B65}; +var \u{13B66}; +var \u{13B67}; +var \u{13B68}; +var \u{13B69}; +var \u{13B6A}; +var \u{13B6B}; +var \u{13B6C}; +var \u{13B6D}; +var \u{13B6E}; +var \u{13B6F}; +var \u{13B70}; +var \u{13B71}; +var \u{13B72}; +var \u{13B73}; +var \u{13B74}; +var \u{13B75}; +var \u{13B76}; +var \u{13B77}; +var \u{13B78}; +var \u{13B79}; +var \u{13B7A}; +var \u{13B7B}; +var \u{13B7C}; +var \u{13B7D}; +var \u{13B7E}; +var \u{13B7F}; +var \u{13B80}; +var \u{13B81}; +var \u{13B82}; +var \u{13B83}; +var \u{13B84}; +var \u{13B85}; +var \u{13B86}; +var \u{13B87}; +var \u{13B88}; +var \u{13B89}; +var \u{13B8A}; +var \u{13B8B}; +var \u{13B8C}; +var \u{13B8D}; +var \u{13B8E}; +var \u{13B8F}; +var \u{13B90}; +var \u{13B91}; +var \u{13B92}; +var \u{13B93}; +var \u{13B94}; +var \u{13B95}; +var \u{13B96}; +var \u{13B97}; +var \u{13B98}; +var \u{13B99}; +var \u{13B9A}; +var \u{13B9B}; +var \u{13B9C}; +var \u{13B9D}; +var \u{13B9E}; +var \u{13B9F}; +var \u{13BA0}; +var \u{13BA1}; +var \u{13BA2}; +var \u{13BA3}; +var \u{13BA4}; +var \u{13BA5}; +var \u{13BA6}; +var \u{13BA7}; +var \u{13BA8}; +var \u{13BA9}; +var \u{13BAA}; +var \u{13BAB}; +var \u{13BAC}; +var \u{13BAD}; +var \u{13BAE}; +var \u{13BAF}; +var \u{13BB0}; +var \u{13BB1}; +var \u{13BB2}; +var \u{13BB3}; +var \u{13BB4}; +var \u{13BB5}; +var \u{13BB6}; +var \u{13BB7}; +var \u{13BB8}; +var \u{13BB9}; +var \u{13BBA}; +var \u{13BBB}; +var \u{13BBC}; +var \u{13BBD}; +var \u{13BBE}; +var \u{13BBF}; +var \u{13BC0}; +var \u{13BC1}; +var \u{13BC2}; +var \u{13BC3}; +var \u{13BC4}; +var \u{13BC5}; +var \u{13BC6}; +var \u{13BC7}; +var \u{13BC8}; +var \u{13BC9}; +var \u{13BCA}; +var \u{13BCB}; +var \u{13BCC}; +var \u{13BCD}; +var \u{13BCE}; +var \u{13BCF}; +var \u{13BD0}; +var \u{13BD1}; +var \u{13BD2}; +var \u{13BD3}; +var \u{13BD4}; +var \u{13BD5}; +var \u{13BD6}; +var \u{13BD7}; +var \u{13BD8}; +var \u{13BD9}; +var \u{13BDA}; +var \u{13BDB}; +var \u{13BDC}; +var \u{13BDD}; +var \u{13BDE}; +var \u{13BDF}; +var \u{13BE0}; +var \u{13BE1}; +var \u{13BE2}; +var \u{13BE3}; +var \u{13BE4}; +var \u{13BE5}; +var \u{13BE6}; +var \u{13BE7}; +var \u{13BE8}; +var \u{13BE9}; +var \u{13BEA}; +var \u{13BEB}; +var \u{13BEC}; +var \u{13BED}; +var \u{13BEE}; +var \u{13BEF}; +var \u{13BF0}; +var \u{13BF1}; +var \u{13BF2}; +var \u{13BF3}; +var \u{13BF4}; +var \u{13BF5}; +var \u{13BF6}; +var \u{13BF7}; +var \u{13BF8}; +var \u{13BF9}; +var \u{13BFA}; +var \u{13BFB}; +var \u{13BFC}; +var \u{13BFD}; +var \u{13BFE}; +var \u{13BFF}; +var \u{13C00}; +var \u{13C01}; +var \u{13C02}; +var \u{13C03}; +var \u{13C04}; +var \u{13C05}; +var \u{13C06}; +var \u{13C07}; +var \u{13C08}; +var \u{13C09}; +var \u{13C0A}; +var \u{13C0B}; +var \u{13C0C}; +var \u{13C0D}; +var \u{13C0E}; +var \u{13C0F}; +var \u{13C10}; +var \u{13C11}; +var \u{13C12}; +var \u{13C13}; +var \u{13C14}; +var \u{13C15}; +var \u{13C16}; +var \u{13C17}; +var \u{13C18}; +var \u{13C19}; +var \u{13C1A}; +var \u{13C1B}; +var \u{13C1C}; +var \u{13C1D}; +var \u{13C1E}; +var \u{13C1F}; +var \u{13C20}; +var \u{13C21}; +var \u{13C22}; +var \u{13C23}; +var \u{13C24}; +var \u{13C25}; +var \u{13C26}; +var \u{13C27}; +var \u{13C28}; +var \u{13C29}; +var \u{13C2A}; +var \u{13C2B}; +var \u{13C2C}; +var \u{13C2D}; +var \u{13C2E}; +var \u{13C2F}; +var \u{13C30}; +var \u{13C31}; +var \u{13C32}; +var \u{13C33}; +var \u{13C34}; +var \u{13C35}; +var \u{13C36}; +var \u{13C37}; +var \u{13C38}; +var \u{13C39}; +var \u{13C3A}; +var \u{13C3B}; +var \u{13C3C}; +var \u{13C3D}; +var \u{13C3E}; +var \u{13C3F}; +var \u{13C40}; +var \u{13C41}; +var \u{13C42}; +var \u{13C43}; +var \u{13C44}; +var \u{13C45}; +var \u{13C46}; +var \u{13C47}; +var \u{13C48}; +var \u{13C49}; +var \u{13C4A}; +var \u{13C4B}; +var \u{13C4C}; +var \u{13C4D}; +var \u{13C4E}; +var \u{13C4F}; +var \u{13C50}; +var \u{13C51}; +var \u{13C52}; +var \u{13C53}; +var \u{13C54}; +var \u{13C55}; +var \u{13C56}; +var \u{13C57}; +var \u{13C58}; +var \u{13C59}; +var \u{13C5A}; +var \u{13C5B}; +var \u{13C5C}; +var \u{13C5D}; +var \u{13C5E}; +var \u{13C5F}; +var \u{13C60}; +var \u{13C61}; +var \u{13C62}; +var \u{13C63}; +var \u{13C64}; +var \u{13C65}; +var \u{13C66}; +var \u{13C67}; +var \u{13C68}; +var \u{13C69}; +var \u{13C6A}; +var \u{13C6B}; +var \u{13C6C}; +var \u{13C6D}; +var \u{13C6E}; +var \u{13C6F}; +var \u{13C70}; +var \u{13C71}; +var \u{13C72}; +var \u{13C73}; +var \u{13C74}; +var \u{13C75}; +var \u{13C76}; +var \u{13C77}; +var \u{13C78}; +var \u{13C79}; +var \u{13C7A}; +var \u{13C7B}; +var \u{13C7C}; +var \u{13C7D}; +var \u{13C7E}; +var \u{13C7F}; +var \u{13C80}; +var \u{13C81}; +var \u{13C82}; +var \u{13C83}; +var \u{13C84}; +var \u{13C85}; +var \u{13C86}; +var \u{13C87}; +var \u{13C88}; +var \u{13C89}; +var \u{13C8A}; +var \u{13C8B}; +var \u{13C8C}; +var \u{13C8D}; +var \u{13C8E}; +var \u{13C8F}; +var \u{13C90}; +var \u{13C91}; +var \u{13C92}; +var \u{13C93}; +var \u{13C94}; +var \u{13C95}; +var \u{13C96}; +var \u{13C97}; +var \u{13C98}; +var \u{13C99}; +var \u{13C9A}; +var \u{13C9B}; +var \u{13C9C}; +var \u{13C9D}; +var \u{13C9E}; +var \u{13C9F}; +var \u{13CA0}; +var \u{13CA1}; +var \u{13CA2}; +var \u{13CA3}; +var \u{13CA4}; +var \u{13CA5}; +var \u{13CA6}; +var \u{13CA7}; +var \u{13CA8}; +var \u{13CA9}; +var \u{13CAA}; +var \u{13CAB}; +var \u{13CAC}; +var \u{13CAD}; +var \u{13CAE}; +var \u{13CAF}; +var \u{13CB0}; +var \u{13CB1}; +var \u{13CB2}; +var \u{13CB3}; +var \u{13CB4}; +var \u{13CB5}; +var \u{13CB6}; +var \u{13CB7}; +var \u{13CB8}; +var \u{13CB9}; +var \u{13CBA}; +var \u{13CBB}; +var \u{13CBC}; +var \u{13CBD}; +var \u{13CBE}; +var \u{13CBF}; +var \u{13CC0}; +var \u{13CC1}; +var \u{13CC2}; +var \u{13CC3}; +var \u{13CC4}; +var \u{13CC5}; +var \u{13CC6}; +var \u{13CC7}; +var \u{13CC8}; +var \u{13CC9}; +var \u{13CCA}; +var \u{13CCB}; +var \u{13CCC}; +var \u{13CCD}; +var \u{13CCE}; +var \u{13CCF}; +var \u{13CD0}; +var \u{13CD1}; +var \u{13CD2}; +var \u{13CD3}; +var \u{13CD4}; +var \u{13CD5}; +var \u{13CD6}; +var \u{13CD7}; +var \u{13CD8}; +var \u{13CD9}; +var \u{13CDA}; +var \u{13CDB}; +var \u{13CDC}; +var \u{13CDD}; +var \u{13CDE}; +var \u{13CDF}; +var \u{13CE0}; +var \u{13CE1}; +var \u{13CE2}; +var \u{13CE3}; +var \u{13CE4}; +var \u{13CE5}; +var \u{13CE6}; +var \u{13CE7}; +var \u{13CE8}; +var \u{13CE9}; +var \u{13CEA}; +var \u{13CEB}; +var \u{13CEC}; +var \u{13CED}; +var \u{13CEE}; +var \u{13CEF}; +var \u{13CF0}; +var \u{13CF1}; +var \u{13CF2}; +var \u{13CF3}; +var \u{13CF4}; +var \u{13CF5}; +var \u{13CF6}; +var \u{13CF7}; +var \u{13CF8}; +var \u{13CF9}; +var \u{13CFA}; +var \u{13CFB}; +var \u{13CFC}; +var \u{13CFD}; +var \u{13CFE}; +var \u{13CFF}; +var \u{13D00}; +var \u{13D01}; +var \u{13D02}; +var \u{13D03}; +var \u{13D04}; +var \u{13D05}; +var \u{13D06}; +var \u{13D07}; +var \u{13D08}; +var \u{13D09}; +var \u{13D0A}; +var \u{13D0B}; +var \u{13D0C}; +var \u{13D0D}; +var \u{13D0E}; +var \u{13D0F}; +var \u{13D10}; +var \u{13D11}; +var \u{13D12}; +var \u{13D13}; +var \u{13D14}; +var \u{13D15}; +var \u{13D16}; +var \u{13D17}; +var \u{13D18}; +var \u{13D19}; +var \u{13D1A}; +var \u{13D1B}; +var \u{13D1C}; +var \u{13D1D}; +var \u{13D1E}; +var \u{13D1F}; +var \u{13D20}; +var \u{13D21}; +var \u{13D22}; +var \u{13D23}; +var \u{13D24}; +var \u{13D25}; +var \u{13D26}; +var \u{13D27}; +var \u{13D28}; +var \u{13D29}; +var \u{13D2A}; +var \u{13D2B}; +var \u{13D2C}; +var \u{13D2D}; +var \u{13D2E}; +var \u{13D2F}; +var \u{13D30}; +var \u{13D31}; +var \u{13D32}; +var \u{13D33}; +var \u{13D34}; +var \u{13D35}; +var \u{13D36}; +var \u{13D37}; +var \u{13D38}; +var \u{13D39}; +var \u{13D3A}; +var \u{13D3B}; +var \u{13D3C}; +var \u{13D3D}; +var \u{13D3E}; +var \u{13D3F}; +var \u{13D40}; +var \u{13D41}; +var \u{13D42}; +var \u{13D43}; +var \u{13D44}; +var \u{13D45}; +var \u{13D46}; +var \u{13D47}; +var \u{13D48}; +var \u{13D49}; +var \u{13D4A}; +var \u{13D4B}; +var \u{13D4C}; +var \u{13D4D}; +var \u{13D4E}; +var \u{13D4F}; +var \u{13D50}; +var \u{13D51}; +var \u{13D52}; +var \u{13D53}; +var \u{13D54}; +var \u{13D55}; +var \u{13D56}; +var \u{13D57}; +var \u{13D58}; +var \u{13D59}; +var \u{13D5A}; +var \u{13D5B}; +var \u{13D5C}; +var \u{13D5D}; +var \u{13D5E}; +var \u{13D5F}; +var \u{13D60}; +var \u{13D61}; +var \u{13D62}; +var \u{13D63}; +var \u{13D64}; +var \u{13D65}; +var \u{13D66}; +var \u{13D67}; +var \u{13D68}; +var \u{13D69}; +var \u{13D6A}; +var \u{13D6B}; +var \u{13D6C}; +var \u{13D6D}; +var \u{13D6E}; +var \u{13D6F}; +var \u{13D70}; +var \u{13D71}; +var \u{13D72}; +var \u{13D73}; +var \u{13D74}; +var \u{13D75}; +var \u{13D76}; +var \u{13D77}; +var \u{13D78}; +var \u{13D79}; +var \u{13D7A}; +var \u{13D7B}; +var \u{13D7C}; +var \u{13D7D}; +var \u{13D7E}; +var \u{13D7F}; +var \u{13D80}; +var \u{13D81}; +var \u{13D82}; +var \u{13D83}; +var \u{13D84}; +var \u{13D85}; +var \u{13D86}; +var \u{13D87}; +var \u{13D88}; +var \u{13D89}; +var \u{13D8A}; +var \u{13D8B}; +var \u{13D8C}; +var \u{13D8D}; +var \u{13D8E}; +var \u{13D8F}; +var \u{13D90}; +var \u{13D91}; +var \u{13D92}; +var \u{13D93}; +var \u{13D94}; +var \u{13D95}; +var \u{13D96}; +var \u{13D97}; +var \u{13D98}; +var \u{13D99}; +var \u{13D9A}; +var \u{13D9B}; +var \u{13D9C}; +var \u{13D9D}; +var \u{13D9E}; +var \u{13D9F}; +var \u{13DA0}; +var \u{13DA1}; +var \u{13DA2}; +var \u{13DA3}; +var \u{13DA4}; +var \u{13DA5}; +var \u{13DA6}; +var \u{13DA7}; +var \u{13DA8}; +var \u{13DA9}; +var \u{13DAA}; +var \u{13DAB}; +var \u{13DAC}; +var \u{13DAD}; +var \u{13DAE}; +var \u{13DAF}; +var \u{13DB0}; +var \u{13DB1}; +var \u{13DB2}; +var \u{13DB3}; +var \u{13DB4}; +var \u{13DB5}; +var \u{13DB6}; +var \u{13DB7}; +var \u{13DB8}; +var \u{13DB9}; +var \u{13DBA}; +var \u{13DBB}; +var \u{13DBC}; +var \u{13DBD}; +var \u{13DBE}; +var \u{13DBF}; +var \u{13DC0}; +var \u{13DC1}; +var \u{13DC2}; +var \u{13DC3}; +var \u{13DC4}; +var \u{13DC5}; +var \u{13DC6}; +var \u{13DC7}; +var \u{13DC8}; +var \u{13DC9}; +var \u{13DCA}; +var \u{13DCB}; +var \u{13DCC}; +var \u{13DCD}; +var \u{13DCE}; +var \u{13DCF}; +var \u{13DD0}; +var \u{13DD1}; +var \u{13DD2}; +var \u{13DD3}; +var \u{13DD4}; +var \u{13DD5}; +var \u{13DD6}; +var \u{13DD7}; +var \u{13DD8}; +var \u{13DD9}; +var \u{13DDA}; +var \u{13DDB}; +var \u{13DDC}; +var \u{13DDD}; +var \u{13DDE}; +var \u{13DDF}; +var \u{13DE0}; +var \u{13DE1}; +var \u{13DE2}; +var \u{13DE3}; +var \u{13DE4}; +var \u{13DE5}; +var \u{13DE6}; +var \u{13DE7}; +var \u{13DE8}; +var \u{13DE9}; +var \u{13DEA}; +var \u{13DEB}; +var \u{13DEC}; +var \u{13DED}; +var \u{13DEE}; +var \u{13DEF}; +var \u{13DF0}; +var \u{13DF1}; +var \u{13DF2}; +var \u{13DF3}; +var \u{13DF4}; +var \u{13DF5}; +var \u{13DF6}; +var \u{13DF7}; +var \u{13DF8}; +var \u{13DF9}; +var \u{13DFA}; +var \u{13DFB}; +var \u{13DFC}; +var \u{13DFD}; +var \u{13DFE}; +var \u{13DFF}; +var \u{13E00}; +var \u{13E01}; +var \u{13E02}; +var \u{13E03}; +var \u{13E04}; +var \u{13E05}; +var \u{13E06}; +var \u{13E07}; +var \u{13E08}; +var \u{13E09}; +var \u{13E0A}; +var \u{13E0B}; +var \u{13E0C}; +var \u{13E0D}; +var \u{13E0E}; +var \u{13E0F}; +var \u{13E10}; +var \u{13E11}; +var \u{13E12}; +var \u{13E13}; +var \u{13E14}; +var \u{13E15}; +var \u{13E16}; +var \u{13E17}; +var \u{13E18}; +var \u{13E19}; +var \u{13E1A}; +var \u{13E1B}; +var \u{13E1C}; +var \u{13E1D}; +var \u{13E1E}; +var \u{13E1F}; +var \u{13E20}; +var \u{13E21}; +var \u{13E22}; +var \u{13E23}; +var \u{13E24}; +var \u{13E25}; +var \u{13E26}; +var \u{13E27}; +var \u{13E28}; +var \u{13E29}; +var \u{13E2A}; +var \u{13E2B}; +var \u{13E2C}; +var \u{13E2D}; +var \u{13E2E}; +var \u{13E2F}; +var \u{13E30}; +var \u{13E31}; +var \u{13E32}; +var \u{13E33}; +var \u{13E34}; +var \u{13E35}; +var \u{13E36}; +var \u{13E37}; +var \u{13E38}; +var \u{13E39}; +var \u{13E3A}; +var \u{13E3B}; +var \u{13E3C}; +var \u{13E3D}; +var \u{13E3E}; +var \u{13E3F}; +var \u{13E40}; +var \u{13E41}; +var \u{13E42}; +var \u{13E43}; +var \u{13E44}; +var \u{13E45}; +var \u{13E46}; +var \u{13E47}; +var \u{13E48}; +var \u{13E49}; +var \u{13E4A}; +var \u{13E4B}; +var \u{13E4C}; +var \u{13E4D}; +var \u{13E4E}; +var \u{13E4F}; +var \u{13E50}; +var \u{13E51}; +var \u{13E52}; +var \u{13E53}; +var \u{13E54}; +var \u{13E55}; +var \u{13E56}; +var \u{13E57}; +var \u{13E58}; +var \u{13E59}; +var \u{13E5A}; +var \u{13E5B}; +var \u{13E5C}; +var \u{13E5D}; +var \u{13E5E}; +var \u{13E5F}; +var \u{13E60}; +var \u{13E61}; +var \u{13E62}; +var \u{13E63}; +var \u{13E64}; +var \u{13E65}; +var \u{13E66}; +var \u{13E67}; +var \u{13E68}; +var \u{13E69}; +var \u{13E6A}; +var \u{13E6B}; +var \u{13E6C}; +var \u{13E6D}; +var \u{13E6E}; +var \u{13E6F}; +var \u{13E70}; +var \u{13E71}; +var \u{13E72}; +var \u{13E73}; +var \u{13E74}; +var \u{13E75}; +var \u{13E76}; +var \u{13E77}; +var \u{13E78}; +var \u{13E79}; +var \u{13E7A}; +var \u{13E7B}; +var \u{13E7C}; +var \u{13E7D}; +var \u{13E7E}; +var \u{13E7F}; +var \u{13E80}; +var \u{13E81}; +var \u{13E82}; +var \u{13E83}; +var \u{13E84}; +var \u{13E85}; +var \u{13E86}; +var \u{13E87}; +var \u{13E88}; +var \u{13E89}; +var \u{13E8A}; +var \u{13E8B}; +var \u{13E8C}; +var \u{13E8D}; +var \u{13E8E}; +var \u{13E8F}; +var \u{13E90}; +var \u{13E91}; +var \u{13E92}; +var \u{13E93}; +var \u{13E94}; +var \u{13E95}; +var \u{13E96}; +var \u{13E97}; +var \u{13E98}; +var \u{13E99}; +var \u{13E9A}; +var \u{13E9B}; +var \u{13E9C}; +var \u{13E9D}; +var \u{13E9E}; +var \u{13E9F}; +var \u{13EA0}; +var \u{13EA1}; +var \u{13EA2}; +var \u{13EA3}; +var \u{13EA4}; +var \u{13EA5}; +var \u{13EA6}; +var \u{13EA7}; +var \u{13EA8}; +var \u{13EA9}; +var \u{13EAA}; +var \u{13EAB}; +var \u{13EAC}; +var \u{13EAD}; +var \u{13EAE}; +var \u{13EAF}; +var \u{13EB0}; +var \u{13EB1}; +var \u{13EB2}; +var \u{13EB3}; +var \u{13EB4}; +var \u{13EB5}; +var \u{13EB6}; +var \u{13EB7}; +var \u{13EB8}; +var \u{13EB9}; +var \u{13EBA}; +var \u{13EBB}; +var \u{13EBC}; +var \u{13EBD}; +var \u{13EBE}; +var \u{13EBF}; +var \u{13EC0}; +var \u{13EC1}; +var \u{13EC2}; +var \u{13EC3}; +var \u{13EC4}; +var \u{13EC5}; +var \u{13EC6}; +var \u{13EC7}; +var \u{13EC8}; +var \u{13EC9}; +var \u{13ECA}; +var \u{13ECB}; +var \u{13ECC}; +var \u{13ECD}; +var \u{13ECE}; +var \u{13ECF}; +var \u{13ED0}; +var \u{13ED1}; +var \u{13ED2}; +var \u{13ED3}; +var \u{13ED4}; +var \u{13ED5}; +var \u{13ED6}; +var \u{13ED7}; +var \u{13ED8}; +var \u{13ED9}; +var \u{13EDA}; +var \u{13EDB}; +var \u{13EDC}; +var \u{13EDD}; +var \u{13EDE}; +var \u{13EDF}; +var \u{13EE0}; +var \u{13EE1}; +var \u{13EE2}; +var \u{13EE3}; +var \u{13EE4}; +var \u{13EE5}; +var \u{13EE6}; +var \u{13EE7}; +var \u{13EE8}; +var \u{13EE9}; +var \u{13EEA}; +var \u{13EEB}; +var \u{13EEC}; +var \u{13EED}; +var \u{13EEE}; +var \u{13EEF}; +var \u{13EF0}; +var \u{13EF1}; +var \u{13EF2}; +var \u{13EF3}; +var \u{13EF4}; +var \u{13EF5}; +var \u{13EF6}; +var \u{13EF7}; +var \u{13EF8}; +var \u{13EF9}; +var \u{13EFA}; +var \u{13EFB}; +var \u{13EFC}; +var \u{13EFD}; +var \u{13EFE}; +var \u{13EFF}; +var \u{13F00}; +var \u{13F01}; +var \u{13F02}; +var \u{13F03}; +var \u{13F04}; +var \u{13F05}; +var \u{13F06}; +var \u{13F07}; +var \u{13F08}; +var \u{13F09}; +var \u{13F0A}; +var \u{13F0B}; +var \u{13F0C}; +var \u{13F0D}; +var \u{13F0E}; +var \u{13F0F}; +var \u{13F10}; +var \u{13F11}; +var \u{13F12}; +var \u{13F13}; +var \u{13F14}; +var \u{13F15}; +var \u{13F16}; +var \u{13F17}; +var \u{13F18}; +var \u{13F19}; +var \u{13F1A}; +var \u{13F1B}; +var \u{13F1C}; +var \u{13F1D}; +var \u{13F1E}; +var \u{13F1F}; +var \u{13F20}; +var \u{13F21}; +var \u{13F22}; +var \u{13F23}; +var \u{13F24}; +var \u{13F25}; +var \u{13F26}; +var \u{13F27}; +var \u{13F28}; +var \u{13F29}; +var \u{13F2A}; +var \u{13F2B}; +var \u{13F2C}; +var \u{13F2D}; +var \u{13F2E}; +var \u{13F2F}; +var \u{13F30}; +var \u{13F31}; +var \u{13F32}; +var \u{13F33}; +var \u{13F34}; +var \u{13F35}; +var \u{13F36}; +var \u{13F37}; +var \u{13F38}; +var \u{13F39}; +var \u{13F3A}; +var \u{13F3B}; +var \u{13F3C}; +var \u{13F3D}; +var \u{13F3E}; +var \u{13F3F}; +var \u{13F40}; +var \u{13F41}; +var \u{13F42}; +var \u{13F43}; +var \u{13F44}; +var \u{13F45}; +var \u{13F46}; +var \u{13F47}; +var \u{13F48}; +var \u{13F49}; +var \u{13F4A}; +var \u{13F4B}; +var \u{13F4C}; +var \u{13F4D}; +var \u{13F4E}; +var \u{13F4F}; +var \u{13F50}; +var \u{13F51}; +var \u{13F52}; +var \u{13F53}; +var \u{13F54}; +var \u{13F55}; +var \u{13F56}; +var \u{13F57}; +var \u{13F58}; +var \u{13F59}; +var \u{13F5A}; +var \u{13F5B}; +var \u{13F5C}; +var \u{13F5D}; +var \u{13F5E}; +var \u{13F5F}; +var \u{13F60}; +var \u{13F61}; +var \u{13F62}; +var \u{13F63}; +var \u{13F64}; +var \u{13F65}; +var \u{13F66}; +var \u{13F67}; +var \u{13F68}; +var \u{13F69}; +var \u{13F6A}; +var \u{13F6B}; +var \u{13F6C}; +var \u{13F6D}; +var \u{13F6E}; +var \u{13F6F}; +var \u{13F70}; +var \u{13F71}; +var \u{13F72}; +var \u{13F73}; +var \u{13F74}; +var \u{13F75}; +var \u{13F76}; +var \u{13F77}; +var \u{13F78}; +var \u{13F79}; +var \u{13F7A}; +var \u{13F7B}; +var \u{13F7C}; +var \u{13F7D}; +var \u{13F7E}; +var \u{13F7F}; +var \u{13F80}; +var \u{13F81}; +var \u{13F82}; +var \u{13F83}; +var \u{13F84}; +var \u{13F85}; +var \u{13F86}; +var \u{13F87}; +var \u{13F88}; +var \u{13F89}; +var \u{13F8A}; +var \u{13F8B}; +var \u{13F8C}; +var \u{13F8D}; +var \u{13F8E}; +var \u{13F8F}; +var \u{13F90}; +var \u{13F91}; +var \u{13F92}; +var \u{13F93}; +var \u{13F94}; +var \u{13F95}; +var \u{13F96}; +var \u{13F97}; +var \u{13F98}; +var \u{13F99}; +var \u{13F9A}; +var \u{13F9B}; +var \u{13F9C}; +var \u{13F9D}; +var \u{13F9E}; +var \u{13F9F}; +var \u{13FA0}; +var \u{13FA1}; +var \u{13FA2}; +var \u{13FA3}; +var \u{13FA4}; +var \u{13FA5}; +var \u{13FA6}; +var \u{13FA7}; +var \u{13FA8}; +var \u{13FA9}; +var \u{13FAA}; +var \u{13FAB}; +var \u{13FAC}; +var \u{13FAD}; +var \u{13FAE}; +var \u{13FAF}; +var \u{13FB0}; +var \u{13FB1}; +var \u{13FB2}; +var \u{13FB3}; +var \u{13FB4}; +var \u{13FB5}; +var \u{13FB6}; +var \u{13FB7}; +var \u{13FB8}; +var \u{13FB9}; +var \u{13FBA}; +var \u{13FBB}; +var \u{13FBC}; +var \u{13FBD}; +var \u{13FBE}; +var \u{13FBF}; +var \u{13FC0}; +var \u{13FC1}; +var \u{13FC2}; +var \u{13FC3}; +var \u{13FC4}; +var \u{13FC5}; +var \u{13FC6}; +var \u{13FC7}; +var \u{13FC8}; +var \u{13FC9}; +var \u{13FCA}; +var \u{13FCB}; +var \u{13FCC}; +var \u{13FCD}; +var \u{13FCE}; +var \u{13FCF}; +var \u{13FD0}; +var \u{13FD1}; +var \u{13FD2}; +var \u{13FD3}; +var \u{13FD4}; +var \u{13FD5}; +var \u{13FD6}; +var \u{13FD7}; +var \u{13FD8}; +var \u{13FD9}; +var \u{13FDA}; +var \u{13FDB}; +var \u{13FDC}; +var \u{13FDD}; +var \u{13FDE}; +var \u{13FDF}; +var \u{13FE0}; +var \u{13FE1}; +var \u{13FE2}; +var \u{13FE3}; +var \u{13FE4}; +var \u{13FE5}; +var \u{13FE6}; +var \u{13FE7}; +var \u{13FE8}; +var \u{13FE9}; +var \u{13FEA}; +var \u{13FEB}; +var \u{13FEC}; +var \u{13FED}; +var \u{13FEE}; +var \u{13FEF}; +var \u{13FF0}; +var \u{13FF1}; +var \u{13FF2}; +var \u{13FF3}; +var \u{13FF4}; +var \u{13FF5}; +var \u{13FF6}; +var \u{13FF7}; +var \u{13FF8}; +var \u{13FF9}; +var \u{13FFA}; +var \u{13FFB}; +var \u{13FFC}; +var \u{13FFD}; +var \u{13FFE}; +var \u{13FFF}; +var \u{14000}; +var \u{14001}; +var \u{14002}; +var \u{14003}; +var \u{14004}; +var \u{14005}; +var \u{14006}; +var \u{14007}; +var \u{14008}; +var \u{14009}; +var \u{1400A}; +var \u{1400B}; +var \u{1400C}; +var \u{1400D}; +var \u{1400E}; +var \u{1400F}; +var \u{14010}; +var \u{14011}; +var \u{14012}; +var \u{14013}; +var \u{14014}; +var \u{14015}; +var \u{14016}; +var \u{14017}; +var \u{14018}; +var \u{14019}; +var \u{1401A}; +var \u{1401B}; +var \u{1401C}; +var \u{1401D}; +var \u{1401E}; +var \u{1401F}; +var \u{14020}; +var \u{14021}; +var \u{14022}; +var \u{14023}; +var \u{14024}; +var \u{14025}; +var \u{14026}; +var \u{14027}; +var \u{14028}; +var \u{14029}; +var \u{1402A}; +var \u{1402B}; +var \u{1402C}; +var \u{1402D}; +var \u{1402E}; +var \u{1402F}; +var \u{14030}; +var \u{14031}; +var \u{14032}; +var \u{14033}; +var \u{14034}; +var \u{14035}; +var \u{14036}; +var \u{14037}; +var \u{14038}; +var \u{14039}; +var \u{1403A}; +var \u{1403B}; +var \u{1403C}; +var \u{1403D}; +var \u{1403E}; +var \u{1403F}; +var \u{14040}; +var \u{14041}; +var \u{14042}; +var \u{14043}; +var \u{14044}; +var \u{14045}; +var \u{14046}; +var \u{14047}; +var \u{14048}; +var \u{14049}; +var \u{1404A}; +var \u{1404B}; +var \u{1404C}; +var \u{1404D}; +var \u{1404E}; +var \u{1404F}; +var \u{14050}; +var \u{14051}; +var \u{14052}; +var \u{14053}; +var \u{14054}; +var \u{14055}; +var \u{14056}; +var \u{14057}; +var \u{14058}; +var \u{14059}; +var \u{1405A}; +var \u{1405B}; +var \u{1405C}; +var \u{1405D}; +var \u{1405E}; +var \u{1405F}; +var \u{14060}; +var \u{14061}; +var \u{14062}; +var \u{14063}; +var \u{14064}; +var \u{14065}; +var \u{14066}; +var \u{14067}; +var \u{14068}; +var \u{14069}; +var \u{1406A}; +var \u{1406B}; +var \u{1406C}; +var \u{1406D}; +var \u{1406E}; +var \u{1406F}; +var \u{14070}; +var \u{14071}; +var \u{14072}; +var \u{14073}; +var \u{14074}; +var \u{14075}; +var \u{14076}; +var \u{14077}; +var \u{14078}; +var \u{14079}; +var \u{1407A}; +var \u{1407B}; +var \u{1407C}; +var \u{1407D}; +var \u{1407E}; +var \u{1407F}; +var \u{14080}; +var \u{14081}; +var \u{14082}; +var \u{14083}; +var \u{14084}; +var \u{14085}; +var \u{14086}; +var \u{14087}; +var \u{14088}; +var \u{14089}; +var \u{1408A}; +var \u{1408B}; +var \u{1408C}; +var \u{1408D}; +var \u{1408E}; +var \u{1408F}; +var \u{14090}; +var \u{14091}; +var \u{14092}; +var \u{14093}; +var \u{14094}; +var \u{14095}; +var \u{14096}; +var \u{14097}; +var \u{14098}; +var \u{14099}; +var \u{1409A}; +var \u{1409B}; +var \u{1409C}; +var \u{1409D}; +var \u{1409E}; +var \u{1409F}; +var \u{140A0}; +var \u{140A1}; +var \u{140A2}; +var \u{140A3}; +var \u{140A4}; +var \u{140A5}; +var \u{140A6}; +var \u{140A7}; +var \u{140A8}; +var \u{140A9}; +var \u{140AA}; +var \u{140AB}; +var \u{140AC}; +var \u{140AD}; +var \u{140AE}; +var \u{140AF}; +var \u{140B0}; +var \u{140B1}; +var \u{140B2}; +var \u{140B3}; +var \u{140B4}; +var \u{140B5}; +var \u{140B6}; +var \u{140B7}; +var \u{140B8}; +var \u{140B9}; +var \u{140BA}; +var \u{140BB}; +var \u{140BC}; +var \u{140BD}; +var \u{140BE}; +var \u{140BF}; +var \u{140C0}; +var \u{140C1}; +var \u{140C2}; +var \u{140C3}; +var \u{140C4}; +var \u{140C5}; +var \u{140C6}; +var \u{140C7}; +var \u{140C8}; +var \u{140C9}; +var \u{140CA}; +var \u{140CB}; +var \u{140CC}; +var \u{140CD}; +var \u{140CE}; +var \u{140CF}; +var \u{140D0}; +var \u{140D1}; +var \u{140D2}; +var \u{140D3}; +var \u{140D4}; +var \u{140D5}; +var \u{140D6}; +var \u{140D7}; +var \u{140D8}; +var \u{140D9}; +var \u{140DA}; +var \u{140DB}; +var \u{140DC}; +var \u{140DD}; +var \u{140DE}; +var \u{140DF}; +var \u{140E0}; +var \u{140E1}; +var \u{140E2}; +var \u{140E3}; +var \u{140E4}; +var \u{140E5}; +var \u{140E6}; +var \u{140E7}; +var \u{140E8}; +var \u{140E9}; +var \u{140EA}; +var \u{140EB}; +var \u{140EC}; +var \u{140ED}; +var \u{140EE}; +var \u{140EF}; +var \u{140F0}; +var \u{140F1}; +var \u{140F2}; +var \u{140F3}; +var \u{140F4}; +var \u{140F5}; +var \u{140F6}; +var \u{140F7}; +var \u{140F8}; +var \u{140F9}; +var \u{140FA}; +var \u{140FB}; +var \u{140FC}; +var \u{140FD}; +var \u{140FE}; +var \u{140FF}; +var \u{14100}; +var \u{14101}; +var \u{14102}; +var \u{14103}; +var \u{14104}; +var \u{14105}; +var \u{14106}; +var \u{14107}; +var \u{14108}; +var \u{14109}; +var \u{1410A}; +var \u{1410B}; +var \u{1410C}; +var \u{1410D}; +var \u{1410E}; +var \u{1410F}; +var \u{14110}; +var \u{14111}; +var \u{14112}; +var \u{14113}; +var \u{14114}; +var \u{14115}; +var \u{14116}; +var \u{14117}; +var \u{14118}; +var \u{14119}; +var \u{1411A}; +var \u{1411B}; +var \u{1411C}; +var \u{1411D}; +var \u{1411E}; +var \u{1411F}; +var \u{14120}; +var \u{14121}; +var \u{14122}; +var \u{14123}; +var \u{14124}; +var \u{14125}; +var \u{14126}; +var \u{14127}; +var \u{14128}; +var \u{14129}; +var \u{1412A}; +var \u{1412B}; +var \u{1412C}; +var \u{1412D}; +var \u{1412E}; +var \u{1412F}; +var \u{14130}; +var \u{14131}; +var \u{14132}; +var \u{14133}; +var \u{14134}; +var \u{14135}; +var \u{14136}; +var \u{14137}; +var \u{14138}; +var \u{14139}; +var \u{1413A}; +var \u{1413B}; +var \u{1413C}; +var \u{1413D}; +var \u{1413E}; +var \u{1413F}; +var \u{14140}; +var \u{14141}; +var \u{14142}; +var \u{14143}; +var \u{14144}; +var \u{14145}; +var \u{14146}; +var \u{14147}; +var \u{14148}; +var \u{14149}; +var \u{1414A}; +var \u{1414B}; +var \u{1414C}; +var \u{1414D}; +var \u{1414E}; +var \u{1414F}; +var \u{14150}; +var \u{14151}; +var \u{14152}; +var \u{14153}; +var \u{14154}; +var \u{14155}; +var \u{14156}; +var \u{14157}; +var \u{14158}; +var \u{14159}; +var \u{1415A}; +var \u{1415B}; +var \u{1415C}; +var \u{1415D}; +var \u{1415E}; +var \u{1415F}; +var \u{14160}; +var \u{14161}; +var \u{14162}; +var \u{14163}; +var \u{14164}; +var \u{14165}; +var \u{14166}; +var \u{14167}; +var \u{14168}; +var \u{14169}; +var \u{1416A}; +var \u{1416B}; +var \u{1416C}; +var \u{1416D}; +var \u{1416E}; +var \u{1416F}; +var \u{14170}; +var \u{14171}; +var \u{14172}; +var \u{14173}; +var \u{14174}; +var \u{14175}; +var \u{14176}; +var \u{14177}; +var \u{14178}; +var \u{14179}; +var \u{1417A}; +var \u{1417B}; +var \u{1417C}; +var \u{1417D}; +var \u{1417E}; +var \u{1417F}; +var \u{14180}; +var \u{14181}; +var \u{14182}; +var \u{14183}; +var \u{14184}; +var \u{14185}; +var \u{14186}; +var \u{14187}; +var \u{14188}; +var \u{14189}; +var \u{1418A}; +var \u{1418B}; +var \u{1418C}; +var \u{1418D}; +var \u{1418E}; +var \u{1418F}; +var \u{14190}; +var \u{14191}; +var \u{14192}; +var \u{14193}; +var \u{14194}; +var \u{14195}; +var \u{14196}; +var \u{14197}; +var \u{14198}; +var \u{14199}; +var \u{1419A}; +var \u{1419B}; +var \u{1419C}; +var \u{1419D}; +var \u{1419E}; +var \u{1419F}; +var \u{141A0}; +var \u{141A1}; +var \u{141A2}; +var \u{141A3}; +var \u{141A4}; +var \u{141A5}; +var \u{141A6}; +var \u{141A7}; +var \u{141A8}; +var \u{141A9}; +var \u{141AA}; +var \u{141AB}; +var \u{141AC}; +var \u{141AD}; +var \u{141AE}; +var \u{141AF}; +var \u{141B0}; +var \u{141B1}; +var \u{141B2}; +var \u{141B3}; +var \u{141B4}; +var \u{141B5}; +var \u{141B6}; +var \u{141B7}; +var \u{141B8}; +var \u{141B9}; +var \u{141BA}; +var \u{141BB}; +var \u{141BC}; +var \u{141BD}; +var \u{141BE}; +var \u{141BF}; +var \u{141C0}; +var \u{141C1}; +var \u{141C2}; +var \u{141C3}; +var \u{141C4}; +var \u{141C5}; +var \u{141C6}; +var \u{141C7}; +var \u{141C8}; +var \u{141C9}; +var \u{141CA}; +var \u{141CB}; +var \u{141CC}; +var \u{141CD}; +var \u{141CE}; +var \u{141CF}; +var \u{141D0}; +var \u{141D1}; +var \u{141D2}; +var \u{141D3}; +var \u{141D4}; +var \u{141D5}; +var \u{141D6}; +var \u{141D7}; +var \u{141D8}; +var \u{141D9}; +var \u{141DA}; +var \u{141DB}; +var \u{141DC}; +var \u{141DD}; +var \u{141DE}; +var \u{141DF}; +var \u{141E0}; +var \u{141E1}; +var \u{141E2}; +var \u{141E3}; +var \u{141E4}; +var \u{141E5}; +var \u{141E6}; +var \u{141E7}; +var \u{141E8}; +var \u{141E9}; +var \u{141EA}; +var \u{141EB}; +var \u{141EC}; +var \u{141ED}; +var \u{141EE}; +var \u{141EF}; +var \u{141F0}; +var \u{141F1}; +var \u{141F2}; +var \u{141F3}; +var \u{141F4}; +var \u{141F5}; +var \u{141F6}; +var \u{141F7}; +var \u{141F8}; +var \u{141F9}; +var \u{141FA}; +var \u{141FB}; +var \u{141FC}; +var \u{141FD}; +var \u{141FE}; +var \u{141FF}; +var \u{14200}; +var \u{14201}; +var \u{14202}; +var \u{14203}; +var \u{14204}; +var \u{14205}; +var \u{14206}; +var \u{14207}; +var \u{14208}; +var \u{14209}; +var \u{1420A}; +var \u{1420B}; +var \u{1420C}; +var \u{1420D}; +var \u{1420E}; +var \u{1420F}; +var \u{14210}; +var \u{14211}; +var \u{14212}; +var \u{14213}; +var \u{14214}; +var \u{14215}; +var \u{14216}; +var \u{14217}; +var \u{14218}; +var \u{14219}; +var \u{1421A}; +var \u{1421B}; +var \u{1421C}; +var \u{1421D}; +var \u{1421E}; +var \u{1421F}; +var \u{14220}; +var \u{14221}; +var \u{14222}; +var \u{14223}; +var \u{14224}; +var \u{14225}; +var \u{14226}; +var \u{14227}; +var \u{14228}; +var \u{14229}; +var \u{1422A}; +var \u{1422B}; +var \u{1422C}; +var \u{1422D}; +var \u{1422E}; +var \u{1422F}; +var \u{14230}; +var \u{14231}; +var \u{14232}; +var \u{14233}; +var \u{14234}; +var \u{14235}; +var \u{14236}; +var \u{14237}; +var \u{14238}; +var \u{14239}; +var \u{1423A}; +var \u{1423B}; +var \u{1423C}; +var \u{1423D}; +var \u{1423E}; +var \u{1423F}; +var \u{14240}; +var \u{14241}; +var \u{14242}; +var \u{14243}; +var \u{14244}; +var \u{14245}; +var \u{14246}; +var \u{14247}; +var \u{14248}; +var \u{14249}; +var \u{1424A}; +var \u{1424B}; +var \u{1424C}; +var \u{1424D}; +var \u{1424E}; +var \u{1424F}; +var \u{14250}; +var \u{14251}; +var \u{14252}; +var \u{14253}; +var \u{14254}; +var \u{14255}; +var \u{14256}; +var \u{14257}; +var \u{14258}; +var \u{14259}; +var \u{1425A}; +var \u{1425B}; +var \u{1425C}; +var \u{1425D}; +var \u{1425E}; +var \u{1425F}; +var \u{14260}; +var \u{14261}; +var \u{14262}; +var \u{14263}; +var \u{14264}; +var \u{14265}; +var \u{14266}; +var \u{14267}; +var \u{14268}; +var \u{14269}; +var \u{1426A}; +var \u{1426B}; +var \u{1426C}; +var \u{1426D}; +var \u{1426E}; +var \u{1426F}; +var \u{14270}; +var \u{14271}; +var \u{14272}; +var \u{14273}; +var \u{14274}; +var \u{14275}; +var \u{14276}; +var \u{14277}; +var \u{14278}; +var \u{14279}; +var \u{1427A}; +var \u{1427B}; +var \u{1427C}; +var \u{1427D}; +var \u{1427E}; +var \u{1427F}; +var \u{14280}; +var \u{14281}; +var \u{14282}; +var \u{14283}; +var \u{14284}; +var \u{14285}; +var \u{14286}; +var \u{14287}; +var \u{14288}; +var \u{14289}; +var \u{1428A}; +var \u{1428B}; +var \u{1428C}; +var \u{1428D}; +var \u{1428E}; +var \u{1428F}; +var \u{14290}; +var \u{14291}; +var \u{14292}; +var \u{14293}; +var \u{14294}; +var \u{14295}; +var \u{14296}; +var \u{14297}; +var \u{14298}; +var \u{14299}; +var \u{1429A}; +var \u{1429B}; +var \u{1429C}; +var \u{1429D}; +var \u{1429E}; +var \u{1429F}; +var \u{142A0}; +var \u{142A1}; +var \u{142A2}; +var \u{142A3}; +var \u{142A4}; +var \u{142A5}; +var \u{142A6}; +var \u{142A7}; +var \u{142A8}; +var \u{142A9}; +var \u{142AA}; +var \u{142AB}; +var \u{142AC}; +var \u{142AD}; +var \u{142AE}; +var \u{142AF}; +var \u{142B0}; +var \u{142B1}; +var \u{142B2}; +var \u{142B3}; +var \u{142B4}; +var \u{142B5}; +var \u{142B6}; +var \u{142B7}; +var \u{142B8}; +var \u{142B9}; +var \u{142BA}; +var \u{142BB}; +var \u{142BC}; +var \u{142BD}; +var \u{142BE}; +var \u{142BF}; +var \u{142C0}; +var \u{142C1}; +var \u{142C2}; +var \u{142C3}; +var \u{142C4}; +var \u{142C5}; +var \u{142C6}; +var \u{142C7}; +var \u{142C8}; +var \u{142C9}; +var \u{142CA}; +var \u{142CB}; +var \u{142CC}; +var \u{142CD}; +var \u{142CE}; +var \u{142CF}; +var \u{142D0}; +var \u{142D1}; +var \u{142D2}; +var \u{142D3}; +var \u{142D4}; +var \u{142D5}; +var \u{142D6}; +var \u{142D7}; +var \u{142D8}; +var \u{142D9}; +var \u{142DA}; +var \u{142DB}; +var \u{142DC}; +var \u{142DD}; +var \u{142DE}; +var \u{142DF}; +var \u{142E0}; +var \u{142E1}; +var \u{142E2}; +var \u{142E3}; +var \u{142E4}; +var \u{142E5}; +var \u{142E6}; +var \u{142E7}; +var \u{142E8}; +var \u{142E9}; +var \u{142EA}; +var \u{142EB}; +var \u{142EC}; +var \u{142ED}; +var \u{142EE}; +var \u{142EF}; +var \u{142F0}; +var \u{142F1}; +var \u{142F2}; +var \u{142F3}; +var \u{142F4}; +var \u{142F5}; +var \u{142F6}; +var \u{142F7}; +var \u{142F8}; +var \u{142F9}; +var \u{142FA}; +var \u{142FB}; +var \u{142FC}; +var \u{142FD}; +var \u{142FE}; +var \u{142FF}; +var \u{14300}; +var \u{14301}; +var \u{14302}; +var \u{14303}; +var \u{14304}; +var \u{14305}; +var \u{14306}; +var \u{14307}; +var \u{14308}; +var \u{14309}; +var \u{1430A}; +var \u{1430B}; +var \u{1430C}; +var \u{1430D}; +var \u{1430E}; +var \u{1430F}; +var \u{14310}; +var \u{14311}; +var \u{14312}; +var \u{14313}; +var \u{14314}; +var \u{14315}; +var \u{14316}; +var \u{14317}; +var \u{14318}; +var \u{14319}; +var \u{1431A}; +var \u{1431B}; +var \u{1431C}; +var \u{1431D}; +var \u{1431E}; +var \u{1431F}; +var \u{14320}; +var \u{14321}; +var \u{14322}; +var \u{14323}; +var \u{14324}; +var \u{14325}; +var \u{14326}; +var \u{14327}; +var \u{14328}; +var \u{14329}; +var \u{1432A}; +var \u{1432B}; +var \u{1432C}; +var \u{1432D}; +var \u{1432E}; +var \u{1432F}; +var \u{14330}; +var \u{14331}; +var \u{14332}; +var \u{14333}; +var \u{14334}; +var \u{14335}; +var \u{14336}; +var \u{14337}; +var \u{14338}; +var \u{14339}; +var \u{1433A}; +var \u{1433B}; +var \u{1433C}; +var \u{1433D}; +var \u{1433E}; +var \u{1433F}; +var \u{14340}; +var \u{14341}; +var \u{14342}; +var \u{14343}; +var \u{14344}; +var \u{14345}; +var \u{14346}; +var \u{14347}; +var \u{14348}; +var \u{14349}; +var \u{1434A}; +var \u{1434B}; +var \u{1434C}; +var \u{1434D}; +var \u{1434E}; +var \u{1434F}; +var \u{14350}; +var \u{14351}; +var \u{14352}; +var \u{14353}; +var \u{14354}; +var \u{14355}; +var \u{14356}; +var \u{14357}; +var \u{14358}; +var \u{14359}; +var \u{1435A}; +var \u{1435B}; +var \u{1435C}; +var \u{1435D}; +var \u{1435E}; +var \u{1435F}; +var \u{14360}; +var \u{14361}; +var \u{14362}; +var \u{14363}; +var \u{14364}; +var \u{14365}; +var \u{14366}; +var \u{14367}; +var \u{14368}; +var \u{14369}; +var \u{1436A}; +var \u{1436B}; +var \u{1436C}; +var \u{1436D}; +var \u{1436E}; +var \u{1436F}; +var \u{14370}; +var \u{14371}; +var \u{14372}; +var \u{14373}; +var \u{14374}; +var \u{14375}; +var \u{14376}; +var \u{14377}; +var \u{14378}; +var \u{14379}; +var \u{1437A}; +var \u{1437B}; +var \u{1437C}; +var \u{1437D}; +var \u{1437E}; +var \u{1437F}; +var \u{14380}; +var \u{14381}; +var \u{14382}; +var \u{14383}; +var \u{14384}; +var \u{14385}; +var \u{14386}; +var \u{14387}; +var \u{14388}; +var \u{14389}; +var \u{1438A}; +var \u{1438B}; +var \u{1438C}; +var \u{1438D}; +var \u{1438E}; +var \u{1438F}; +var \u{14390}; +var \u{14391}; +var \u{14392}; +var \u{14393}; +var \u{14394}; +var \u{14395}; +var \u{14396}; +var \u{14397}; +var \u{14398}; +var \u{14399}; +var \u{1439A}; +var \u{1439B}; +var \u{1439C}; +var \u{1439D}; +var \u{1439E}; +var \u{1439F}; +var \u{143A0}; +var \u{143A1}; +var \u{143A2}; +var \u{143A3}; +var \u{143A4}; +var \u{143A5}; +var \u{143A6}; +var \u{143A7}; +var \u{143A8}; +var \u{143A9}; +var \u{143AA}; +var \u{143AB}; +var \u{143AC}; +var \u{143AD}; +var \u{143AE}; +var \u{143AF}; +var \u{143B0}; +var \u{143B1}; +var \u{143B2}; +var \u{143B3}; +var \u{143B4}; +var \u{143B5}; +var \u{143B6}; +var \u{143B7}; +var \u{143B8}; +var \u{143B9}; +var \u{143BA}; +var \u{143BB}; +var \u{143BC}; +var \u{143BD}; +var \u{143BE}; +var \u{143BF}; +var \u{143C0}; +var \u{143C1}; +var \u{143C2}; +var \u{143C3}; +var \u{143C4}; +var \u{143C5}; +var \u{143C6}; +var \u{143C7}; +var \u{143C8}; +var \u{143C9}; +var \u{143CA}; +var \u{143CB}; +var \u{143CC}; +var \u{143CD}; +var \u{143CE}; +var \u{143CF}; +var \u{143D0}; +var \u{143D1}; +var \u{143D2}; +var \u{143D3}; +var \u{143D4}; +var \u{143D5}; +var \u{143D6}; +var \u{143D7}; +var \u{143D8}; +var \u{143D9}; +var \u{143DA}; +var \u{143DB}; +var \u{143DC}; +var \u{143DD}; +var \u{143DE}; +var \u{143DF}; +var \u{143E0}; +var \u{143E1}; +var \u{143E2}; +var \u{143E3}; +var \u{143E4}; +var \u{143E5}; +var \u{143E6}; +var \u{143E7}; +var \u{143E8}; +var \u{143E9}; +var \u{143EA}; +var \u{143EB}; +var \u{143EC}; +var \u{143ED}; +var \u{143EE}; +var \u{143EF}; +var \u{143F0}; +var \u{143F1}; +var \u{143F2}; +var \u{143F3}; +var \u{143F4}; +var \u{143F5}; +var \u{143F6}; +var \u{143F7}; +var \u{143F8}; +var \u{143F9}; +var \u{143FA}; +var \u{16100}; +var \u{16101}; +var \u{16102}; +var \u{16103}; +var \u{16104}; +var \u{16105}; +var \u{16106}; +var \u{16107}; +var \u{16108}; +var \u{16109}; +var \u{1610A}; +var \u{1610B}; +var \u{1610C}; +var \u{1610D}; +var \u{1610E}; +var \u{1610F}; +var \u{16110}; +var \u{16111}; +var \u{16112}; +var \u{16113}; +var \u{16114}; +var \u{16115}; +var \u{16116}; +var \u{16117}; +var \u{16118}; +var \u{16119}; +var \u{1611A}; +var \u{1611B}; +var \u{1611C}; +var \u{1611D}; +var \u{16D40}; +var \u{16D41}; +var \u{16D42}; +var \u{16D43}; +var \u{16D44}; +var \u{16D45}; +var \u{16D46}; +var \u{16D47}; +var \u{16D48}; +var \u{16D49}; +var \u{16D4A}; +var \u{16D4B}; +var \u{16D4C}; +var \u{16D4D}; +var \u{16D4E}; +var \u{16D4F}; +var \u{16D50}; +var \u{16D51}; +var \u{16D52}; +var \u{16D53}; +var \u{16D54}; +var \u{16D55}; +var \u{16D56}; +var \u{16D57}; +var \u{16D58}; +var \u{16D59}; +var \u{16D5A}; +var \u{16D5B}; +var \u{16D5C}; +var \u{16D5D}; +var \u{16D5E}; +var \u{16D5F}; +var \u{16D60}; +var \u{16D61}; +var \u{16D62}; +var \u{16D63}; +var \u{16D64}; +var \u{16D65}; +var \u{16D66}; +var \u{16D67}; +var \u{16D68}; +var \u{16D69}; +var \u{16D6A}; +var \u{16D6B}; +var \u{16D6C}; +var \u{18CFF}; +var \u{1E5D0}; +var \u{1E5D1}; +var \u{1E5D2}; +var \u{1E5D3}; +var \u{1E5D4}; +var \u{1E5D5}; +var \u{1E5D6}; +var \u{1E5D7}; +var \u{1E5D8}; +var \u{1E5D9}; +var \u{1E5DA}; +var \u{1E5DB}; +var \u{1E5DC}; +var \u{1E5DD}; +var \u{1E5DE}; +var \u{1E5DF}; +var \u{1E5E0}; +var \u{1E5E1}; +var \u{1E5E2}; +var \u{1E5E3}; +var \u{1E5E4}; +var \u{1E5E5}; +var \u{1E5E6}; +var \u{1E5E7}; +var \u{1E5E8}; +var \u{1E5E9}; +var \u{1E5EA}; +var \u{1E5EB}; +var \u{1E5EC}; +var \u{1E5ED}; +var \u{1E5F0}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0.js new file mode 100644 index 000000000..8c6617317 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-16.0.0.js @@ -0,0 +1,4315 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v16.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var Ᲊ; +var ᲊ; +var Ɤ; +var Ꟍ; +var ꟍ; +var Ꟛ; +var ꟛ; +var Ƛ; +var 𐗀; +var 𐗁; +var 𐗂; +var 𐗃; +var 𐗄; +var 𐗅; +var 𐗆; +var 𐗇; +var 𐗈; +var 𐗉; +var 𐗊; +var 𐗋; +var 𐗌; +var 𐗍; +var 𐗎; +var 𐗏; +var 𐗐; +var 𐗑; +var 𐗒; +var 𐗓; +var 𐗔; +var 𐗕; +var 𐗖; +var 𐗗; +var 𐗘; +var 𐗙; +var 𐗚; +var 𐗛; +var 𐗜; +var 𐗝; +var 𐗞; +var 𐗟; +var 𐗠; +var 𐗡; +var 𐗢; +var 𐗣; +var 𐗤; +var 𐗥; +var 𐗦; +var 𐗧; +var 𐗨; +var 𐗩; +var 𐗪; +var 𐗫; +var 𐗬; +var 𐗭; +var 𐗮; +var 𐗯; +var 𐗰; +var 𐗱; +var 𐗲; +var 𐗳; +var 𐵊; +var 𐵋; +var 𐵌; +var 𐵍; +var 𐵎; +var 𐵏; +var 𐵐; +var 𐵑; +var 𐵒; +var 𐵓; +var 𐵔; +var 𐵕; +var 𐵖; +var 𐵗; +var 𐵘; +var 𐵙; +var 𐵚; +var 𐵛; +var 𐵜; +var 𐵝; +var 𐵞; +var 𐵟; +var 𐵠; +var 𐵡; +var 𐵢; +var 𐵣; +var 𐵤; +var 𐵥; +var 𐵯; +var 𐵰; +var 𐵱; +var 𐵲; +var 𐵳; +var 𐵴; +var 𐵵; +var 𐵶; +var 𐵷; +var 𐵸; +var 𐵹; +var 𐵺; +var 𐵻; +var 𐵼; +var 𐵽; +var 𐵾; +var 𐵿; +var 𐶀; +var 𐶁; +var 𐶂; +var 𐶃; +var 𐶄; +var 𐶅; +var 𐻂; +var 𐻃; +var 𐻄; +var 𑎀; +var 𑎁; +var 𑎂; +var 𑎃; +var 𑎄; +var 𑎅; +var 𑎆; +var 𑎇; +var 𑎈; +var 𑎉; +var 𑎋; +var 𑎎; +var 𑎐; +var 𑎑; +var 𑎒; +var 𑎓; +var 𑎔; +var 𑎕; +var 𑎖; +var 𑎗; +var 𑎘; +var 𑎙; +var 𑎚; +var 𑎛; +var 𑎜; +var 𑎝; +var 𑎞; +var 𑎟; +var 𑎠; +var 𑎡; +var 𑎢; +var 𑎣; +var 𑎤; +var 𑎥; +var 𑎦; +var 𑎧; +var 𑎨; +var 𑎩; +var 𑎪; +var 𑎫; +var 𑎬; +var 𑎭; +var 𑎮; +var 𑎯; +var 𑎰; +var 𑎱; +var 𑎲; +var 𑎳; +var 𑎴; +var 𑎵; +var 𑎷; +var 𑏑; +var 𑏓; +var 𑯀; +var 𑯁; +var 𑯂; +var 𑯃; +var 𑯄; +var 𑯅; +var 𑯆; +var 𑯇; +var 𑯈; +var 𑯉; +var 𑯊; +var 𑯋; +var 𑯌; +var 𑯍; +var 𑯎; +var 𑯏; +var 𑯐; +var 𑯑; +var 𑯒; +var 𑯓; +var 𑯔; +var 𑯕; +var 𑯖; +var 𑯗; +var 𑯘; +var 𑯙; +var 𑯚; +var 𑯛; +var 𑯜; +var 𑯝; +var 𑯞; +var 𑯟; +var 𑯠; +var 𓑠; +var 𓑡; +var 𓑢; +var 𓑣; +var 𓑤; +var 𓑥; +var 𓑦; +var 𓑧; +var 𓑨; +var 𓑩; +var 𓑪; +var 𓑫; +var 𓑬; +var 𓑭; +var 𓑮; +var 𓑯; +var 𓑰; +var 𓑱; +var 𓑲; +var 𓑳; +var 𓑴; +var 𓑵; +var 𓑶; +var 𓑷; +var 𓑸; +var 𓑹; +var 𓑺; +var 𓑻; +var 𓑼; +var 𓑽; +var 𓑾; +var 𓑿; +var 𓒀; +var 𓒁; +var 𓒂; +var 𓒃; +var 𓒄; +var 𓒅; +var 𓒆; +var 𓒇; +var 𓒈; +var 𓒉; +var 𓒊; +var 𓒋; +var 𓒌; +var 𓒍; +var 𓒎; +var 𓒏; +var 𓒐; +var 𓒑; +var 𓒒; +var 𓒓; +var 𓒔; +var 𓒕; +var 𓒖; +var 𓒗; +var 𓒘; +var 𓒙; +var 𓒚; +var 𓒛; +var 𓒜; +var 𓒝; +var 𓒞; +var 𓒟; +var 𓒠; +var 𓒡; +var 𓒢; +var 𓒣; +var 𓒤; +var 𓒥; +var 𓒦; +var 𓒧; +var 𓒨; +var 𓒩; +var 𓒪; +var 𓒫; +var 𓒬; +var 𓒭; +var 𓒮; +var 𓒯; +var 𓒰; +var 𓒱; +var 𓒲; +var 𓒳; +var 𓒴; +var 𓒵; +var 𓒶; +var 𓒷; +var 𓒸; +var 𓒹; +var 𓒺; +var 𓒻; +var 𓒼; +var 𓒽; +var 𓒾; +var 𓒿; +var 𓓀; +var 𓓁; +var 𓓂; +var 𓓃; +var 𓓄; +var 𓓅; +var 𓓆; +var 𓓇; +var 𓓈; +var 𓓉; +var 𓓊; +var 𓓋; +var 𓓌; +var 𓓍; +var 𓓎; +var 𓓏; +var 𓓐; +var 𓓑; +var 𓓒; +var 𓓓; +var 𓓔; +var 𓓕; +var 𓓖; +var 𓓗; +var 𓓘; +var 𓓙; +var 𓓚; +var 𓓛; +var 𓓜; +var 𓓝; +var 𓓞; +var 𓓟; +var 𓓠; +var 𓓡; +var 𓓢; +var 𓓣; +var 𓓤; +var 𓓥; +var 𓓦; +var 𓓧; +var 𓓨; +var 𓓩; +var 𓓪; +var 𓓫; +var 𓓬; +var 𓓭; +var 𓓮; +var 𓓯; +var 𓓰; +var 𓓱; +var 𓓲; +var 𓓳; +var 𓓴; +var 𓓵; +var 𓓶; +var 𓓷; +var 𓓸; +var 𓓹; +var 𓓺; +var 𓓻; +var 𓓼; +var 𓓽; +var 𓓾; +var 𓓿; +var 𓔀; +var 𓔁; +var 𓔂; +var 𓔃; +var 𓔄; +var 𓔅; +var 𓔆; +var 𓔇; +var 𓔈; +var 𓔉; +var 𓔊; +var 𓔋; +var 𓔌; +var 𓔍; +var 𓔎; +var 𓔏; +var 𓔐; +var 𓔑; +var 𓔒; +var 𓔓; +var 𓔔; +var 𓔕; +var 𓔖; +var 𓔗; +var 𓔘; +var 𓔙; +var 𓔚; +var 𓔛; +var 𓔜; +var 𓔝; +var 𓔞; +var 𓔟; +var 𓔠; +var 𓔡; +var 𓔢; +var 𓔣; +var 𓔤; +var 𓔥; +var 𓔦; +var 𓔧; +var 𓔨; +var 𓔩; +var 𓔪; +var 𓔫; +var 𓔬; +var 𓔭; +var 𓔮; +var 𓔯; +var 𓔰; +var 𓔱; +var 𓔲; +var 𓔳; +var 𓔴; +var 𓔵; +var 𓔶; +var 𓔷; +var 𓔸; +var 𓔹; +var 𓔺; +var 𓔻; +var 𓔼; +var 𓔽; +var 𓔾; +var 𓔿; +var 𓕀; +var 𓕁; +var 𓕂; +var 𓕃; +var 𓕄; +var 𓕅; +var 𓕆; +var 𓕇; +var 𓕈; +var 𓕉; +var 𓕊; +var 𓕋; +var 𓕌; +var 𓕍; +var 𓕎; +var 𓕏; +var 𓕐; +var 𓕑; +var 𓕒; +var 𓕓; +var 𓕔; +var 𓕕; +var 𓕖; +var 𓕗; +var 𓕘; +var 𓕙; +var 𓕚; +var 𓕛; +var 𓕜; +var 𓕝; +var 𓕞; +var 𓕟; +var 𓕠; +var 𓕡; +var 𓕢; +var 𓕣; +var 𓕤; +var 𓕥; +var 𓕦; +var 𓕧; +var 𓕨; +var 𓕩; +var 𓕪; +var 𓕫; +var 𓕬; +var 𓕭; +var 𓕮; +var 𓕯; +var 𓕰; +var 𓕱; +var 𓕲; +var 𓕳; +var 𓕴; +var 𓕵; +var 𓕶; +var 𓕷; +var 𓕸; +var 𓕹; +var 𓕺; +var 𓕻; +var 𓕼; +var 𓕽; +var 𓕾; +var 𓕿; +var 𓖀; +var 𓖁; +var 𓖂; +var 𓖃; +var 𓖄; +var 𓖅; +var 𓖆; +var 𓖇; +var 𓖈; +var 𓖉; +var 𓖊; +var 𓖋; +var 𓖌; +var 𓖍; +var 𓖎; +var 𓖏; +var 𓖐; +var 𓖑; +var 𓖒; +var 𓖓; +var 𓖔; +var 𓖕; +var 𓖖; +var 𓖗; +var 𓖘; +var 𓖙; +var 𓖚; +var 𓖛; +var 𓖜; +var 𓖝; +var 𓖞; +var 𓖟; +var 𓖠; +var 𓖡; +var 𓖢; +var 𓖣; +var 𓖤; +var 𓖥; +var 𓖦; +var 𓖧; +var 𓖨; +var 𓖩; +var 𓖪; +var 𓖫; +var 𓖬; +var 𓖭; +var 𓖮; +var 𓖯; +var 𓖰; +var 𓖱; +var 𓖲; +var 𓖳; +var 𓖴; +var 𓖵; +var 𓖶; +var 𓖷; +var 𓖸; +var 𓖹; +var 𓖺; +var 𓖻; +var 𓖼; +var 𓖽; +var 𓖾; +var 𓖿; +var 𓗀; +var 𓗁; +var 𓗂; +var 𓗃; +var 𓗄; +var 𓗅; +var 𓗆; +var 𓗇; +var 𓗈; +var 𓗉; +var 𓗊; +var 𓗋; +var 𓗌; +var 𓗍; +var 𓗎; +var 𓗏; +var 𓗐; +var 𓗑; +var 𓗒; +var 𓗓; +var 𓗔; +var 𓗕; +var 𓗖; +var 𓗗; +var 𓗘; +var 𓗙; +var 𓗚; +var 𓗛; +var 𓗜; +var 𓗝; +var 𓗞; +var 𓗟; +var 𓗠; +var 𓗡; +var 𓗢; +var 𓗣; +var 𓗤; +var 𓗥; +var 𓗦; +var 𓗧; +var 𓗨; +var 𓗩; +var 𓗪; +var 𓗫; +var 𓗬; +var 𓗭; +var 𓗮; +var 𓗯; +var 𓗰; +var 𓗱; +var 𓗲; +var 𓗳; +var 𓗴; +var 𓗵; +var 𓗶; +var 𓗷; +var 𓗸; +var 𓗹; +var 𓗺; +var 𓗻; +var 𓗼; +var 𓗽; +var 𓗾; +var 𓗿; +var 𓘀; +var 𓘁; +var 𓘂; +var 𓘃; +var 𓘄; +var 𓘅; +var 𓘆; +var 𓘇; +var 𓘈; +var 𓘉; +var 𓘊; +var 𓘋; +var 𓘌; +var 𓘍; +var 𓘎; +var 𓘏; +var 𓘐; +var 𓘑; +var 𓘒; +var 𓘓; +var 𓘔; +var 𓘕; +var 𓘖; +var 𓘗; +var 𓘘; +var 𓘙; +var 𓘚; +var 𓘛; +var 𓘜; +var 𓘝; +var 𓘞; +var 𓘟; +var 𓘠; +var 𓘡; +var 𓘢; +var 𓘣; +var 𓘤; +var 𓘥; +var 𓘦; +var 𓘧; +var 𓘨; +var 𓘩; +var 𓘪; +var 𓘫; +var 𓘬; +var 𓘭; +var 𓘮; +var 𓘯; +var 𓘰; +var 𓘱; +var 𓘲; +var 𓘳; +var 𓘴; +var 𓘵; +var 𓘶; +var 𓘷; +var 𓘸; +var 𓘹; +var 𓘺; +var 𓘻; +var 𓘼; +var 𓘽; +var 𓘾; +var 𓘿; +var 𓙀; +var 𓙁; +var 𓙂; +var 𓙃; +var 𓙄; +var 𓙅; +var 𓙆; +var 𓙇; +var 𓙈; +var 𓙉; +var 𓙊; +var 𓙋; +var 𓙌; +var 𓙍; +var 𓙎; +var 𓙏; +var 𓙐; +var 𓙑; +var 𓙒; +var 𓙓; +var 𓙔; +var 𓙕; +var 𓙖; +var 𓙗; +var 𓙘; +var 𓙙; +var 𓙚; +var 𓙛; +var 𓙜; +var 𓙝; +var 𓙞; +var 𓙟; +var 𓙠; +var 𓙡; +var 𓙢; +var 𓙣; +var 𓙤; +var 𓙥; +var 𓙦; +var 𓙧; +var 𓙨; +var 𓙩; +var 𓙪; +var 𓙫; +var 𓙬; +var 𓙭; +var 𓙮; +var 𓙯; +var 𓙰; +var 𓙱; +var 𓙲; +var 𓙳; +var 𓙴; +var 𓙵; +var 𓙶; +var 𓙷; +var 𓙸; +var 𓙹; +var 𓙺; +var 𓙻; +var 𓙼; +var 𓙽; +var 𓙾; +var 𓙿; +var 𓚀; +var 𓚁; +var 𓚂; +var 𓚃; +var 𓚄; +var 𓚅; +var 𓚆; +var 𓚇; +var 𓚈; +var 𓚉; +var 𓚊; +var 𓚋; +var 𓚌; +var 𓚍; +var 𓚎; +var 𓚏; +var 𓚐; +var 𓚑; +var 𓚒; +var 𓚓; +var 𓚔; +var 𓚕; +var 𓚖; +var 𓚗; +var 𓚘; +var 𓚙; +var 𓚚; +var 𓚛; +var 𓚜; +var 𓚝; +var 𓚞; +var 𓚟; +var 𓚠; +var 𓚡; +var 𓚢; +var 𓚣; +var 𓚤; +var 𓚥; +var 𓚦; +var 𓚧; +var 𓚨; +var 𓚩; +var 𓚪; +var 𓚫; +var 𓚬; +var 𓚭; +var 𓚮; +var 𓚯; +var 𓚰; +var 𓚱; +var 𓚲; +var 𓚳; +var 𓚴; +var 𓚵; +var 𓚶; +var 𓚷; +var 𓚸; +var 𓚹; +var 𓚺; +var 𓚻; +var 𓚼; +var 𓚽; +var 𓚾; +var 𓚿; +var 𓛀; +var 𓛁; +var 𓛂; +var 𓛃; +var 𓛄; +var 𓛅; +var 𓛆; +var 𓛇; +var 𓛈; +var 𓛉; +var 𓛊; +var 𓛋; +var 𓛌; +var 𓛍; +var 𓛎; +var 𓛏; +var 𓛐; +var 𓛑; +var 𓛒; +var 𓛓; +var 𓛔; +var 𓛕; +var 𓛖; +var 𓛗; +var 𓛘; +var 𓛙; +var 𓛚; +var 𓛛; +var 𓛜; +var 𓛝; +var 𓛞; +var 𓛟; +var 𓛠; +var 𓛡; +var 𓛢; +var 𓛣; +var 𓛤; +var 𓛥; +var 𓛦; +var 𓛧; +var 𓛨; +var 𓛩; +var 𓛪; +var 𓛫; +var 𓛬; +var 𓛭; +var 𓛮; +var 𓛯; +var 𓛰; +var 𓛱; +var 𓛲; +var 𓛳; +var 𓛴; +var 𓛵; +var 𓛶; +var 𓛷; +var 𓛸; +var 𓛹; +var 𓛺; +var 𓛻; +var 𓛼; +var 𓛽; +var 𓛾; +var 𓛿; +var 𓜀; +var 𓜁; +var 𓜂; +var 𓜃; +var 𓜄; +var 𓜅; +var 𓜆; +var 𓜇; +var 𓜈; +var 𓜉; +var 𓜊; +var 𓜋; +var 𓜌; +var 𓜍; +var 𓜎; +var 𓜏; +var 𓜐; +var 𓜑; +var 𓜒; +var 𓜓; +var 𓜔; +var 𓜕; +var 𓜖; +var 𓜗; +var 𓜘; +var 𓜙; +var 𓜚; +var 𓜛; +var 𓜜; +var 𓜝; +var 𓜞; +var 𓜟; +var 𓜠; +var 𓜡; +var 𓜢; +var 𓜣; +var 𓜤; +var 𓜥; +var 𓜦; +var 𓜧; +var 𓜨; +var 𓜩; +var 𓜪; +var 𓜫; +var 𓜬; +var 𓜭; +var 𓜮; +var 𓜯; +var 𓜰; +var 𓜱; +var 𓜲; +var 𓜳; +var 𓜴; +var 𓜵; +var 𓜶; +var 𓜷; +var 𓜸; +var 𓜹; +var 𓜺; +var 𓜻; +var 𓜼; +var 𓜽; +var 𓜾; +var 𓜿; +var 𓝀; +var 𓝁; +var 𓝂; +var 𓝃; +var 𓝄; +var 𓝅; +var 𓝆; +var 𓝇; +var 𓝈; +var 𓝉; +var 𓝊; +var 𓝋; +var 𓝌; +var 𓝍; +var 𓝎; +var 𓝏; +var 𓝐; +var 𓝑; +var 𓝒; +var 𓝓; +var 𓝔; +var 𓝕; +var 𓝖; +var 𓝗; +var 𓝘; +var 𓝙; +var 𓝚; +var 𓝛; +var 𓝜; +var 𓝝; +var 𓝞; +var 𓝟; +var 𓝠; +var 𓝡; +var 𓝢; +var 𓝣; +var 𓝤; +var 𓝥; +var 𓝦; +var 𓝧; +var 𓝨; +var 𓝩; +var 𓝪; +var 𓝫; +var 𓝬; +var 𓝭; +var 𓝮; +var 𓝯; +var 𓝰; +var 𓝱; +var 𓝲; +var 𓝳; +var 𓝴; +var 𓝵; +var 𓝶; +var 𓝷; +var 𓝸; +var 𓝹; +var 𓝺; +var 𓝻; +var 𓝼; +var 𓝽; +var 𓝾; +var 𓝿; +var 𓞀; +var 𓞁; +var 𓞂; +var 𓞃; +var 𓞄; +var 𓞅; +var 𓞆; +var 𓞇; +var 𓞈; +var 𓞉; +var 𓞊; +var 𓞋; +var 𓞌; +var 𓞍; +var 𓞎; +var 𓞏; +var 𓞐; +var 𓞑; +var 𓞒; +var 𓞓; +var 𓞔; +var 𓞕; +var 𓞖; +var 𓞗; +var 𓞘; +var 𓞙; +var 𓞚; +var 𓞛; +var 𓞜; +var 𓞝; +var 𓞞; +var 𓞟; +var 𓞠; +var 𓞡; +var 𓞢; +var 𓞣; +var 𓞤; +var 𓞥; +var 𓞦; +var 𓞧; +var 𓞨; +var 𓞩; +var 𓞪; +var 𓞫; +var 𓞬; +var 𓞭; +var 𓞮; +var 𓞯; +var 𓞰; +var 𓞱; +var 𓞲; +var 𓞳; +var 𓞴; +var 𓞵; +var 𓞶; +var 𓞷; +var 𓞸; +var 𓞹; +var 𓞺; +var 𓞻; +var 𓞼; +var 𓞽; +var 𓞾; +var 𓞿; +var 𓟀; +var 𓟁; +var 𓟂; +var 𓟃; +var 𓟄; +var 𓟅; +var 𓟆; +var 𓟇; +var 𓟈; +var 𓟉; +var 𓟊; +var 𓟋; +var 𓟌; +var 𓟍; +var 𓟎; +var 𓟏; +var 𓟐; +var 𓟑; +var 𓟒; +var 𓟓; +var 𓟔; +var 𓟕; +var 𓟖; +var 𓟗; +var 𓟘; +var 𓟙; +var 𓟚; +var 𓟛; +var 𓟜; +var 𓟝; +var 𓟞; +var 𓟟; +var 𓟠; +var 𓟡; +var 𓟢; +var 𓟣; +var 𓟤; +var 𓟥; +var 𓟦; +var 𓟧; +var 𓟨; +var 𓟩; +var 𓟪; +var 𓟫; +var 𓟬; +var 𓟭; +var 𓟮; +var 𓟯; +var 𓟰; +var 𓟱; +var 𓟲; +var 𓟳; +var 𓟴; +var 𓟵; +var 𓟶; +var 𓟷; +var 𓟸; +var 𓟹; +var 𓟺; +var 𓟻; +var 𓟼; +var 𓟽; +var 𓟾; +var 𓟿; +var 𓠀; +var 𓠁; +var 𓠂; +var 𓠃; +var 𓠄; +var 𓠅; +var 𓠆; +var 𓠇; +var 𓠈; +var 𓠉; +var 𓠊; +var 𓠋; +var 𓠌; +var 𓠍; +var 𓠎; +var 𓠏; +var 𓠐; +var 𓠑; +var 𓠒; +var 𓠓; +var 𓠔; +var 𓠕; +var 𓠖; +var 𓠗; +var 𓠘; +var 𓠙; +var 𓠚; +var 𓠛; +var 𓠜; +var 𓠝; +var 𓠞; +var 𓠟; +var 𓠠; +var 𓠡; +var 𓠢; +var 𓠣; +var 𓠤; +var 𓠥; +var 𓠦; +var 𓠧; +var 𓠨; +var 𓠩; +var 𓠪; +var 𓠫; +var 𓠬; +var 𓠭; +var 𓠮; +var 𓠯; +var 𓠰; +var 𓠱; +var 𓠲; +var 𓠳; +var 𓠴; +var 𓠵; +var 𓠶; +var 𓠷; +var 𓠸; +var 𓠹; +var 𓠺; +var 𓠻; +var 𓠼; +var 𓠽; +var 𓠾; +var 𓠿; +var 𓡀; +var 𓡁; +var 𓡂; +var 𓡃; +var 𓡄; +var 𓡅; +var 𓡆; +var 𓡇; +var 𓡈; +var 𓡉; +var 𓡊; +var 𓡋; +var 𓡌; +var 𓡍; +var 𓡎; +var 𓡏; +var 𓡐; +var 𓡑; +var 𓡒; +var 𓡓; +var 𓡔; +var 𓡕; +var 𓡖; +var 𓡗; +var 𓡘; +var 𓡙; +var 𓡚; +var 𓡛; +var 𓡜; +var 𓡝; +var 𓡞; +var 𓡟; +var 𓡠; +var 𓡡; +var 𓡢; +var 𓡣; +var 𓡤; +var 𓡥; +var 𓡦; +var 𓡧; +var 𓡨; +var 𓡩; +var 𓡪; +var 𓡫; +var 𓡬; +var 𓡭; +var 𓡮; +var 𓡯; +var 𓡰; +var 𓡱; +var 𓡲; +var 𓡳; +var 𓡴; +var 𓡵; +var 𓡶; +var 𓡷; +var 𓡸; +var 𓡹; +var 𓡺; +var 𓡻; +var 𓡼; +var 𓡽; +var 𓡾; +var 𓡿; +var 𓢀; +var 𓢁; +var 𓢂; +var 𓢃; +var 𓢄; +var 𓢅; +var 𓢆; +var 𓢇; +var 𓢈; +var 𓢉; +var 𓢊; +var 𓢋; +var 𓢌; +var 𓢍; +var 𓢎; +var 𓢏; +var 𓢐; +var 𓢑; +var 𓢒; +var 𓢓; +var 𓢔; +var 𓢕; +var 𓢖; +var 𓢗; +var 𓢘; +var 𓢙; +var 𓢚; +var 𓢛; +var 𓢜; +var 𓢝; +var 𓢞; +var 𓢟; +var 𓢠; +var 𓢡; +var 𓢢; +var 𓢣; +var 𓢤; +var 𓢥; +var 𓢦; +var 𓢧; +var 𓢨; +var 𓢩; +var 𓢪; +var 𓢫; +var 𓢬; +var 𓢭; +var 𓢮; +var 𓢯; +var 𓢰; +var 𓢱; +var 𓢲; +var 𓢳; +var 𓢴; +var 𓢵; +var 𓢶; +var 𓢷; +var 𓢸; +var 𓢹; +var 𓢺; +var 𓢻; +var 𓢼; +var 𓢽; +var 𓢾; +var 𓢿; +var 𓣀; +var 𓣁; +var 𓣂; +var 𓣃; +var 𓣄; +var 𓣅; +var 𓣆; +var 𓣇; +var 𓣈; +var 𓣉; +var 𓣊; +var 𓣋; +var 𓣌; +var 𓣍; +var 𓣎; +var 𓣏; +var 𓣐; +var 𓣑; +var 𓣒; +var 𓣓; +var 𓣔; +var 𓣕; +var 𓣖; +var 𓣗; +var 𓣘; +var 𓣙; +var 𓣚; +var 𓣛; +var 𓣜; +var 𓣝; +var 𓣞; +var 𓣟; +var 𓣠; +var 𓣡; +var 𓣢; +var 𓣣; +var 𓣤; +var 𓣥; +var 𓣦; +var 𓣧; +var 𓣨; +var 𓣩; +var 𓣪; +var 𓣫; +var 𓣬; +var 𓣭; +var 𓣮; +var 𓣯; +var 𓣰; +var 𓣱; +var 𓣲; +var 𓣳; +var 𓣴; +var 𓣵; +var 𓣶; +var 𓣷; +var 𓣸; +var 𓣹; +var 𓣺; +var 𓣻; +var 𓣼; +var 𓣽; +var 𓣾; +var 𓣿; +var 𓤀; +var 𓤁; +var 𓤂; +var 𓤃; +var 𓤄; +var 𓤅; +var 𓤆; +var 𓤇; +var 𓤈; +var 𓤉; +var 𓤊; +var 𓤋; +var 𓤌; +var 𓤍; +var 𓤎; +var 𓤏; +var 𓤐; +var 𓤑; +var 𓤒; +var 𓤓; +var 𓤔; +var 𓤕; +var 𓤖; +var 𓤗; +var 𓤘; +var 𓤙; +var 𓤚; +var 𓤛; +var 𓤜; +var 𓤝; +var 𓤞; +var 𓤟; +var 𓤠; +var 𓤡; +var 𓤢; +var 𓤣; +var 𓤤; +var 𓤥; +var 𓤦; +var 𓤧; +var 𓤨; +var 𓤩; +var 𓤪; +var 𓤫; +var 𓤬; +var 𓤭; +var 𓤮; +var 𓤯; +var 𓤰; +var 𓤱; +var 𓤲; +var 𓤳; +var 𓤴; +var 𓤵; +var 𓤶; +var 𓤷; +var 𓤸; +var 𓤹; +var 𓤺; +var 𓤻; +var 𓤼; +var 𓤽; +var 𓤾; +var 𓤿; +var 𓥀; +var 𓥁; +var 𓥂; +var 𓥃; +var 𓥄; +var 𓥅; +var 𓥆; +var 𓥇; +var 𓥈; +var 𓥉; +var 𓥊; +var 𓥋; +var 𓥌; +var 𓥍; +var 𓥎; +var 𓥏; +var 𓥐; +var 𓥑; +var 𓥒; +var 𓥓; +var 𓥔; +var 𓥕; +var 𓥖; +var 𓥗; +var 𓥘; +var 𓥙; +var 𓥚; +var 𓥛; +var 𓥜; +var 𓥝; +var 𓥞; +var 𓥟; +var 𓥠; +var 𓥡; +var 𓥢; +var 𓥣; +var 𓥤; +var 𓥥; +var 𓥦; +var 𓥧; +var 𓥨; +var 𓥩; +var 𓥪; +var 𓥫; +var 𓥬; +var 𓥭; +var 𓥮; +var 𓥯; +var 𓥰; +var 𓥱; +var 𓥲; +var 𓥳; +var 𓥴; +var 𓥵; +var 𓥶; +var 𓥷; +var 𓥸; +var 𓥹; +var 𓥺; +var 𓥻; +var 𓥼; +var 𓥽; +var 𓥾; +var 𓥿; +var 𓦀; +var 𓦁; +var 𓦂; +var 𓦃; +var 𓦄; +var 𓦅; +var 𓦆; +var 𓦇; +var 𓦈; +var 𓦉; +var 𓦊; +var 𓦋; +var 𓦌; +var 𓦍; +var 𓦎; +var 𓦏; +var 𓦐; +var 𓦑; +var 𓦒; +var 𓦓; +var 𓦔; +var 𓦕; +var 𓦖; +var 𓦗; +var 𓦘; +var 𓦙; +var 𓦚; +var 𓦛; +var 𓦜; +var 𓦝; +var 𓦞; +var 𓦟; +var 𓦠; +var 𓦡; +var 𓦢; +var 𓦣; +var 𓦤; +var 𓦥; +var 𓦦; +var 𓦧; +var 𓦨; +var 𓦩; +var 𓦪; +var 𓦫; +var 𓦬; +var 𓦭; +var 𓦮; +var 𓦯; +var 𓦰; +var 𓦱; +var 𓦲; +var 𓦳; +var 𓦴; +var 𓦵; +var 𓦶; +var 𓦷; +var 𓦸; +var 𓦹; +var 𓦺; +var 𓦻; +var 𓦼; +var 𓦽; +var 𓦾; +var 𓦿; +var 𓧀; +var 𓧁; +var 𓧂; +var 𓧃; +var 𓧄; +var 𓧅; +var 𓧆; +var 𓧇; +var 𓧈; +var 𓧉; +var 𓧊; +var 𓧋; +var 𓧌; +var 𓧍; +var 𓧎; +var 𓧏; +var 𓧐; +var 𓧑; +var 𓧒; +var 𓧓; +var 𓧔; +var 𓧕; +var 𓧖; +var 𓧗; +var 𓧘; +var 𓧙; +var 𓧚; +var 𓧛; +var 𓧜; +var 𓧝; +var 𓧞; +var 𓧟; +var 𓧠; +var 𓧡; +var 𓧢; +var 𓧣; +var 𓧤; +var 𓧥; +var 𓧦; +var 𓧧; +var 𓧨; +var 𓧩; +var 𓧪; +var 𓧫; +var 𓧬; +var 𓧭; +var 𓧮; +var 𓧯; +var 𓧰; +var 𓧱; +var 𓧲; +var 𓧳; +var 𓧴; +var 𓧵; +var 𓧶; +var 𓧷; +var 𓧸; +var 𓧹; +var 𓧺; +var 𓧻; +var 𓧼; +var 𓧽; +var 𓧾; +var 𓧿; +var 𓨀; +var 𓨁; +var 𓨂; +var 𓨃; +var 𓨄; +var 𓨅; +var 𓨆; +var 𓨇; +var 𓨈; +var 𓨉; +var 𓨊; +var 𓨋; +var 𓨌; +var 𓨍; +var 𓨎; +var 𓨏; +var 𓨐; +var 𓨑; +var 𓨒; +var 𓨓; +var 𓨔; +var 𓨕; +var 𓨖; +var 𓨗; +var 𓨘; +var 𓨙; +var 𓨚; +var 𓨛; +var 𓨜; +var 𓨝; +var 𓨞; +var 𓨟; +var 𓨠; +var 𓨡; +var 𓨢; +var 𓨣; +var 𓨤; +var 𓨥; +var 𓨦; +var 𓨧; +var 𓨨; +var 𓨩; +var 𓨪; +var 𓨫; +var 𓨬; +var 𓨭; +var 𓨮; +var 𓨯; +var 𓨰; +var 𓨱; +var 𓨲; +var 𓨳; +var 𓨴; +var 𓨵; +var 𓨶; +var 𓨷; +var 𓨸; +var 𓨹; +var 𓨺; +var 𓨻; +var 𓨼; +var 𓨽; +var 𓨾; +var 𓨿; +var 𓩀; +var 𓩁; +var 𓩂; +var 𓩃; +var 𓩄; +var 𓩅; +var 𓩆; +var 𓩇; +var 𓩈; +var 𓩉; +var 𓩊; +var 𓩋; +var 𓩌; +var 𓩍; +var 𓩎; +var 𓩏; +var 𓩐; +var 𓩑; +var 𓩒; +var 𓩓; +var 𓩔; +var 𓩕; +var 𓩖; +var 𓩗; +var 𓩘; +var 𓩙; +var 𓩚; +var 𓩛; +var 𓩜; +var 𓩝; +var 𓩞; +var 𓩟; +var 𓩠; +var 𓩡; +var 𓩢; +var 𓩣; +var 𓩤; +var 𓩥; +var 𓩦; +var 𓩧; +var 𓩨; +var 𓩩; +var 𓩪; +var 𓩫; +var 𓩬; +var 𓩭; +var 𓩮; +var 𓩯; +var 𓩰; +var 𓩱; +var 𓩲; +var 𓩳; +var 𓩴; +var 𓩵; +var 𓩶; +var 𓩷; +var 𓩸; +var 𓩹; +var 𓩺; +var 𓩻; +var 𓩼; +var 𓩽; +var 𓩾; +var 𓩿; +var 𓪀; +var 𓪁; +var 𓪂; +var 𓪃; +var 𓪄; +var 𓪅; +var 𓪆; +var 𓪇; +var 𓪈; +var 𓪉; +var 𓪊; +var 𓪋; +var 𓪌; +var 𓪍; +var 𓪎; +var 𓪏; +var 𓪐; +var 𓪑; +var 𓪒; +var 𓪓; +var 𓪔; +var 𓪕; +var 𓪖; +var 𓪗; +var 𓪘; +var 𓪙; +var 𓪚; +var 𓪛; +var 𓪜; +var 𓪝; +var 𓪞; +var 𓪟; +var 𓪠; +var 𓪡; +var 𓪢; +var 𓪣; +var 𓪤; +var 𓪥; +var 𓪦; +var 𓪧; +var 𓪨; +var 𓪩; +var 𓪪; +var 𓪫; +var 𓪬; +var 𓪭; +var 𓪮; +var 𓪯; +var 𓪰; +var 𓪱; +var 𓪲; +var 𓪳; +var 𓪴; +var 𓪵; +var 𓪶; +var 𓪷; +var 𓪸; +var 𓪹; +var 𓪺; +var 𓪻; +var 𓪼; +var 𓪽; +var 𓪾; +var 𓪿; +var 𓫀; +var 𓫁; +var 𓫂; +var 𓫃; +var 𓫄; +var 𓫅; +var 𓫆; +var 𓫇; +var 𓫈; +var 𓫉; +var 𓫊; +var 𓫋; +var 𓫌; +var 𓫍; +var 𓫎; +var 𓫏; +var 𓫐; +var 𓫑; +var 𓫒; +var 𓫓; +var 𓫔; +var 𓫕; +var 𓫖; +var 𓫗; +var 𓫘; +var 𓫙; +var 𓫚; +var 𓫛; +var 𓫜; +var 𓫝; +var 𓫞; +var 𓫟; +var 𓫠; +var 𓫡; +var 𓫢; +var 𓫣; +var 𓫤; +var 𓫥; +var 𓫦; +var 𓫧; +var 𓫨; +var 𓫩; +var 𓫪; +var 𓫫; +var 𓫬; +var 𓫭; +var 𓫮; +var 𓫯; +var 𓫰; +var 𓫱; +var 𓫲; +var 𓫳; +var 𓫴; +var 𓫵; +var 𓫶; +var 𓫷; +var 𓫸; +var 𓫹; +var 𓫺; +var 𓫻; +var 𓫼; +var 𓫽; +var 𓫾; +var 𓫿; +var 𓬀; +var 𓬁; +var 𓬂; +var 𓬃; +var 𓬄; +var 𓬅; +var 𓬆; +var 𓬇; +var 𓬈; +var 𓬉; +var 𓬊; +var 𓬋; +var 𓬌; +var 𓬍; +var 𓬎; +var 𓬏; +var 𓬐; +var 𓬑; +var 𓬒; +var 𓬓; +var 𓬔; +var 𓬕; +var 𓬖; +var 𓬗; +var 𓬘; +var 𓬙; +var 𓬚; +var 𓬛; +var 𓬜; +var 𓬝; +var 𓬞; +var 𓬟; +var 𓬠; +var 𓬡; +var 𓬢; +var 𓬣; +var 𓬤; +var 𓬥; +var 𓬦; +var 𓬧; +var 𓬨; +var 𓬩; +var 𓬪; +var 𓬫; +var 𓬬; +var 𓬭; +var 𓬮; +var 𓬯; +var 𓬰; +var 𓬱; +var 𓬲; +var 𓬳; +var 𓬴; +var 𓬵; +var 𓬶; +var 𓬷; +var 𓬸; +var 𓬹; +var 𓬺; +var 𓬻; +var 𓬼; +var 𓬽; +var 𓬾; +var 𓬿; +var 𓭀; +var 𓭁; +var 𓭂; +var 𓭃; +var 𓭄; +var 𓭅; +var 𓭆; +var 𓭇; +var 𓭈; +var 𓭉; +var 𓭊; +var 𓭋; +var 𓭌; +var 𓭍; +var 𓭎; +var 𓭏; +var 𓭐; +var 𓭑; +var 𓭒; +var 𓭓; +var 𓭔; +var 𓭕; +var 𓭖; +var 𓭗; +var 𓭘; +var 𓭙; +var 𓭚; +var 𓭛; +var 𓭜; +var 𓭝; +var 𓭞; +var 𓭟; +var 𓭠; +var 𓭡; +var 𓭢; +var 𓭣; +var 𓭤; +var 𓭥; +var 𓭦; +var 𓭧; +var 𓭨; +var 𓭩; +var 𓭪; +var 𓭫; +var 𓭬; +var 𓭭; +var 𓭮; +var 𓭯; +var 𓭰; +var 𓭱; +var 𓭲; +var 𓭳; +var 𓭴; +var 𓭵; +var 𓭶; +var 𓭷; +var 𓭸; +var 𓭹; +var 𓭺; +var 𓭻; +var 𓭼; +var 𓭽; +var 𓭾; +var 𓭿; +var 𓮀; +var 𓮁; +var 𓮂; +var 𓮃; +var 𓮄; +var 𓮅; +var 𓮆; +var 𓮇; +var 𓮈; +var 𓮉; +var 𓮊; +var 𓮋; +var 𓮌; +var 𓮍; +var 𓮎; +var 𓮏; +var 𓮐; +var 𓮑; +var 𓮒; +var 𓮓; +var 𓮔; +var 𓮕; +var 𓮖; +var 𓮗; +var 𓮘; +var 𓮙; +var 𓮚; +var 𓮛; +var 𓮜; +var 𓮝; +var 𓮞; +var 𓮟; +var 𓮠; +var 𓮡; +var 𓮢; +var 𓮣; +var 𓮤; +var 𓮥; +var 𓮦; +var 𓮧; +var 𓮨; +var 𓮩; +var 𓮪; +var 𓮫; +var 𓮬; +var 𓮭; +var 𓮮; +var 𓮯; +var 𓮰; +var 𓮱; +var 𓮲; +var 𓮳; +var 𓮴; +var 𓮵; +var 𓮶; +var 𓮷; +var 𓮸; +var 𓮹; +var 𓮺; +var 𓮻; +var 𓮼; +var 𓮽; +var 𓮾; +var 𓮿; +var 𓯀; +var 𓯁; +var 𓯂; +var 𓯃; +var 𓯄; +var 𓯅; +var 𓯆; +var 𓯇; +var 𓯈; +var 𓯉; +var 𓯊; +var 𓯋; +var 𓯌; +var 𓯍; +var 𓯎; +var 𓯏; +var 𓯐; +var 𓯑; +var 𓯒; +var 𓯓; +var 𓯔; +var 𓯕; +var 𓯖; +var 𓯗; +var 𓯘; +var 𓯙; +var 𓯚; +var 𓯛; +var 𓯜; +var 𓯝; +var 𓯞; +var 𓯟; +var 𓯠; +var 𓯡; +var 𓯢; +var 𓯣; +var 𓯤; +var 𓯥; +var 𓯦; +var 𓯧; +var 𓯨; +var 𓯩; +var 𓯪; +var 𓯫; +var 𓯬; +var 𓯭; +var 𓯮; +var 𓯯; +var 𓯰; +var 𓯱; +var 𓯲; +var 𓯳; +var 𓯴; +var 𓯵; +var 𓯶; +var 𓯷; +var 𓯸; +var 𓯹; +var 𓯺; +var 𓯻; +var 𓯼; +var 𓯽; +var 𓯾; +var 𓯿; +var 𓰀; +var 𓰁; +var 𓰂; +var 𓰃; +var 𓰄; +var 𓰅; +var 𓰆; +var 𓰇; +var 𓰈; +var 𓰉; +var 𓰊; +var 𓰋; +var 𓰌; +var 𓰍; +var 𓰎; +var 𓰏; +var 𓰐; +var 𓰑; +var 𓰒; +var 𓰓; +var 𓰔; +var 𓰕; +var 𓰖; +var 𓰗; +var 𓰘; +var 𓰙; +var 𓰚; +var 𓰛; +var 𓰜; +var 𓰝; +var 𓰞; +var 𓰟; +var 𓰠; +var 𓰡; +var 𓰢; +var 𓰣; +var 𓰤; +var 𓰥; +var 𓰦; +var 𓰧; +var 𓰨; +var 𓰩; +var 𓰪; +var 𓰫; +var 𓰬; +var 𓰭; +var 𓰮; +var 𓰯; +var 𓰰; +var 𓰱; +var 𓰲; +var 𓰳; +var 𓰴; +var 𓰵; +var 𓰶; +var 𓰷; +var 𓰸; +var 𓰹; +var 𓰺; +var 𓰻; +var 𓰼; +var 𓰽; +var 𓰾; +var 𓰿; +var 𓱀; +var 𓱁; +var 𓱂; +var 𓱃; +var 𓱄; +var 𓱅; +var 𓱆; +var 𓱇; +var 𓱈; +var 𓱉; +var 𓱊; +var 𓱋; +var 𓱌; +var 𓱍; +var 𓱎; +var 𓱏; +var 𓱐; +var 𓱑; +var 𓱒; +var 𓱓; +var 𓱔; +var 𓱕; +var 𓱖; +var 𓱗; +var 𓱘; +var 𓱙; +var 𓱚; +var 𓱛; +var 𓱜; +var 𓱝; +var 𓱞; +var 𓱟; +var 𓱠; +var 𓱡; +var 𓱢; +var 𓱣; +var 𓱤; +var 𓱥; +var 𓱦; +var 𓱧; +var 𓱨; +var 𓱩; +var 𓱪; +var 𓱫; +var 𓱬; +var 𓱭; +var 𓱮; +var 𓱯; +var 𓱰; +var 𓱱; +var 𓱲; +var 𓱳; +var 𓱴; +var 𓱵; +var 𓱶; +var 𓱷; +var 𓱸; +var 𓱹; +var 𓱺; +var 𓱻; +var 𓱼; +var 𓱽; +var 𓱾; +var 𓱿; +var 𓲀; +var 𓲁; +var 𓲂; +var 𓲃; +var 𓲄; +var 𓲅; +var 𓲆; +var 𓲇; +var 𓲈; +var 𓲉; +var 𓲊; +var 𓲋; +var 𓲌; +var 𓲍; +var 𓲎; +var 𓲏; +var 𓲐; +var 𓲑; +var 𓲒; +var 𓲓; +var 𓲔; +var 𓲕; +var 𓲖; +var 𓲗; +var 𓲘; +var 𓲙; +var 𓲚; +var 𓲛; +var 𓲜; +var 𓲝; +var 𓲞; +var 𓲟; +var 𓲠; +var 𓲡; +var 𓲢; +var 𓲣; +var 𓲤; +var 𓲥; +var 𓲦; +var 𓲧; +var 𓲨; +var 𓲩; +var 𓲪; +var 𓲫; +var 𓲬; +var 𓲭; +var 𓲮; +var 𓲯; +var 𓲰; +var 𓲱; +var 𓲲; +var 𓲳; +var 𓲴; +var 𓲵; +var 𓲶; +var 𓲷; +var 𓲸; +var 𓲹; +var 𓲺; +var 𓲻; +var 𓲼; +var 𓲽; +var 𓲾; +var 𓲿; +var 𓳀; +var 𓳁; +var 𓳂; +var 𓳃; +var 𓳄; +var 𓳅; +var 𓳆; +var 𓳇; +var 𓳈; +var 𓳉; +var 𓳊; +var 𓳋; +var 𓳌; +var 𓳍; +var 𓳎; +var 𓳏; +var 𓳐; +var 𓳑; +var 𓳒; +var 𓳓; +var 𓳔; +var 𓳕; +var 𓳖; +var 𓳗; +var 𓳘; +var 𓳙; +var 𓳚; +var 𓳛; +var 𓳜; +var 𓳝; +var 𓳞; +var 𓳟; +var 𓳠; +var 𓳡; +var 𓳢; +var 𓳣; +var 𓳤; +var 𓳥; +var 𓳦; +var 𓳧; +var 𓳨; +var 𓳩; +var 𓳪; +var 𓳫; +var 𓳬; +var 𓳭; +var 𓳮; +var 𓳯; +var 𓳰; +var 𓳱; +var 𓳲; +var 𓳳; +var 𓳴; +var 𓳵; +var 𓳶; +var 𓳷; +var 𓳸; +var 𓳹; +var 𓳺; +var 𓳻; +var 𓳼; +var 𓳽; +var 𓳾; +var 𓳿; +var 𓴀; +var 𓴁; +var 𓴂; +var 𓴃; +var 𓴄; +var 𓴅; +var 𓴆; +var 𓴇; +var 𓴈; +var 𓴉; +var 𓴊; +var 𓴋; +var 𓴌; +var 𓴍; +var 𓴎; +var 𓴏; +var 𓴐; +var 𓴑; +var 𓴒; +var 𓴓; +var 𓴔; +var 𓴕; +var 𓴖; +var 𓴗; +var 𓴘; +var 𓴙; +var 𓴚; +var 𓴛; +var 𓴜; +var 𓴝; +var 𓴞; +var 𓴟; +var 𓴠; +var 𓴡; +var 𓴢; +var 𓴣; +var 𓴤; +var 𓴥; +var 𓴦; +var 𓴧; +var 𓴨; +var 𓴩; +var 𓴪; +var 𓴫; +var 𓴬; +var 𓴭; +var 𓴮; +var 𓴯; +var 𓴰; +var 𓴱; +var 𓴲; +var 𓴳; +var 𓴴; +var 𓴵; +var 𓴶; +var 𓴷; +var 𓴸; +var 𓴹; +var 𓴺; +var 𓴻; +var 𓴼; +var 𓴽; +var 𓴾; +var 𓴿; +var 𓵀; +var 𓵁; +var 𓵂; +var 𓵃; +var 𓵄; +var 𓵅; +var 𓵆; +var 𓵇; +var 𓵈; +var 𓵉; +var 𓵊; +var 𓵋; +var 𓵌; +var 𓵍; +var 𓵎; +var 𓵏; +var 𓵐; +var 𓵑; +var 𓵒; +var 𓵓; +var 𓵔; +var 𓵕; +var 𓵖; +var 𓵗; +var 𓵘; +var 𓵙; +var 𓵚; +var 𓵛; +var 𓵜; +var 𓵝; +var 𓵞; +var 𓵟; +var 𓵠; +var 𓵡; +var 𓵢; +var 𓵣; +var 𓵤; +var 𓵥; +var 𓵦; +var 𓵧; +var 𓵨; +var 𓵩; +var 𓵪; +var 𓵫; +var 𓵬; +var 𓵭; +var 𓵮; +var 𓵯; +var 𓵰; +var 𓵱; +var 𓵲; +var 𓵳; +var 𓵴; +var 𓵵; +var 𓵶; +var 𓵷; +var 𓵸; +var 𓵹; +var 𓵺; +var 𓵻; +var 𓵼; +var 𓵽; +var 𓵾; +var 𓵿; +var 𓶀; +var 𓶁; +var 𓶂; +var 𓶃; +var 𓶄; +var 𓶅; +var 𓶆; +var 𓶇; +var 𓶈; +var 𓶉; +var 𓶊; +var 𓶋; +var 𓶌; +var 𓶍; +var 𓶎; +var 𓶏; +var 𓶐; +var 𓶑; +var 𓶒; +var 𓶓; +var 𓶔; +var 𓶕; +var 𓶖; +var 𓶗; +var 𓶘; +var 𓶙; +var 𓶚; +var 𓶛; +var 𓶜; +var 𓶝; +var 𓶞; +var 𓶟; +var 𓶠; +var 𓶡; +var 𓶢; +var 𓶣; +var 𓶤; +var 𓶥; +var 𓶦; +var 𓶧; +var 𓶨; +var 𓶩; +var 𓶪; +var 𓶫; +var 𓶬; +var 𓶭; +var 𓶮; +var 𓶯; +var 𓶰; +var 𓶱; +var 𓶲; +var 𓶳; +var 𓶴; +var 𓶵; +var 𓶶; +var 𓶷; +var 𓶸; +var 𓶹; +var 𓶺; +var 𓶻; +var 𓶼; +var 𓶽; +var 𓶾; +var 𓶿; +var 𓷀; +var 𓷁; +var 𓷂; +var 𓷃; +var 𓷄; +var 𓷅; +var 𓷆; +var 𓷇; +var 𓷈; +var 𓷉; +var 𓷊; +var 𓷋; +var 𓷌; +var 𓷍; +var 𓷎; +var 𓷏; +var 𓷐; +var 𓷑; +var 𓷒; +var 𓷓; +var 𓷔; +var 𓷕; +var 𓷖; +var 𓷗; +var 𓷘; +var 𓷙; +var 𓷚; +var 𓷛; +var 𓷜; +var 𓷝; +var 𓷞; +var 𓷟; +var 𓷠; +var 𓷡; +var 𓷢; +var 𓷣; +var 𓷤; +var 𓷥; +var 𓷦; +var 𓷧; +var 𓷨; +var 𓷩; +var 𓷪; +var 𓷫; +var 𓷬; +var 𓷭; +var 𓷮; +var 𓷯; +var 𓷰; +var 𓷱; +var 𓷲; +var 𓷳; +var 𓷴; +var 𓷵; +var 𓷶; +var 𓷷; +var 𓷸; +var 𓷹; +var 𓷺; +var 𓷻; +var 𓷼; +var 𓷽; +var 𓷾; +var 𓷿; +var 𓸀; +var 𓸁; +var 𓸂; +var 𓸃; +var 𓸄; +var 𓸅; +var 𓸆; +var 𓸇; +var 𓸈; +var 𓸉; +var 𓸊; +var 𓸋; +var 𓸌; +var 𓸍; +var 𓸎; +var 𓸏; +var 𓸐; +var 𓸑; +var 𓸒; +var 𓸓; +var 𓸔; +var 𓸕; +var 𓸖; +var 𓸗; +var 𓸘; +var 𓸙; +var 𓸚; +var 𓸛; +var 𓸜; +var 𓸝; +var 𓸞; +var 𓸟; +var 𓸠; +var 𓸡; +var 𓸢; +var 𓸣; +var 𓸤; +var 𓸥; +var 𓸦; +var 𓸧; +var 𓸨; +var 𓸩; +var 𓸪; +var 𓸫; +var 𓸬; +var 𓸭; +var 𓸮; +var 𓸯; +var 𓸰; +var 𓸱; +var 𓸲; +var 𓸳; +var 𓸴; +var 𓸵; +var 𓸶; +var 𓸷; +var 𓸸; +var 𓸹; +var 𓸺; +var 𓸻; +var 𓸼; +var 𓸽; +var 𓸾; +var 𓸿; +var 𓹀; +var 𓹁; +var 𓹂; +var 𓹃; +var 𓹄; +var 𓹅; +var 𓹆; +var 𓹇; +var 𓹈; +var 𓹉; +var 𓹊; +var 𓹋; +var 𓹌; +var 𓹍; +var 𓹎; +var 𓹏; +var 𓹐; +var 𓹑; +var 𓹒; +var 𓹓; +var 𓹔; +var 𓹕; +var 𓹖; +var 𓹗; +var 𓹘; +var 𓹙; +var 𓹚; +var 𓹛; +var 𓹜; +var 𓹝; +var 𓹞; +var 𓹟; +var 𓹠; +var 𓹡; +var 𓹢; +var 𓹣; +var 𓹤; +var 𓹥; +var 𓹦; +var 𓹧; +var 𓹨; +var 𓹩; +var 𓹪; +var 𓹫; +var 𓹬; +var 𓹭; +var 𓹮; +var 𓹯; +var 𓹰; +var 𓹱; +var 𓹲; +var 𓹳; +var 𓹴; +var 𓹵; +var 𓹶; +var 𓹷; +var 𓹸; +var 𓹹; +var 𓹺; +var 𓹻; +var 𓹼; +var 𓹽; +var 𓹾; +var 𓹿; +var 𓺀; +var 𓺁; +var 𓺂; +var 𓺃; +var 𓺄; +var 𓺅; +var 𓺆; +var 𓺇; +var 𓺈; +var 𓺉; +var 𓺊; +var 𓺋; +var 𓺌; +var 𓺍; +var 𓺎; +var 𓺏; +var 𓺐; +var 𓺑; +var 𓺒; +var 𓺓; +var 𓺔; +var 𓺕; +var 𓺖; +var 𓺗; +var 𓺘; +var 𓺙; +var 𓺚; +var 𓺛; +var 𓺜; +var 𓺝; +var 𓺞; +var 𓺟; +var 𓺠; +var 𓺡; +var 𓺢; +var 𓺣; +var 𓺤; +var 𓺥; +var 𓺦; +var 𓺧; +var 𓺨; +var 𓺩; +var 𓺪; +var 𓺫; +var 𓺬; +var 𓺭; +var 𓺮; +var 𓺯; +var 𓺰; +var 𓺱; +var 𓺲; +var 𓺳; +var 𓺴; +var 𓺵; +var 𓺶; +var 𓺷; +var 𓺸; +var 𓺹; +var 𓺺; +var 𓺻; +var 𓺼; +var 𓺽; +var 𓺾; +var 𓺿; +var 𓻀; +var 𓻁; +var 𓻂; +var 𓻃; +var 𓻄; +var 𓻅; +var 𓻆; +var 𓻇; +var 𓻈; +var 𓻉; +var 𓻊; +var 𓻋; +var 𓻌; +var 𓻍; +var 𓻎; +var 𓻏; +var 𓻐; +var 𓻑; +var 𓻒; +var 𓻓; +var 𓻔; +var 𓻕; +var 𓻖; +var 𓻗; +var 𓻘; +var 𓻙; +var 𓻚; +var 𓻛; +var 𓻜; +var 𓻝; +var 𓻞; +var 𓻟; +var 𓻠; +var 𓻡; +var 𓻢; +var 𓻣; +var 𓻤; +var 𓻥; +var 𓻦; +var 𓻧; +var 𓻨; +var 𓻩; +var 𓻪; +var 𓻫; +var 𓻬; +var 𓻭; +var 𓻮; +var 𓻯; +var 𓻰; +var 𓻱; +var 𓻲; +var 𓻳; +var 𓻴; +var 𓻵; +var 𓻶; +var 𓻷; +var 𓻸; +var 𓻹; +var 𓻺; +var 𓻻; +var 𓻼; +var 𓻽; +var 𓻾; +var 𓻿; +var 𓼀; +var 𓼁; +var 𓼂; +var 𓼃; +var 𓼄; +var 𓼅; +var 𓼆; +var 𓼇; +var 𓼈; +var 𓼉; +var 𓼊; +var 𓼋; +var 𓼌; +var 𓼍; +var 𓼎; +var 𓼏; +var 𓼐; +var 𓼑; +var 𓼒; +var 𓼓; +var 𓼔; +var 𓼕; +var 𓼖; +var 𓼗; +var 𓼘; +var 𓼙; +var 𓼚; +var 𓼛; +var 𓼜; +var 𓼝; +var 𓼞; +var 𓼟; +var 𓼠; +var 𓼡; +var 𓼢; +var 𓼣; +var 𓼤; +var 𓼥; +var 𓼦; +var 𓼧; +var 𓼨; +var 𓼩; +var 𓼪; +var 𓼫; +var 𓼬; +var 𓼭; +var 𓼮; +var 𓼯; +var 𓼰; +var 𓼱; +var 𓼲; +var 𓼳; +var 𓼴; +var 𓼵; +var 𓼶; +var 𓼷; +var 𓼸; +var 𓼹; +var 𓼺; +var 𓼻; +var 𓼼; +var 𓼽; +var 𓼾; +var 𓼿; +var 𓽀; +var 𓽁; +var 𓽂; +var 𓽃; +var 𓽄; +var 𓽅; +var 𓽆; +var 𓽇; +var 𓽈; +var 𓽉; +var 𓽊; +var 𓽋; +var 𓽌; +var 𓽍; +var 𓽎; +var 𓽏; +var 𓽐; +var 𓽑; +var 𓽒; +var 𓽓; +var 𓽔; +var 𓽕; +var 𓽖; +var 𓽗; +var 𓽘; +var 𓽙; +var 𓽚; +var 𓽛; +var 𓽜; +var 𓽝; +var 𓽞; +var 𓽟; +var 𓽠; +var 𓽡; +var 𓽢; +var 𓽣; +var 𓽤; +var 𓽥; +var 𓽦; +var 𓽧; +var 𓽨; +var 𓽩; +var 𓽪; +var 𓽫; +var 𓽬; +var 𓽭; +var 𓽮; +var 𓽯; +var 𓽰; +var 𓽱; +var 𓽲; +var 𓽳; +var 𓽴; +var 𓽵; +var 𓽶; +var 𓽷; +var 𓽸; +var 𓽹; +var 𓽺; +var 𓽻; +var 𓽼; +var 𓽽; +var 𓽾; +var 𓽿; +var 𓾀; +var 𓾁; +var 𓾂; +var 𓾃; +var 𓾄; +var 𓾅; +var 𓾆; +var 𓾇; +var 𓾈; +var 𓾉; +var 𓾊; +var 𓾋; +var 𓾌; +var 𓾍; +var 𓾎; +var 𓾏; +var 𓾐; +var 𓾑; +var 𓾒; +var 𓾓; +var 𓾔; +var 𓾕; +var 𓾖; +var 𓾗; +var 𓾘; +var 𓾙; +var 𓾚; +var 𓾛; +var 𓾜; +var 𓾝; +var 𓾞; +var 𓾟; +var 𓾠; +var 𓾡; +var 𓾢; +var 𓾣; +var 𓾤; +var 𓾥; +var 𓾦; +var 𓾧; +var 𓾨; +var 𓾩; +var 𓾪; +var 𓾫; +var 𓾬; +var 𓾭; +var 𓾮; +var 𓾯; +var 𓾰; +var 𓾱; +var 𓾲; +var 𓾳; +var 𓾴; +var 𓾵; +var 𓾶; +var 𓾷; +var 𓾸; +var 𓾹; +var 𓾺; +var 𓾻; +var 𓾼; +var 𓾽; +var 𓾾; +var 𓾿; +var 𓿀; +var 𓿁; +var 𓿂; +var 𓿃; +var 𓿄; +var 𓿅; +var 𓿆; +var 𓿇; +var 𓿈; +var 𓿉; +var 𓿊; +var 𓿋; +var 𓿌; +var 𓿍; +var 𓿎; +var 𓿏; +var 𓿐; +var 𓿑; +var 𓿒; +var 𓿓; +var 𓿔; +var 𓿕; +var 𓿖; +var 𓿗; +var 𓿘; +var 𓿙; +var 𓿚; +var 𓿛; +var 𓿜; +var 𓿝; +var 𓿞; +var 𓿟; +var 𓿠; +var 𓿡; +var 𓿢; +var 𓿣; +var 𓿤; +var 𓿥; +var 𓿦; +var 𓿧; +var 𓿨; +var 𓿩; +var 𓿪; +var 𓿫; +var 𓿬; +var 𓿭; +var 𓿮; +var 𓿯; +var 𓿰; +var 𓿱; +var 𓿲; +var 𓿳; +var 𓿴; +var 𓿵; +var 𓿶; +var 𓿷; +var 𓿸; +var 𓿹; +var 𓿺; +var 𓿻; +var 𓿼; +var 𓿽; +var 𓿾; +var 𓿿; +var 𔀀; +var 𔀁; +var 𔀂; +var 𔀃; +var 𔀄; +var 𔀅; +var 𔀆; +var 𔀇; +var 𔀈; +var 𔀉; +var 𔀊; +var 𔀋; +var 𔀌; +var 𔀍; +var 𔀎; +var 𔀏; +var 𔀐; +var 𔀑; +var 𔀒; +var 𔀓; +var 𔀔; +var 𔀕; +var 𔀖; +var 𔀗; +var 𔀘; +var 𔀙; +var 𔀚; +var 𔀛; +var 𔀜; +var 𔀝; +var 𔀞; +var 𔀟; +var 𔀠; +var 𔀡; +var 𔀢; +var 𔀣; +var 𔀤; +var 𔀥; +var 𔀦; +var 𔀧; +var 𔀨; +var 𔀩; +var 𔀪; +var 𔀫; +var 𔀬; +var 𔀭; +var 𔀮; +var 𔀯; +var 𔀰; +var 𔀱; +var 𔀲; +var 𔀳; +var 𔀴; +var 𔀵; +var 𔀶; +var 𔀷; +var 𔀸; +var 𔀹; +var 𔀺; +var 𔀻; +var 𔀼; +var 𔀽; +var 𔀾; +var 𔀿; +var 𔁀; +var 𔁁; +var 𔁂; +var 𔁃; +var 𔁄; +var 𔁅; +var 𔁆; +var 𔁇; +var 𔁈; +var 𔁉; +var 𔁊; +var 𔁋; +var 𔁌; +var 𔁍; +var 𔁎; +var 𔁏; +var 𔁐; +var 𔁑; +var 𔁒; +var 𔁓; +var 𔁔; +var 𔁕; +var 𔁖; +var 𔁗; +var 𔁘; +var 𔁙; +var 𔁚; +var 𔁛; +var 𔁜; +var 𔁝; +var 𔁞; +var 𔁟; +var 𔁠; +var 𔁡; +var 𔁢; +var 𔁣; +var 𔁤; +var 𔁥; +var 𔁦; +var 𔁧; +var 𔁨; +var 𔁩; +var 𔁪; +var 𔁫; +var 𔁬; +var 𔁭; +var 𔁮; +var 𔁯; +var 𔁰; +var 𔁱; +var 𔁲; +var 𔁳; +var 𔁴; +var 𔁵; +var 𔁶; +var 𔁷; +var 𔁸; +var 𔁹; +var 𔁺; +var 𔁻; +var 𔁼; +var 𔁽; +var 𔁾; +var 𔁿; +var 𔂀; +var 𔂁; +var 𔂂; +var 𔂃; +var 𔂄; +var 𔂅; +var 𔂆; +var 𔂇; +var 𔂈; +var 𔂉; +var 𔂊; +var 𔂋; +var 𔂌; +var 𔂍; +var 𔂎; +var 𔂏; +var 𔂐; +var 𔂑; +var 𔂒; +var 𔂓; +var 𔂔; +var 𔂕; +var 𔂖; +var 𔂗; +var 𔂘; +var 𔂙; +var 𔂚; +var 𔂛; +var 𔂜; +var 𔂝; +var 𔂞; +var 𔂟; +var 𔂠; +var 𔂡; +var 𔂢; +var 𔂣; +var 𔂤; +var 𔂥; +var 𔂦; +var 𔂧; +var 𔂨; +var 𔂩; +var 𔂪; +var 𔂫; +var 𔂬; +var 𔂭; +var 𔂮; +var 𔂯; +var 𔂰; +var 𔂱; +var 𔂲; +var 𔂳; +var 𔂴; +var 𔂵; +var 𔂶; +var 𔂷; +var 𔂸; +var 𔂹; +var 𔂺; +var 𔂻; +var 𔂼; +var 𔂽; +var 𔂾; +var 𔂿; +var 𔃀; +var 𔃁; +var 𔃂; +var 𔃃; +var 𔃄; +var 𔃅; +var 𔃆; +var 𔃇; +var 𔃈; +var 𔃉; +var 𔃊; +var 𔃋; +var 𔃌; +var 𔃍; +var 𔃎; +var 𔃏; +var 𔃐; +var 𔃑; +var 𔃒; +var 𔃓; +var 𔃔; +var 𔃕; +var 𔃖; +var 𔃗; +var 𔃘; +var 𔃙; +var 𔃚; +var 𔃛; +var 𔃜; +var 𔃝; +var 𔃞; +var 𔃟; +var 𔃠; +var 𔃡; +var 𔃢; +var 𔃣; +var 𔃤; +var 𔃥; +var 𔃦; +var 𔃧; +var 𔃨; +var 𔃩; +var 𔃪; +var 𔃫; +var 𔃬; +var 𔃭; +var 𔃮; +var 𔃯; +var 𔃰; +var 𔃱; +var 𔃲; +var 𔃳; +var 𔃴; +var 𔃵; +var 𔃶; +var 𔃷; +var 𔃸; +var 𔃹; +var 𔃺; +var 𔃻; +var 𔃼; +var 𔃽; +var 𔃾; +var 𔃿; +var 𔄀; +var 𔄁; +var 𔄂; +var 𔄃; +var 𔄄; +var 𔄅; +var 𔄆; +var 𔄇; +var 𔄈; +var 𔄉; +var 𔄊; +var 𔄋; +var 𔄌; +var 𔄍; +var 𔄎; +var 𔄏; +var 𔄐; +var 𔄑; +var 𔄒; +var 𔄓; +var 𔄔; +var 𔄕; +var 𔄖; +var 𔄗; +var 𔄘; +var 𔄙; +var 𔄚; +var 𔄛; +var 𔄜; +var 𔄝; +var 𔄞; +var 𔄟; +var 𔄠; +var 𔄡; +var 𔄢; +var 𔄣; +var 𔄤; +var 𔄥; +var 𔄦; +var 𔄧; +var 𔄨; +var 𔄩; +var 𔄪; +var 𔄫; +var 𔄬; +var 𔄭; +var 𔄮; +var 𔄯; +var 𔄰; +var 𔄱; +var 𔄲; +var 𔄳; +var 𔄴; +var 𔄵; +var 𔄶; +var 𔄷; +var 𔄸; +var 𔄹; +var 𔄺; +var 𔄻; +var 𔄼; +var 𔄽; +var 𔄾; +var 𔄿; +var 𔅀; +var 𔅁; +var 𔅂; +var 𔅃; +var 𔅄; +var 𔅅; +var 𔅆; +var 𔅇; +var 𔅈; +var 𔅉; +var 𔅊; +var 𔅋; +var 𔅌; +var 𔅍; +var 𔅎; +var 𔅏; +var 𔅐; +var 𔅑; +var 𔅒; +var 𔅓; +var 𔅔; +var 𔅕; +var 𔅖; +var 𔅗; +var 𔅘; +var 𔅙; +var 𔅚; +var 𔅛; +var 𔅜; +var 𔅝; +var 𔅞; +var 𔅟; +var 𔅠; +var 𔅡; +var 𔅢; +var 𔅣; +var 𔅤; +var 𔅥; +var 𔅦; +var 𔅧; +var 𔅨; +var 𔅩; +var 𔅪; +var 𔅫; +var 𔅬; +var 𔅭; +var 𔅮; +var 𔅯; +var 𔅰; +var 𔅱; +var 𔅲; +var 𔅳; +var 𔅴; +var 𔅵; +var 𔅶; +var 𔅷; +var 𔅸; +var 𔅹; +var 𔅺; +var 𔅻; +var 𔅼; +var 𔅽; +var 𔅾; +var 𔅿; +var 𔆀; +var 𔆁; +var 𔆂; +var 𔆃; +var 𔆄; +var 𔆅; +var 𔆆; +var 𔆇; +var 𔆈; +var 𔆉; +var 𔆊; +var 𔆋; +var 𔆌; +var 𔆍; +var 𔆎; +var 𔆏; +var 𔆐; +var 𔆑; +var 𔆒; +var 𔆓; +var 𔆔; +var 𔆕; +var 𔆖; +var 𔆗; +var 𔆘; +var 𔆙; +var 𔆚; +var 𔆛; +var 𔆜; +var 𔆝; +var 𔆞; +var 𔆟; +var 𔆠; +var 𔆡; +var 𔆢; +var 𔆣; +var 𔆤; +var 𔆥; +var 𔆦; +var 𔆧; +var 𔆨; +var 𔆩; +var 𔆪; +var 𔆫; +var 𔆬; +var 𔆭; +var 𔆮; +var 𔆯; +var 𔆰; +var 𔆱; +var 𔆲; +var 𔆳; +var 𔆴; +var 𔆵; +var 𔆶; +var 𔆷; +var 𔆸; +var 𔆹; +var 𔆺; +var 𔆻; +var 𔆼; +var 𔆽; +var 𔆾; +var 𔆿; +var 𔇀; +var 𔇁; +var 𔇂; +var 𔇃; +var 𔇄; +var 𔇅; +var 𔇆; +var 𔇇; +var 𔇈; +var 𔇉; +var 𔇊; +var 𔇋; +var 𔇌; +var 𔇍; +var 𔇎; +var 𔇏; +var 𔇐; +var 𔇑; +var 𔇒; +var 𔇓; +var 𔇔; +var 𔇕; +var 𔇖; +var 𔇗; +var 𔇘; +var 𔇙; +var 𔇚; +var 𔇛; +var 𔇜; +var 𔇝; +var 𔇞; +var 𔇟; +var 𔇠; +var 𔇡; +var 𔇢; +var 𔇣; +var 𔇤; +var 𔇥; +var 𔇦; +var 𔇧; +var 𔇨; +var 𔇩; +var 𔇪; +var 𔇫; +var 𔇬; +var 𔇭; +var 𔇮; +var 𔇯; +var 𔇰; +var 𔇱; +var 𔇲; +var 𔇳; +var 𔇴; +var 𔇵; +var 𔇶; +var 𔇷; +var 𔇸; +var 𔇹; +var 𔇺; +var 𔇻; +var 𔇼; +var 𔇽; +var 𔇾; +var 𔇿; +var 𔈀; +var 𔈁; +var 𔈂; +var 𔈃; +var 𔈄; +var 𔈅; +var 𔈆; +var 𔈇; +var 𔈈; +var 𔈉; +var 𔈊; +var 𔈋; +var 𔈌; +var 𔈍; +var 𔈎; +var 𔈏; +var 𔈐; +var 𔈑; +var 𔈒; +var 𔈓; +var 𔈔; +var 𔈕; +var 𔈖; +var 𔈗; +var 𔈘; +var 𔈙; +var 𔈚; +var 𔈛; +var 𔈜; +var 𔈝; +var 𔈞; +var 𔈟; +var 𔈠; +var 𔈡; +var 𔈢; +var 𔈣; +var 𔈤; +var 𔈥; +var 𔈦; +var 𔈧; +var 𔈨; +var 𔈩; +var 𔈪; +var 𔈫; +var 𔈬; +var 𔈭; +var 𔈮; +var 𔈯; +var 𔈰; +var 𔈱; +var 𔈲; +var 𔈳; +var 𔈴; +var 𔈵; +var 𔈶; +var 𔈷; +var 𔈸; +var 𔈹; +var 𔈺; +var 𔈻; +var 𔈼; +var 𔈽; +var 𔈾; +var 𔈿; +var 𔉀; +var 𔉁; +var 𔉂; +var 𔉃; +var 𔉄; +var 𔉅; +var 𔉆; +var 𔉇; +var 𔉈; +var 𔉉; +var 𔉊; +var 𔉋; +var 𔉌; +var 𔉍; +var 𔉎; +var 𔉏; +var 𔉐; +var 𔉑; +var 𔉒; +var 𔉓; +var 𔉔; +var 𔉕; +var 𔉖; +var 𔉗; +var 𔉘; +var 𔉙; +var 𔉚; +var 𔉛; +var 𔉜; +var 𔉝; +var 𔉞; +var 𔉟; +var 𔉠; +var 𔉡; +var 𔉢; +var 𔉣; +var 𔉤; +var 𔉥; +var 𔉦; +var 𔉧; +var 𔉨; +var 𔉩; +var 𔉪; +var 𔉫; +var 𔉬; +var 𔉭; +var 𔉮; +var 𔉯; +var 𔉰; +var 𔉱; +var 𔉲; +var 𔉳; +var 𔉴; +var 𔉵; +var 𔉶; +var 𔉷; +var 𔉸; +var 𔉹; +var 𔉺; +var 𔉻; +var 𔉼; +var 𔉽; +var 𔉾; +var 𔉿; +var 𔊀; +var 𔊁; +var 𔊂; +var 𔊃; +var 𔊄; +var 𔊅; +var 𔊆; +var 𔊇; +var 𔊈; +var 𔊉; +var 𔊊; +var 𔊋; +var 𔊌; +var 𔊍; +var 𔊎; +var 𔊏; +var 𔊐; +var 𔊑; +var 𔊒; +var 𔊓; +var 𔊔; +var 𔊕; +var 𔊖; +var 𔊗; +var 𔊘; +var 𔊙; +var 𔊚; +var 𔊛; +var 𔊜; +var 𔊝; +var 𔊞; +var 𔊟; +var 𔊠; +var 𔊡; +var 𔊢; +var 𔊣; +var 𔊤; +var 𔊥; +var 𔊦; +var 𔊧; +var 𔊨; +var 𔊩; +var 𔊪; +var 𔊫; +var 𔊬; +var 𔊭; +var 𔊮; +var 𔊯; +var 𔊰; +var 𔊱; +var 𔊲; +var 𔊳; +var 𔊴; +var 𔊵; +var 𔊶; +var 𔊷; +var 𔊸; +var 𔊹; +var 𔊺; +var 𔊻; +var 𔊼; +var 𔊽; +var 𔊾; +var 𔊿; +var 𔋀; +var 𔋁; +var 𔋂; +var 𔋃; +var 𔋄; +var 𔋅; +var 𔋆; +var 𔋇; +var 𔋈; +var 𔋉; +var 𔋊; +var 𔋋; +var 𔋌; +var 𔋍; +var 𔋎; +var 𔋏; +var 𔋐; +var 𔋑; +var 𔋒; +var 𔋓; +var 𔋔; +var 𔋕; +var 𔋖; +var 𔋗; +var 𔋘; +var 𔋙; +var 𔋚; +var 𔋛; +var 𔋜; +var 𔋝; +var 𔋞; +var 𔋟; +var 𔋠; +var 𔋡; +var 𔋢; +var 𔋣; +var 𔋤; +var 𔋥; +var 𔋦; +var 𔋧; +var 𔋨; +var 𔋩; +var 𔋪; +var 𔋫; +var 𔋬; +var 𔋭; +var 𔋮; +var 𔋯; +var 𔋰; +var 𔋱; +var 𔋲; +var 𔋳; +var 𔋴; +var 𔋵; +var 𔋶; +var 𔋷; +var 𔋸; +var 𔋹; +var 𔋺; +var 𔋻; +var 𔋼; +var 𔋽; +var 𔋾; +var 𔋿; +var 𔌀; +var 𔌁; +var 𔌂; +var 𔌃; +var 𔌄; +var 𔌅; +var 𔌆; +var 𔌇; +var 𔌈; +var 𔌉; +var 𔌊; +var 𔌋; +var 𔌌; +var 𔌍; +var 𔌎; +var 𔌏; +var 𔌐; +var 𔌑; +var 𔌒; +var 𔌓; +var 𔌔; +var 𔌕; +var 𔌖; +var 𔌗; +var 𔌘; +var 𔌙; +var 𔌚; +var 𔌛; +var 𔌜; +var 𔌝; +var 𔌞; +var 𔌟; +var 𔌠; +var 𔌡; +var 𔌢; +var 𔌣; +var 𔌤; +var 𔌥; +var 𔌦; +var 𔌧; +var 𔌨; +var 𔌩; +var 𔌪; +var 𔌫; +var 𔌬; +var 𔌭; +var 𔌮; +var 𔌯; +var 𔌰; +var 𔌱; +var 𔌲; +var 𔌳; +var 𔌴; +var 𔌵; +var 𔌶; +var 𔌷; +var 𔌸; +var 𔌹; +var 𔌺; +var 𔌻; +var 𔌼; +var 𔌽; +var 𔌾; +var 𔌿; +var 𔍀; +var 𔍁; +var 𔍂; +var 𔍃; +var 𔍄; +var 𔍅; +var 𔍆; +var 𔍇; +var 𔍈; +var 𔍉; +var 𔍊; +var 𔍋; +var 𔍌; +var 𔍍; +var 𔍎; +var 𔍏; +var 𔍐; +var 𔍑; +var 𔍒; +var 𔍓; +var 𔍔; +var 𔍕; +var 𔍖; +var 𔍗; +var 𔍘; +var 𔍙; +var 𔍚; +var 𔍛; +var 𔍜; +var 𔍝; +var 𔍞; +var 𔍟; +var 𔍠; +var 𔍡; +var 𔍢; +var 𔍣; +var 𔍤; +var 𔍥; +var 𔍦; +var 𔍧; +var 𔍨; +var 𔍩; +var 𔍪; +var 𔍫; +var 𔍬; +var 𔍭; +var 𔍮; +var 𔍯; +var 𔍰; +var 𔍱; +var 𔍲; +var 𔍳; +var 𔍴; +var 𔍵; +var 𔍶; +var 𔍷; +var 𔍸; +var 𔍹; +var 𔍺; +var 𔍻; +var 𔍼; +var 𔍽; +var 𔍾; +var 𔍿; +var 𔎀; +var 𔎁; +var 𔎂; +var 𔎃; +var 𔎄; +var 𔎅; +var 𔎆; +var 𔎇; +var 𔎈; +var 𔎉; +var 𔎊; +var 𔎋; +var 𔎌; +var 𔎍; +var 𔎎; +var 𔎏; +var 𔎐; +var 𔎑; +var 𔎒; +var 𔎓; +var 𔎔; +var 𔎕; +var 𔎖; +var 𔎗; +var 𔎘; +var 𔎙; +var 𔎚; +var 𔎛; +var 𔎜; +var 𔎝; +var 𔎞; +var 𔎟; +var 𔎠; +var 𔎡; +var 𔎢; +var 𔎣; +var 𔎤; +var 𔎥; +var 𔎦; +var 𔎧; +var 𔎨; +var 𔎩; +var 𔎪; +var 𔎫; +var 𔎬; +var 𔎭; +var 𔎮; +var 𔎯; +var 𔎰; +var 𔎱; +var 𔎲; +var 𔎳; +var 𔎴; +var 𔎵; +var 𔎶; +var 𔎷; +var 𔎸; +var 𔎹; +var 𔎺; +var 𔎻; +var 𔎼; +var 𔎽; +var 𔎾; +var 𔎿; +var 𔏀; +var 𔏁; +var 𔏂; +var 𔏃; +var 𔏄; +var 𔏅; +var 𔏆; +var 𔏇; +var 𔏈; +var 𔏉; +var 𔏊; +var 𔏋; +var 𔏌; +var 𔏍; +var 𔏎; +var 𔏏; +var 𔏐; +var 𔏑; +var 𔏒; +var 𔏓; +var 𔏔; +var 𔏕; +var 𔏖; +var 𔏗; +var 𔏘; +var 𔏙; +var 𔏚; +var 𔏛; +var 𔏜; +var 𔏝; +var 𔏞; +var 𔏟; +var 𔏠; +var 𔏡; +var 𔏢; +var 𔏣; +var 𔏤; +var 𔏥; +var 𔏦; +var 𔏧; +var 𔏨; +var 𔏩; +var 𔏪; +var 𔏫; +var 𔏬; +var 𔏭; +var 𔏮; +var 𔏯; +var 𔏰; +var 𔏱; +var 𔏲; +var 𔏳; +var 𔏴; +var 𔏵; +var 𔏶; +var 𔏷; +var 𔏸; +var 𔏹; +var 𔏺; +var 𖄀; +var 𖄁; +var 𖄂; +var 𖄃; +var 𖄄; +var 𖄅; +var 𖄆; +var 𖄇; +var 𖄈; +var 𖄉; +var 𖄊; +var 𖄋; +var 𖄌; +var 𖄍; +var 𖄎; +var 𖄏; +var 𖄐; +var 𖄑; +var 𖄒; +var 𖄓; +var 𖄔; +var 𖄕; +var 𖄖; +var 𖄗; +var 𖄘; +var 𖄙; +var 𖄚; +var 𖄛; +var 𖄜; +var 𖄝; +var 𖵀; +var 𖵁; +var 𖵂; +var 𖵃; +var 𖵄; +var 𖵅; +var 𖵆; +var 𖵇; +var 𖵈; +var 𖵉; +var 𖵊; +var 𖵋; +var 𖵌; +var 𖵍; +var 𖵎; +var 𖵏; +var 𖵐; +var 𖵑; +var 𖵒; +var 𖵓; +var 𖵔; +var 𖵕; +var 𖵖; +var 𖵗; +var 𖵘; +var 𖵙; +var 𖵚; +var 𖵛; +var 𖵜; +var 𖵝; +var 𖵞; +var 𖵟; +var 𖵠; +var 𖵡; +var 𖵢; +var 𖵣; +var 𖵤; +var 𖵥; +var 𖵦; +var 𖵧; +var 𖵨; +var 𖵩; +var 𖵪; +var 𖵫; +var 𖵬; +var 𘳿; +var 𞗐; +var 𞗑; +var 𞗒; +var 𞗓; +var 𞗔; +var 𞗕; +var 𞗖; +var 𞗗; +var 𞗘; +var 𞗙; +var 𞗚; +var 𞗛; +var 𞗜; +var 𞗝; +var 𞗞; +var 𞗟; +var 𞗠; +var 𞗡; +var 𞗢; +var 𞗣; +var 𞗤; +var 𞗥; +var 𞗦; +var 𞗧; +var 𞗨; +var 𞗩; +var 𞗪; +var 𞗫; +var 𞗬; +var 𞗭; +var 𞗰; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0-class-escaped.js new file mode 100644 index 000000000..9389dcc81 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0-class-escaped.js @@ -0,0 +1,4666 @@ +// Copyright 2025 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v17.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u088F; + #\u0C5C; + #\u0CDC; + #\uA7CE; + #\uA7CF; + #\uA7D2; + #\uA7D4; + #\uA7F1; + #\u{10940}; + #\u{10941}; + #\u{10942}; + #\u{10943}; + #\u{10944}; + #\u{10945}; + #\u{10946}; + #\u{10947}; + #\u{10948}; + #\u{10949}; + #\u{1094A}; + #\u{1094B}; + #\u{1094C}; + #\u{1094D}; + #\u{1094E}; + #\u{1094F}; + #\u{10950}; + #\u{10951}; + #\u{10952}; + #\u{10953}; + #\u{10954}; + #\u{10955}; + #\u{10956}; + #\u{10957}; + #\u{10958}; + #\u{10959}; + #\u{10EC5}; + #\u{10EC6}; + #\u{10EC7}; + #\u{11DB0}; + #\u{11DB1}; + #\u{11DB2}; + #\u{11DB3}; + #\u{11DB4}; + #\u{11DB5}; + #\u{11DB6}; + #\u{11DB7}; + #\u{11DB8}; + #\u{11DB9}; + #\u{11DBA}; + #\u{11DBB}; + #\u{11DBC}; + #\u{11DBD}; + #\u{11DBE}; + #\u{11DBF}; + #\u{11DC0}; + #\u{11DC1}; + #\u{11DC2}; + #\u{11DC3}; + #\u{11DC4}; + #\u{11DC5}; + #\u{11DC6}; + #\u{11DC7}; + #\u{11DC8}; + #\u{11DC9}; + #\u{11DCA}; + #\u{11DCB}; + #\u{11DCC}; + #\u{11DCD}; + #\u{11DCE}; + #\u{11DCF}; + #\u{11DD0}; + #\u{11DD1}; + #\u{11DD2}; + #\u{11DD3}; + #\u{11DD4}; + #\u{11DD5}; + #\u{11DD6}; + #\u{11DD7}; + #\u{11DD8}; + #\u{11DD9}; + #\u{11DDA}; + #\u{11DDB}; + #\u{16EA0}; + #\u{16EA1}; + #\u{16EA2}; + #\u{16EA3}; + #\u{16EA4}; + #\u{16EA5}; + #\u{16EA6}; + #\u{16EA7}; + #\u{16EA8}; + #\u{16EA9}; + #\u{16EAA}; + #\u{16EAB}; + #\u{16EAC}; + #\u{16EAD}; + #\u{16EAE}; + #\u{16EAF}; + #\u{16EB0}; + #\u{16EB1}; + #\u{16EB2}; + #\u{16EB3}; + #\u{16EB4}; + #\u{16EB5}; + #\u{16EB6}; + #\u{16EB7}; + #\u{16EB8}; + #\u{16EBB}; + #\u{16EBC}; + #\u{16EBD}; + #\u{16EBE}; + #\u{16EBF}; + #\u{16EC0}; + #\u{16EC1}; + #\u{16EC2}; + #\u{16EC3}; + #\u{16EC4}; + #\u{16EC5}; + #\u{16EC6}; + #\u{16EC7}; + #\u{16EC8}; + #\u{16EC9}; + #\u{16ECA}; + #\u{16ECB}; + #\u{16ECC}; + #\u{16ECD}; + #\u{16ECE}; + #\u{16ECF}; + #\u{16ED0}; + #\u{16ED1}; + #\u{16ED2}; + #\u{16ED3}; + #\u{16FF2}; + #\u{16FF3}; + #\u{16FF4}; + #\u{16FF5}; + #\u{16FF6}; + #\u{187F8}; + #\u{187F9}; + #\u{187FA}; + #\u{187FB}; + #\u{187FC}; + #\u{187FD}; + #\u{187FE}; + #\u{187FF}; + #\u{18D09}; + #\u{18D0A}; + #\u{18D0B}; + #\u{18D0C}; + #\u{18D0D}; + #\u{18D0E}; + #\u{18D0F}; + #\u{18D10}; + #\u{18D11}; + #\u{18D12}; + #\u{18D13}; + #\u{18D14}; + #\u{18D15}; + #\u{18D16}; + #\u{18D17}; + #\u{18D18}; + #\u{18D19}; + #\u{18D1A}; + #\u{18D1B}; + #\u{18D1C}; + #\u{18D1D}; + #\u{18D1E}; + #\u{18D80}; + #\u{18D81}; + #\u{18D82}; + #\u{18D83}; + #\u{18D84}; + #\u{18D85}; + #\u{18D86}; + #\u{18D87}; + #\u{18D88}; + #\u{18D89}; + #\u{18D8A}; + #\u{18D8B}; + #\u{18D8C}; + #\u{18D8D}; + #\u{18D8E}; + #\u{18D8F}; + #\u{18D90}; + #\u{18D91}; + #\u{18D92}; + #\u{18D93}; + #\u{18D94}; + #\u{18D95}; + #\u{18D96}; + #\u{18D97}; + #\u{18D98}; + #\u{18D99}; + #\u{18D9A}; + #\u{18D9B}; + #\u{18D9C}; + #\u{18D9D}; + #\u{18D9E}; + #\u{18D9F}; + #\u{18DA0}; + #\u{18DA1}; + #\u{18DA2}; + #\u{18DA3}; + #\u{18DA4}; + #\u{18DA5}; + #\u{18DA6}; + #\u{18DA7}; + #\u{18DA8}; + #\u{18DA9}; + #\u{18DAA}; + #\u{18DAB}; + #\u{18DAC}; + #\u{18DAD}; + #\u{18DAE}; + #\u{18DAF}; + #\u{18DB0}; + #\u{18DB1}; + #\u{18DB2}; + #\u{18DB3}; + #\u{18DB4}; + #\u{18DB5}; + #\u{18DB6}; + #\u{18DB7}; + #\u{18DB8}; + #\u{18DB9}; + #\u{18DBA}; + #\u{18DBB}; + #\u{18DBC}; + #\u{18DBD}; + #\u{18DBE}; + #\u{18DBF}; + #\u{18DC0}; + #\u{18DC1}; + #\u{18DC2}; + #\u{18DC3}; + #\u{18DC4}; + #\u{18DC5}; + #\u{18DC6}; + #\u{18DC7}; + #\u{18DC8}; + #\u{18DC9}; + #\u{18DCA}; + #\u{18DCB}; + #\u{18DCC}; + #\u{18DCD}; + #\u{18DCE}; + #\u{18DCF}; + #\u{18DD0}; + #\u{18DD1}; + #\u{18DD2}; + #\u{18DD3}; + #\u{18DD4}; + #\u{18DD5}; + #\u{18DD6}; + #\u{18DD7}; + #\u{18DD8}; + #\u{18DD9}; + #\u{18DDA}; + #\u{18DDB}; + #\u{18DDC}; + #\u{18DDD}; + #\u{18DDE}; + #\u{18DDF}; + #\u{18DE0}; + #\u{18DE1}; + #\u{18DE2}; + #\u{18DE3}; + #\u{18DE4}; + #\u{18DE5}; + #\u{18DE6}; + #\u{18DE7}; + #\u{18DE8}; + #\u{18DE9}; + #\u{18DEA}; + #\u{18DEB}; + #\u{18DEC}; + #\u{18DED}; + #\u{18DEE}; + #\u{18DEF}; + #\u{18DF0}; + #\u{18DF1}; + #\u{18DF2}; + #\u{1E6C0}; + #\u{1E6C1}; + #\u{1E6C2}; + #\u{1E6C3}; + #\u{1E6C4}; + #\u{1E6C5}; + #\u{1E6C6}; + #\u{1E6C7}; + #\u{1E6C8}; + #\u{1E6C9}; + #\u{1E6CA}; + #\u{1E6CB}; + #\u{1E6CC}; + #\u{1E6CD}; + #\u{1E6CE}; + #\u{1E6CF}; + #\u{1E6D0}; + #\u{1E6D1}; + #\u{1E6D2}; + #\u{1E6D3}; + #\u{1E6D4}; + #\u{1E6D5}; + #\u{1E6D6}; + #\u{1E6D7}; + #\u{1E6D8}; + #\u{1E6D9}; + #\u{1E6DA}; + #\u{1E6DB}; + #\u{1E6DC}; + #\u{1E6DD}; + #\u{1E6DE}; + #\u{1E6E0}; + #\u{1E6E1}; + #\u{1E6E2}; + #\u{1E6E4}; + #\u{1E6E5}; + #\u{1E6E7}; + #\u{1E6E8}; + #\u{1E6E9}; + #\u{1E6EA}; + #\u{1E6EB}; + #\u{1E6EC}; + #\u{1E6ED}; + #\u{1E6F0}; + #\u{1E6F1}; + #\u{1E6F2}; + #\u{1E6F3}; + #\u{1E6F4}; + #\u{1E6FE}; + #\u{1E6FF}; + #\u{2B73A}; + #\u{2B73B}; + #\u{2B73C}; + #\u{2B73D}; + #\u{2B73E}; + #\u{2B73F}; + #\u{2CEA2}; + #\u{2CEA3}; + #\u{2CEA4}; + #\u{2CEA5}; + #\u{2CEA6}; + #\u{2CEA7}; + #\u{2CEA8}; + #\u{2CEA9}; + #\u{2CEAA}; + #\u{2CEAB}; + #\u{2CEAC}; + #\u{2CEAD}; + #\u{323B0}; + #\u{323B1}; + #\u{323B2}; + #\u{323B3}; + #\u{323B4}; + #\u{323B5}; + #\u{323B6}; + #\u{323B7}; + #\u{323B8}; + #\u{323B9}; + #\u{323BA}; + #\u{323BB}; + #\u{323BC}; + #\u{323BD}; + #\u{323BE}; + #\u{323BF}; + #\u{323C0}; + #\u{323C1}; + #\u{323C2}; + #\u{323C3}; + #\u{323C4}; + #\u{323C5}; + #\u{323C6}; + #\u{323C7}; + #\u{323C8}; + #\u{323C9}; + #\u{323CA}; + #\u{323CB}; + #\u{323CC}; + #\u{323CD}; + #\u{323CE}; + #\u{323CF}; + #\u{323D0}; + #\u{323D1}; + #\u{323D2}; + #\u{323D3}; + #\u{323D4}; + #\u{323D5}; + #\u{323D6}; + #\u{323D7}; + #\u{323D8}; + #\u{323D9}; + #\u{323DA}; + #\u{323DB}; + #\u{323DC}; + #\u{323DD}; + #\u{323DE}; + #\u{323DF}; + #\u{323E0}; + #\u{323E1}; + #\u{323E2}; + #\u{323E3}; + #\u{323E4}; + #\u{323E5}; + #\u{323E6}; + #\u{323E7}; + #\u{323E8}; + #\u{323E9}; + #\u{323EA}; + #\u{323EB}; + #\u{323EC}; + #\u{323ED}; + #\u{323EE}; + #\u{323EF}; + #\u{323F0}; + #\u{323F1}; + #\u{323F2}; + #\u{323F3}; + #\u{323F4}; + #\u{323F5}; + #\u{323F6}; + #\u{323F7}; + #\u{323F8}; + #\u{323F9}; + #\u{323FA}; + #\u{323FB}; + #\u{323FC}; + #\u{323FD}; + #\u{323FE}; + #\u{323FF}; + #\u{32400}; + #\u{32401}; + #\u{32402}; + #\u{32403}; + #\u{32404}; + #\u{32405}; + #\u{32406}; + #\u{32407}; + #\u{32408}; + #\u{32409}; + #\u{3240A}; + #\u{3240B}; + #\u{3240C}; + #\u{3240D}; + #\u{3240E}; + #\u{3240F}; + #\u{32410}; + #\u{32411}; + #\u{32412}; + #\u{32413}; + #\u{32414}; + #\u{32415}; + #\u{32416}; + #\u{32417}; + #\u{32418}; + #\u{32419}; + #\u{3241A}; + #\u{3241B}; + #\u{3241C}; + #\u{3241D}; + #\u{3241E}; + #\u{3241F}; + #\u{32420}; + #\u{32421}; + #\u{32422}; + #\u{32423}; + #\u{32424}; + #\u{32425}; + #\u{32426}; + #\u{32427}; + #\u{32428}; + #\u{32429}; + #\u{3242A}; + #\u{3242B}; + #\u{3242C}; + #\u{3242D}; + #\u{3242E}; + #\u{3242F}; + #\u{32430}; + #\u{32431}; + #\u{32432}; + #\u{32433}; + #\u{32434}; + #\u{32435}; + #\u{32436}; + #\u{32437}; + #\u{32438}; + #\u{32439}; + #\u{3243A}; + #\u{3243B}; + #\u{3243C}; + #\u{3243D}; + #\u{3243E}; + #\u{3243F}; + #\u{32440}; + #\u{32441}; + #\u{32442}; + #\u{32443}; + #\u{32444}; + #\u{32445}; + #\u{32446}; + #\u{32447}; + #\u{32448}; + #\u{32449}; + #\u{3244A}; + #\u{3244B}; + #\u{3244C}; + #\u{3244D}; + #\u{3244E}; + #\u{3244F}; + #\u{32450}; + #\u{32451}; + #\u{32452}; + #\u{32453}; + #\u{32454}; + #\u{32455}; + #\u{32456}; + #\u{32457}; + #\u{32458}; + #\u{32459}; + #\u{3245A}; + #\u{3245B}; + #\u{3245C}; + #\u{3245D}; + #\u{3245E}; + #\u{3245F}; + #\u{32460}; + #\u{32461}; + #\u{32462}; + #\u{32463}; + #\u{32464}; + #\u{32465}; + #\u{32466}; + #\u{32467}; + #\u{32468}; + #\u{32469}; + #\u{3246A}; + #\u{3246B}; + #\u{3246C}; + #\u{3246D}; + #\u{3246E}; + #\u{3246F}; + #\u{32470}; + #\u{32471}; + #\u{32472}; + #\u{32473}; + #\u{32474}; + #\u{32475}; + #\u{32476}; + #\u{32477}; + #\u{32478}; + #\u{32479}; + #\u{3247A}; + #\u{3247B}; + #\u{3247C}; + #\u{3247D}; + #\u{3247E}; + #\u{3247F}; + #\u{32480}; + #\u{32481}; + #\u{32482}; + #\u{32483}; + #\u{32484}; + #\u{32485}; + #\u{32486}; + #\u{32487}; + #\u{32488}; + #\u{32489}; + #\u{3248A}; + #\u{3248B}; + #\u{3248C}; + #\u{3248D}; + #\u{3248E}; + #\u{3248F}; + #\u{32490}; + #\u{32491}; + #\u{32492}; + #\u{32493}; + #\u{32494}; + #\u{32495}; + #\u{32496}; + #\u{32497}; + #\u{32498}; + #\u{32499}; + #\u{3249A}; + #\u{3249B}; + #\u{3249C}; + #\u{3249D}; + #\u{3249E}; + #\u{3249F}; + #\u{324A0}; + #\u{324A1}; + #\u{324A2}; + #\u{324A3}; + #\u{324A4}; + #\u{324A5}; + #\u{324A6}; + #\u{324A7}; + #\u{324A8}; + #\u{324A9}; + #\u{324AA}; + #\u{324AB}; + #\u{324AC}; + #\u{324AD}; + #\u{324AE}; + #\u{324AF}; + #\u{324B0}; + #\u{324B1}; + #\u{324B2}; + #\u{324B3}; + #\u{324B4}; + #\u{324B5}; + #\u{324B6}; + #\u{324B7}; + #\u{324B8}; + #\u{324B9}; + #\u{324BA}; + #\u{324BB}; + #\u{324BC}; + #\u{324BD}; + #\u{324BE}; + #\u{324BF}; + #\u{324C0}; + #\u{324C1}; + #\u{324C2}; + #\u{324C3}; + #\u{324C4}; + #\u{324C5}; + #\u{324C6}; + #\u{324C7}; + #\u{324C8}; + #\u{324C9}; + #\u{324CA}; + #\u{324CB}; + #\u{324CC}; + #\u{324CD}; + #\u{324CE}; + #\u{324CF}; + #\u{324D0}; + #\u{324D1}; + #\u{324D2}; + #\u{324D3}; + #\u{324D4}; + #\u{324D5}; + #\u{324D6}; + #\u{324D7}; + #\u{324D8}; + #\u{324D9}; + #\u{324DA}; + #\u{324DB}; + #\u{324DC}; + #\u{324DD}; + #\u{324DE}; + #\u{324DF}; + #\u{324E0}; + #\u{324E1}; + #\u{324E2}; + #\u{324E3}; + #\u{324E4}; + #\u{324E5}; + #\u{324E6}; + #\u{324E7}; + #\u{324E8}; + #\u{324E9}; + #\u{324EA}; + #\u{324EB}; + #\u{324EC}; + #\u{324ED}; + #\u{324EE}; + #\u{324EF}; + #\u{324F0}; + #\u{324F1}; + #\u{324F2}; + #\u{324F3}; + #\u{324F4}; + #\u{324F5}; + #\u{324F6}; + #\u{324F7}; + #\u{324F8}; + #\u{324F9}; + #\u{324FA}; + #\u{324FB}; + #\u{324FC}; + #\u{324FD}; + #\u{324FE}; + #\u{324FF}; + #\u{32500}; + #\u{32501}; + #\u{32502}; + #\u{32503}; + #\u{32504}; + #\u{32505}; + #\u{32506}; + #\u{32507}; + #\u{32508}; + #\u{32509}; + #\u{3250A}; + #\u{3250B}; + #\u{3250C}; + #\u{3250D}; + #\u{3250E}; + #\u{3250F}; + #\u{32510}; + #\u{32511}; + #\u{32512}; + #\u{32513}; + #\u{32514}; + #\u{32515}; + #\u{32516}; + #\u{32517}; + #\u{32518}; + #\u{32519}; + #\u{3251A}; + #\u{3251B}; + #\u{3251C}; + #\u{3251D}; + #\u{3251E}; + #\u{3251F}; + #\u{32520}; + #\u{32521}; + #\u{32522}; + #\u{32523}; + #\u{32524}; + #\u{32525}; + #\u{32526}; + #\u{32527}; + #\u{32528}; + #\u{32529}; + #\u{3252A}; + #\u{3252B}; + #\u{3252C}; + #\u{3252D}; + #\u{3252E}; + #\u{3252F}; + #\u{32530}; + #\u{32531}; + #\u{32532}; + #\u{32533}; + #\u{32534}; + #\u{32535}; + #\u{32536}; + #\u{32537}; + #\u{32538}; + #\u{32539}; + #\u{3253A}; + #\u{3253B}; + #\u{3253C}; + #\u{3253D}; + #\u{3253E}; + #\u{3253F}; + #\u{32540}; + #\u{32541}; + #\u{32542}; + #\u{32543}; + #\u{32544}; + #\u{32545}; + #\u{32546}; + #\u{32547}; + #\u{32548}; + #\u{32549}; + #\u{3254A}; + #\u{3254B}; + #\u{3254C}; + #\u{3254D}; + #\u{3254E}; + #\u{3254F}; + #\u{32550}; + #\u{32551}; + #\u{32552}; + #\u{32553}; + #\u{32554}; + #\u{32555}; + #\u{32556}; + #\u{32557}; + #\u{32558}; + #\u{32559}; + #\u{3255A}; + #\u{3255B}; + #\u{3255C}; + #\u{3255D}; + #\u{3255E}; + #\u{3255F}; + #\u{32560}; + #\u{32561}; + #\u{32562}; + #\u{32563}; + #\u{32564}; + #\u{32565}; + #\u{32566}; + #\u{32567}; + #\u{32568}; + #\u{32569}; + #\u{3256A}; + #\u{3256B}; + #\u{3256C}; + #\u{3256D}; + #\u{3256E}; + #\u{3256F}; + #\u{32570}; + #\u{32571}; + #\u{32572}; + #\u{32573}; + #\u{32574}; + #\u{32575}; + #\u{32576}; + #\u{32577}; + #\u{32578}; + #\u{32579}; + #\u{3257A}; + #\u{3257B}; + #\u{3257C}; + #\u{3257D}; + #\u{3257E}; + #\u{3257F}; + #\u{32580}; + #\u{32581}; + #\u{32582}; + #\u{32583}; + #\u{32584}; + #\u{32585}; + #\u{32586}; + #\u{32587}; + #\u{32588}; + #\u{32589}; + #\u{3258A}; + #\u{3258B}; + #\u{3258C}; + #\u{3258D}; + #\u{3258E}; + #\u{3258F}; + #\u{32590}; + #\u{32591}; + #\u{32592}; + #\u{32593}; + #\u{32594}; + #\u{32595}; + #\u{32596}; + #\u{32597}; + #\u{32598}; + #\u{32599}; + #\u{3259A}; + #\u{3259B}; + #\u{3259C}; + #\u{3259D}; + #\u{3259E}; + #\u{3259F}; + #\u{325A0}; + #\u{325A1}; + #\u{325A2}; + #\u{325A3}; + #\u{325A4}; + #\u{325A5}; + #\u{325A6}; + #\u{325A7}; + #\u{325A8}; + #\u{325A9}; + #\u{325AA}; + #\u{325AB}; + #\u{325AC}; + #\u{325AD}; + #\u{325AE}; + #\u{325AF}; + #\u{325B0}; + #\u{325B1}; + #\u{325B2}; + #\u{325B3}; + #\u{325B4}; + #\u{325B5}; + #\u{325B6}; + #\u{325B7}; + #\u{325B8}; + #\u{325B9}; + #\u{325BA}; + #\u{325BB}; + #\u{325BC}; + #\u{325BD}; + #\u{325BE}; + #\u{325BF}; + #\u{325C0}; + #\u{325C1}; + #\u{325C2}; + #\u{325C3}; + #\u{325C4}; + #\u{325C5}; + #\u{325C6}; + #\u{325C7}; + #\u{325C8}; + #\u{325C9}; + #\u{325CA}; + #\u{325CB}; + #\u{325CC}; + #\u{325CD}; + #\u{325CE}; + #\u{325CF}; + #\u{325D0}; + #\u{325D1}; + #\u{325D2}; + #\u{325D3}; + #\u{325D4}; + #\u{325D5}; + #\u{325D6}; + #\u{325D7}; + #\u{325D8}; + #\u{325D9}; + #\u{325DA}; + #\u{325DB}; + #\u{325DC}; + #\u{325DD}; + #\u{325DE}; + #\u{325DF}; + #\u{325E0}; + #\u{325E1}; + #\u{325E2}; + #\u{325E3}; + #\u{325E4}; + #\u{325E5}; + #\u{325E6}; + #\u{325E7}; + #\u{325E8}; + #\u{325E9}; + #\u{325EA}; + #\u{325EB}; + #\u{325EC}; + #\u{325ED}; + #\u{325EE}; + #\u{325EF}; + #\u{325F0}; + #\u{325F1}; + #\u{325F2}; + #\u{325F3}; + #\u{325F4}; + #\u{325F5}; + #\u{325F6}; + #\u{325F7}; + #\u{325F8}; + #\u{325F9}; + #\u{325FA}; + #\u{325FB}; + #\u{325FC}; + #\u{325FD}; + #\u{325FE}; + #\u{325FF}; + #\u{32600}; + #\u{32601}; + #\u{32602}; + #\u{32603}; + #\u{32604}; + #\u{32605}; + #\u{32606}; + #\u{32607}; + #\u{32608}; + #\u{32609}; + #\u{3260A}; + #\u{3260B}; + #\u{3260C}; + #\u{3260D}; + #\u{3260E}; + #\u{3260F}; + #\u{32610}; + #\u{32611}; + #\u{32612}; + #\u{32613}; + #\u{32614}; + #\u{32615}; + #\u{32616}; + #\u{32617}; + #\u{32618}; + #\u{32619}; + #\u{3261A}; + #\u{3261B}; + #\u{3261C}; + #\u{3261D}; + #\u{3261E}; + #\u{3261F}; + #\u{32620}; + #\u{32621}; + #\u{32622}; + #\u{32623}; + #\u{32624}; + #\u{32625}; + #\u{32626}; + #\u{32627}; + #\u{32628}; + #\u{32629}; + #\u{3262A}; + #\u{3262B}; + #\u{3262C}; + #\u{3262D}; + #\u{3262E}; + #\u{3262F}; + #\u{32630}; + #\u{32631}; + #\u{32632}; + #\u{32633}; + #\u{32634}; + #\u{32635}; + #\u{32636}; + #\u{32637}; + #\u{32638}; + #\u{32639}; + #\u{3263A}; + #\u{3263B}; + #\u{3263C}; + #\u{3263D}; + #\u{3263E}; + #\u{3263F}; + #\u{32640}; + #\u{32641}; + #\u{32642}; + #\u{32643}; + #\u{32644}; + #\u{32645}; + #\u{32646}; + #\u{32647}; + #\u{32648}; + #\u{32649}; + #\u{3264A}; + #\u{3264B}; + #\u{3264C}; + #\u{3264D}; + #\u{3264E}; + #\u{3264F}; + #\u{32650}; + #\u{32651}; + #\u{32652}; + #\u{32653}; + #\u{32654}; + #\u{32655}; + #\u{32656}; + #\u{32657}; + #\u{32658}; + #\u{32659}; + #\u{3265A}; + #\u{3265B}; + #\u{3265C}; + #\u{3265D}; + #\u{3265E}; + #\u{3265F}; + #\u{32660}; + #\u{32661}; + #\u{32662}; + #\u{32663}; + #\u{32664}; + #\u{32665}; + #\u{32666}; + #\u{32667}; + #\u{32668}; + #\u{32669}; + #\u{3266A}; + #\u{3266B}; + #\u{3266C}; + #\u{3266D}; + #\u{3266E}; + #\u{3266F}; + #\u{32670}; + #\u{32671}; + #\u{32672}; + #\u{32673}; + #\u{32674}; + #\u{32675}; + #\u{32676}; + #\u{32677}; + #\u{32678}; + #\u{32679}; + #\u{3267A}; + #\u{3267B}; + #\u{3267C}; + #\u{3267D}; + #\u{3267E}; + #\u{3267F}; + #\u{32680}; + #\u{32681}; + #\u{32682}; + #\u{32683}; + #\u{32684}; + #\u{32685}; + #\u{32686}; + #\u{32687}; + #\u{32688}; + #\u{32689}; + #\u{3268A}; + #\u{3268B}; + #\u{3268C}; + #\u{3268D}; + #\u{3268E}; + #\u{3268F}; + #\u{32690}; + #\u{32691}; + #\u{32692}; + #\u{32693}; + #\u{32694}; + #\u{32695}; + #\u{32696}; + #\u{32697}; + #\u{32698}; + #\u{32699}; + #\u{3269A}; + #\u{3269B}; + #\u{3269C}; + #\u{3269D}; + #\u{3269E}; + #\u{3269F}; + #\u{326A0}; + #\u{326A1}; + #\u{326A2}; + #\u{326A3}; + #\u{326A4}; + #\u{326A5}; + #\u{326A6}; + #\u{326A7}; + #\u{326A8}; + #\u{326A9}; + #\u{326AA}; + #\u{326AB}; + #\u{326AC}; + #\u{326AD}; + #\u{326AE}; + #\u{326AF}; + #\u{326B0}; + #\u{326B1}; + #\u{326B2}; + #\u{326B3}; + #\u{326B4}; + #\u{326B5}; + #\u{326B6}; + #\u{326B7}; + #\u{326B8}; + #\u{326B9}; + #\u{326BA}; + #\u{326BB}; + #\u{326BC}; + #\u{326BD}; + #\u{326BE}; + #\u{326BF}; + #\u{326C0}; + #\u{326C1}; + #\u{326C2}; + #\u{326C3}; + #\u{326C4}; + #\u{326C5}; + #\u{326C6}; + #\u{326C7}; + #\u{326C8}; + #\u{326C9}; + #\u{326CA}; + #\u{326CB}; + #\u{326CC}; + #\u{326CD}; + #\u{326CE}; + #\u{326CF}; + #\u{326D0}; + #\u{326D1}; + #\u{326D2}; + #\u{326D3}; + #\u{326D4}; + #\u{326D5}; + #\u{326D6}; + #\u{326D7}; + #\u{326D8}; + #\u{326D9}; + #\u{326DA}; + #\u{326DB}; + #\u{326DC}; + #\u{326DD}; + #\u{326DE}; + #\u{326DF}; + #\u{326E0}; + #\u{326E1}; + #\u{326E2}; + #\u{326E3}; + #\u{326E4}; + #\u{326E5}; + #\u{326E6}; + #\u{326E7}; + #\u{326E8}; + #\u{326E9}; + #\u{326EA}; + #\u{326EB}; + #\u{326EC}; + #\u{326ED}; + #\u{326EE}; + #\u{326EF}; + #\u{326F0}; + #\u{326F1}; + #\u{326F2}; + #\u{326F3}; + #\u{326F4}; + #\u{326F5}; + #\u{326F6}; + #\u{326F7}; + #\u{326F8}; + #\u{326F9}; + #\u{326FA}; + #\u{326FB}; + #\u{326FC}; + #\u{326FD}; + #\u{326FE}; + #\u{326FF}; + #\u{32700}; + #\u{32701}; + #\u{32702}; + #\u{32703}; + #\u{32704}; + #\u{32705}; + #\u{32706}; + #\u{32707}; + #\u{32708}; + #\u{32709}; + #\u{3270A}; + #\u{3270B}; + #\u{3270C}; + #\u{3270D}; + #\u{3270E}; + #\u{3270F}; + #\u{32710}; + #\u{32711}; + #\u{32712}; + #\u{32713}; + #\u{32714}; + #\u{32715}; + #\u{32716}; + #\u{32717}; + #\u{32718}; + #\u{32719}; + #\u{3271A}; + #\u{3271B}; + #\u{3271C}; + #\u{3271D}; + #\u{3271E}; + #\u{3271F}; + #\u{32720}; + #\u{32721}; + #\u{32722}; + #\u{32723}; + #\u{32724}; + #\u{32725}; + #\u{32726}; + #\u{32727}; + #\u{32728}; + #\u{32729}; + #\u{3272A}; + #\u{3272B}; + #\u{3272C}; + #\u{3272D}; + #\u{3272E}; + #\u{3272F}; + #\u{32730}; + #\u{32731}; + #\u{32732}; + #\u{32733}; + #\u{32734}; + #\u{32735}; + #\u{32736}; + #\u{32737}; + #\u{32738}; + #\u{32739}; + #\u{3273A}; + #\u{3273B}; + #\u{3273C}; + #\u{3273D}; + #\u{3273E}; + #\u{3273F}; + #\u{32740}; + #\u{32741}; + #\u{32742}; + #\u{32743}; + #\u{32744}; + #\u{32745}; + #\u{32746}; + #\u{32747}; + #\u{32748}; + #\u{32749}; + #\u{3274A}; + #\u{3274B}; + #\u{3274C}; + #\u{3274D}; + #\u{3274E}; + #\u{3274F}; + #\u{32750}; + #\u{32751}; + #\u{32752}; + #\u{32753}; + #\u{32754}; + #\u{32755}; + #\u{32756}; + #\u{32757}; + #\u{32758}; + #\u{32759}; + #\u{3275A}; + #\u{3275B}; + #\u{3275C}; + #\u{3275D}; + #\u{3275E}; + #\u{3275F}; + #\u{32760}; + #\u{32761}; + #\u{32762}; + #\u{32763}; + #\u{32764}; + #\u{32765}; + #\u{32766}; + #\u{32767}; + #\u{32768}; + #\u{32769}; + #\u{3276A}; + #\u{3276B}; + #\u{3276C}; + #\u{3276D}; + #\u{3276E}; + #\u{3276F}; + #\u{32770}; + #\u{32771}; + #\u{32772}; + #\u{32773}; + #\u{32774}; + #\u{32775}; + #\u{32776}; + #\u{32777}; + #\u{32778}; + #\u{32779}; + #\u{3277A}; + #\u{3277B}; + #\u{3277C}; + #\u{3277D}; + #\u{3277E}; + #\u{3277F}; + #\u{32780}; + #\u{32781}; + #\u{32782}; + #\u{32783}; + #\u{32784}; + #\u{32785}; + #\u{32786}; + #\u{32787}; + #\u{32788}; + #\u{32789}; + #\u{3278A}; + #\u{3278B}; + #\u{3278C}; + #\u{3278D}; + #\u{3278E}; + #\u{3278F}; + #\u{32790}; + #\u{32791}; + #\u{32792}; + #\u{32793}; + #\u{32794}; + #\u{32795}; + #\u{32796}; + #\u{32797}; + #\u{32798}; + #\u{32799}; + #\u{3279A}; + #\u{3279B}; + #\u{3279C}; + #\u{3279D}; + #\u{3279E}; + #\u{3279F}; + #\u{327A0}; + #\u{327A1}; + #\u{327A2}; + #\u{327A3}; + #\u{327A4}; + #\u{327A5}; + #\u{327A6}; + #\u{327A7}; + #\u{327A8}; + #\u{327A9}; + #\u{327AA}; + #\u{327AB}; + #\u{327AC}; + #\u{327AD}; + #\u{327AE}; + #\u{327AF}; + #\u{327B0}; + #\u{327B1}; + #\u{327B2}; + #\u{327B3}; + #\u{327B4}; + #\u{327B5}; + #\u{327B6}; + #\u{327B7}; + #\u{327B8}; + #\u{327B9}; + #\u{327BA}; + #\u{327BB}; + #\u{327BC}; + #\u{327BD}; + #\u{327BE}; + #\u{327BF}; + #\u{327C0}; + #\u{327C1}; + #\u{327C2}; + #\u{327C3}; + #\u{327C4}; + #\u{327C5}; + #\u{327C6}; + #\u{327C7}; + #\u{327C8}; + #\u{327C9}; + #\u{327CA}; + #\u{327CB}; + #\u{327CC}; + #\u{327CD}; + #\u{327CE}; + #\u{327CF}; + #\u{327D0}; + #\u{327D1}; + #\u{327D2}; + #\u{327D3}; + #\u{327D4}; + #\u{327D5}; + #\u{327D6}; + #\u{327D7}; + #\u{327D8}; + #\u{327D9}; + #\u{327DA}; + #\u{327DB}; + #\u{327DC}; + #\u{327DD}; + #\u{327DE}; + #\u{327DF}; + #\u{327E0}; + #\u{327E1}; + #\u{327E2}; + #\u{327E3}; + #\u{327E4}; + #\u{327E5}; + #\u{327E6}; + #\u{327E7}; + #\u{327E8}; + #\u{327E9}; + #\u{327EA}; + #\u{327EB}; + #\u{327EC}; + #\u{327ED}; + #\u{327EE}; + #\u{327EF}; + #\u{327F0}; + #\u{327F1}; + #\u{327F2}; + #\u{327F3}; + #\u{327F4}; + #\u{327F5}; + #\u{327F6}; + #\u{327F7}; + #\u{327F8}; + #\u{327F9}; + #\u{327FA}; + #\u{327FB}; + #\u{327FC}; + #\u{327FD}; + #\u{327FE}; + #\u{327FF}; + #\u{32800}; + #\u{32801}; + #\u{32802}; + #\u{32803}; + #\u{32804}; + #\u{32805}; + #\u{32806}; + #\u{32807}; + #\u{32808}; + #\u{32809}; + #\u{3280A}; + #\u{3280B}; + #\u{3280C}; + #\u{3280D}; + #\u{3280E}; + #\u{3280F}; + #\u{32810}; + #\u{32811}; + #\u{32812}; + #\u{32813}; + #\u{32814}; + #\u{32815}; + #\u{32816}; + #\u{32817}; + #\u{32818}; + #\u{32819}; + #\u{3281A}; + #\u{3281B}; + #\u{3281C}; + #\u{3281D}; + #\u{3281E}; + #\u{3281F}; + #\u{32820}; + #\u{32821}; + #\u{32822}; + #\u{32823}; + #\u{32824}; + #\u{32825}; + #\u{32826}; + #\u{32827}; + #\u{32828}; + #\u{32829}; + #\u{3282A}; + #\u{3282B}; + #\u{3282C}; + #\u{3282D}; + #\u{3282E}; + #\u{3282F}; + #\u{32830}; + #\u{32831}; + #\u{32832}; + #\u{32833}; + #\u{32834}; + #\u{32835}; + #\u{32836}; + #\u{32837}; + #\u{32838}; + #\u{32839}; + #\u{3283A}; + #\u{3283B}; + #\u{3283C}; + #\u{3283D}; + #\u{3283E}; + #\u{3283F}; + #\u{32840}; + #\u{32841}; + #\u{32842}; + #\u{32843}; + #\u{32844}; + #\u{32845}; + #\u{32846}; + #\u{32847}; + #\u{32848}; + #\u{32849}; + #\u{3284A}; + #\u{3284B}; + #\u{3284C}; + #\u{3284D}; + #\u{3284E}; + #\u{3284F}; + #\u{32850}; + #\u{32851}; + #\u{32852}; + #\u{32853}; + #\u{32854}; + #\u{32855}; + #\u{32856}; + #\u{32857}; + #\u{32858}; + #\u{32859}; + #\u{3285A}; + #\u{3285B}; + #\u{3285C}; + #\u{3285D}; + #\u{3285E}; + #\u{3285F}; + #\u{32860}; + #\u{32861}; + #\u{32862}; + #\u{32863}; + #\u{32864}; + #\u{32865}; + #\u{32866}; + #\u{32867}; + #\u{32868}; + #\u{32869}; + #\u{3286A}; + #\u{3286B}; + #\u{3286C}; + #\u{3286D}; + #\u{3286E}; + #\u{3286F}; + #\u{32870}; + #\u{32871}; + #\u{32872}; + #\u{32873}; + #\u{32874}; + #\u{32875}; + #\u{32876}; + #\u{32877}; + #\u{32878}; + #\u{32879}; + #\u{3287A}; + #\u{3287B}; + #\u{3287C}; + #\u{3287D}; + #\u{3287E}; + #\u{3287F}; + #\u{32880}; + #\u{32881}; + #\u{32882}; + #\u{32883}; + #\u{32884}; + #\u{32885}; + #\u{32886}; + #\u{32887}; + #\u{32888}; + #\u{32889}; + #\u{3288A}; + #\u{3288B}; + #\u{3288C}; + #\u{3288D}; + #\u{3288E}; + #\u{3288F}; + #\u{32890}; + #\u{32891}; + #\u{32892}; + #\u{32893}; + #\u{32894}; + #\u{32895}; + #\u{32896}; + #\u{32897}; + #\u{32898}; + #\u{32899}; + #\u{3289A}; + #\u{3289B}; + #\u{3289C}; + #\u{3289D}; + #\u{3289E}; + #\u{3289F}; + #\u{328A0}; + #\u{328A1}; + #\u{328A2}; + #\u{328A3}; + #\u{328A4}; + #\u{328A5}; + #\u{328A6}; + #\u{328A7}; + #\u{328A8}; + #\u{328A9}; + #\u{328AA}; + #\u{328AB}; + #\u{328AC}; + #\u{328AD}; + #\u{328AE}; + #\u{328AF}; + #\u{328B0}; + #\u{328B1}; + #\u{328B2}; + #\u{328B3}; + #\u{328B4}; + #\u{328B5}; + #\u{328B6}; + #\u{328B7}; + #\u{328B8}; + #\u{328B9}; + #\u{328BA}; + #\u{328BB}; + #\u{328BC}; + #\u{328BD}; + #\u{328BE}; + #\u{328BF}; + #\u{328C0}; + #\u{328C1}; + #\u{328C2}; + #\u{328C3}; + #\u{328C4}; + #\u{328C5}; + #\u{328C6}; + #\u{328C7}; + #\u{328C8}; + #\u{328C9}; + #\u{328CA}; + #\u{328CB}; + #\u{328CC}; + #\u{328CD}; + #\u{328CE}; + #\u{328CF}; + #\u{328D0}; + #\u{328D1}; + #\u{328D2}; + #\u{328D3}; + #\u{328D4}; + #\u{328D5}; + #\u{328D6}; + #\u{328D7}; + #\u{328D8}; + #\u{328D9}; + #\u{328DA}; + #\u{328DB}; + #\u{328DC}; + #\u{328DD}; + #\u{328DE}; + #\u{328DF}; + #\u{328E0}; + #\u{328E1}; + #\u{328E2}; + #\u{328E3}; + #\u{328E4}; + #\u{328E5}; + #\u{328E6}; + #\u{328E7}; + #\u{328E8}; + #\u{328E9}; + #\u{328EA}; + #\u{328EB}; + #\u{328EC}; + #\u{328ED}; + #\u{328EE}; + #\u{328EF}; + #\u{328F0}; + #\u{328F1}; + #\u{328F2}; + #\u{328F3}; + #\u{328F4}; + #\u{328F5}; + #\u{328F6}; + #\u{328F7}; + #\u{328F8}; + #\u{328F9}; + #\u{328FA}; + #\u{328FB}; + #\u{328FC}; + #\u{328FD}; + #\u{328FE}; + #\u{328FF}; + #\u{32900}; + #\u{32901}; + #\u{32902}; + #\u{32903}; + #\u{32904}; + #\u{32905}; + #\u{32906}; + #\u{32907}; + #\u{32908}; + #\u{32909}; + #\u{3290A}; + #\u{3290B}; + #\u{3290C}; + #\u{3290D}; + #\u{3290E}; + #\u{3290F}; + #\u{32910}; + #\u{32911}; + #\u{32912}; + #\u{32913}; + #\u{32914}; + #\u{32915}; + #\u{32916}; + #\u{32917}; + #\u{32918}; + #\u{32919}; + #\u{3291A}; + #\u{3291B}; + #\u{3291C}; + #\u{3291D}; + #\u{3291E}; + #\u{3291F}; + #\u{32920}; + #\u{32921}; + #\u{32922}; + #\u{32923}; + #\u{32924}; + #\u{32925}; + #\u{32926}; + #\u{32927}; + #\u{32928}; + #\u{32929}; + #\u{3292A}; + #\u{3292B}; + #\u{3292C}; + #\u{3292D}; + #\u{3292E}; + #\u{3292F}; + #\u{32930}; + #\u{32931}; + #\u{32932}; + #\u{32933}; + #\u{32934}; + #\u{32935}; + #\u{32936}; + #\u{32937}; + #\u{32938}; + #\u{32939}; + #\u{3293A}; + #\u{3293B}; + #\u{3293C}; + #\u{3293D}; + #\u{3293E}; + #\u{3293F}; + #\u{32940}; + #\u{32941}; + #\u{32942}; + #\u{32943}; + #\u{32944}; + #\u{32945}; + #\u{32946}; + #\u{32947}; + #\u{32948}; + #\u{32949}; + #\u{3294A}; + #\u{3294B}; + #\u{3294C}; + #\u{3294D}; + #\u{3294E}; + #\u{3294F}; + #\u{32950}; + #\u{32951}; + #\u{32952}; + #\u{32953}; + #\u{32954}; + #\u{32955}; + #\u{32956}; + #\u{32957}; + #\u{32958}; + #\u{32959}; + #\u{3295A}; + #\u{3295B}; + #\u{3295C}; + #\u{3295D}; + #\u{3295E}; + #\u{3295F}; + #\u{32960}; + #\u{32961}; + #\u{32962}; + #\u{32963}; + #\u{32964}; + #\u{32965}; + #\u{32966}; + #\u{32967}; + #\u{32968}; + #\u{32969}; + #\u{3296A}; + #\u{3296B}; + #\u{3296C}; + #\u{3296D}; + #\u{3296E}; + #\u{3296F}; + #\u{32970}; + #\u{32971}; + #\u{32972}; + #\u{32973}; + #\u{32974}; + #\u{32975}; + #\u{32976}; + #\u{32977}; + #\u{32978}; + #\u{32979}; + #\u{3297A}; + #\u{3297B}; + #\u{3297C}; + #\u{3297D}; + #\u{3297E}; + #\u{3297F}; + #\u{32980}; + #\u{32981}; + #\u{32982}; + #\u{32983}; + #\u{32984}; + #\u{32985}; + #\u{32986}; + #\u{32987}; + #\u{32988}; + #\u{32989}; + #\u{3298A}; + #\u{3298B}; + #\u{3298C}; + #\u{3298D}; + #\u{3298E}; + #\u{3298F}; + #\u{32990}; + #\u{32991}; + #\u{32992}; + #\u{32993}; + #\u{32994}; + #\u{32995}; + #\u{32996}; + #\u{32997}; + #\u{32998}; + #\u{32999}; + #\u{3299A}; + #\u{3299B}; + #\u{3299C}; + #\u{3299D}; + #\u{3299E}; + #\u{3299F}; + #\u{329A0}; + #\u{329A1}; + #\u{329A2}; + #\u{329A3}; + #\u{329A4}; + #\u{329A5}; + #\u{329A6}; + #\u{329A7}; + #\u{329A8}; + #\u{329A9}; + #\u{329AA}; + #\u{329AB}; + #\u{329AC}; + #\u{329AD}; + #\u{329AE}; + #\u{329AF}; + #\u{329B0}; + #\u{329B1}; + #\u{329B2}; + #\u{329B3}; + #\u{329B4}; + #\u{329B5}; + #\u{329B6}; + #\u{329B7}; + #\u{329B8}; + #\u{329B9}; + #\u{329BA}; + #\u{329BB}; + #\u{329BC}; + #\u{329BD}; + #\u{329BE}; + #\u{329BF}; + #\u{329C0}; + #\u{329C1}; + #\u{329C2}; + #\u{329C3}; + #\u{329C4}; + #\u{329C5}; + #\u{329C6}; + #\u{329C7}; + #\u{329C8}; + #\u{329C9}; + #\u{329CA}; + #\u{329CB}; + #\u{329CC}; + #\u{329CD}; + #\u{329CE}; + #\u{329CF}; + #\u{329D0}; + #\u{329D1}; + #\u{329D2}; + #\u{329D3}; + #\u{329D4}; + #\u{329D5}; + #\u{329D6}; + #\u{329D7}; + #\u{329D8}; + #\u{329D9}; + #\u{329DA}; + #\u{329DB}; + #\u{329DC}; + #\u{329DD}; + #\u{329DE}; + #\u{329DF}; + #\u{329E0}; + #\u{329E1}; + #\u{329E2}; + #\u{329E3}; + #\u{329E4}; + #\u{329E5}; + #\u{329E6}; + #\u{329E7}; + #\u{329E8}; + #\u{329E9}; + #\u{329EA}; + #\u{329EB}; + #\u{329EC}; + #\u{329ED}; + #\u{329EE}; + #\u{329EF}; + #\u{329F0}; + #\u{329F1}; + #\u{329F2}; + #\u{329F3}; + #\u{329F4}; + #\u{329F5}; + #\u{329F6}; + #\u{329F7}; + #\u{329F8}; + #\u{329F9}; + #\u{329FA}; + #\u{329FB}; + #\u{329FC}; + #\u{329FD}; + #\u{329FE}; + #\u{329FF}; + #\u{32A00}; + #\u{32A01}; + #\u{32A02}; + #\u{32A03}; + #\u{32A04}; + #\u{32A05}; + #\u{32A06}; + #\u{32A07}; + #\u{32A08}; + #\u{32A09}; + #\u{32A0A}; + #\u{32A0B}; + #\u{32A0C}; + #\u{32A0D}; + #\u{32A0E}; + #\u{32A0F}; + #\u{32A10}; + #\u{32A11}; + #\u{32A12}; + #\u{32A13}; + #\u{32A14}; + #\u{32A15}; + #\u{32A16}; + #\u{32A17}; + #\u{32A18}; + #\u{32A19}; + #\u{32A1A}; + #\u{32A1B}; + #\u{32A1C}; + #\u{32A1D}; + #\u{32A1E}; + #\u{32A1F}; + #\u{32A20}; + #\u{32A21}; + #\u{32A22}; + #\u{32A23}; + #\u{32A24}; + #\u{32A25}; + #\u{32A26}; + #\u{32A27}; + #\u{32A28}; + #\u{32A29}; + #\u{32A2A}; + #\u{32A2B}; + #\u{32A2C}; + #\u{32A2D}; + #\u{32A2E}; + #\u{32A2F}; + #\u{32A30}; + #\u{32A31}; + #\u{32A32}; + #\u{32A33}; + #\u{32A34}; + #\u{32A35}; + #\u{32A36}; + #\u{32A37}; + #\u{32A38}; + #\u{32A39}; + #\u{32A3A}; + #\u{32A3B}; + #\u{32A3C}; + #\u{32A3D}; + #\u{32A3E}; + #\u{32A3F}; + #\u{32A40}; + #\u{32A41}; + #\u{32A42}; + #\u{32A43}; + #\u{32A44}; + #\u{32A45}; + #\u{32A46}; + #\u{32A47}; + #\u{32A48}; + #\u{32A49}; + #\u{32A4A}; + #\u{32A4B}; + #\u{32A4C}; + #\u{32A4D}; + #\u{32A4E}; + #\u{32A4F}; + #\u{32A50}; + #\u{32A51}; + #\u{32A52}; + #\u{32A53}; + #\u{32A54}; + #\u{32A55}; + #\u{32A56}; + #\u{32A57}; + #\u{32A58}; + #\u{32A59}; + #\u{32A5A}; + #\u{32A5B}; + #\u{32A5C}; + #\u{32A5D}; + #\u{32A5E}; + #\u{32A5F}; + #\u{32A60}; + #\u{32A61}; + #\u{32A62}; + #\u{32A63}; + #\u{32A64}; + #\u{32A65}; + #\u{32A66}; + #\u{32A67}; + #\u{32A68}; + #\u{32A69}; + #\u{32A6A}; + #\u{32A6B}; + #\u{32A6C}; + #\u{32A6D}; + #\u{32A6E}; + #\u{32A6F}; + #\u{32A70}; + #\u{32A71}; + #\u{32A72}; + #\u{32A73}; + #\u{32A74}; + #\u{32A75}; + #\u{32A76}; + #\u{32A77}; + #\u{32A78}; + #\u{32A79}; + #\u{32A7A}; + #\u{32A7B}; + #\u{32A7C}; + #\u{32A7D}; + #\u{32A7E}; + #\u{32A7F}; + #\u{32A80}; + #\u{32A81}; + #\u{32A82}; + #\u{32A83}; + #\u{32A84}; + #\u{32A85}; + #\u{32A86}; + #\u{32A87}; + #\u{32A88}; + #\u{32A89}; + #\u{32A8A}; + #\u{32A8B}; + #\u{32A8C}; + #\u{32A8D}; + #\u{32A8E}; + #\u{32A8F}; + #\u{32A90}; + #\u{32A91}; + #\u{32A92}; + #\u{32A93}; + #\u{32A94}; + #\u{32A95}; + #\u{32A96}; + #\u{32A97}; + #\u{32A98}; + #\u{32A99}; + #\u{32A9A}; + #\u{32A9B}; + #\u{32A9C}; + #\u{32A9D}; + #\u{32A9E}; + #\u{32A9F}; + #\u{32AA0}; + #\u{32AA1}; + #\u{32AA2}; + #\u{32AA3}; + #\u{32AA4}; + #\u{32AA5}; + #\u{32AA6}; + #\u{32AA7}; + #\u{32AA8}; + #\u{32AA9}; + #\u{32AAA}; + #\u{32AAB}; + #\u{32AAC}; + #\u{32AAD}; + #\u{32AAE}; + #\u{32AAF}; + #\u{32AB0}; + #\u{32AB1}; + #\u{32AB2}; + #\u{32AB3}; + #\u{32AB4}; + #\u{32AB5}; + #\u{32AB6}; + #\u{32AB7}; + #\u{32AB8}; + #\u{32AB9}; + #\u{32ABA}; + #\u{32ABB}; + #\u{32ABC}; + #\u{32ABD}; + #\u{32ABE}; + #\u{32ABF}; + #\u{32AC0}; + #\u{32AC1}; + #\u{32AC2}; + #\u{32AC3}; + #\u{32AC4}; + #\u{32AC5}; + #\u{32AC6}; + #\u{32AC7}; + #\u{32AC8}; + #\u{32AC9}; + #\u{32ACA}; + #\u{32ACB}; + #\u{32ACC}; + #\u{32ACD}; + #\u{32ACE}; + #\u{32ACF}; + #\u{32AD0}; + #\u{32AD1}; + #\u{32AD2}; + #\u{32AD3}; + #\u{32AD4}; + #\u{32AD5}; + #\u{32AD6}; + #\u{32AD7}; + #\u{32AD8}; + #\u{32AD9}; + #\u{32ADA}; + #\u{32ADB}; + #\u{32ADC}; + #\u{32ADD}; + #\u{32ADE}; + #\u{32ADF}; + #\u{32AE0}; + #\u{32AE1}; + #\u{32AE2}; + #\u{32AE3}; + #\u{32AE4}; + #\u{32AE5}; + #\u{32AE6}; + #\u{32AE7}; + #\u{32AE8}; + #\u{32AE9}; + #\u{32AEA}; + #\u{32AEB}; + #\u{32AEC}; + #\u{32AED}; + #\u{32AEE}; + #\u{32AEF}; + #\u{32AF0}; + #\u{32AF1}; + #\u{32AF2}; + #\u{32AF3}; + #\u{32AF4}; + #\u{32AF5}; + #\u{32AF6}; + #\u{32AF7}; + #\u{32AF8}; + #\u{32AF9}; + #\u{32AFA}; + #\u{32AFB}; + #\u{32AFC}; + #\u{32AFD}; + #\u{32AFE}; + #\u{32AFF}; + #\u{32B00}; + #\u{32B01}; + #\u{32B02}; + #\u{32B03}; + #\u{32B04}; + #\u{32B05}; + #\u{32B06}; + #\u{32B07}; + #\u{32B08}; + #\u{32B09}; + #\u{32B0A}; + #\u{32B0B}; + #\u{32B0C}; + #\u{32B0D}; + #\u{32B0E}; + #\u{32B0F}; + #\u{32B10}; + #\u{32B11}; + #\u{32B12}; + #\u{32B13}; + #\u{32B14}; + #\u{32B15}; + #\u{32B16}; + #\u{32B17}; + #\u{32B18}; + #\u{32B19}; + #\u{32B1A}; + #\u{32B1B}; + #\u{32B1C}; + #\u{32B1D}; + #\u{32B1E}; + #\u{32B1F}; + #\u{32B20}; + #\u{32B21}; + #\u{32B22}; + #\u{32B23}; + #\u{32B24}; + #\u{32B25}; + #\u{32B26}; + #\u{32B27}; + #\u{32B28}; + #\u{32B29}; + #\u{32B2A}; + #\u{32B2B}; + #\u{32B2C}; + #\u{32B2D}; + #\u{32B2E}; + #\u{32B2F}; + #\u{32B30}; + #\u{32B31}; + #\u{32B32}; + #\u{32B33}; + #\u{32B34}; + #\u{32B35}; + #\u{32B36}; + #\u{32B37}; + #\u{32B38}; + #\u{32B39}; + #\u{32B3A}; + #\u{32B3B}; + #\u{32B3C}; + #\u{32B3D}; + #\u{32B3E}; + #\u{32B3F}; + #\u{32B40}; + #\u{32B41}; + #\u{32B42}; + #\u{32B43}; + #\u{32B44}; + #\u{32B45}; + #\u{32B46}; + #\u{32B47}; + #\u{32B48}; + #\u{32B49}; + #\u{32B4A}; + #\u{32B4B}; + #\u{32B4C}; + #\u{32B4D}; + #\u{32B4E}; + #\u{32B4F}; + #\u{32B50}; + #\u{32B51}; + #\u{32B52}; + #\u{32B53}; + #\u{32B54}; + #\u{32B55}; + #\u{32B56}; + #\u{32B57}; + #\u{32B58}; + #\u{32B59}; + #\u{32B5A}; + #\u{32B5B}; + #\u{32B5C}; + #\u{32B5D}; + #\u{32B5E}; + #\u{32B5F}; + #\u{32B60}; + #\u{32B61}; + #\u{32B62}; + #\u{32B63}; + #\u{32B64}; + #\u{32B65}; + #\u{32B66}; + #\u{32B67}; + #\u{32B68}; + #\u{32B69}; + #\u{32B6A}; + #\u{32B6B}; + #\u{32B6C}; + #\u{32B6D}; + #\u{32B6E}; + #\u{32B6F}; + #\u{32B70}; + #\u{32B71}; + #\u{32B72}; + #\u{32B73}; + #\u{32B74}; + #\u{32B75}; + #\u{32B76}; + #\u{32B77}; + #\u{32B78}; + #\u{32B79}; + #\u{32B7A}; + #\u{32B7B}; + #\u{32B7C}; + #\u{32B7D}; + #\u{32B7E}; + #\u{32B7F}; + #\u{32B80}; + #\u{32B81}; + #\u{32B82}; + #\u{32B83}; + #\u{32B84}; + #\u{32B85}; + #\u{32B86}; + #\u{32B87}; + #\u{32B88}; + #\u{32B89}; + #\u{32B8A}; + #\u{32B8B}; + #\u{32B8C}; + #\u{32B8D}; + #\u{32B8E}; + #\u{32B8F}; + #\u{32B90}; + #\u{32B91}; + #\u{32B92}; + #\u{32B93}; + #\u{32B94}; + #\u{32B95}; + #\u{32B96}; + #\u{32B97}; + #\u{32B98}; + #\u{32B99}; + #\u{32B9A}; + #\u{32B9B}; + #\u{32B9C}; + #\u{32B9D}; + #\u{32B9E}; + #\u{32B9F}; + #\u{32BA0}; + #\u{32BA1}; + #\u{32BA2}; + #\u{32BA3}; + #\u{32BA4}; + #\u{32BA5}; + #\u{32BA6}; + #\u{32BA7}; + #\u{32BA8}; + #\u{32BA9}; + #\u{32BAA}; + #\u{32BAB}; + #\u{32BAC}; + #\u{32BAD}; + #\u{32BAE}; + #\u{32BAF}; + #\u{32BB0}; + #\u{32BB1}; + #\u{32BB2}; + #\u{32BB3}; + #\u{32BB4}; + #\u{32BB5}; + #\u{32BB6}; + #\u{32BB7}; + #\u{32BB8}; + #\u{32BB9}; + #\u{32BBA}; + #\u{32BBB}; + #\u{32BBC}; + #\u{32BBD}; + #\u{32BBE}; + #\u{32BBF}; + #\u{32BC0}; + #\u{32BC1}; + #\u{32BC2}; + #\u{32BC3}; + #\u{32BC4}; + #\u{32BC5}; + #\u{32BC6}; + #\u{32BC7}; + #\u{32BC8}; + #\u{32BC9}; + #\u{32BCA}; + #\u{32BCB}; + #\u{32BCC}; + #\u{32BCD}; + #\u{32BCE}; + #\u{32BCF}; + #\u{32BD0}; + #\u{32BD1}; + #\u{32BD2}; + #\u{32BD3}; + #\u{32BD4}; + #\u{32BD5}; + #\u{32BD6}; + #\u{32BD7}; + #\u{32BD8}; + #\u{32BD9}; + #\u{32BDA}; + #\u{32BDB}; + #\u{32BDC}; + #\u{32BDD}; + #\u{32BDE}; + #\u{32BDF}; + #\u{32BE0}; + #\u{32BE1}; + #\u{32BE2}; + #\u{32BE3}; + #\u{32BE4}; + #\u{32BE5}; + #\u{32BE6}; + #\u{32BE7}; + #\u{32BE8}; + #\u{32BE9}; + #\u{32BEA}; + #\u{32BEB}; + #\u{32BEC}; + #\u{32BED}; + #\u{32BEE}; + #\u{32BEF}; + #\u{32BF0}; + #\u{32BF1}; + #\u{32BF2}; + #\u{32BF3}; + #\u{32BF4}; + #\u{32BF5}; + #\u{32BF6}; + #\u{32BF7}; + #\u{32BF8}; + #\u{32BF9}; + #\u{32BFA}; + #\u{32BFB}; + #\u{32BFC}; + #\u{32BFD}; + #\u{32BFE}; + #\u{32BFF}; + #\u{32C00}; + #\u{32C01}; + #\u{32C02}; + #\u{32C03}; + #\u{32C04}; + #\u{32C05}; + #\u{32C06}; + #\u{32C07}; + #\u{32C08}; + #\u{32C09}; + #\u{32C0A}; + #\u{32C0B}; + #\u{32C0C}; + #\u{32C0D}; + #\u{32C0E}; + #\u{32C0F}; + #\u{32C10}; + #\u{32C11}; + #\u{32C12}; + #\u{32C13}; + #\u{32C14}; + #\u{32C15}; + #\u{32C16}; + #\u{32C17}; + #\u{32C18}; + #\u{32C19}; + #\u{32C1A}; + #\u{32C1B}; + #\u{32C1C}; + #\u{32C1D}; + #\u{32C1E}; + #\u{32C1F}; + #\u{32C20}; + #\u{32C21}; + #\u{32C22}; + #\u{32C23}; + #\u{32C24}; + #\u{32C25}; + #\u{32C26}; + #\u{32C27}; + #\u{32C28}; + #\u{32C29}; + #\u{32C2A}; + #\u{32C2B}; + #\u{32C2C}; + #\u{32C2D}; + #\u{32C2E}; + #\u{32C2F}; + #\u{32C30}; + #\u{32C31}; + #\u{32C32}; + #\u{32C33}; + #\u{32C34}; + #\u{32C35}; + #\u{32C36}; + #\u{32C37}; + #\u{32C38}; + #\u{32C39}; + #\u{32C3A}; + #\u{32C3B}; + #\u{32C3C}; + #\u{32C3D}; + #\u{32C3E}; + #\u{32C3F}; + #\u{32C40}; + #\u{32C41}; + #\u{32C42}; + #\u{32C43}; + #\u{32C44}; + #\u{32C45}; + #\u{32C46}; + #\u{32C47}; + #\u{32C48}; + #\u{32C49}; + #\u{32C4A}; + #\u{32C4B}; + #\u{32C4C}; + #\u{32C4D}; + #\u{32C4E}; + #\u{32C4F}; + #\u{32C50}; + #\u{32C51}; + #\u{32C52}; + #\u{32C53}; + #\u{32C54}; + #\u{32C55}; + #\u{32C56}; + #\u{32C57}; + #\u{32C58}; + #\u{32C59}; + #\u{32C5A}; + #\u{32C5B}; + #\u{32C5C}; + #\u{32C5D}; + #\u{32C5E}; + #\u{32C5F}; + #\u{32C60}; + #\u{32C61}; + #\u{32C62}; + #\u{32C63}; + #\u{32C64}; + #\u{32C65}; + #\u{32C66}; + #\u{32C67}; + #\u{32C68}; + #\u{32C69}; + #\u{32C6A}; + #\u{32C6B}; + #\u{32C6C}; + #\u{32C6D}; + #\u{32C6E}; + #\u{32C6F}; + #\u{32C70}; + #\u{32C71}; + #\u{32C72}; + #\u{32C73}; + #\u{32C74}; + #\u{32C75}; + #\u{32C76}; + #\u{32C77}; + #\u{32C78}; + #\u{32C79}; + #\u{32C7A}; + #\u{32C7B}; + #\u{32C7C}; + #\u{32C7D}; + #\u{32C7E}; + #\u{32C7F}; + #\u{32C80}; + #\u{32C81}; + #\u{32C82}; + #\u{32C83}; + #\u{32C84}; + #\u{32C85}; + #\u{32C86}; + #\u{32C87}; + #\u{32C88}; + #\u{32C89}; + #\u{32C8A}; + #\u{32C8B}; + #\u{32C8C}; + #\u{32C8D}; + #\u{32C8E}; + #\u{32C8F}; + #\u{32C90}; + #\u{32C91}; + #\u{32C92}; + #\u{32C93}; + #\u{32C94}; + #\u{32C95}; + #\u{32C96}; + #\u{32C97}; + #\u{32C98}; + #\u{32C99}; + #\u{32C9A}; + #\u{32C9B}; + #\u{32C9C}; + #\u{32C9D}; + #\u{32C9E}; + #\u{32C9F}; + #\u{32CA0}; + #\u{32CA1}; + #\u{32CA2}; + #\u{32CA3}; + #\u{32CA4}; + #\u{32CA5}; + #\u{32CA6}; + #\u{32CA7}; + #\u{32CA8}; + #\u{32CA9}; + #\u{32CAA}; + #\u{32CAB}; + #\u{32CAC}; + #\u{32CAD}; + #\u{32CAE}; + #\u{32CAF}; + #\u{32CB0}; + #\u{32CB1}; + #\u{32CB2}; + #\u{32CB3}; + #\u{32CB4}; + #\u{32CB5}; + #\u{32CB6}; + #\u{32CB7}; + #\u{32CB8}; + #\u{32CB9}; + #\u{32CBA}; + #\u{32CBB}; + #\u{32CBC}; + #\u{32CBD}; + #\u{32CBE}; + #\u{32CBF}; + #\u{32CC0}; + #\u{32CC1}; + #\u{32CC2}; + #\u{32CC3}; + #\u{32CC4}; + #\u{32CC5}; + #\u{32CC6}; + #\u{32CC7}; + #\u{32CC8}; + #\u{32CC9}; + #\u{32CCA}; + #\u{32CCB}; + #\u{32CCC}; + #\u{32CCD}; + #\u{32CCE}; + #\u{32CCF}; + #\u{32CD0}; + #\u{32CD1}; + #\u{32CD2}; + #\u{32CD3}; + #\u{32CD4}; + #\u{32CD5}; + #\u{32CD6}; + #\u{32CD7}; + #\u{32CD8}; + #\u{32CD9}; + #\u{32CDA}; + #\u{32CDB}; + #\u{32CDC}; + #\u{32CDD}; + #\u{32CDE}; + #\u{32CDF}; + #\u{32CE0}; + #\u{32CE1}; + #\u{32CE2}; + #\u{32CE3}; + #\u{32CE4}; + #\u{32CE5}; + #\u{32CE6}; + #\u{32CE7}; + #\u{32CE8}; + #\u{32CE9}; + #\u{32CEA}; + #\u{32CEB}; + #\u{32CEC}; + #\u{32CED}; + #\u{32CEE}; + #\u{32CEF}; + #\u{32CF0}; + #\u{32CF1}; + #\u{32CF2}; + #\u{32CF3}; + #\u{32CF4}; + #\u{32CF5}; + #\u{32CF6}; + #\u{32CF7}; + #\u{32CF8}; + #\u{32CF9}; + #\u{32CFA}; + #\u{32CFB}; + #\u{32CFC}; + #\u{32CFD}; + #\u{32CFE}; + #\u{32CFF}; + #\u{32D00}; + #\u{32D01}; + #\u{32D02}; + #\u{32D03}; + #\u{32D04}; + #\u{32D05}; + #\u{32D06}; + #\u{32D07}; + #\u{32D08}; + #\u{32D09}; + #\u{32D0A}; + #\u{32D0B}; + #\u{32D0C}; + #\u{32D0D}; + #\u{32D0E}; + #\u{32D0F}; + #\u{32D10}; + #\u{32D11}; + #\u{32D12}; + #\u{32D13}; + #\u{32D14}; + #\u{32D15}; + #\u{32D16}; + #\u{32D17}; + #\u{32D18}; + #\u{32D19}; + #\u{32D1A}; + #\u{32D1B}; + #\u{32D1C}; + #\u{32D1D}; + #\u{32D1E}; + #\u{32D1F}; + #\u{32D20}; + #\u{32D21}; + #\u{32D22}; + #\u{32D23}; + #\u{32D24}; + #\u{32D25}; + #\u{32D26}; + #\u{32D27}; + #\u{32D28}; + #\u{32D29}; + #\u{32D2A}; + #\u{32D2B}; + #\u{32D2C}; + #\u{32D2D}; + #\u{32D2E}; + #\u{32D2F}; + #\u{32D30}; + #\u{32D31}; + #\u{32D32}; + #\u{32D33}; + #\u{32D34}; + #\u{32D35}; + #\u{32D36}; + #\u{32D37}; + #\u{32D38}; + #\u{32D39}; + #\u{32D3A}; + #\u{32D3B}; + #\u{32D3C}; + #\u{32D3D}; + #\u{32D3E}; + #\u{32D3F}; + #\u{32D40}; + #\u{32D41}; + #\u{32D42}; + #\u{32D43}; + #\u{32D44}; + #\u{32D45}; + #\u{32D46}; + #\u{32D47}; + #\u{32D48}; + #\u{32D49}; + #\u{32D4A}; + #\u{32D4B}; + #\u{32D4C}; + #\u{32D4D}; + #\u{32D4E}; + #\u{32D4F}; + #\u{32D50}; + #\u{32D51}; + #\u{32D52}; + #\u{32D53}; + #\u{32D54}; + #\u{32D55}; + #\u{32D56}; + #\u{32D57}; + #\u{32D58}; + #\u{32D59}; + #\u{32D5A}; + #\u{32D5B}; + #\u{32D5C}; + #\u{32D5D}; + #\u{32D5E}; + #\u{32D5F}; + #\u{32D60}; + #\u{32D61}; + #\u{32D62}; + #\u{32D63}; + #\u{32D64}; + #\u{32D65}; + #\u{32D66}; + #\u{32D67}; + #\u{32D68}; + #\u{32D69}; + #\u{32D6A}; + #\u{32D6B}; + #\u{32D6C}; + #\u{32D6D}; + #\u{32D6E}; + #\u{32D6F}; + #\u{32D70}; + #\u{32D71}; + #\u{32D72}; + #\u{32D73}; + #\u{32D74}; + #\u{32D75}; + #\u{32D76}; + #\u{32D77}; + #\u{32D78}; + #\u{32D79}; + #\u{32D7A}; + #\u{32D7B}; + #\u{32D7C}; + #\u{32D7D}; + #\u{32D7E}; + #\u{32D7F}; + #\u{32D80}; + #\u{32D81}; + #\u{32D82}; + #\u{32D83}; + #\u{32D84}; + #\u{32D85}; + #\u{32D86}; + #\u{32D87}; + #\u{32D88}; + #\u{32D89}; + #\u{32D8A}; + #\u{32D8B}; + #\u{32D8C}; + #\u{32D8D}; + #\u{32D8E}; + #\u{32D8F}; + #\u{32D90}; + #\u{32D91}; + #\u{32D92}; + #\u{32D93}; + #\u{32D94}; + #\u{32D95}; + #\u{32D96}; + #\u{32D97}; + #\u{32D98}; + #\u{32D99}; + #\u{32D9A}; + #\u{32D9B}; + #\u{32D9C}; + #\u{32D9D}; + #\u{32D9E}; + #\u{32D9F}; + #\u{32DA0}; + #\u{32DA1}; + #\u{32DA2}; + #\u{32DA3}; + #\u{32DA4}; + #\u{32DA5}; + #\u{32DA6}; + #\u{32DA7}; + #\u{32DA8}; + #\u{32DA9}; + #\u{32DAA}; + #\u{32DAB}; + #\u{32DAC}; + #\u{32DAD}; + #\u{32DAE}; + #\u{32DAF}; + #\u{32DB0}; + #\u{32DB1}; + #\u{32DB2}; + #\u{32DB3}; + #\u{32DB4}; + #\u{32DB5}; + #\u{32DB6}; + #\u{32DB7}; + #\u{32DB8}; + #\u{32DB9}; + #\u{32DBA}; + #\u{32DBB}; + #\u{32DBC}; + #\u{32DBD}; + #\u{32DBE}; + #\u{32DBF}; + #\u{32DC0}; + #\u{32DC1}; + #\u{32DC2}; + #\u{32DC3}; + #\u{32DC4}; + #\u{32DC5}; + #\u{32DC6}; + #\u{32DC7}; + #\u{32DC8}; + #\u{32DC9}; + #\u{32DCA}; + #\u{32DCB}; + #\u{32DCC}; + #\u{32DCD}; + #\u{32DCE}; + #\u{32DCF}; + #\u{32DD0}; + #\u{32DD1}; + #\u{32DD2}; + #\u{32DD3}; + #\u{32DD4}; + #\u{32DD5}; + #\u{32DD6}; + #\u{32DD7}; + #\u{32DD8}; + #\u{32DD9}; + #\u{32DDA}; + #\u{32DDB}; + #\u{32DDC}; + #\u{32DDD}; + #\u{32DDE}; + #\u{32DDF}; + #\u{32DE0}; + #\u{32DE1}; + #\u{32DE2}; + #\u{32DE3}; + #\u{32DE4}; + #\u{32DE5}; + #\u{32DE6}; + #\u{32DE7}; + #\u{32DE8}; + #\u{32DE9}; + #\u{32DEA}; + #\u{32DEB}; + #\u{32DEC}; + #\u{32DED}; + #\u{32DEE}; + #\u{32DEF}; + #\u{32DF0}; + #\u{32DF1}; + #\u{32DF2}; + #\u{32DF3}; + #\u{32DF4}; + #\u{32DF5}; + #\u{32DF6}; + #\u{32DF7}; + #\u{32DF8}; + #\u{32DF9}; + #\u{32DFA}; + #\u{32DFB}; + #\u{32DFC}; + #\u{32DFD}; + #\u{32DFE}; + #\u{32DFF}; + #\u{32E00}; + #\u{32E01}; + #\u{32E02}; + #\u{32E03}; + #\u{32E04}; + #\u{32E05}; + #\u{32E06}; + #\u{32E07}; + #\u{32E08}; + #\u{32E09}; + #\u{32E0A}; + #\u{32E0B}; + #\u{32E0C}; + #\u{32E0D}; + #\u{32E0E}; + #\u{32E0F}; + #\u{32E10}; + #\u{32E11}; + #\u{32E12}; + #\u{32E13}; + #\u{32E14}; + #\u{32E15}; + #\u{32E16}; + #\u{32E17}; + #\u{32E18}; + #\u{32E19}; + #\u{32E1A}; + #\u{32E1B}; + #\u{32E1C}; + #\u{32E1D}; + #\u{32E1E}; + #\u{32E1F}; + #\u{32E20}; + #\u{32E21}; + #\u{32E22}; + #\u{32E23}; + #\u{32E24}; + #\u{32E25}; + #\u{32E26}; + #\u{32E27}; + #\u{32E28}; + #\u{32E29}; + #\u{32E2A}; + #\u{32E2B}; + #\u{32E2C}; + #\u{32E2D}; + #\u{32E2E}; + #\u{32E2F}; + #\u{32E30}; + #\u{32E31}; + #\u{32E32}; + #\u{32E33}; + #\u{32E34}; + #\u{32E35}; + #\u{32E36}; + #\u{32E37}; + #\u{32E38}; + #\u{32E39}; + #\u{32E3A}; + #\u{32E3B}; + #\u{32E3C}; + #\u{32E3D}; + #\u{32E3E}; + #\u{32E3F}; + #\u{32E40}; + #\u{32E41}; + #\u{32E42}; + #\u{32E43}; + #\u{32E44}; + #\u{32E45}; + #\u{32E46}; + #\u{32E47}; + #\u{32E48}; + #\u{32E49}; + #\u{32E4A}; + #\u{32E4B}; + #\u{32E4C}; + #\u{32E4D}; + #\u{32E4E}; + #\u{32E4F}; + #\u{32E50}; + #\u{32E51}; + #\u{32E52}; + #\u{32E53}; + #\u{32E54}; + #\u{32E55}; + #\u{32E56}; + #\u{32E57}; + #\u{32E58}; + #\u{32E59}; + #\u{32E5A}; + #\u{32E5B}; + #\u{32E5C}; + #\u{32E5D}; + #\u{32E5E}; + #\u{32E5F}; + #\u{32E60}; + #\u{32E61}; + #\u{32E62}; + #\u{32E63}; + #\u{32E64}; + #\u{32E65}; + #\u{32E66}; + #\u{32E67}; + #\u{32E68}; + #\u{32E69}; + #\u{32E6A}; + #\u{32E6B}; + #\u{32E6C}; + #\u{32E6D}; + #\u{32E6E}; + #\u{32E6F}; + #\u{32E70}; + #\u{32E71}; + #\u{32E72}; + #\u{32E73}; + #\u{32E74}; + #\u{32E75}; + #\u{32E76}; + #\u{32E77}; + #\u{32E78}; + #\u{32E79}; + #\u{32E7A}; + #\u{32E7B}; + #\u{32E7C}; + #\u{32E7D}; + #\u{32E7E}; + #\u{32E7F}; + #\u{32E80}; + #\u{32E81}; + #\u{32E82}; + #\u{32E83}; + #\u{32E84}; + #\u{32E85}; + #\u{32E86}; + #\u{32E87}; + #\u{32E88}; + #\u{32E89}; + #\u{32E8A}; + #\u{32E8B}; + #\u{32E8C}; + #\u{32E8D}; + #\u{32E8E}; + #\u{32E8F}; + #\u{32E90}; + #\u{32E91}; + #\u{32E92}; + #\u{32E93}; + #\u{32E94}; + #\u{32E95}; + #\u{32E96}; + #\u{32E97}; + #\u{32E98}; + #\u{32E99}; + #\u{32E9A}; + #\u{32E9B}; + #\u{32E9C}; + #\u{32E9D}; + #\u{32E9E}; + #\u{32E9F}; + #\u{32EA0}; + #\u{32EA1}; + #\u{32EA2}; + #\u{32EA3}; + #\u{32EA4}; + #\u{32EA5}; + #\u{32EA6}; + #\u{32EA7}; + #\u{32EA8}; + #\u{32EA9}; + #\u{32EAA}; + #\u{32EAB}; + #\u{32EAC}; + #\u{32EAD}; + #\u{32EAE}; + #\u{32EAF}; + #\u{32EB0}; + #\u{32EB1}; + #\u{32EB2}; + #\u{32EB3}; + #\u{32EB4}; + #\u{32EB5}; + #\u{32EB6}; + #\u{32EB7}; + #\u{32EB8}; + #\u{32EB9}; + #\u{32EBA}; + #\u{32EBB}; + #\u{32EBC}; + #\u{32EBD}; + #\u{32EBE}; + #\u{32EBF}; + #\u{32EC0}; + #\u{32EC1}; + #\u{32EC2}; + #\u{32EC3}; + #\u{32EC4}; + #\u{32EC5}; + #\u{32EC6}; + #\u{32EC7}; + #\u{32EC8}; + #\u{32EC9}; + #\u{32ECA}; + #\u{32ECB}; + #\u{32ECC}; + #\u{32ECD}; + #\u{32ECE}; + #\u{32ECF}; + #\u{32ED0}; + #\u{32ED1}; + #\u{32ED2}; + #\u{32ED3}; + #\u{32ED4}; + #\u{32ED5}; + #\u{32ED6}; + #\u{32ED7}; + #\u{32ED8}; + #\u{32ED9}; + #\u{32EDA}; + #\u{32EDB}; + #\u{32EDC}; + #\u{32EDD}; + #\u{32EDE}; + #\u{32EDF}; + #\u{32EE0}; + #\u{32EE1}; + #\u{32EE2}; + #\u{32EE3}; + #\u{32EE4}; + #\u{32EE5}; + #\u{32EE6}; + #\u{32EE7}; + #\u{32EE8}; + #\u{32EE9}; + #\u{32EEA}; + #\u{32EEB}; + #\u{32EEC}; + #\u{32EED}; + #\u{32EEE}; + #\u{32EEF}; + #\u{32EF0}; + #\u{32EF1}; + #\u{32EF2}; + #\u{32EF3}; + #\u{32EF4}; + #\u{32EF5}; + #\u{32EF6}; + #\u{32EF7}; + #\u{32EF8}; + #\u{32EF9}; + #\u{32EFA}; + #\u{32EFB}; + #\u{32EFC}; + #\u{32EFD}; + #\u{32EFE}; + #\u{32EFF}; + #\u{32F00}; + #\u{32F01}; + #\u{32F02}; + #\u{32F03}; + #\u{32F04}; + #\u{32F05}; + #\u{32F06}; + #\u{32F07}; + #\u{32F08}; + #\u{32F09}; + #\u{32F0A}; + #\u{32F0B}; + #\u{32F0C}; + #\u{32F0D}; + #\u{32F0E}; + #\u{32F0F}; + #\u{32F10}; + #\u{32F11}; + #\u{32F12}; + #\u{32F13}; + #\u{32F14}; + #\u{32F15}; + #\u{32F16}; + #\u{32F17}; + #\u{32F18}; + #\u{32F19}; + #\u{32F1A}; + #\u{32F1B}; + #\u{32F1C}; + #\u{32F1D}; + #\u{32F1E}; + #\u{32F1F}; + #\u{32F20}; + #\u{32F21}; + #\u{32F22}; + #\u{32F23}; + #\u{32F24}; + #\u{32F25}; + #\u{32F26}; + #\u{32F27}; + #\u{32F28}; + #\u{32F29}; + #\u{32F2A}; + #\u{32F2B}; + #\u{32F2C}; + #\u{32F2D}; + #\u{32F2E}; + #\u{32F2F}; + #\u{32F30}; + #\u{32F31}; + #\u{32F32}; + #\u{32F33}; + #\u{32F34}; + #\u{32F35}; + #\u{32F36}; + #\u{32F37}; + #\u{32F38}; + #\u{32F39}; + #\u{32F3A}; + #\u{32F3B}; + #\u{32F3C}; + #\u{32F3D}; + #\u{32F3E}; + #\u{32F3F}; + #\u{32F40}; + #\u{32F41}; + #\u{32F42}; + #\u{32F43}; + #\u{32F44}; + #\u{32F45}; + #\u{32F46}; + #\u{32F47}; + #\u{32F48}; + #\u{32F49}; + #\u{32F4A}; + #\u{32F4B}; + #\u{32F4C}; + #\u{32F4D}; + #\u{32F4E}; + #\u{32F4F}; + #\u{32F50}; + #\u{32F51}; + #\u{32F52}; + #\u{32F53}; + #\u{32F54}; + #\u{32F55}; + #\u{32F56}; + #\u{32F57}; + #\u{32F58}; + #\u{32F59}; + #\u{32F5A}; + #\u{32F5B}; + #\u{32F5C}; + #\u{32F5D}; + #\u{32F5E}; + #\u{32F5F}; + #\u{32F60}; + #\u{32F61}; + #\u{32F62}; + #\u{32F63}; + #\u{32F64}; + #\u{32F65}; + #\u{32F66}; + #\u{32F67}; + #\u{32F68}; + #\u{32F69}; + #\u{32F6A}; + #\u{32F6B}; + #\u{32F6C}; + #\u{32F6D}; + #\u{32F6E}; + #\u{32F6F}; + #\u{32F70}; + #\u{32F71}; + #\u{32F72}; + #\u{32F73}; + #\u{32F74}; + #\u{32F75}; + #\u{32F76}; + #\u{32F77}; + #\u{32F78}; + #\u{32F79}; + #\u{32F7A}; + #\u{32F7B}; + #\u{32F7C}; + #\u{32F7D}; + #\u{32F7E}; + #\u{32F7F}; + #\u{32F80}; + #\u{32F81}; + #\u{32F82}; + #\u{32F83}; + #\u{32F84}; + #\u{32F85}; + #\u{32F86}; + #\u{32F87}; + #\u{32F88}; + #\u{32F89}; + #\u{32F8A}; + #\u{32F8B}; + #\u{32F8C}; + #\u{32F8D}; + #\u{32F8E}; + #\u{32F8F}; + #\u{32F90}; + #\u{32F91}; + #\u{32F92}; + #\u{32F93}; + #\u{32F94}; + #\u{32F95}; + #\u{32F96}; + #\u{32F97}; + #\u{32F98}; + #\u{32F99}; + #\u{32F9A}; + #\u{32F9B}; + #\u{32F9C}; + #\u{32F9D}; + #\u{32F9E}; + #\u{32F9F}; + #\u{32FA0}; + #\u{32FA1}; + #\u{32FA2}; + #\u{32FA3}; + #\u{32FA4}; + #\u{32FA5}; + #\u{32FA6}; + #\u{32FA7}; + #\u{32FA8}; + #\u{32FA9}; + #\u{32FAA}; + #\u{32FAB}; + #\u{32FAC}; + #\u{32FAD}; + #\u{32FAE}; + #\u{32FAF}; + #\u{32FB0}; + #\u{32FB1}; + #\u{32FB2}; + #\u{32FB3}; + #\u{32FB4}; + #\u{32FB5}; + #\u{32FB6}; + #\u{32FB7}; + #\u{32FB8}; + #\u{32FB9}; + #\u{32FBA}; + #\u{32FBB}; + #\u{32FBC}; + #\u{32FBD}; + #\u{32FBE}; + #\u{32FBF}; + #\u{32FC0}; + #\u{32FC1}; + #\u{32FC2}; + #\u{32FC3}; + #\u{32FC4}; + #\u{32FC5}; + #\u{32FC6}; + #\u{32FC7}; + #\u{32FC8}; + #\u{32FC9}; + #\u{32FCA}; + #\u{32FCB}; + #\u{32FCC}; + #\u{32FCD}; + #\u{32FCE}; + #\u{32FCF}; + #\u{32FD0}; + #\u{32FD1}; + #\u{32FD2}; + #\u{32FD3}; + #\u{32FD4}; + #\u{32FD5}; + #\u{32FD6}; + #\u{32FD7}; + #\u{32FD8}; + #\u{32FD9}; + #\u{32FDA}; + #\u{32FDB}; + #\u{32FDC}; + #\u{32FDD}; + #\u{32FDE}; + #\u{32FDF}; + #\u{32FE0}; + #\u{32FE1}; + #\u{32FE2}; + #\u{32FE3}; + #\u{32FE4}; + #\u{32FE5}; + #\u{32FE6}; + #\u{32FE7}; + #\u{32FE8}; + #\u{32FE9}; + #\u{32FEA}; + #\u{32FEB}; + #\u{32FEC}; + #\u{32FED}; + #\u{32FEE}; + #\u{32FEF}; + #\u{32FF0}; + #\u{32FF1}; + #\u{32FF2}; + #\u{32FF3}; + #\u{32FF4}; + #\u{32FF5}; + #\u{32FF6}; + #\u{32FF7}; + #\u{32FF8}; + #\u{32FF9}; + #\u{32FFA}; + #\u{32FFB}; + #\u{32FFC}; + #\u{32FFD}; + #\u{32FFE}; + #\u{32FFF}; + #\u{33000}; + #\u{33001}; + #\u{33002}; + #\u{33003}; + #\u{33004}; + #\u{33005}; + #\u{33006}; + #\u{33007}; + #\u{33008}; + #\u{33009}; + #\u{3300A}; + #\u{3300B}; + #\u{3300C}; + #\u{3300D}; + #\u{3300E}; + #\u{3300F}; + #\u{33010}; + #\u{33011}; + #\u{33012}; + #\u{33013}; + #\u{33014}; + #\u{33015}; + #\u{33016}; + #\u{33017}; + #\u{33018}; + #\u{33019}; + #\u{3301A}; + #\u{3301B}; + #\u{3301C}; + #\u{3301D}; + #\u{3301E}; + #\u{3301F}; + #\u{33020}; + #\u{33021}; + #\u{33022}; + #\u{33023}; + #\u{33024}; + #\u{33025}; + #\u{33026}; + #\u{33027}; + #\u{33028}; + #\u{33029}; + #\u{3302A}; + #\u{3302B}; + #\u{3302C}; + #\u{3302D}; + #\u{3302E}; + #\u{3302F}; + #\u{33030}; + #\u{33031}; + #\u{33032}; + #\u{33033}; + #\u{33034}; + #\u{33035}; + #\u{33036}; + #\u{33037}; + #\u{33038}; + #\u{33039}; + #\u{3303A}; + #\u{3303B}; + #\u{3303C}; + #\u{3303D}; + #\u{3303E}; + #\u{3303F}; + #\u{33040}; + #\u{33041}; + #\u{33042}; + #\u{33043}; + #\u{33044}; + #\u{33045}; + #\u{33046}; + #\u{33047}; + #\u{33048}; + #\u{33049}; + #\u{3304A}; + #\u{3304B}; + #\u{3304C}; + #\u{3304D}; + #\u{3304E}; + #\u{3304F}; + #\u{33050}; + #\u{33051}; + #\u{33052}; + #\u{33053}; + #\u{33054}; + #\u{33055}; + #\u{33056}; + #\u{33057}; + #\u{33058}; + #\u{33059}; + #\u{3305A}; + #\u{3305B}; + #\u{3305C}; + #\u{3305D}; + #\u{3305E}; + #\u{3305F}; + #\u{33060}; + #\u{33061}; + #\u{33062}; + #\u{33063}; + #\u{33064}; + #\u{33065}; + #\u{33066}; + #\u{33067}; + #\u{33068}; + #\u{33069}; + #\u{3306A}; + #\u{3306B}; + #\u{3306C}; + #\u{3306D}; + #\u{3306E}; + #\u{3306F}; + #\u{33070}; + #\u{33071}; + #\u{33072}; + #\u{33073}; + #\u{33074}; + #\u{33075}; + #\u{33076}; + #\u{33077}; + #\u{33078}; + #\u{33079}; + #\u{3307A}; + #\u{3307B}; + #\u{3307C}; + #\u{3307D}; + #\u{3307E}; + #\u{3307F}; + #\u{33080}; + #\u{33081}; + #\u{33082}; + #\u{33083}; + #\u{33084}; + #\u{33085}; + #\u{33086}; + #\u{33087}; + #\u{33088}; + #\u{33089}; + #\u{3308A}; + #\u{3308B}; + #\u{3308C}; + #\u{3308D}; + #\u{3308E}; + #\u{3308F}; + #\u{33090}; + #\u{33091}; + #\u{33092}; + #\u{33093}; + #\u{33094}; + #\u{33095}; + #\u{33096}; + #\u{33097}; + #\u{33098}; + #\u{33099}; + #\u{3309A}; + #\u{3309B}; + #\u{3309C}; + #\u{3309D}; + #\u{3309E}; + #\u{3309F}; + #\u{330A0}; + #\u{330A1}; + #\u{330A2}; + #\u{330A3}; + #\u{330A4}; + #\u{330A5}; + #\u{330A6}; + #\u{330A7}; + #\u{330A8}; + #\u{330A9}; + #\u{330AA}; + #\u{330AB}; + #\u{330AC}; + #\u{330AD}; + #\u{330AE}; + #\u{330AF}; + #\u{330B0}; + #\u{330B1}; + #\u{330B2}; + #\u{330B3}; + #\u{330B4}; + #\u{330B5}; + #\u{330B6}; + #\u{330B7}; + #\u{330B8}; + #\u{330B9}; + #\u{330BA}; + #\u{330BB}; + #\u{330BC}; + #\u{330BD}; + #\u{330BE}; + #\u{330BF}; + #\u{330C0}; + #\u{330C1}; + #\u{330C2}; + #\u{330C3}; + #\u{330C4}; + #\u{330C5}; + #\u{330C6}; + #\u{330C7}; + #\u{330C8}; + #\u{330C9}; + #\u{330CA}; + #\u{330CB}; + #\u{330CC}; + #\u{330CD}; + #\u{330CE}; + #\u{330CF}; + #\u{330D0}; + #\u{330D1}; + #\u{330D2}; + #\u{330D3}; + #\u{330D4}; + #\u{330D5}; + #\u{330D6}; + #\u{330D7}; + #\u{330D8}; + #\u{330D9}; + #\u{330DA}; + #\u{330DB}; + #\u{330DC}; + #\u{330DD}; + #\u{330DE}; + #\u{330DF}; + #\u{330E0}; + #\u{330E1}; + #\u{330E2}; + #\u{330E3}; + #\u{330E4}; + #\u{330E5}; + #\u{330E6}; + #\u{330E7}; + #\u{330E8}; + #\u{330E9}; + #\u{330EA}; + #\u{330EB}; + #\u{330EC}; + #\u{330ED}; + #\u{330EE}; + #\u{330EF}; + #\u{330F0}; + #\u{330F1}; + #\u{330F2}; + #\u{330F3}; + #\u{330F4}; + #\u{330F5}; + #\u{330F6}; + #\u{330F7}; + #\u{330F8}; + #\u{330F9}; + #\u{330FA}; + #\u{330FB}; + #\u{330FC}; + #\u{330FD}; + #\u{330FE}; + #\u{330FF}; + #\u{33100}; + #\u{33101}; + #\u{33102}; + #\u{33103}; + #\u{33104}; + #\u{33105}; + #\u{33106}; + #\u{33107}; + #\u{33108}; + #\u{33109}; + #\u{3310A}; + #\u{3310B}; + #\u{3310C}; + #\u{3310D}; + #\u{3310E}; + #\u{3310F}; + #\u{33110}; + #\u{33111}; + #\u{33112}; + #\u{33113}; + #\u{33114}; + #\u{33115}; + #\u{33116}; + #\u{33117}; + #\u{33118}; + #\u{33119}; + #\u{3311A}; + #\u{3311B}; + #\u{3311C}; + #\u{3311D}; + #\u{3311E}; + #\u{3311F}; + #\u{33120}; + #\u{33121}; + #\u{33122}; + #\u{33123}; + #\u{33124}; + #\u{33125}; + #\u{33126}; + #\u{33127}; + #\u{33128}; + #\u{33129}; + #\u{3312A}; + #\u{3312B}; + #\u{3312C}; + #\u{3312D}; + #\u{3312E}; + #\u{3312F}; + #\u{33130}; + #\u{33131}; + #\u{33132}; + #\u{33133}; + #\u{33134}; + #\u{33135}; + #\u{33136}; + #\u{33137}; + #\u{33138}; + #\u{33139}; + #\u{3313A}; + #\u{3313B}; + #\u{3313C}; + #\u{3313D}; + #\u{3313E}; + #\u{3313F}; + #\u{33140}; + #\u{33141}; + #\u{33142}; + #\u{33143}; + #\u{33144}; + #\u{33145}; + #\u{33146}; + #\u{33147}; + #\u{33148}; + #\u{33149}; + #\u{3314A}; + #\u{3314B}; + #\u{3314C}; + #\u{3314D}; + #\u{3314E}; + #\u{3314F}; + #\u{33150}; + #\u{33151}; + #\u{33152}; + #\u{33153}; + #\u{33154}; + #\u{33155}; + #\u{33156}; + #\u{33157}; + #\u{33158}; + #\u{33159}; + #\u{3315A}; + #\u{3315B}; + #\u{3315C}; + #\u{3315D}; + #\u{3315E}; + #\u{3315F}; + #\u{33160}; + #\u{33161}; + #\u{33162}; + #\u{33163}; + #\u{33164}; + #\u{33165}; + #\u{33166}; + #\u{33167}; + #\u{33168}; + #\u{33169}; + #\u{3316A}; + #\u{3316B}; + #\u{3316C}; + #\u{3316D}; + #\u{3316E}; + #\u{3316F}; + #\u{33170}; + #\u{33171}; + #\u{33172}; + #\u{33173}; + #\u{33174}; + #\u{33175}; + #\u{33176}; + #\u{33177}; + #\u{33178}; + #\u{33179}; + #\u{3317A}; + #\u{3317B}; + #\u{3317C}; + #\u{3317D}; + #\u{3317E}; + #\u{3317F}; + #\u{33180}; + #\u{33181}; + #\u{33182}; + #\u{33183}; + #\u{33184}; + #\u{33185}; + #\u{33186}; + #\u{33187}; + #\u{33188}; + #\u{33189}; + #\u{3318A}; + #\u{3318B}; + #\u{3318C}; + #\u{3318D}; + #\u{3318E}; + #\u{3318F}; + #\u{33190}; + #\u{33191}; + #\u{33192}; + #\u{33193}; + #\u{33194}; + #\u{33195}; + #\u{33196}; + #\u{33197}; + #\u{33198}; + #\u{33199}; + #\u{3319A}; + #\u{3319B}; + #\u{3319C}; + #\u{3319D}; + #\u{3319E}; + #\u{3319F}; + #\u{331A0}; + #\u{331A1}; + #\u{331A2}; + #\u{331A3}; + #\u{331A4}; + #\u{331A5}; + #\u{331A6}; + #\u{331A7}; + #\u{331A8}; + #\u{331A9}; + #\u{331AA}; + #\u{331AB}; + #\u{331AC}; + #\u{331AD}; + #\u{331AE}; + #\u{331AF}; + #\u{331B0}; + #\u{331B1}; + #\u{331B2}; + #\u{331B3}; + #\u{331B4}; + #\u{331B5}; + #\u{331B6}; + #\u{331B7}; + #\u{331B8}; + #\u{331B9}; + #\u{331BA}; + #\u{331BB}; + #\u{331BC}; + #\u{331BD}; + #\u{331BE}; + #\u{331BF}; + #\u{331C0}; + #\u{331C1}; + #\u{331C2}; + #\u{331C3}; + #\u{331C4}; + #\u{331C5}; + #\u{331C6}; + #\u{331C7}; + #\u{331C8}; + #\u{331C9}; + #\u{331CA}; + #\u{331CB}; + #\u{331CC}; + #\u{331CD}; + #\u{331CE}; + #\u{331CF}; + #\u{331D0}; + #\u{331D1}; + #\u{331D2}; + #\u{331D3}; + #\u{331D4}; + #\u{331D5}; + #\u{331D6}; + #\u{331D7}; + #\u{331D8}; + #\u{331D9}; + #\u{331DA}; + #\u{331DB}; + #\u{331DC}; + #\u{331DD}; + #\u{331DE}; + #\u{331DF}; + #\u{331E0}; + #\u{331E1}; + #\u{331E2}; + #\u{331E3}; + #\u{331E4}; + #\u{331E5}; + #\u{331E6}; + #\u{331E7}; + #\u{331E8}; + #\u{331E9}; + #\u{331EA}; + #\u{331EB}; + #\u{331EC}; + #\u{331ED}; + #\u{331EE}; + #\u{331EF}; + #\u{331F0}; + #\u{331F1}; + #\u{331F2}; + #\u{331F3}; + #\u{331F4}; + #\u{331F5}; + #\u{331F6}; + #\u{331F7}; + #\u{331F8}; + #\u{331F9}; + #\u{331FA}; + #\u{331FB}; + #\u{331FC}; + #\u{331FD}; + #\u{331FE}; + #\u{331FF}; + #\u{33200}; + #\u{33201}; + #\u{33202}; + #\u{33203}; + #\u{33204}; + #\u{33205}; + #\u{33206}; + #\u{33207}; + #\u{33208}; + #\u{33209}; + #\u{3320A}; + #\u{3320B}; + #\u{3320C}; + #\u{3320D}; + #\u{3320E}; + #\u{3320F}; + #\u{33210}; + #\u{33211}; + #\u{33212}; + #\u{33213}; + #\u{33214}; + #\u{33215}; + #\u{33216}; + #\u{33217}; + #\u{33218}; + #\u{33219}; + #\u{3321A}; + #\u{3321B}; + #\u{3321C}; + #\u{3321D}; + #\u{3321E}; + #\u{3321F}; + #\u{33220}; + #\u{33221}; + #\u{33222}; + #\u{33223}; + #\u{33224}; + #\u{33225}; + #\u{33226}; + #\u{33227}; + #\u{33228}; + #\u{33229}; + #\u{3322A}; + #\u{3322B}; + #\u{3322C}; + #\u{3322D}; + #\u{3322E}; + #\u{3322F}; + #\u{33230}; + #\u{33231}; + #\u{33232}; + #\u{33233}; + #\u{33234}; + #\u{33235}; + #\u{33236}; + #\u{33237}; + #\u{33238}; + #\u{33239}; + #\u{3323A}; + #\u{3323B}; + #\u{3323C}; + #\u{3323D}; + #\u{3323E}; + #\u{3323F}; + #\u{33240}; + #\u{33241}; + #\u{33242}; + #\u{33243}; + #\u{33244}; + #\u{33245}; + #\u{33246}; + #\u{33247}; + #\u{33248}; + #\u{33249}; + #\u{3324A}; + #\u{3324B}; + #\u{3324C}; + #\u{3324D}; + #\u{3324E}; + #\u{3324F}; + #\u{33250}; + #\u{33251}; + #\u{33252}; + #\u{33253}; + #\u{33254}; + #\u{33255}; + #\u{33256}; + #\u{33257}; + #\u{33258}; + #\u{33259}; + #\u{3325A}; + #\u{3325B}; + #\u{3325C}; + #\u{3325D}; + #\u{3325E}; + #\u{3325F}; + #\u{33260}; + #\u{33261}; + #\u{33262}; + #\u{33263}; + #\u{33264}; + #\u{33265}; + #\u{33266}; + #\u{33267}; + #\u{33268}; + #\u{33269}; + #\u{3326A}; + #\u{3326B}; + #\u{3326C}; + #\u{3326D}; + #\u{3326E}; + #\u{3326F}; + #\u{33270}; + #\u{33271}; + #\u{33272}; + #\u{33273}; + #\u{33274}; + #\u{33275}; + #\u{33276}; + #\u{33277}; + #\u{33278}; + #\u{33279}; + #\u{3327A}; + #\u{3327B}; + #\u{3327C}; + #\u{3327D}; + #\u{3327E}; + #\u{3327F}; + #\u{33280}; + #\u{33281}; + #\u{33282}; + #\u{33283}; + #\u{33284}; + #\u{33285}; + #\u{33286}; + #\u{33287}; + #\u{33288}; + #\u{33289}; + #\u{3328A}; + #\u{3328B}; + #\u{3328C}; + #\u{3328D}; + #\u{3328E}; + #\u{3328F}; + #\u{33290}; + #\u{33291}; + #\u{33292}; + #\u{33293}; + #\u{33294}; + #\u{33295}; + #\u{33296}; + #\u{33297}; + #\u{33298}; + #\u{33299}; + #\u{3329A}; + #\u{3329B}; + #\u{3329C}; + #\u{3329D}; + #\u{3329E}; + #\u{3329F}; + #\u{332A0}; + #\u{332A1}; + #\u{332A2}; + #\u{332A3}; + #\u{332A4}; + #\u{332A5}; + #\u{332A6}; + #\u{332A7}; + #\u{332A8}; + #\u{332A9}; + #\u{332AA}; + #\u{332AB}; + #\u{332AC}; + #\u{332AD}; + #\u{332AE}; + #\u{332AF}; + #\u{332B0}; + #\u{332B1}; + #\u{332B2}; + #\u{332B3}; + #\u{332B4}; + #\u{332B5}; + #\u{332B6}; + #\u{332B7}; + #\u{332B8}; + #\u{332B9}; + #\u{332BA}; + #\u{332BB}; + #\u{332BC}; + #\u{332BD}; + #\u{332BE}; + #\u{332BF}; + #\u{332C0}; + #\u{332C1}; + #\u{332C2}; + #\u{332C3}; + #\u{332C4}; + #\u{332C5}; + #\u{332C6}; + #\u{332C7}; + #\u{332C8}; + #\u{332C9}; + #\u{332CA}; + #\u{332CB}; + #\u{332CC}; + #\u{332CD}; + #\u{332CE}; + #\u{332CF}; + #\u{332D0}; + #\u{332D1}; + #\u{332D2}; + #\u{332D3}; + #\u{332D4}; + #\u{332D5}; + #\u{332D6}; + #\u{332D7}; + #\u{332D8}; + #\u{332D9}; + #\u{332DA}; + #\u{332DB}; + #\u{332DC}; + #\u{332DD}; + #\u{332DE}; + #\u{332DF}; + #\u{332E0}; + #\u{332E1}; + #\u{332E2}; + #\u{332E3}; + #\u{332E4}; + #\u{332E5}; + #\u{332E6}; + #\u{332E7}; + #\u{332E8}; + #\u{332E9}; + #\u{332EA}; + #\u{332EB}; + #\u{332EC}; + #\u{332ED}; + #\u{332EE}; + #\u{332EF}; + #\u{332F0}; + #\u{332F1}; + #\u{332F2}; + #\u{332F3}; + #\u{332F4}; + #\u{332F5}; + #\u{332F6}; + #\u{332F7}; + #\u{332F8}; + #\u{332F9}; + #\u{332FA}; + #\u{332FB}; + #\u{332FC}; + #\u{332FD}; + #\u{332FE}; + #\u{332FF}; + #\u{33300}; + #\u{33301}; + #\u{33302}; + #\u{33303}; + #\u{33304}; + #\u{33305}; + #\u{33306}; + #\u{33307}; + #\u{33308}; + #\u{33309}; + #\u{3330A}; + #\u{3330B}; + #\u{3330C}; + #\u{3330D}; + #\u{3330E}; + #\u{3330F}; + #\u{33310}; + #\u{33311}; + #\u{33312}; + #\u{33313}; + #\u{33314}; + #\u{33315}; + #\u{33316}; + #\u{33317}; + #\u{33318}; + #\u{33319}; + #\u{3331A}; + #\u{3331B}; + #\u{3331C}; + #\u{3331D}; + #\u{3331E}; + #\u{3331F}; + #\u{33320}; + #\u{33321}; + #\u{33322}; + #\u{33323}; + #\u{33324}; + #\u{33325}; + #\u{33326}; + #\u{33327}; + #\u{33328}; + #\u{33329}; + #\u{3332A}; + #\u{3332B}; + #\u{3332C}; + #\u{3332D}; + #\u{3332E}; + #\u{3332F}; + #\u{33330}; + #\u{33331}; + #\u{33332}; + #\u{33333}; + #\u{33334}; + #\u{33335}; + #\u{33336}; + #\u{33337}; + #\u{33338}; + #\u{33339}; + #\u{3333A}; + #\u{3333B}; + #\u{3333C}; + #\u{3333D}; + #\u{3333E}; + #\u{3333F}; + #\u{33340}; + #\u{33341}; + #\u{33342}; + #\u{33343}; + #\u{33344}; + #\u{33345}; + #\u{33346}; + #\u{33347}; + #\u{33348}; + #\u{33349}; + #\u{3334A}; + #\u{3334B}; + #\u{3334C}; + #\u{3334D}; + #\u{3334E}; + #\u{3334F}; + #\u{33350}; + #\u{33351}; + #\u{33352}; + #\u{33353}; + #\u{33354}; + #\u{33355}; + #\u{33356}; + #\u{33357}; + #\u{33358}; + #\u{33359}; + #\u{3335A}; + #\u{3335B}; + #\u{3335C}; + #\u{3335D}; + #\u{3335E}; + #\u{3335F}; + #\u{33360}; + #\u{33361}; + #\u{33362}; + #\u{33363}; + #\u{33364}; + #\u{33365}; + #\u{33366}; + #\u{33367}; + #\u{33368}; + #\u{33369}; + #\u{3336A}; + #\u{3336B}; + #\u{3336C}; + #\u{3336D}; + #\u{3336E}; + #\u{3336F}; + #\u{33370}; + #\u{33371}; + #\u{33372}; + #\u{33373}; + #\u{33374}; + #\u{33375}; + #\u{33376}; + #\u{33377}; + #\u{33378}; + #\u{33379}; + #\u{3337A}; + #\u{3337B}; + #\u{3337C}; + #\u{3337D}; + #\u{3337E}; + #\u{3337F}; + #\u{33380}; + #\u{33381}; + #\u{33382}; + #\u{33383}; + #\u{33384}; + #\u{33385}; + #\u{33386}; + #\u{33387}; + #\u{33388}; + #\u{33389}; + #\u{3338A}; + #\u{3338B}; + #\u{3338C}; + #\u{3338D}; + #\u{3338E}; + #\u{3338F}; + #\u{33390}; + #\u{33391}; + #\u{33392}; + #\u{33393}; + #\u{33394}; + #\u{33395}; + #\u{33396}; + #\u{33397}; + #\u{33398}; + #\u{33399}; + #\u{3339A}; + #\u{3339B}; + #\u{3339C}; + #\u{3339D}; + #\u{3339E}; + #\u{3339F}; + #\u{333A0}; + #\u{333A1}; + #\u{333A2}; + #\u{333A3}; + #\u{333A4}; + #\u{333A5}; + #\u{333A6}; + #\u{333A7}; + #\u{333A8}; + #\u{333A9}; + #\u{333AA}; + #\u{333AB}; + #\u{333AC}; + #\u{333AD}; + #\u{333AE}; + #\u{333AF}; + #\u{333B0}; + #\u{333B1}; + #\u{333B2}; + #\u{333B3}; + #\u{333B4}; + #\u{333B5}; + #\u{333B6}; + #\u{333B7}; + #\u{333B8}; + #\u{333B9}; + #\u{333BA}; + #\u{333BB}; + #\u{333BC}; + #\u{333BD}; + #\u{333BE}; + #\u{333BF}; + #\u{333C0}; + #\u{333C1}; + #\u{333C2}; + #\u{333C3}; + #\u{333C4}; + #\u{333C5}; + #\u{333C6}; + #\u{333C7}; + #\u{333C8}; + #\u{333C9}; + #\u{333CA}; + #\u{333CB}; + #\u{333CC}; + #\u{333CD}; + #\u{333CE}; + #\u{333CF}; + #\u{333D0}; + #\u{333D1}; + #\u{333D2}; + #\u{333D3}; + #\u{333D4}; + #\u{333D5}; + #\u{333D6}; + #\u{333D7}; + #\u{333D8}; + #\u{333D9}; + #\u{333DA}; + #\u{333DB}; + #\u{333DC}; + #\u{333DD}; + #\u{333DE}; + #\u{333DF}; + #\u{333E0}; + #\u{333E1}; + #\u{333E2}; + #\u{333E3}; + #\u{333E4}; + #\u{333E5}; + #\u{333E6}; + #\u{333E7}; + #\u{333E8}; + #\u{333E9}; + #\u{333EA}; + #\u{333EB}; + #\u{333EC}; + #\u{333ED}; + #\u{333EE}; + #\u{333EF}; + #\u{333F0}; + #\u{333F1}; + #\u{333F2}; + #\u{333F3}; + #\u{333F4}; + #\u{333F5}; + #\u{333F6}; + #\u{333F7}; + #\u{333F8}; + #\u{333F9}; + #\u{333FA}; + #\u{333FB}; + #\u{333FC}; + #\u{333FD}; + #\u{333FE}; + #\u{333FF}; + #\u{33400}; + #\u{33401}; + #\u{33402}; + #\u{33403}; + #\u{33404}; + #\u{33405}; + #\u{33406}; + #\u{33407}; + #\u{33408}; + #\u{33409}; + #\u{3340A}; + #\u{3340B}; + #\u{3340C}; + #\u{3340D}; + #\u{3340E}; + #\u{3340F}; + #\u{33410}; + #\u{33411}; + #\u{33412}; + #\u{33413}; + #\u{33414}; + #\u{33415}; + #\u{33416}; + #\u{33417}; + #\u{33418}; + #\u{33419}; + #\u{3341A}; + #\u{3341B}; + #\u{3341C}; + #\u{3341D}; + #\u{3341E}; + #\u{3341F}; + #\u{33420}; + #\u{33421}; + #\u{33422}; + #\u{33423}; + #\u{33424}; + #\u{33425}; + #\u{33426}; + #\u{33427}; + #\u{33428}; + #\u{33429}; + #\u{3342A}; + #\u{3342B}; + #\u{3342C}; + #\u{3342D}; + #\u{3342E}; + #\u{3342F}; + #\u{33430}; + #\u{33431}; + #\u{33432}; + #\u{33433}; + #\u{33434}; + #\u{33435}; + #\u{33436}; + #\u{33437}; + #\u{33438}; + #\u{33439}; + #\u{3343A}; + #\u{3343B}; + #\u{3343C}; + #\u{3343D}; + #\u{3343E}; + #\u{3343F}; + #\u{33440}; + #\u{33441}; + #\u{33442}; + #\u{33443}; + #\u{33444}; + #\u{33445}; + #\u{33446}; + #\u{33447}; + #\u{33448}; + #\u{33449}; + #\u{3344A}; + #\u{3344B}; + #\u{3344C}; + #\u{3344D}; + #\u{3344E}; + #\u{3344F}; + #\u{33450}; + #\u{33451}; + #\u{33452}; + #\u{33453}; + #\u{33454}; + #\u{33455}; + #\u{33456}; + #\u{33457}; + #\u{33458}; + #\u{33459}; + #\u{3345A}; + #\u{3345B}; + #\u{3345C}; + #\u{3345D}; + #\u{3345E}; + #\u{3345F}; + #\u{33460}; + #\u{33461}; + #\u{33462}; + #\u{33463}; + #\u{33464}; + #\u{33465}; + #\u{33466}; + #\u{33467}; + #\u{33468}; + #\u{33469}; + #\u{3346A}; + #\u{3346B}; + #\u{3346C}; + #\u{3346D}; + #\u{3346E}; + #\u{3346F}; + #\u{33470}; + #\u{33471}; + #\u{33472}; + #\u{33473}; + #\u{33474}; + #\u{33475}; + #\u{33476}; + #\u{33477}; + #\u{33478}; + #\u{33479}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0-class.js new file mode 100644 index 000000000..c34276777 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0-class.js @@ -0,0 +1,4663 @@ +// Copyright 2025 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v17.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #࢏; + #౜; + #೜; + #꟎; + #꟏; + #꟒; + #꟔; + #꟱; + #𐥀; + #𐥁; + #𐥂; + #𐥃; + #𐥄; + #𐥅; + #𐥆; + #𐥇; + #𐥈; + #𐥉; + #𐥊; + #𐥋; + #𐥌; + #𐥍; + #𐥎; + #𐥏; + #𐥐; + #𐥑; + #𐥒; + #𐥓; + #𐥔; + #𐥕; + #𐥖; + #𐥗; + #𐥘; + #𐥙; + #𐻅; + #𐻆; + #𐻇; + #𑶰; + #𑶱; + #𑶲; + #𑶳; + #𑶴; + #𑶵; + #𑶶; + #𑶷; + #𑶸; + #𑶹; + #𑶺; + #𑶻; + #𑶼; + #𑶽; + #𑶾; + #𑶿; + #𑷀; + #𑷁; + #𑷂; + #𑷃; + #𑷄; + #𑷅; + #𑷆; + #𑷇; + #𑷈; + #𑷉; + #𑷊; + #𑷋; + #𑷌; + #𑷍; + #𑷎; + #𑷏; + #𑷐; + #𑷑; + #𑷒; + #𑷓; + #𑷔; + #𑷕; + #𑷖; + #𑷗; + #𑷘; + #𑷙; + #𑷚; + #𑷛; + #𖺠; + #𖺡; + #𖺢; + #𖺣; + #𖺤; + #𖺥; + #𖺦; + #𖺧; + #𖺨; + #𖺩; + #𖺪; + #𖺫; + #𖺬; + #𖺭; + #𖺮; + #𖺯; + #𖺰; + #𖺱; + #𖺲; + #𖺳; + #𖺴; + #𖺵; + #𖺶; + #𖺷; + #𖺸; + #𖺻; + #𖺼; + #𖺽; + #𖺾; + #𖺿; + #𖻀; + #𖻁; + #𖻂; + #𖻃; + #𖻄; + #𖻅; + #𖻆; + #𖻇; + #𖻈; + #𖻉; + #𖻊; + #𖻋; + #𖻌; + #𖻍; + #𖻎; + #𖻏; + #𖻐; + #𖻑; + #𖻒; + #𖻓; + #𖿲; + #𖿳; + #𖿴; + #𖿵; + #𖿶; + #𘟸; + #𘟹; + #𘟺; + #𘟻; + #𘟼; + #𘟽; + #𘟾; + #𘟿; + #𘴉; + #𘴊; + #𘴋; + #𘴌; + #𘴍; + #𘴎; + #𘴏; + #𘴐; + #𘴑; + #𘴒; + #𘴓; + #𘴔; + #𘴕; + #𘴖; + #𘴗; + #𘴘; + #𘴙; + #𘴚; + #𘴛; + #𘴜; + #𘴝; + #𘴞; + #𘶀; + #𘶁; + #𘶂; + #𘶃; + #𘶄; + #𘶅; + #𘶆; + #𘶇; + #𘶈; + #𘶉; + #𘶊; + #𘶋; + #𘶌; + #𘶍; + #𘶎; + #𘶏; + #𘶐; + #𘶑; + #𘶒; + #𘶓; + #𘶔; + #𘶕; + #𘶖; + #𘶗; + #𘶘; + #𘶙; + #𘶚; + #𘶛; + #𘶜; + #𘶝; + #𘶞; + #𘶟; + #𘶠; + #𘶡; + #𘶢; + #𘶣; + #𘶤; + #𘶥; + #𘶦; + #𘶧; + #𘶨; + #𘶩; + #𘶪; + #𘶫; + #𘶬; + #𘶭; + #𘶮; + #𘶯; + #𘶰; + #𘶱; + #𘶲; + #𘶳; + #𘶴; + #𘶵; + #𘶶; + #𘶷; + #𘶸; + #𘶹; + #𘶺; + #𘶻; + #𘶼; + #𘶽; + #𘶾; + #𘶿; + #𘷀; + #𘷁; + #𘷂; + #𘷃; + #𘷄; + #𘷅; + #𘷆; + #𘷇; + #𘷈; + #𘷉; + #𘷊; + #𘷋; + #𘷌; + #𘷍; + #𘷎; + #𘷏; + #𘷐; + #𘷑; + #𘷒; + #𘷓; + #𘷔; + #𘷕; + #𘷖; + #𘷗; + #𘷘; + #𘷙; + #𘷚; + #𘷛; + #𘷜; + #𘷝; + #𘷞; + #𘷟; + #𘷠; + #𘷡; + #𘷢; + #𘷣; + #𘷤; + #𘷥; + #𘷦; + #𘷧; + #𘷨; + #𘷩; + #𘷪; + #𘷫; + #𘷬; + #𘷭; + #𘷮; + #𘷯; + #𘷰; + #𘷱; + #𘷲; + #𞛀; + #𞛁; + #𞛂; + #𞛃; + #𞛄; + #𞛅; + #𞛆; + #𞛇; + #𞛈; + #𞛉; + #𞛊; + #𞛋; + #𞛌; + #𞛍; + #𞛎; + #𞛏; + #𞛐; + #𞛑; + #𞛒; + #𞛓; + #𞛔; + #𞛕; + #𞛖; + #𞛗; + #𞛘; + #𞛙; + #𞛚; + #𞛛; + #𞛜; + #𞛝; + #𞛞; + #𞛠; + #𞛡; + #𞛢; + #𞛤; + #𞛥; + #𞛧; + #𞛨; + #𞛩; + #𞛪; + #𞛫; + #𞛬; + #𞛭; + #𞛰; + #𞛱; + #𞛲; + #𞛳; + #𞛴; + #𞛾; + #𞛿; + #𫜺; + #𫜻; + #𫜼; + #𫜽; + #𫜾; + #𫜿; + #𬺢; + #𬺣; + #𬺤; + #𬺥; + #𬺦; + #𬺧; + #𬺨; + #𬺩; + #𬺪; + #𬺫; + #𬺬; + #𬺭; + #𲎰; + #𲎱; + #𲎲; + #𲎳; + #𲎴; + #𲎵; + #𲎶; + #𲎷; + #𲎸; + #𲎹; + #𲎺; + #𲎻; + #𲎼; + #𲎽; + #𲎾; + #𲎿; + #𲏀; + #𲏁; + #𲏂; + #𲏃; + #𲏄; + #𲏅; + #𲏆; + #𲏇; + #𲏈; + #𲏉; + #𲏊; + #𲏋; + #𲏌; + #𲏍; + #𲏎; + #𲏏; + #𲏐; + #𲏑; + #𲏒; + #𲏓; + #𲏔; + #𲏕; + #𲏖; + #𲏗; + #𲏘; + #𲏙; + #𲏚; + #𲏛; + #𲏜; + #𲏝; + #𲏞; + #𲏟; + #𲏠; + #𲏡; + #𲏢; + #𲏣; + #𲏤; + #𲏥; + #𲏦; + #𲏧; + #𲏨; + #𲏩; + #𲏪; + #𲏫; + #𲏬; + #𲏭; + #𲏮; + #𲏯; + #𲏰; + #𲏱; + #𲏲; + #𲏳; + #𲏴; + #𲏵; + #𲏶; + #𲏷; + #𲏸; + #𲏹; + #𲏺; + #𲏻; + #𲏼; + #𲏽; + #𲏾; + #𲏿; + #𲐀; + #𲐁; + #𲐂; + #𲐃; + #𲐄; + #𲐅; + #𲐆; + #𲐇; + #𲐈; + #𲐉; + #𲐊; + #𲐋; + #𲐌; + #𲐍; + #𲐎; + #𲐏; + #𲐐; + #𲐑; + #𲐒; + #𲐓; + #𲐔; + #𲐕; + #𲐖; + #𲐗; + #𲐘; + #𲐙; + #𲐚; + #𲐛; + #𲐜; + #𲐝; + #𲐞; + #𲐟; + #𲐠; + #𲐡; + #𲐢; + #𲐣; + #𲐤; + #𲐥; + #𲐦; + #𲐧; + #𲐨; + #𲐩; + #𲐪; + #𲐫; + #𲐬; + #𲐭; + #𲐮; + #𲐯; + #𲐰; + #𲐱; + #𲐲; + #𲐳; + #𲐴; + #𲐵; + #𲐶; + #𲐷; + #𲐸; + #𲐹; + #𲐺; + #𲐻; + #𲐼; + #𲐽; + #𲐾; + #𲐿; + #𲑀; + #𲑁; + #𲑂; + #𲑃; + #𲑄; + #𲑅; + #𲑆; + #𲑇; + #𲑈; + #𲑉; + #𲑊; + #𲑋; + #𲑌; + #𲑍; + #𲑎; + #𲑏; + #𲑐; + #𲑑; + #𲑒; + #𲑓; + #𲑔; + #𲑕; + #𲑖; + #𲑗; + #𲑘; + #𲑙; + #𲑚; + #𲑛; + #𲑜; + #𲑝; + #𲑞; + #𲑟; + #𲑠; + #𲑡; + #𲑢; + #𲑣; + #𲑤; + #𲑥; + #𲑦; + #𲑧; + #𲑨; + #𲑩; + #𲑪; + #𲑫; + #𲑬; + #𲑭; + #𲑮; + #𲑯; + #𲑰; + #𲑱; + #𲑲; + #𲑳; + #𲑴; + #𲑵; + #𲑶; + #𲑷; + #𲑸; + #𲑹; + #𲑺; + #𲑻; + #𲑼; + #𲑽; + #𲑾; + #𲑿; + #𲒀; + #𲒁; + #𲒂; + #𲒃; + #𲒄; + #𲒅; + #𲒆; + #𲒇; + #𲒈; + #𲒉; + #𲒊; + #𲒋; + #𲒌; + #𲒍; + #𲒎; + #𲒏; + #𲒐; + #𲒑; + #𲒒; + #𲒓; + #𲒔; + #𲒕; + #𲒖; + #𲒗; + #𲒘; + #𲒙; + #𲒚; + #𲒛; + #𲒜; + #𲒝; + #𲒞; + #𲒟; + #𲒠; + #𲒡; + #𲒢; + #𲒣; + #𲒤; + #𲒥; + #𲒦; + #𲒧; + #𲒨; + #𲒩; + #𲒪; + #𲒫; + #𲒬; + #𲒭; + #𲒮; + #𲒯; + #𲒰; + #𲒱; + #𲒲; + #𲒳; + #𲒴; + #𲒵; + #𲒶; + #𲒷; + #𲒸; + #𲒹; + #𲒺; + #𲒻; + #𲒼; + #𲒽; + #𲒾; + #𲒿; + #𲓀; + #𲓁; + #𲓂; + #𲓃; + #𲓄; + #𲓅; + #𲓆; + #𲓇; + #𲓈; + #𲓉; + #𲓊; + #𲓋; + #𲓌; + #𲓍; + #𲓎; + #𲓏; + #𲓐; + #𲓑; + #𲓒; + #𲓓; + #𲓔; + #𲓕; + #𲓖; + #𲓗; + #𲓘; + #𲓙; + #𲓚; + #𲓛; + #𲓜; + #𲓝; + #𲓞; + #𲓟; + #𲓠; + #𲓡; + #𲓢; + #𲓣; + #𲓤; + #𲓥; + #𲓦; + #𲓧; + #𲓨; + #𲓩; + #𲓪; + #𲓫; + #𲓬; + #𲓭; + #𲓮; + #𲓯; + #𲓰; + #𲓱; + #𲓲; + #𲓳; + #𲓴; + #𲓵; + #𲓶; + #𲓷; + #𲓸; + #𲓹; + #𲓺; + #𲓻; + #𲓼; + #𲓽; + #𲓾; + #𲓿; + #𲔀; + #𲔁; + #𲔂; + #𲔃; + #𲔄; + #𲔅; + #𲔆; + #𲔇; + #𲔈; + #𲔉; + #𲔊; + #𲔋; + #𲔌; + #𲔍; + #𲔎; + #𲔏; + #𲔐; + #𲔑; + #𲔒; + #𲔓; + #𲔔; + #𲔕; + #𲔖; + #𲔗; + #𲔘; + #𲔙; + #𲔚; + #𲔛; + #𲔜; + #𲔝; + #𲔞; + #𲔟; + #𲔠; + #𲔡; + #𲔢; + #𲔣; + #𲔤; + #𲔥; + #𲔦; + #𲔧; + #𲔨; + #𲔩; + #𲔪; + #𲔫; + #𲔬; + #𲔭; + #𲔮; + #𲔯; + #𲔰; + #𲔱; + #𲔲; + #𲔳; + #𲔴; + #𲔵; + #𲔶; + #𲔷; + #𲔸; + #𲔹; + #𲔺; + #𲔻; + #𲔼; + #𲔽; + #𲔾; + #𲔿; + #𲕀; + #𲕁; + #𲕂; + #𲕃; + #𲕄; + #𲕅; + #𲕆; + #𲕇; + #𲕈; + #𲕉; + #𲕊; + #𲕋; + #𲕌; + #𲕍; + #𲕎; + #𲕏; + #𲕐; + #𲕑; + #𲕒; + #𲕓; + #𲕔; + #𲕕; + #𲕖; + #𲕗; + #𲕘; + #𲕙; + #𲕚; + #𲕛; + #𲕜; + #𲕝; + #𲕞; + #𲕟; + #𲕠; + #𲕡; + #𲕢; + #𲕣; + #𲕤; + #𲕥; + #𲕦; + #𲕧; + #𲕨; + #𲕩; + #𲕪; + #𲕫; + #𲕬; + #𲕭; + #𲕮; + #𲕯; + #𲕰; + #𲕱; + #𲕲; + #𲕳; + #𲕴; + #𲕵; + #𲕶; + #𲕷; + #𲕸; + #𲕹; + #𲕺; + #𲕻; + #𲕼; + #𲕽; + #𲕾; + #𲕿; + #𲖀; + #𲖁; + #𲖂; + #𲖃; + #𲖄; + #𲖅; + #𲖆; + #𲖇; + #𲖈; + #𲖉; + #𲖊; + #𲖋; + #𲖌; + #𲖍; + #𲖎; + #𲖏; + #𲖐; + #𲖑; + #𲖒; + #𲖓; + #𲖔; + #𲖕; + #𲖖; + #𲖗; + #𲖘; + #𲖙; + #𲖚; + #𲖛; + #𲖜; + #𲖝; + #𲖞; + #𲖟; + #𲖠; + #𲖡; + #𲖢; + #𲖣; + #𲖤; + #𲖥; + #𲖦; + #𲖧; + #𲖨; + #𲖩; + #𲖪; + #𲖫; + #𲖬; + #𲖭; + #𲖮; + #𲖯; + #𲖰; + #𲖱; + #𲖲; + #𲖳; + #𲖴; + #𲖵; + #𲖶; + #𲖷; + #𲖸; + #𲖹; + #𲖺; + #𲖻; + #𲖼; + #𲖽; + #𲖾; + #𲖿; + #𲗀; + #𲗁; + #𲗂; + #𲗃; + #𲗄; + #𲗅; + #𲗆; + #𲗇; + #𲗈; + #𲗉; + #𲗊; + #𲗋; + #𲗌; + #𲗍; + #𲗎; + #𲗏; + #𲗐; + #𲗑; + #𲗒; + #𲗓; + #𲗔; + #𲗕; + #𲗖; + #𲗗; + #𲗘; + #𲗙; + #𲗚; + #𲗛; + #𲗜; + #𲗝; + #𲗞; + #𲗟; + #𲗠; + #𲗡; + #𲗢; + #𲗣; + #𲗤; + #𲗥; + #𲗦; + #𲗧; + #𲗨; + #𲗩; + #𲗪; + #𲗫; + #𲗬; + #𲗭; + #𲗮; + #𲗯; + #𲗰; + #𲗱; + #𲗲; + #𲗳; + #𲗴; + #𲗵; + #𲗶; + #𲗷; + #𲗸; + #𲗹; + #𲗺; + #𲗻; + #𲗼; + #𲗽; + #𲗾; + #𲗿; + #𲘀; + #𲘁; + #𲘂; + #𲘃; + #𲘄; + #𲘅; + #𲘆; + #𲘇; + #𲘈; + #𲘉; + #𲘊; + #𲘋; + #𲘌; + #𲘍; + #𲘎; + #𲘏; + #𲘐; + #𲘑; + #𲘒; + #𲘓; + #𲘔; + #𲘕; + #𲘖; + #𲘗; + #𲘘; + #𲘙; + #𲘚; + #𲘛; + #𲘜; + #𲘝; + #𲘞; + #𲘟; + #𲘠; + #𲘡; + #𲘢; + #𲘣; + #𲘤; + #𲘥; + #𲘦; + #𲘧; + #𲘨; + #𲘩; + #𲘪; + #𲘫; + #𲘬; + #𲘭; + #𲘮; + #𲘯; + #𲘰; + #𲘱; + #𲘲; + #𲘳; + #𲘴; + #𲘵; + #𲘶; + #𲘷; + #𲘸; + #𲘹; + #𲘺; + #𲘻; + #𲘼; + #𲘽; + #𲘾; + #𲘿; + #𲙀; + #𲙁; + #𲙂; + #𲙃; + #𲙄; + #𲙅; + #𲙆; + #𲙇; + #𲙈; + #𲙉; + #𲙊; + #𲙋; + #𲙌; + #𲙍; + #𲙎; + #𲙏; + #𲙐; + #𲙑; + #𲙒; + #𲙓; + #𲙔; + #𲙕; + #𲙖; + #𲙗; + #𲙘; + #𲙙; + #𲙚; + #𲙛; + #𲙜; + #𲙝; + #𲙞; + #𲙟; + #𲙠; + #𲙡; + #𲙢; + #𲙣; + #𲙤; + #𲙥; + #𲙦; + #𲙧; + #𲙨; + #𲙩; + #𲙪; + #𲙫; + #𲙬; + #𲙭; + #𲙮; + #𲙯; + #𲙰; + #𲙱; + #𲙲; + #𲙳; + #𲙴; + #𲙵; + #𲙶; + #𲙷; + #𲙸; + #𲙹; + #𲙺; + #𲙻; + #𲙼; + #𲙽; + #𲙾; + #𲙿; + #𲚀; + #𲚁; + #𲚂; + #𲚃; + #𲚄; + #𲚅; + #𲚆; + #𲚇; + #𲚈; + #𲚉; + #𲚊; + #𲚋; + #𲚌; + #𲚍; + #𲚎; + #𲚏; + #𲚐; + #𲚑; + #𲚒; + #𲚓; + #𲚔; + #𲚕; + #𲚖; + #𲚗; + #𲚘; + #𲚙; + #𲚚; + #𲚛; + #𲚜; + #𲚝; + #𲚞; + #𲚟; + #𲚠; + #𲚡; + #𲚢; + #𲚣; + #𲚤; + #𲚥; + #𲚦; + #𲚧; + #𲚨; + #𲚩; + #𲚪; + #𲚫; + #𲚬; + #𲚭; + #𲚮; + #𲚯; + #𲚰; + #𲚱; + #𲚲; + #𲚳; + #𲚴; + #𲚵; + #𲚶; + #𲚷; + #𲚸; + #𲚹; + #𲚺; + #𲚻; + #𲚼; + #𲚽; + #𲚾; + #𲚿; + #𲛀; + #𲛁; + #𲛂; + #𲛃; + #𲛄; + #𲛅; + #𲛆; + #𲛇; + #𲛈; + #𲛉; + #𲛊; + #𲛋; + #𲛌; + #𲛍; + #𲛎; + #𲛏; + #𲛐; + #𲛑; + #𲛒; + #𲛓; + #𲛔; + #𲛕; + #𲛖; + #𲛗; + #𲛘; + #𲛙; + #𲛚; + #𲛛; + #𲛜; + #𲛝; + #𲛞; + #𲛟; + #𲛠; + #𲛡; + #𲛢; + #𲛣; + #𲛤; + #𲛥; + #𲛦; + #𲛧; + #𲛨; + #𲛩; + #𲛪; + #𲛫; + #𲛬; + #𲛭; + #𲛮; + #𲛯; + #𲛰; + #𲛱; + #𲛲; + #𲛳; + #𲛴; + #𲛵; + #𲛶; + #𲛷; + #𲛸; + #𲛹; + #𲛺; + #𲛻; + #𲛼; + #𲛽; + #𲛾; + #𲛿; + #𲜀; + #𲜁; + #𲜂; + #𲜃; + #𲜄; + #𲜅; + #𲜆; + #𲜇; + #𲜈; + #𲜉; + #𲜊; + #𲜋; + #𲜌; + #𲜍; + #𲜎; + #𲜏; + #𲜐; + #𲜑; + #𲜒; + #𲜓; + #𲜔; + #𲜕; + #𲜖; + #𲜗; + #𲜘; + #𲜙; + #𲜚; + #𲜛; + #𲜜; + #𲜝; + #𲜞; + #𲜟; + #𲜠; + #𲜡; + #𲜢; + #𲜣; + #𲜤; + #𲜥; + #𲜦; + #𲜧; + #𲜨; + #𲜩; + #𲜪; + #𲜫; + #𲜬; + #𲜭; + #𲜮; + #𲜯; + #𲜰; + #𲜱; + #𲜲; + #𲜳; + #𲜴; + #𲜵; + #𲜶; + #𲜷; + #𲜸; + #𲜹; + #𲜺; + #𲜻; + #𲜼; + #𲜽; + #𲜾; + #𲜿; + #𲝀; + #𲝁; + #𲝂; + #𲝃; + #𲝄; + #𲝅; + #𲝆; + #𲝇; + #𲝈; + #𲝉; + #𲝊; + #𲝋; + #𲝌; + #𲝍; + #𲝎; + #𲝏; + #𲝐; + #𲝑; + #𲝒; + #𲝓; + #𲝔; + #𲝕; + #𲝖; + #𲝗; + #𲝘; + #𲝙; + #𲝚; + #𲝛; + #𲝜; + #𲝝; + #𲝞; + #𲝟; + #𲝠; + #𲝡; + #𲝢; + #𲝣; + #𲝤; + #𲝥; + #𲝦; + #𲝧; + #𲝨; + #𲝩; + #𲝪; + #𲝫; + #𲝬; + #𲝭; + #𲝮; + #𲝯; + #𲝰; + #𲝱; + #𲝲; + #𲝳; + #𲝴; + #𲝵; + #𲝶; + #𲝷; + #𲝸; + #𲝹; + #𲝺; + #𲝻; + #𲝼; + #𲝽; + #𲝾; + #𲝿; + #𲞀; + #𲞁; + #𲞂; + #𲞃; + #𲞄; + #𲞅; + #𲞆; + #𲞇; + #𲞈; + #𲞉; + #𲞊; + #𲞋; + #𲞌; + #𲞍; + #𲞎; + #𲞏; + #𲞐; + #𲞑; + #𲞒; + #𲞓; + #𲞔; + #𲞕; + #𲞖; + #𲞗; + #𲞘; + #𲞙; + #𲞚; + #𲞛; + #𲞜; + #𲞝; + #𲞞; + #𲞟; + #𲞠; + #𲞡; + #𲞢; + #𲞣; + #𲞤; + #𲞥; + #𲞦; + #𲞧; + #𲞨; + #𲞩; + #𲞪; + #𲞫; + #𲞬; + #𲞭; + #𲞮; + #𲞯; + #𲞰; + #𲞱; + #𲞲; + #𲞳; + #𲞴; + #𲞵; + #𲞶; + #𲞷; + #𲞸; + #𲞹; + #𲞺; + #𲞻; + #𲞼; + #𲞽; + #𲞾; + #𲞿; + #𲟀; + #𲟁; + #𲟂; + #𲟃; + #𲟄; + #𲟅; + #𲟆; + #𲟇; + #𲟈; + #𲟉; + #𲟊; + #𲟋; + #𲟌; + #𲟍; + #𲟎; + #𲟏; + #𲟐; + #𲟑; + #𲟒; + #𲟓; + #𲟔; + #𲟕; + #𲟖; + #𲟗; + #𲟘; + #𲟙; + #𲟚; + #𲟛; + #𲟜; + #𲟝; + #𲟞; + #𲟟; + #𲟠; + #𲟡; + #𲟢; + #𲟣; + #𲟤; + #𲟥; + #𲟦; + #𲟧; + #𲟨; + #𲟩; + #𲟪; + #𲟫; + #𲟬; + #𲟭; + #𲟮; + #𲟯; + #𲟰; + #𲟱; + #𲟲; + #𲟳; + #𲟴; + #𲟵; + #𲟶; + #𲟷; + #𲟸; + #𲟹; + #𲟺; + #𲟻; + #𲟼; + #𲟽; + #𲟾; + #𲟿; + #𲠀; + #𲠁; + #𲠂; + #𲠃; + #𲠄; + #𲠅; + #𲠆; + #𲠇; + #𲠈; + #𲠉; + #𲠊; + #𲠋; + #𲠌; + #𲠍; + #𲠎; + #𲠏; + #𲠐; + #𲠑; + #𲠒; + #𲠓; + #𲠔; + #𲠕; + #𲠖; + #𲠗; + #𲠘; + #𲠙; + #𲠚; + #𲠛; + #𲠜; + #𲠝; + #𲠞; + #𲠟; + #𲠠; + #𲠡; + #𲠢; + #𲠣; + #𲠤; + #𲠥; + #𲠦; + #𲠧; + #𲠨; + #𲠩; + #𲠪; + #𲠫; + #𲠬; + #𲠭; + #𲠮; + #𲠯; + #𲠰; + #𲠱; + #𲠲; + #𲠳; + #𲠴; + #𲠵; + #𲠶; + #𲠷; + #𲠸; + #𲠹; + #𲠺; + #𲠻; + #𲠼; + #𲠽; + #𲠾; + #𲠿; + #𲡀; + #𲡁; + #𲡂; + #𲡃; + #𲡄; + #𲡅; + #𲡆; + #𲡇; + #𲡈; + #𲡉; + #𲡊; + #𲡋; + #𲡌; + #𲡍; + #𲡎; + #𲡏; + #𲡐; + #𲡑; + #𲡒; + #𲡓; + #𲡔; + #𲡕; + #𲡖; + #𲡗; + #𲡘; + #𲡙; + #𲡚; + #𲡛; + #𲡜; + #𲡝; + #𲡞; + #𲡟; + #𲡠; + #𲡡; + #𲡢; + #𲡣; + #𲡤; + #𲡥; + #𲡦; + #𲡧; + #𲡨; + #𲡩; + #𲡪; + #𲡫; + #𲡬; + #𲡭; + #𲡮; + #𲡯; + #𲡰; + #𲡱; + #𲡲; + #𲡳; + #𲡴; + #𲡵; + #𲡶; + #𲡷; + #𲡸; + #𲡹; + #𲡺; + #𲡻; + #𲡼; + #𲡽; + #𲡾; + #𲡿; + #𲢀; + #𲢁; + #𲢂; + #𲢃; + #𲢄; + #𲢅; + #𲢆; + #𲢇; + #𲢈; + #𲢉; + #𲢊; + #𲢋; + #𲢌; + #𲢍; + #𲢎; + #𲢏; + #𲢐; + #𲢑; + #𲢒; + #𲢓; + #𲢔; + #𲢕; + #𲢖; + #𲢗; + #𲢘; + #𲢙; + #𲢚; + #𲢛; + #𲢜; + #𲢝; + #𲢞; + #𲢟; + #𲢠; + #𲢡; + #𲢢; + #𲢣; + #𲢤; + #𲢥; + #𲢦; + #𲢧; + #𲢨; + #𲢩; + #𲢪; + #𲢫; + #𲢬; + #𲢭; + #𲢮; + #𲢯; + #𲢰; + #𲢱; + #𲢲; + #𲢳; + #𲢴; + #𲢵; + #𲢶; + #𲢷; + #𲢸; + #𲢹; + #𲢺; + #𲢻; + #𲢼; + #𲢽; + #𲢾; + #𲢿; + #𲣀; + #𲣁; + #𲣂; + #𲣃; + #𲣄; + #𲣅; + #𲣆; + #𲣇; + #𲣈; + #𲣉; + #𲣊; + #𲣋; + #𲣌; + #𲣍; + #𲣎; + #𲣏; + #𲣐; + #𲣑; + #𲣒; + #𲣓; + #𲣔; + #𲣕; + #𲣖; + #𲣗; + #𲣘; + #𲣙; + #𲣚; + #𲣛; + #𲣜; + #𲣝; + #𲣞; + #𲣟; + #𲣠; + #𲣡; + #𲣢; + #𲣣; + #𲣤; + #𲣥; + #𲣦; + #𲣧; + #𲣨; + #𲣩; + #𲣪; + #𲣫; + #𲣬; + #𲣭; + #𲣮; + #𲣯; + #𲣰; + #𲣱; + #𲣲; + #𲣳; + #𲣴; + #𲣵; + #𲣶; + #𲣷; + #𲣸; + #𲣹; + #𲣺; + #𲣻; + #𲣼; + #𲣽; + #𲣾; + #𲣿; + #𲤀; + #𲤁; + #𲤂; + #𲤃; + #𲤄; + #𲤅; + #𲤆; + #𲤇; + #𲤈; + #𲤉; + #𲤊; + #𲤋; + #𲤌; + #𲤍; + #𲤎; + #𲤏; + #𲤐; + #𲤑; + #𲤒; + #𲤓; + #𲤔; + #𲤕; + #𲤖; + #𲤗; + #𲤘; + #𲤙; + #𲤚; + #𲤛; + #𲤜; + #𲤝; + #𲤞; + #𲤟; + #𲤠; + #𲤡; + #𲤢; + #𲤣; + #𲤤; + #𲤥; + #𲤦; + #𲤧; + #𲤨; + #𲤩; + #𲤪; + #𲤫; + #𲤬; + #𲤭; + #𲤮; + #𲤯; + #𲤰; + #𲤱; + #𲤲; + #𲤳; + #𲤴; + #𲤵; + #𲤶; + #𲤷; + #𲤸; + #𲤹; + #𲤺; + #𲤻; + #𲤼; + #𲤽; + #𲤾; + #𲤿; + #𲥀; + #𲥁; + #𲥂; + #𲥃; + #𲥄; + #𲥅; + #𲥆; + #𲥇; + #𲥈; + #𲥉; + #𲥊; + #𲥋; + #𲥌; + #𲥍; + #𲥎; + #𲥏; + #𲥐; + #𲥑; + #𲥒; + #𲥓; + #𲥔; + #𲥕; + #𲥖; + #𲥗; + #𲥘; + #𲥙; + #𲥚; + #𲥛; + #𲥜; + #𲥝; + #𲥞; + #𲥟; + #𲥠; + #𲥡; + #𲥢; + #𲥣; + #𲥤; + #𲥥; + #𲥦; + #𲥧; + #𲥨; + #𲥩; + #𲥪; + #𲥫; + #𲥬; + #𲥭; + #𲥮; + #𲥯; + #𲥰; + #𲥱; + #𲥲; + #𲥳; + #𲥴; + #𲥵; + #𲥶; + #𲥷; + #𲥸; + #𲥹; + #𲥺; + #𲥻; + #𲥼; + #𲥽; + #𲥾; + #𲥿; + #𲦀; + #𲦁; + #𲦂; + #𲦃; + #𲦄; + #𲦅; + #𲦆; + #𲦇; + #𲦈; + #𲦉; + #𲦊; + #𲦋; + #𲦌; + #𲦍; + #𲦎; + #𲦏; + #𲦐; + #𲦑; + #𲦒; + #𲦓; + #𲦔; + #𲦕; + #𲦖; + #𲦗; + #𲦘; + #𲦙; + #𲦚; + #𲦛; + #𲦜; + #𲦝; + #𲦞; + #𲦟; + #𲦠; + #𲦡; + #𲦢; + #𲦣; + #𲦤; + #𲦥; + #𲦦; + #𲦧; + #𲦨; + #𲦩; + #𲦪; + #𲦫; + #𲦬; + #𲦭; + #𲦮; + #𲦯; + #𲦰; + #𲦱; + #𲦲; + #𲦳; + #𲦴; + #𲦵; + #𲦶; + #𲦷; + #𲦸; + #𲦹; + #𲦺; + #𲦻; + #𲦼; + #𲦽; + #𲦾; + #𲦿; + #𲧀; + #𲧁; + #𲧂; + #𲧃; + #𲧄; + #𲧅; + #𲧆; + #𲧇; + #𲧈; + #𲧉; + #𲧊; + #𲧋; + #𲧌; + #𲧍; + #𲧎; + #𲧏; + #𲧐; + #𲧑; + #𲧒; + #𲧓; + #𲧔; + #𲧕; + #𲧖; + #𲧗; + #𲧘; + #𲧙; + #𲧚; + #𲧛; + #𲧜; + #𲧝; + #𲧞; + #𲧟; + #𲧠; + #𲧡; + #𲧢; + #𲧣; + #𲧤; + #𲧥; + #𲧦; + #𲧧; + #𲧨; + #𲧩; + #𲧪; + #𲧫; + #𲧬; + #𲧭; + #𲧮; + #𲧯; + #𲧰; + #𲧱; + #𲧲; + #𲧳; + #𲧴; + #𲧵; + #𲧶; + #𲧷; + #𲧸; + #𲧹; + #𲧺; + #𲧻; + #𲧼; + #𲧽; + #𲧾; + #𲧿; + #𲨀; + #𲨁; + #𲨂; + #𲨃; + #𲨄; + #𲨅; + #𲨆; + #𲨇; + #𲨈; + #𲨉; + #𲨊; + #𲨋; + #𲨌; + #𲨍; + #𲨎; + #𲨏; + #𲨐; + #𲨑; + #𲨒; + #𲨓; + #𲨔; + #𲨕; + #𲨖; + #𲨗; + #𲨘; + #𲨙; + #𲨚; + #𲨛; + #𲨜; + #𲨝; + #𲨞; + #𲨟; + #𲨠; + #𲨡; + #𲨢; + #𲨣; + #𲨤; + #𲨥; + #𲨦; + #𲨧; + #𲨨; + #𲨩; + #𲨪; + #𲨫; + #𲨬; + #𲨭; + #𲨮; + #𲨯; + #𲨰; + #𲨱; + #𲨲; + #𲨳; + #𲨴; + #𲨵; + #𲨶; + #𲨷; + #𲨸; + #𲨹; + #𲨺; + #𲨻; + #𲨼; + #𲨽; + #𲨾; + #𲨿; + #𲩀; + #𲩁; + #𲩂; + #𲩃; + #𲩄; + #𲩅; + #𲩆; + #𲩇; + #𲩈; + #𲩉; + #𲩊; + #𲩋; + #𲩌; + #𲩍; + #𲩎; + #𲩏; + #𲩐; + #𲩑; + #𲩒; + #𲩓; + #𲩔; + #𲩕; + #𲩖; + #𲩗; + #𲩘; + #𲩙; + #𲩚; + #𲩛; + #𲩜; + #𲩝; + #𲩞; + #𲩟; + #𲩠; + #𲩡; + #𲩢; + #𲩣; + #𲩤; + #𲩥; + #𲩦; + #𲩧; + #𲩨; + #𲩩; + #𲩪; + #𲩫; + #𲩬; + #𲩭; + #𲩮; + #𲩯; + #𲩰; + #𲩱; + #𲩲; + #𲩳; + #𲩴; + #𲩵; + #𲩶; + #𲩷; + #𲩸; + #𲩹; + #𲩺; + #𲩻; + #𲩼; + #𲩽; + #𲩾; + #𲩿; + #𲪀; + #𲪁; + #𲪂; + #𲪃; + #𲪄; + #𲪅; + #𲪆; + #𲪇; + #𲪈; + #𲪉; + #𲪊; + #𲪋; + #𲪌; + #𲪍; + #𲪎; + #𲪏; + #𲪐; + #𲪑; + #𲪒; + #𲪓; + #𲪔; + #𲪕; + #𲪖; + #𲪗; + #𲪘; + #𲪙; + #𲪚; + #𲪛; + #𲪜; + #𲪝; + #𲪞; + #𲪟; + #𲪠; + #𲪡; + #𲪢; + #𲪣; + #𲪤; + #𲪥; + #𲪦; + #𲪧; + #𲪨; + #𲪩; + #𲪪; + #𲪫; + #𲪬; + #𲪭; + #𲪮; + #𲪯; + #𲪰; + #𲪱; + #𲪲; + #𲪳; + #𲪴; + #𲪵; + #𲪶; + #𲪷; + #𲪸; + #𲪹; + #𲪺; + #𲪻; + #𲪼; + #𲪽; + #𲪾; + #𲪿; + #𲫀; + #𲫁; + #𲫂; + #𲫃; + #𲫄; + #𲫅; + #𲫆; + #𲫇; + #𲫈; + #𲫉; + #𲫊; + #𲫋; + #𲫌; + #𲫍; + #𲫎; + #𲫏; + #𲫐; + #𲫑; + #𲫒; + #𲫓; + #𲫔; + #𲫕; + #𲫖; + #𲫗; + #𲫘; + #𲫙; + #𲫚; + #𲫛; + #𲫜; + #𲫝; + #𲫞; + #𲫟; + #𲫠; + #𲫡; + #𲫢; + #𲫣; + #𲫤; + #𲫥; + #𲫦; + #𲫧; + #𲫨; + #𲫩; + #𲫪; + #𲫫; + #𲫬; + #𲫭; + #𲫮; + #𲫯; + #𲫰; + #𲫱; + #𲫲; + #𲫳; + #𲫴; + #𲫵; + #𲫶; + #𲫷; + #𲫸; + #𲫹; + #𲫺; + #𲫻; + #𲫼; + #𲫽; + #𲫾; + #𲫿; + #𲬀; + #𲬁; + #𲬂; + #𲬃; + #𲬄; + #𲬅; + #𲬆; + #𲬇; + #𲬈; + #𲬉; + #𲬊; + #𲬋; + #𲬌; + #𲬍; + #𲬎; + #𲬏; + #𲬐; + #𲬑; + #𲬒; + #𲬓; + #𲬔; + #𲬕; + #𲬖; + #𲬗; + #𲬘; + #𲬙; + #𲬚; + #𲬛; + #𲬜; + #𲬝; + #𲬞; + #𲬟; + #𲬠; + #𲬡; + #𲬢; + #𲬣; + #𲬤; + #𲬥; + #𲬦; + #𲬧; + #𲬨; + #𲬩; + #𲬪; + #𲬫; + #𲬬; + #𲬭; + #𲬮; + #𲬯; + #𲬰; + #𲬱; + #𲬲; + #𲬳; + #𲬴; + #𲬵; + #𲬶; + #𲬷; + #𲬸; + #𲬹; + #𲬺; + #𲬻; + #𲬼; + #𲬽; + #𲬾; + #𲬿; + #𲭀; + #𲭁; + #𲭂; + #𲭃; + #𲭄; + #𲭅; + #𲭆; + #𲭇; + #𲭈; + #𲭉; + #𲭊; + #𲭋; + #𲭌; + #𲭍; + #𲭎; + #𲭏; + #𲭐; + #𲭑; + #𲭒; + #𲭓; + #𲭔; + #𲭕; + #𲭖; + #𲭗; + #𲭘; + #𲭙; + #𲭚; + #𲭛; + #𲭜; + #𲭝; + #𲭞; + #𲭟; + #𲭠; + #𲭡; + #𲭢; + #𲭣; + #𲭤; + #𲭥; + #𲭦; + #𲭧; + #𲭨; + #𲭩; + #𲭪; + #𲭫; + #𲭬; + #𲭭; + #𲭮; + #𲭯; + #𲭰; + #𲭱; + #𲭲; + #𲭳; + #𲭴; + #𲭵; + #𲭶; + #𲭷; + #𲭸; + #𲭹; + #𲭺; + #𲭻; + #𲭼; + #𲭽; + #𲭾; + #𲭿; + #𲮀; + #𲮁; + #𲮂; + #𲮃; + #𲮄; + #𲮅; + #𲮆; + #𲮇; + #𲮈; + #𲮉; + #𲮊; + #𲮋; + #𲮌; + #𲮍; + #𲮎; + #𲮏; + #𲮐; + #𲮑; + #𲮒; + #𲮓; + #𲮔; + #𲮕; + #𲮖; + #𲮗; + #𲮘; + #𲮙; + #𲮚; + #𲮛; + #𲮜; + #𲮝; + #𲮞; + #𲮟; + #𲮠; + #𲮡; + #𲮢; + #𲮣; + #𲮤; + #𲮥; + #𲮦; + #𲮧; + #𲮨; + #𲮩; + #𲮪; + #𲮫; + #𲮬; + #𲮭; + #𲮮; + #𲮯; + #𲮰; + #𲮱; + #𲮲; + #𲮳; + #𲮴; + #𲮵; + #𲮶; + #𲮷; + #𲮸; + #𲮹; + #𲮺; + #𲮻; + #𲮼; + #𲮽; + #𲮾; + #𲮿; + #𲯀; + #𲯁; + #𲯂; + #𲯃; + #𲯄; + #𲯅; + #𲯆; + #𲯇; + #𲯈; + #𲯉; + #𲯊; + #𲯋; + #𲯌; + #𲯍; + #𲯎; + #𲯏; + #𲯐; + #𲯑; + #𲯒; + #𲯓; + #𲯔; + #𲯕; + #𲯖; + #𲯗; + #𲯘; + #𲯙; + #𲯚; + #𲯛; + #𲯜; + #𲯝; + #𲯞; + #𲯟; + #𲯠; + #𲯡; + #𲯢; + #𲯣; + #𲯤; + #𲯥; + #𲯦; + #𲯧; + #𲯨; + #𲯩; + #𲯪; + #𲯫; + #𲯬; + #𲯭; + #𲯮; + #𲯯; + #𲯰; + #𲯱; + #𲯲; + #𲯳; + #𲯴; + #𲯵; + #𲯶; + #𲯷; + #𲯸; + #𲯹; + #𲯺; + #𲯻; + #𲯼; + #𲯽; + #𲯾; + #𲯿; + #𲰀; + #𲰁; + #𲰂; + #𲰃; + #𲰄; + #𲰅; + #𲰆; + #𲰇; + #𲰈; + #𲰉; + #𲰊; + #𲰋; + #𲰌; + #𲰍; + #𲰎; + #𲰏; + #𲰐; + #𲰑; + #𲰒; + #𲰓; + #𲰔; + #𲰕; + #𲰖; + #𲰗; + #𲰘; + #𲰙; + #𲰚; + #𲰛; + #𲰜; + #𲰝; + #𲰞; + #𲰟; + #𲰠; + #𲰡; + #𲰢; + #𲰣; + #𲰤; + #𲰥; + #𲰦; + #𲰧; + #𲰨; + #𲰩; + #𲰪; + #𲰫; + #𲰬; + #𲰭; + #𲰮; + #𲰯; + #𲰰; + #𲰱; + #𲰲; + #𲰳; + #𲰴; + #𲰵; + #𲰶; + #𲰷; + #𲰸; + #𲰹; + #𲰺; + #𲰻; + #𲰼; + #𲰽; + #𲰾; + #𲰿; + #𲱀; + #𲱁; + #𲱂; + #𲱃; + #𲱄; + #𲱅; + #𲱆; + #𲱇; + #𲱈; + #𲱉; + #𲱊; + #𲱋; + #𲱌; + #𲱍; + #𲱎; + #𲱏; + #𲱐; + #𲱑; + #𲱒; + #𲱓; + #𲱔; + #𲱕; + #𲱖; + #𲱗; + #𲱘; + #𲱙; + #𲱚; + #𲱛; + #𲱜; + #𲱝; + #𲱞; + #𲱟; + #𲱠; + #𲱡; + #𲱢; + #𲱣; + #𲱤; + #𲱥; + #𲱦; + #𲱧; + #𲱨; + #𲱩; + #𲱪; + #𲱫; + #𲱬; + #𲱭; + #𲱮; + #𲱯; + #𲱰; + #𲱱; + #𲱲; + #𲱳; + #𲱴; + #𲱵; + #𲱶; + #𲱷; + #𲱸; + #𲱹; + #𲱺; + #𲱻; + #𲱼; + #𲱽; + #𲱾; + #𲱿; + #𲲀; + #𲲁; + #𲲂; + #𲲃; + #𲲄; + #𲲅; + #𲲆; + #𲲇; + #𲲈; + #𲲉; + #𲲊; + #𲲋; + #𲲌; + #𲲍; + #𲲎; + #𲲏; + #𲲐; + #𲲑; + #𲲒; + #𲲓; + #𲲔; + #𲲕; + #𲲖; + #𲲗; + #𲲘; + #𲲙; + #𲲚; + #𲲛; + #𲲜; + #𲲝; + #𲲞; + #𲲟; + #𲲠; + #𲲡; + #𲲢; + #𲲣; + #𲲤; + #𲲥; + #𲲦; + #𲲧; + #𲲨; + #𲲩; + #𲲪; + #𲲫; + #𲲬; + #𲲭; + #𲲮; + #𲲯; + #𲲰; + #𲲱; + #𲲲; + #𲲳; + #𲲴; + #𲲵; + #𲲶; + #𲲷; + #𲲸; + #𲲹; + #𲲺; + #𲲻; + #𲲼; + #𲲽; + #𲲾; + #𲲿; + #𲳀; + #𲳁; + #𲳂; + #𲳃; + #𲳄; + #𲳅; + #𲳆; + #𲳇; + #𲳈; + #𲳉; + #𲳊; + #𲳋; + #𲳌; + #𲳍; + #𲳎; + #𲳏; + #𲳐; + #𲳑; + #𲳒; + #𲳓; + #𲳔; + #𲳕; + #𲳖; + #𲳗; + #𲳘; + #𲳙; + #𲳚; + #𲳛; + #𲳜; + #𲳝; + #𲳞; + #𲳟; + #𲳠; + #𲳡; + #𲳢; + #𲳣; + #𲳤; + #𲳥; + #𲳦; + #𲳧; + #𲳨; + #𲳩; + #𲳪; + #𲳫; + #𲳬; + #𲳭; + #𲳮; + #𲳯; + #𲳰; + #𲳱; + #𲳲; + #𲳳; + #𲳴; + #𲳵; + #𲳶; + #𲳷; + #𲳸; + #𲳹; + #𲳺; + #𲳻; + #𲳼; + #𲳽; + #𲳾; + #𲳿; + #𲴀; + #𲴁; + #𲴂; + #𲴃; + #𲴄; + #𲴅; + #𲴆; + #𲴇; + #𲴈; + #𲴉; + #𲴊; + #𲴋; + #𲴌; + #𲴍; + #𲴎; + #𲴏; + #𲴐; + #𲴑; + #𲴒; + #𲴓; + #𲴔; + #𲴕; + #𲴖; + #𲴗; + #𲴘; + #𲴙; + #𲴚; + #𲴛; + #𲴜; + #𲴝; + #𲴞; + #𲴟; + #𲴠; + #𲴡; + #𲴢; + #𲴣; + #𲴤; + #𲴥; + #𲴦; + #𲴧; + #𲴨; + #𲴩; + #𲴪; + #𲴫; + #𲴬; + #𲴭; + #𲴮; + #𲴯; + #𲴰; + #𲴱; + #𲴲; + #𲴳; + #𲴴; + #𲴵; + #𲴶; + #𲴷; + #𲴸; + #𲴹; + #𲴺; + #𲴻; + #𲴼; + #𲴽; + #𲴾; + #𲴿; + #𲵀; + #𲵁; + #𲵂; + #𲵃; + #𲵄; + #𲵅; + #𲵆; + #𲵇; + #𲵈; + #𲵉; + #𲵊; + #𲵋; + #𲵌; + #𲵍; + #𲵎; + #𲵏; + #𲵐; + #𲵑; + #𲵒; + #𲵓; + #𲵔; + #𲵕; + #𲵖; + #𲵗; + #𲵘; + #𲵙; + #𲵚; + #𲵛; + #𲵜; + #𲵝; + #𲵞; + #𲵟; + #𲵠; + #𲵡; + #𲵢; + #𲵣; + #𲵤; + #𲵥; + #𲵦; + #𲵧; + #𲵨; + #𲵩; + #𲵪; + #𲵫; + #𲵬; + #𲵭; + #𲵮; + #𲵯; + #𲵰; + #𲵱; + #𲵲; + #𲵳; + #𲵴; + #𲵵; + #𲵶; + #𲵷; + #𲵸; + #𲵹; + #𲵺; + #𲵻; + #𲵼; + #𲵽; + #𲵾; + #𲵿; + #𲶀; + #𲶁; + #𲶂; + #𲶃; + #𲶄; + #𲶅; + #𲶆; + #𲶇; + #𲶈; + #𲶉; + #𲶊; + #𲶋; + #𲶌; + #𲶍; + #𲶎; + #𲶏; + #𲶐; + #𲶑; + #𲶒; + #𲶓; + #𲶔; + #𲶕; + #𲶖; + #𲶗; + #𲶘; + #𲶙; + #𲶚; + #𲶛; + #𲶜; + #𲶝; + #𲶞; + #𲶟; + #𲶠; + #𲶡; + #𲶢; + #𲶣; + #𲶤; + #𲶥; + #𲶦; + #𲶧; + #𲶨; + #𲶩; + #𲶪; + #𲶫; + #𲶬; + #𲶭; + #𲶮; + #𲶯; + #𲶰; + #𲶱; + #𲶲; + #𲶳; + #𲶴; + #𲶵; + #𲶶; + #𲶷; + #𲶸; + #𲶹; + #𲶺; + #𲶻; + #𲶼; + #𲶽; + #𲶾; + #𲶿; + #𲷀; + #𲷁; + #𲷂; + #𲷃; + #𲷄; + #𲷅; + #𲷆; + #𲷇; + #𲷈; + #𲷉; + #𲷊; + #𲷋; + #𲷌; + #𲷍; + #𲷎; + #𲷏; + #𲷐; + #𲷑; + #𲷒; + #𲷓; + #𲷔; + #𲷕; + #𲷖; + #𲷗; + #𲷘; + #𲷙; + #𲷚; + #𲷛; + #𲷜; + #𲷝; + #𲷞; + #𲷟; + #𲷠; + #𲷡; + #𲷢; + #𲷣; + #𲷤; + #𲷥; + #𲷦; + #𲷧; + #𲷨; + #𲷩; + #𲷪; + #𲷫; + #𲷬; + #𲷭; + #𲷮; + #𲷯; + #𲷰; + #𲷱; + #𲷲; + #𲷳; + #𲷴; + #𲷵; + #𲷶; + #𲷷; + #𲷸; + #𲷹; + #𲷺; + #𲷻; + #𲷼; + #𲷽; + #𲷾; + #𲷿; + #𲸀; + #𲸁; + #𲸂; + #𲸃; + #𲸄; + #𲸅; + #𲸆; + #𲸇; + #𲸈; + #𲸉; + #𲸊; + #𲸋; + #𲸌; + #𲸍; + #𲸎; + #𲸏; + #𲸐; + #𲸑; + #𲸒; + #𲸓; + #𲸔; + #𲸕; + #𲸖; + #𲸗; + #𲸘; + #𲸙; + #𲸚; + #𲸛; + #𲸜; + #𲸝; + #𲸞; + #𲸟; + #𲸠; + #𲸡; + #𲸢; + #𲸣; + #𲸤; + #𲸥; + #𲸦; + #𲸧; + #𲸨; + #𲸩; + #𲸪; + #𲸫; + #𲸬; + #𲸭; + #𲸮; + #𲸯; + #𲸰; + #𲸱; + #𲸲; + #𲸳; + #𲸴; + #𲸵; + #𲸶; + #𲸷; + #𲸸; + #𲸹; + #𲸺; + #𲸻; + #𲸼; + #𲸽; + #𲸾; + #𲸿; + #𲹀; + #𲹁; + #𲹂; + #𲹃; + #𲹄; + #𲹅; + #𲹆; + #𲹇; + #𲹈; + #𲹉; + #𲹊; + #𲹋; + #𲹌; + #𲹍; + #𲹎; + #𲹏; + #𲹐; + #𲹑; + #𲹒; + #𲹓; + #𲹔; + #𲹕; + #𲹖; + #𲹗; + #𲹘; + #𲹙; + #𲹚; + #𲹛; + #𲹜; + #𲹝; + #𲹞; + #𲹟; + #𲹠; + #𲹡; + #𲹢; + #𲹣; + #𲹤; + #𲹥; + #𲹦; + #𲹧; + #𲹨; + #𲹩; + #𲹪; + #𲹫; + #𲹬; + #𲹭; + #𲹮; + #𲹯; + #𲹰; + #𲹱; + #𲹲; + #𲹳; + #𲹴; + #𲹵; + #𲹶; + #𲹷; + #𲹸; + #𲹹; + #𲹺; + #𲹻; + #𲹼; + #𲹽; + #𲹾; + #𲹿; + #𲺀; + #𲺁; + #𲺂; + #𲺃; + #𲺄; + #𲺅; + #𲺆; + #𲺇; + #𲺈; + #𲺉; + #𲺊; + #𲺋; + #𲺌; + #𲺍; + #𲺎; + #𲺏; + #𲺐; + #𲺑; + #𲺒; + #𲺓; + #𲺔; + #𲺕; + #𲺖; + #𲺗; + #𲺘; + #𲺙; + #𲺚; + #𲺛; + #𲺜; + #𲺝; + #𲺞; + #𲺟; + #𲺠; + #𲺡; + #𲺢; + #𲺣; + #𲺤; + #𲺥; + #𲺦; + #𲺧; + #𲺨; + #𲺩; + #𲺪; + #𲺫; + #𲺬; + #𲺭; + #𲺮; + #𲺯; + #𲺰; + #𲺱; + #𲺲; + #𲺳; + #𲺴; + #𲺵; + #𲺶; + #𲺷; + #𲺸; + #𲺹; + #𲺺; + #𲺻; + #𲺼; + #𲺽; + #𲺾; + #𲺿; + #𲻀; + #𲻁; + #𲻂; + #𲻃; + #𲻄; + #𲻅; + #𲻆; + #𲻇; + #𲻈; + #𲻉; + #𲻊; + #𲻋; + #𲻌; + #𲻍; + #𲻎; + #𲻏; + #𲻐; + #𲻑; + #𲻒; + #𲻓; + #𲻔; + #𲻕; + #𲻖; + #𲻗; + #𲻘; + #𲻙; + #𲻚; + #𲻛; + #𲻜; + #𲻝; + #𲻞; + #𲻟; + #𲻠; + #𲻡; + #𲻢; + #𲻣; + #𲻤; + #𲻥; + #𲻦; + #𲻧; + #𲻨; + #𲻩; + #𲻪; + #𲻫; + #𲻬; + #𲻭; + #𲻮; + #𲻯; + #𲻰; + #𲻱; + #𲻲; + #𲻳; + #𲻴; + #𲻵; + #𲻶; + #𲻷; + #𲻸; + #𲻹; + #𲻺; + #𲻻; + #𲻼; + #𲻽; + #𲻾; + #𲻿; + #𲼀; + #𲼁; + #𲼂; + #𲼃; + #𲼄; + #𲼅; + #𲼆; + #𲼇; + #𲼈; + #𲼉; + #𲼊; + #𲼋; + #𲼌; + #𲼍; + #𲼎; + #𲼏; + #𲼐; + #𲼑; + #𲼒; + #𲼓; + #𲼔; + #𲼕; + #𲼖; + #𲼗; + #𲼘; + #𲼙; + #𲼚; + #𲼛; + #𲼜; + #𲼝; + #𲼞; + #𲼟; + #𲼠; + #𲼡; + #𲼢; + #𲼣; + #𲼤; + #𲼥; + #𲼦; + #𲼧; + #𲼨; + #𲼩; + #𲼪; + #𲼫; + #𲼬; + #𲼭; + #𲼮; + #𲼯; + #𲼰; + #𲼱; + #𲼲; + #𲼳; + #𲼴; + #𲼵; + #𲼶; + #𲼷; + #𲼸; + #𲼹; + #𲼺; + #𲼻; + #𲼼; + #𲼽; + #𲼾; + #𲼿; + #𲽀; + #𲽁; + #𲽂; + #𲽃; + #𲽄; + #𲽅; + #𲽆; + #𲽇; + #𲽈; + #𲽉; + #𲽊; + #𲽋; + #𲽌; + #𲽍; + #𲽎; + #𲽏; + #𲽐; + #𲽑; + #𲽒; + #𲽓; + #𲽔; + #𲽕; + #𲽖; + #𲽗; + #𲽘; + #𲽙; + #𲽚; + #𲽛; + #𲽜; + #𲽝; + #𲽞; + #𲽟; + #𲽠; + #𲽡; + #𲽢; + #𲽣; + #𲽤; + #𲽥; + #𲽦; + #𲽧; + #𲽨; + #𲽩; + #𲽪; + #𲽫; + #𲽬; + #𲽭; + #𲽮; + #𲽯; + #𲽰; + #𲽱; + #𲽲; + #𲽳; + #𲽴; + #𲽵; + #𲽶; + #𲽷; + #𲽸; + #𲽹; + #𲽺; + #𲽻; + #𲽼; + #𲽽; + #𲽾; + #𲽿; + #𲾀; + #𲾁; + #𲾂; + #𲾃; + #𲾄; + #𲾅; + #𲾆; + #𲾇; + #𲾈; + #𲾉; + #𲾊; + #𲾋; + #𲾌; + #𲾍; + #𲾎; + #𲾏; + #𲾐; + #𲾑; + #𲾒; + #𲾓; + #𲾔; + #𲾕; + #𲾖; + #𲾗; + #𲾘; + #𲾙; + #𲾚; + #𲾛; + #𲾜; + #𲾝; + #𲾞; + #𲾟; + #𲾠; + #𲾡; + #𲾢; + #𲾣; + #𲾤; + #𲾥; + #𲾦; + #𲾧; + #𲾨; + #𲾩; + #𲾪; + #𲾫; + #𲾬; + #𲾭; + #𲾮; + #𲾯; + #𲾰; + #𲾱; + #𲾲; + #𲾳; + #𲾴; + #𲾵; + #𲾶; + #𲾷; + #𲾸; + #𲾹; + #𲾺; + #𲾻; + #𲾼; + #𲾽; + #𲾾; + #𲾿; + #𲿀; + #𲿁; + #𲿂; + #𲿃; + #𲿄; + #𲿅; + #𲿆; + #𲿇; + #𲿈; + #𲿉; + #𲿊; + #𲿋; + #𲿌; + #𲿍; + #𲿎; + #𲿏; + #𲿐; + #𲿑; + #𲿒; + #𲿓; + #𲿔; + #𲿕; + #𲿖; + #𲿗; + #𲿘; + #𲿙; + #𲿚; + #𲿛; + #𲿜; + #𲿝; + #𲿞; + #𲿟; + #𲿠; + #𲿡; + #𲿢; + #𲿣; + #𲿤; + #𲿥; + #𲿦; + #𲿧; + #𲿨; + #𲿩; + #𲿪; + #𲿫; + #𲿬; + #𲿭; + #𲿮; + #𲿯; + #𲿰; + #𲿱; + #𲿲; + #𲿳; + #𲿴; + #𲿵; + #𲿶; + #𲿷; + #𲿸; + #𲿹; + #𲿺; + #𲿻; + #𲿼; + #𲿽; + #𲿾; + #𲿿; + #𳀀; + #𳀁; + #𳀂; + #𳀃; + #𳀄; + #𳀅; + #𳀆; + #𳀇; + #𳀈; + #𳀉; + #𳀊; + #𳀋; + #𳀌; + #𳀍; + #𳀎; + #𳀏; + #𳀐; + #𳀑; + #𳀒; + #𳀓; + #𳀔; + #𳀕; + #𳀖; + #𳀗; + #𳀘; + #𳀙; + #𳀚; + #𳀛; + #𳀜; + #𳀝; + #𳀞; + #𳀟; + #𳀠; + #𳀡; + #𳀢; + #𳀣; + #𳀤; + #𳀥; + #𳀦; + #𳀧; + #𳀨; + #𳀩; + #𳀪; + #𳀫; + #𳀬; + #𳀭; + #𳀮; + #𳀯; + #𳀰; + #𳀱; + #𳀲; + #𳀳; + #𳀴; + #𳀵; + #𳀶; + #𳀷; + #𳀸; + #𳀹; + #𳀺; + #𳀻; + #𳀼; + #𳀽; + #𳀾; + #𳀿; + #𳁀; + #𳁁; + #𳁂; + #𳁃; + #𳁄; + #𳁅; + #𳁆; + #𳁇; + #𳁈; + #𳁉; + #𳁊; + #𳁋; + #𳁌; + #𳁍; + #𳁎; + #𳁏; + #𳁐; + #𳁑; + #𳁒; + #𳁓; + #𳁔; + #𳁕; + #𳁖; + #𳁗; + #𳁘; + #𳁙; + #𳁚; + #𳁛; + #𳁜; + #𳁝; + #𳁞; + #𳁟; + #𳁠; + #𳁡; + #𳁢; + #𳁣; + #𳁤; + #𳁥; + #𳁦; + #𳁧; + #𳁨; + #𳁩; + #𳁪; + #𳁫; + #𳁬; + #𳁭; + #𳁮; + #𳁯; + #𳁰; + #𳁱; + #𳁲; + #𳁳; + #𳁴; + #𳁵; + #𳁶; + #𳁷; + #𳁸; + #𳁹; + #𳁺; + #𳁻; + #𳁼; + #𳁽; + #𳁾; + #𳁿; + #𳂀; + #𳂁; + #𳂂; + #𳂃; + #𳂄; + #𳂅; + #𳂆; + #𳂇; + #𳂈; + #𳂉; + #𳂊; + #𳂋; + #𳂌; + #𳂍; + #𳂎; + #𳂏; + #𳂐; + #𳂑; + #𳂒; + #𳂓; + #𳂔; + #𳂕; + #𳂖; + #𳂗; + #𳂘; + #𳂙; + #𳂚; + #𳂛; + #𳂜; + #𳂝; + #𳂞; + #𳂟; + #𳂠; + #𳂡; + #𳂢; + #𳂣; + #𳂤; + #𳂥; + #𳂦; + #𳂧; + #𳂨; + #𳂩; + #𳂪; + #𳂫; + #𳂬; + #𳂭; + #𳂮; + #𳂯; + #𳂰; + #𳂱; + #𳂲; + #𳂳; + #𳂴; + #𳂵; + #𳂶; + #𳂷; + #𳂸; + #𳂹; + #𳂺; + #𳂻; + #𳂼; + #𳂽; + #𳂾; + #𳂿; + #𳃀; + #𳃁; + #𳃂; + #𳃃; + #𳃄; + #𳃅; + #𳃆; + #𳃇; + #𳃈; + #𳃉; + #𳃊; + #𳃋; + #𳃌; + #𳃍; + #𳃎; + #𳃏; + #𳃐; + #𳃑; + #𳃒; + #𳃓; + #𳃔; + #𳃕; + #𳃖; + #𳃗; + #𳃘; + #𳃙; + #𳃚; + #𳃛; + #𳃜; + #𳃝; + #𳃞; + #𳃟; + #𳃠; + #𳃡; + #𳃢; + #𳃣; + #𳃤; + #𳃥; + #𳃦; + #𳃧; + #𳃨; + #𳃩; + #𳃪; + #𳃫; + #𳃬; + #𳃭; + #𳃮; + #𳃯; + #𳃰; + #𳃱; + #𳃲; + #𳃳; + #𳃴; + #𳃵; + #𳃶; + #𳃷; + #𳃸; + #𳃹; + #𳃺; + #𳃻; + #𳃼; + #𳃽; + #𳃾; + #𳃿; + #𳄀; + #𳄁; + #𳄂; + #𳄃; + #𳄄; + #𳄅; + #𳄆; + #𳄇; + #𳄈; + #𳄉; + #𳄊; + #𳄋; + #𳄌; + #𳄍; + #𳄎; + #𳄏; + #𳄐; + #𳄑; + #𳄒; + #𳄓; + #𳄔; + #𳄕; + #𳄖; + #𳄗; + #𳄘; + #𳄙; + #𳄚; + #𳄛; + #𳄜; + #𳄝; + #𳄞; + #𳄟; + #𳄠; + #𳄡; + #𳄢; + #𳄣; + #𳄤; + #𳄥; + #𳄦; + #𳄧; + #𳄨; + #𳄩; + #𳄪; + #𳄫; + #𳄬; + #𳄭; + #𳄮; + #𳄯; + #𳄰; + #𳄱; + #𳄲; + #𳄳; + #𳄴; + #𳄵; + #𳄶; + #𳄷; + #𳄸; + #𳄹; + #𳄺; + #𳄻; + #𳄼; + #𳄽; + #𳄾; + #𳄿; + #𳅀; + #𳅁; + #𳅂; + #𳅃; + #𳅄; + #𳅅; + #𳅆; + #𳅇; + #𳅈; + #𳅉; + #𳅊; + #𳅋; + #𳅌; + #𳅍; + #𳅎; + #𳅏; + #𳅐; + #𳅑; + #𳅒; + #𳅓; + #𳅔; + #𳅕; + #𳅖; + #𳅗; + #𳅘; + #𳅙; + #𳅚; + #𳅛; + #𳅜; + #𳅝; + #𳅞; + #𳅟; + #𳅠; + #𳅡; + #𳅢; + #𳅣; + #𳅤; + #𳅥; + #𳅦; + #𳅧; + #𳅨; + #𳅩; + #𳅪; + #𳅫; + #𳅬; + #𳅭; + #𳅮; + #𳅯; + #𳅰; + #𳅱; + #𳅲; + #𳅳; + #𳅴; + #𳅵; + #𳅶; + #𳅷; + #𳅸; + #𳅹; + #𳅺; + #𳅻; + #𳅼; + #𳅽; + #𳅾; + #𳅿; + #𳆀; + #𳆁; + #𳆂; + #𳆃; + #𳆄; + #𳆅; + #𳆆; + #𳆇; + #𳆈; + #𳆉; + #𳆊; + #𳆋; + #𳆌; + #𳆍; + #𳆎; + #𳆏; + #𳆐; + #𳆑; + #𳆒; + #𳆓; + #𳆔; + #𳆕; + #𳆖; + #𳆗; + #𳆘; + #𳆙; + #𳆚; + #𳆛; + #𳆜; + #𳆝; + #𳆞; + #𳆟; + #𳆠; + #𳆡; + #𳆢; + #𳆣; + #𳆤; + #𳆥; + #𳆦; + #𳆧; + #𳆨; + #𳆩; + #𳆪; + #𳆫; + #𳆬; + #𳆭; + #𳆮; + #𳆯; + #𳆰; + #𳆱; + #𳆲; + #𳆳; + #𳆴; + #𳆵; + #𳆶; + #𳆷; + #𳆸; + #𳆹; + #𳆺; + #𳆻; + #𳆼; + #𳆽; + #𳆾; + #𳆿; + #𳇀; + #𳇁; + #𳇂; + #𳇃; + #𳇄; + #𳇅; + #𳇆; + #𳇇; + #𳇈; + #𳇉; + #𳇊; + #𳇋; + #𳇌; + #𳇍; + #𳇎; + #𳇏; + #𳇐; + #𳇑; + #𳇒; + #𳇓; + #𳇔; + #𳇕; + #𳇖; + #𳇗; + #𳇘; + #𳇙; + #𳇚; + #𳇛; + #𳇜; + #𳇝; + #𳇞; + #𳇟; + #𳇠; + #𳇡; + #𳇢; + #𳇣; + #𳇤; + #𳇥; + #𳇦; + #𳇧; + #𳇨; + #𳇩; + #𳇪; + #𳇫; + #𳇬; + #𳇭; + #𳇮; + #𳇯; + #𳇰; + #𳇱; + #𳇲; + #𳇳; + #𳇴; + #𳇵; + #𳇶; + #𳇷; + #𳇸; + #𳇹; + #𳇺; + #𳇻; + #𳇼; + #𳇽; + #𳇾; + #𳇿; + #𳈀; + #𳈁; + #𳈂; + #𳈃; + #𳈄; + #𳈅; + #𳈆; + #𳈇; + #𳈈; + #𳈉; + #𳈊; + #𳈋; + #𳈌; + #𳈍; + #𳈎; + #𳈏; + #𳈐; + #𳈑; + #𳈒; + #𳈓; + #𳈔; + #𳈕; + #𳈖; + #𳈗; + #𳈘; + #𳈙; + #𳈚; + #𳈛; + #𳈜; + #𳈝; + #𳈞; + #𳈟; + #𳈠; + #𳈡; + #𳈢; + #𳈣; + #𳈤; + #𳈥; + #𳈦; + #𳈧; + #𳈨; + #𳈩; + #𳈪; + #𳈫; + #𳈬; + #𳈭; + #𳈮; + #𳈯; + #𳈰; + #𳈱; + #𳈲; + #𳈳; + #𳈴; + #𳈵; + #𳈶; + #𳈷; + #𳈸; + #𳈹; + #𳈺; + #𳈻; + #𳈼; + #𳈽; + #𳈾; + #𳈿; + #𳉀; + #𳉁; + #𳉂; + #𳉃; + #𳉄; + #𳉅; + #𳉆; + #𳉇; + #𳉈; + #𳉉; + #𳉊; + #𳉋; + #𳉌; + #𳉍; + #𳉎; + #𳉏; + #𳉐; + #𳉑; + #𳉒; + #𳉓; + #𳉔; + #𳉕; + #𳉖; + #𳉗; + #𳉘; + #𳉙; + #𳉚; + #𳉛; + #𳉜; + #𳉝; + #𳉞; + #𳉟; + #𳉠; + #𳉡; + #𳉢; + #𳉣; + #𳉤; + #𳉥; + #𳉦; + #𳉧; + #𳉨; + #𳉩; + #𳉪; + #𳉫; + #𳉬; + #𳉭; + #𳉮; + #𳉯; + #𳉰; + #𳉱; + #𳉲; + #𳉳; + #𳉴; + #𳉵; + #𳉶; + #𳉷; + #𳉸; + #𳉹; + #𳉺; + #𳉻; + #𳉼; + #𳉽; + #𳉾; + #𳉿; + #𳊀; + #𳊁; + #𳊂; + #𳊃; + #𳊄; + #𳊅; + #𳊆; + #𳊇; + #𳊈; + #𳊉; + #𳊊; + #𳊋; + #𳊌; + #𳊍; + #𳊎; + #𳊏; + #𳊐; + #𳊑; + #𳊒; + #𳊓; + #𳊔; + #𳊕; + #𳊖; + #𳊗; + #𳊘; + #𳊙; + #𳊚; + #𳊛; + #𳊜; + #𳊝; + #𳊞; + #𳊟; + #𳊠; + #𳊡; + #𳊢; + #𳊣; + #𳊤; + #𳊥; + #𳊦; + #𳊧; + #𳊨; + #𳊩; + #𳊪; + #𳊫; + #𳊬; + #𳊭; + #𳊮; + #𳊯; + #𳊰; + #𳊱; + #𳊲; + #𳊳; + #𳊴; + #𳊵; + #𳊶; + #𳊷; + #𳊸; + #𳊹; + #𳊺; + #𳊻; + #𳊼; + #𳊽; + #𳊾; + #𳊿; + #𳋀; + #𳋁; + #𳋂; + #𳋃; + #𳋄; + #𳋅; + #𳋆; + #𳋇; + #𳋈; + #𳋉; + #𳋊; + #𳋋; + #𳋌; + #𳋍; + #𳋎; + #𳋏; + #𳋐; + #𳋑; + #𳋒; + #𳋓; + #𳋔; + #𳋕; + #𳋖; + #𳋗; + #𳋘; + #𳋙; + #𳋚; + #𳋛; + #𳋜; + #𳋝; + #𳋞; + #𳋟; + #𳋠; + #𳋡; + #𳋢; + #𳋣; + #𳋤; + #𳋥; + #𳋦; + #𳋧; + #𳋨; + #𳋩; + #𳋪; + #𳋫; + #𳋬; + #𳋭; + #𳋮; + #𳋯; + #𳋰; + #𳋱; + #𳋲; + #𳋳; + #𳋴; + #𳋵; + #𳋶; + #𳋷; + #𳋸; + #𳋹; + #𳋺; + #𳋻; + #𳋼; + #𳋽; + #𳋾; + #𳋿; + #𳌀; + #𳌁; + #𳌂; + #𳌃; + #𳌄; + #𳌅; + #𳌆; + #𳌇; + #𳌈; + #𳌉; + #𳌊; + #𳌋; + #𳌌; + #𳌍; + #𳌎; + #𳌏; + #𳌐; + #𳌑; + #𳌒; + #𳌓; + #𳌔; + #𳌕; + #𳌖; + #𳌗; + #𳌘; + #𳌙; + #𳌚; + #𳌛; + #𳌜; + #𳌝; + #𳌞; + #𳌟; + #𳌠; + #𳌡; + #𳌢; + #𳌣; + #𳌤; + #𳌥; + #𳌦; + #𳌧; + #𳌨; + #𳌩; + #𳌪; + #𳌫; + #𳌬; + #𳌭; + #𳌮; + #𳌯; + #𳌰; + #𳌱; + #𳌲; + #𳌳; + #𳌴; + #𳌵; + #𳌶; + #𳌷; + #𳌸; + #𳌹; + #𳌺; + #𳌻; + #𳌼; + #𳌽; + #𳌾; + #𳌿; + #𳍀; + #𳍁; + #𳍂; + #𳍃; + #𳍄; + #𳍅; + #𳍆; + #𳍇; + #𳍈; + #𳍉; + #𳍊; + #𳍋; + #𳍌; + #𳍍; + #𳍎; + #𳍏; + #𳍐; + #𳍑; + #𳍒; + #𳍓; + #𳍔; + #𳍕; + #𳍖; + #𳍗; + #𳍘; + #𳍙; + #𳍚; + #𳍛; + #𳍜; + #𳍝; + #𳍞; + #𳍟; + #𳍠; + #𳍡; + #𳍢; + #𳍣; + #𳍤; + #𳍥; + #𳍦; + #𳍧; + #𳍨; + #𳍩; + #𳍪; + #𳍫; + #𳍬; + #𳍭; + #𳍮; + #𳍯; + #𳍰; + #𳍱; + #𳍲; + #𳍳; + #𳍴; + #𳍵; + #𳍶; + #𳍷; + #𳍸; + #𳍹; + #𳍺; + #𳍻; + #𳍼; + #𳍽; + #𳍾; + #𳍿; + #𳎀; + #𳎁; + #𳎂; + #𳎃; + #𳎄; + #𳎅; + #𳎆; + #𳎇; + #𳎈; + #𳎉; + #𳎊; + #𳎋; + #𳎌; + #𳎍; + #𳎎; + #𳎏; + #𳎐; + #𳎑; + #𳎒; + #𳎓; + #𳎔; + #𳎕; + #𳎖; + #𳎗; + #𳎘; + #𳎙; + #𳎚; + #𳎛; + #𳎜; + #𳎝; + #𳎞; + #𳎟; + #𳎠; + #𳎡; + #𳎢; + #𳎣; + #𳎤; + #𳎥; + #𳎦; + #𳎧; + #𳎨; + #𳎩; + #𳎪; + #𳎫; + #𳎬; + #𳎭; + #𳎮; + #𳎯; + #𳎰; + #𳎱; + #𳎲; + #𳎳; + #𳎴; + #𳎵; + #𳎶; + #𳎷; + #𳎸; + #𳎹; + #𳎺; + #𳎻; + #𳎼; + #𳎽; + #𳎾; + #𳎿; + #𳏀; + #𳏁; + #𳏂; + #𳏃; + #𳏄; + #𳏅; + #𳏆; + #𳏇; + #𳏈; + #𳏉; + #𳏊; + #𳏋; + #𳏌; + #𳏍; + #𳏎; + #𳏏; + #𳏐; + #𳏑; + #𳏒; + #𳏓; + #𳏔; + #𳏕; + #𳏖; + #𳏗; + #𳏘; + #𳏙; + #𳏚; + #𳏛; + #𳏜; + #𳏝; + #𳏞; + #𳏟; + #𳏠; + #𳏡; + #𳏢; + #𳏣; + #𳏤; + #𳏥; + #𳏦; + #𳏧; + #𳏨; + #𳏩; + #𳏪; + #𳏫; + #𳏬; + #𳏭; + #𳏮; + #𳏯; + #𳏰; + #𳏱; + #𳏲; + #𳏳; + #𳏴; + #𳏵; + #𳏶; + #𳏷; + #𳏸; + #𳏹; + #𳏺; + #𳏻; + #𳏼; + #𳏽; + #𳏾; + #𳏿; + #𳐀; + #𳐁; + #𳐂; + #𳐃; + #𳐄; + #𳐅; + #𳐆; + #𳐇; + #𳐈; + #𳐉; + #𳐊; + #𳐋; + #𳐌; + #𳐍; + #𳐎; + #𳐏; + #𳐐; + #𳐑; + #𳐒; + #𳐓; + #𳐔; + #𳐕; + #𳐖; + #𳐗; + #𳐘; + #𳐙; + #𳐚; + #𳐛; + #𳐜; + #𳐝; + #𳐞; + #𳐟; + #𳐠; + #𳐡; + #𳐢; + #𳐣; + #𳐤; + #𳐥; + #𳐦; + #𳐧; + #𳐨; + #𳐩; + #𳐪; + #𳐫; + #𳐬; + #𳐭; + #𳐮; + #𳐯; + #𳐰; + #𳐱; + #𳐲; + #𳐳; + #𳐴; + #𳐵; + #𳐶; + #𳐷; + #𳐸; + #𳐹; + #𳐺; + #𳐻; + #𳐼; + #𳐽; + #𳐾; + #𳐿; + #𳑀; + #𳑁; + #𳑂; + #𳑃; + #𳑄; + #𳑅; + #𳑆; + #𳑇; + #𳑈; + #𳑉; + #𳑊; + #𳑋; + #𳑌; + #𳑍; + #𳑎; + #𳑏; + #𳑐; + #𳑑; + #𳑒; + #𳑓; + #𳑔; + #𳑕; + #𳑖; + #𳑗; + #𳑘; + #𳑙; + #𳑚; + #𳑛; + #𳑜; + #𳑝; + #𳑞; + #𳑟; + #𳑠; + #𳑡; + #𳑢; + #𳑣; + #𳑤; + #𳑥; + #𳑦; + #𳑧; + #𳑨; + #𳑩; + #𳑪; + #𳑫; + #𳑬; + #𳑭; + #𳑮; + #𳑯; + #𳑰; + #𳑱; + #𳑲; + #𳑳; + #𳑴; + #𳑵; + #𳑶; + #𳑷; + #𳑸; + #𳑹; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0-escaped.js new file mode 100644 index 000000000..963fe031b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0-escaped.js @@ -0,0 +1,4662 @@ +// Copyright 2025 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v17.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u088F; +var \u0C5C; +var \u0CDC; +var \uA7CE; +var \uA7CF; +var \uA7D2; +var \uA7D4; +var \uA7F1; +var \u{10940}; +var \u{10941}; +var \u{10942}; +var \u{10943}; +var \u{10944}; +var \u{10945}; +var \u{10946}; +var \u{10947}; +var \u{10948}; +var \u{10949}; +var \u{1094A}; +var \u{1094B}; +var \u{1094C}; +var \u{1094D}; +var \u{1094E}; +var \u{1094F}; +var \u{10950}; +var \u{10951}; +var \u{10952}; +var \u{10953}; +var \u{10954}; +var \u{10955}; +var \u{10956}; +var \u{10957}; +var \u{10958}; +var \u{10959}; +var \u{10EC5}; +var \u{10EC6}; +var \u{10EC7}; +var \u{11DB0}; +var \u{11DB1}; +var \u{11DB2}; +var \u{11DB3}; +var \u{11DB4}; +var \u{11DB5}; +var \u{11DB6}; +var \u{11DB7}; +var \u{11DB8}; +var \u{11DB9}; +var \u{11DBA}; +var \u{11DBB}; +var \u{11DBC}; +var \u{11DBD}; +var \u{11DBE}; +var \u{11DBF}; +var \u{11DC0}; +var \u{11DC1}; +var \u{11DC2}; +var \u{11DC3}; +var \u{11DC4}; +var \u{11DC5}; +var \u{11DC6}; +var \u{11DC7}; +var \u{11DC8}; +var \u{11DC9}; +var \u{11DCA}; +var \u{11DCB}; +var \u{11DCC}; +var \u{11DCD}; +var \u{11DCE}; +var \u{11DCF}; +var \u{11DD0}; +var \u{11DD1}; +var \u{11DD2}; +var \u{11DD3}; +var \u{11DD4}; +var \u{11DD5}; +var \u{11DD6}; +var \u{11DD7}; +var \u{11DD8}; +var \u{11DD9}; +var \u{11DDA}; +var \u{11DDB}; +var \u{16EA0}; +var \u{16EA1}; +var \u{16EA2}; +var \u{16EA3}; +var \u{16EA4}; +var \u{16EA5}; +var \u{16EA6}; +var \u{16EA7}; +var \u{16EA8}; +var \u{16EA9}; +var \u{16EAA}; +var \u{16EAB}; +var \u{16EAC}; +var \u{16EAD}; +var \u{16EAE}; +var \u{16EAF}; +var \u{16EB0}; +var \u{16EB1}; +var \u{16EB2}; +var \u{16EB3}; +var \u{16EB4}; +var \u{16EB5}; +var \u{16EB6}; +var \u{16EB7}; +var \u{16EB8}; +var \u{16EBB}; +var \u{16EBC}; +var \u{16EBD}; +var \u{16EBE}; +var \u{16EBF}; +var \u{16EC0}; +var \u{16EC1}; +var \u{16EC2}; +var \u{16EC3}; +var \u{16EC4}; +var \u{16EC5}; +var \u{16EC6}; +var \u{16EC7}; +var \u{16EC8}; +var \u{16EC9}; +var \u{16ECA}; +var \u{16ECB}; +var \u{16ECC}; +var \u{16ECD}; +var \u{16ECE}; +var \u{16ECF}; +var \u{16ED0}; +var \u{16ED1}; +var \u{16ED2}; +var \u{16ED3}; +var \u{16FF2}; +var \u{16FF3}; +var \u{16FF4}; +var \u{16FF5}; +var \u{16FF6}; +var \u{187F8}; +var \u{187F9}; +var \u{187FA}; +var \u{187FB}; +var \u{187FC}; +var \u{187FD}; +var \u{187FE}; +var \u{187FF}; +var \u{18D09}; +var \u{18D0A}; +var \u{18D0B}; +var \u{18D0C}; +var \u{18D0D}; +var \u{18D0E}; +var \u{18D0F}; +var \u{18D10}; +var \u{18D11}; +var \u{18D12}; +var \u{18D13}; +var \u{18D14}; +var \u{18D15}; +var \u{18D16}; +var \u{18D17}; +var \u{18D18}; +var \u{18D19}; +var \u{18D1A}; +var \u{18D1B}; +var \u{18D1C}; +var \u{18D1D}; +var \u{18D1E}; +var \u{18D80}; +var \u{18D81}; +var \u{18D82}; +var \u{18D83}; +var \u{18D84}; +var \u{18D85}; +var \u{18D86}; +var \u{18D87}; +var \u{18D88}; +var \u{18D89}; +var \u{18D8A}; +var \u{18D8B}; +var \u{18D8C}; +var \u{18D8D}; +var \u{18D8E}; +var \u{18D8F}; +var \u{18D90}; +var \u{18D91}; +var \u{18D92}; +var \u{18D93}; +var \u{18D94}; +var \u{18D95}; +var \u{18D96}; +var \u{18D97}; +var \u{18D98}; +var \u{18D99}; +var \u{18D9A}; +var \u{18D9B}; +var \u{18D9C}; +var \u{18D9D}; +var \u{18D9E}; +var \u{18D9F}; +var \u{18DA0}; +var \u{18DA1}; +var \u{18DA2}; +var \u{18DA3}; +var \u{18DA4}; +var \u{18DA5}; +var \u{18DA6}; +var \u{18DA7}; +var \u{18DA8}; +var \u{18DA9}; +var \u{18DAA}; +var \u{18DAB}; +var \u{18DAC}; +var \u{18DAD}; +var \u{18DAE}; +var \u{18DAF}; +var \u{18DB0}; +var \u{18DB1}; +var \u{18DB2}; +var \u{18DB3}; +var \u{18DB4}; +var \u{18DB5}; +var \u{18DB6}; +var \u{18DB7}; +var \u{18DB8}; +var \u{18DB9}; +var \u{18DBA}; +var \u{18DBB}; +var \u{18DBC}; +var \u{18DBD}; +var \u{18DBE}; +var \u{18DBF}; +var \u{18DC0}; +var \u{18DC1}; +var \u{18DC2}; +var \u{18DC3}; +var \u{18DC4}; +var \u{18DC5}; +var \u{18DC6}; +var \u{18DC7}; +var \u{18DC8}; +var \u{18DC9}; +var \u{18DCA}; +var \u{18DCB}; +var \u{18DCC}; +var \u{18DCD}; +var \u{18DCE}; +var \u{18DCF}; +var \u{18DD0}; +var \u{18DD1}; +var \u{18DD2}; +var \u{18DD3}; +var \u{18DD4}; +var \u{18DD5}; +var \u{18DD6}; +var \u{18DD7}; +var \u{18DD8}; +var \u{18DD9}; +var \u{18DDA}; +var \u{18DDB}; +var \u{18DDC}; +var \u{18DDD}; +var \u{18DDE}; +var \u{18DDF}; +var \u{18DE0}; +var \u{18DE1}; +var \u{18DE2}; +var \u{18DE3}; +var \u{18DE4}; +var \u{18DE5}; +var \u{18DE6}; +var \u{18DE7}; +var \u{18DE8}; +var \u{18DE9}; +var \u{18DEA}; +var \u{18DEB}; +var \u{18DEC}; +var \u{18DED}; +var \u{18DEE}; +var \u{18DEF}; +var \u{18DF0}; +var \u{18DF1}; +var \u{18DF2}; +var \u{1E6C0}; +var \u{1E6C1}; +var \u{1E6C2}; +var \u{1E6C3}; +var \u{1E6C4}; +var \u{1E6C5}; +var \u{1E6C6}; +var \u{1E6C7}; +var \u{1E6C8}; +var \u{1E6C9}; +var \u{1E6CA}; +var \u{1E6CB}; +var \u{1E6CC}; +var \u{1E6CD}; +var \u{1E6CE}; +var \u{1E6CF}; +var \u{1E6D0}; +var \u{1E6D1}; +var \u{1E6D2}; +var \u{1E6D3}; +var \u{1E6D4}; +var \u{1E6D5}; +var \u{1E6D6}; +var \u{1E6D7}; +var \u{1E6D8}; +var \u{1E6D9}; +var \u{1E6DA}; +var \u{1E6DB}; +var \u{1E6DC}; +var \u{1E6DD}; +var \u{1E6DE}; +var \u{1E6E0}; +var \u{1E6E1}; +var \u{1E6E2}; +var \u{1E6E4}; +var \u{1E6E5}; +var \u{1E6E7}; +var \u{1E6E8}; +var \u{1E6E9}; +var \u{1E6EA}; +var \u{1E6EB}; +var \u{1E6EC}; +var \u{1E6ED}; +var \u{1E6F0}; +var \u{1E6F1}; +var \u{1E6F2}; +var \u{1E6F3}; +var \u{1E6F4}; +var \u{1E6FE}; +var \u{1E6FF}; +var \u{2B73A}; +var \u{2B73B}; +var \u{2B73C}; +var \u{2B73D}; +var \u{2B73E}; +var \u{2B73F}; +var \u{2CEA2}; +var \u{2CEA3}; +var \u{2CEA4}; +var \u{2CEA5}; +var \u{2CEA6}; +var \u{2CEA7}; +var \u{2CEA8}; +var \u{2CEA9}; +var \u{2CEAA}; +var \u{2CEAB}; +var \u{2CEAC}; +var \u{2CEAD}; +var \u{323B0}; +var \u{323B1}; +var \u{323B2}; +var \u{323B3}; +var \u{323B4}; +var \u{323B5}; +var \u{323B6}; +var \u{323B7}; +var \u{323B8}; +var \u{323B9}; +var \u{323BA}; +var \u{323BB}; +var \u{323BC}; +var \u{323BD}; +var \u{323BE}; +var \u{323BF}; +var \u{323C0}; +var \u{323C1}; +var \u{323C2}; +var \u{323C3}; +var \u{323C4}; +var \u{323C5}; +var \u{323C6}; +var \u{323C7}; +var \u{323C8}; +var \u{323C9}; +var \u{323CA}; +var \u{323CB}; +var \u{323CC}; +var \u{323CD}; +var \u{323CE}; +var \u{323CF}; +var \u{323D0}; +var \u{323D1}; +var \u{323D2}; +var \u{323D3}; +var \u{323D4}; +var \u{323D5}; +var \u{323D6}; +var \u{323D7}; +var \u{323D8}; +var \u{323D9}; +var \u{323DA}; +var \u{323DB}; +var \u{323DC}; +var \u{323DD}; +var \u{323DE}; +var \u{323DF}; +var \u{323E0}; +var \u{323E1}; +var \u{323E2}; +var \u{323E3}; +var \u{323E4}; +var \u{323E5}; +var \u{323E6}; +var \u{323E7}; +var \u{323E8}; +var \u{323E9}; +var \u{323EA}; +var \u{323EB}; +var \u{323EC}; +var \u{323ED}; +var \u{323EE}; +var \u{323EF}; +var \u{323F0}; +var \u{323F1}; +var \u{323F2}; +var \u{323F3}; +var \u{323F4}; +var \u{323F5}; +var \u{323F6}; +var \u{323F7}; +var \u{323F8}; +var \u{323F9}; +var \u{323FA}; +var \u{323FB}; +var \u{323FC}; +var \u{323FD}; +var \u{323FE}; +var \u{323FF}; +var \u{32400}; +var \u{32401}; +var \u{32402}; +var \u{32403}; +var \u{32404}; +var \u{32405}; +var \u{32406}; +var \u{32407}; +var \u{32408}; +var \u{32409}; +var \u{3240A}; +var \u{3240B}; +var \u{3240C}; +var \u{3240D}; +var \u{3240E}; +var \u{3240F}; +var \u{32410}; +var \u{32411}; +var \u{32412}; +var \u{32413}; +var \u{32414}; +var \u{32415}; +var \u{32416}; +var \u{32417}; +var \u{32418}; +var \u{32419}; +var \u{3241A}; +var \u{3241B}; +var \u{3241C}; +var \u{3241D}; +var \u{3241E}; +var \u{3241F}; +var \u{32420}; +var \u{32421}; +var \u{32422}; +var \u{32423}; +var \u{32424}; +var \u{32425}; +var \u{32426}; +var \u{32427}; +var \u{32428}; +var \u{32429}; +var \u{3242A}; +var \u{3242B}; +var \u{3242C}; +var \u{3242D}; +var \u{3242E}; +var \u{3242F}; +var \u{32430}; +var \u{32431}; +var \u{32432}; +var \u{32433}; +var \u{32434}; +var \u{32435}; +var \u{32436}; +var \u{32437}; +var \u{32438}; +var \u{32439}; +var \u{3243A}; +var \u{3243B}; +var \u{3243C}; +var \u{3243D}; +var \u{3243E}; +var \u{3243F}; +var \u{32440}; +var \u{32441}; +var \u{32442}; +var \u{32443}; +var \u{32444}; +var \u{32445}; +var \u{32446}; +var \u{32447}; +var \u{32448}; +var \u{32449}; +var \u{3244A}; +var \u{3244B}; +var \u{3244C}; +var \u{3244D}; +var \u{3244E}; +var \u{3244F}; +var \u{32450}; +var \u{32451}; +var \u{32452}; +var \u{32453}; +var \u{32454}; +var \u{32455}; +var \u{32456}; +var \u{32457}; +var \u{32458}; +var \u{32459}; +var \u{3245A}; +var \u{3245B}; +var \u{3245C}; +var \u{3245D}; +var \u{3245E}; +var \u{3245F}; +var \u{32460}; +var \u{32461}; +var \u{32462}; +var \u{32463}; +var \u{32464}; +var \u{32465}; +var \u{32466}; +var \u{32467}; +var \u{32468}; +var \u{32469}; +var \u{3246A}; +var \u{3246B}; +var \u{3246C}; +var \u{3246D}; +var \u{3246E}; +var \u{3246F}; +var \u{32470}; +var \u{32471}; +var \u{32472}; +var \u{32473}; +var \u{32474}; +var \u{32475}; +var \u{32476}; +var \u{32477}; +var \u{32478}; +var \u{32479}; +var \u{3247A}; +var \u{3247B}; +var \u{3247C}; +var \u{3247D}; +var \u{3247E}; +var \u{3247F}; +var \u{32480}; +var \u{32481}; +var \u{32482}; +var \u{32483}; +var \u{32484}; +var \u{32485}; +var \u{32486}; +var \u{32487}; +var \u{32488}; +var \u{32489}; +var \u{3248A}; +var \u{3248B}; +var \u{3248C}; +var \u{3248D}; +var \u{3248E}; +var \u{3248F}; +var \u{32490}; +var \u{32491}; +var \u{32492}; +var \u{32493}; +var \u{32494}; +var \u{32495}; +var \u{32496}; +var \u{32497}; +var \u{32498}; +var \u{32499}; +var \u{3249A}; +var \u{3249B}; +var \u{3249C}; +var \u{3249D}; +var \u{3249E}; +var \u{3249F}; +var \u{324A0}; +var \u{324A1}; +var \u{324A2}; +var \u{324A3}; +var \u{324A4}; +var \u{324A5}; +var \u{324A6}; +var \u{324A7}; +var \u{324A8}; +var \u{324A9}; +var \u{324AA}; +var \u{324AB}; +var \u{324AC}; +var \u{324AD}; +var \u{324AE}; +var \u{324AF}; +var \u{324B0}; +var \u{324B1}; +var \u{324B2}; +var \u{324B3}; +var \u{324B4}; +var \u{324B5}; +var \u{324B6}; +var \u{324B7}; +var \u{324B8}; +var \u{324B9}; +var \u{324BA}; +var \u{324BB}; +var \u{324BC}; +var \u{324BD}; +var \u{324BE}; +var \u{324BF}; +var \u{324C0}; +var \u{324C1}; +var \u{324C2}; +var \u{324C3}; +var \u{324C4}; +var \u{324C5}; +var \u{324C6}; +var \u{324C7}; +var \u{324C8}; +var \u{324C9}; +var \u{324CA}; +var \u{324CB}; +var \u{324CC}; +var \u{324CD}; +var \u{324CE}; +var \u{324CF}; +var \u{324D0}; +var \u{324D1}; +var \u{324D2}; +var \u{324D3}; +var \u{324D4}; +var \u{324D5}; +var \u{324D6}; +var \u{324D7}; +var \u{324D8}; +var \u{324D9}; +var \u{324DA}; +var \u{324DB}; +var \u{324DC}; +var \u{324DD}; +var \u{324DE}; +var \u{324DF}; +var \u{324E0}; +var \u{324E1}; +var \u{324E2}; +var \u{324E3}; +var \u{324E4}; +var \u{324E5}; +var \u{324E6}; +var \u{324E7}; +var \u{324E8}; +var \u{324E9}; +var \u{324EA}; +var \u{324EB}; +var \u{324EC}; +var \u{324ED}; +var \u{324EE}; +var \u{324EF}; +var \u{324F0}; +var \u{324F1}; +var \u{324F2}; +var \u{324F3}; +var \u{324F4}; +var \u{324F5}; +var \u{324F6}; +var \u{324F7}; +var \u{324F8}; +var \u{324F9}; +var \u{324FA}; +var \u{324FB}; +var \u{324FC}; +var \u{324FD}; +var \u{324FE}; +var \u{324FF}; +var \u{32500}; +var \u{32501}; +var \u{32502}; +var \u{32503}; +var \u{32504}; +var \u{32505}; +var \u{32506}; +var \u{32507}; +var \u{32508}; +var \u{32509}; +var \u{3250A}; +var \u{3250B}; +var \u{3250C}; +var \u{3250D}; +var \u{3250E}; +var \u{3250F}; +var \u{32510}; +var \u{32511}; +var \u{32512}; +var \u{32513}; +var \u{32514}; +var \u{32515}; +var \u{32516}; +var \u{32517}; +var \u{32518}; +var \u{32519}; +var \u{3251A}; +var \u{3251B}; +var \u{3251C}; +var \u{3251D}; +var \u{3251E}; +var \u{3251F}; +var \u{32520}; +var \u{32521}; +var \u{32522}; +var \u{32523}; +var \u{32524}; +var \u{32525}; +var \u{32526}; +var \u{32527}; +var \u{32528}; +var \u{32529}; +var \u{3252A}; +var \u{3252B}; +var \u{3252C}; +var \u{3252D}; +var \u{3252E}; +var \u{3252F}; +var \u{32530}; +var \u{32531}; +var \u{32532}; +var \u{32533}; +var \u{32534}; +var \u{32535}; +var \u{32536}; +var \u{32537}; +var \u{32538}; +var \u{32539}; +var \u{3253A}; +var \u{3253B}; +var \u{3253C}; +var \u{3253D}; +var \u{3253E}; +var \u{3253F}; +var \u{32540}; +var \u{32541}; +var \u{32542}; +var \u{32543}; +var \u{32544}; +var \u{32545}; +var \u{32546}; +var \u{32547}; +var \u{32548}; +var \u{32549}; +var \u{3254A}; +var \u{3254B}; +var \u{3254C}; +var \u{3254D}; +var \u{3254E}; +var \u{3254F}; +var \u{32550}; +var \u{32551}; +var \u{32552}; +var \u{32553}; +var \u{32554}; +var \u{32555}; +var \u{32556}; +var \u{32557}; +var \u{32558}; +var \u{32559}; +var \u{3255A}; +var \u{3255B}; +var \u{3255C}; +var \u{3255D}; +var \u{3255E}; +var \u{3255F}; +var \u{32560}; +var \u{32561}; +var \u{32562}; +var \u{32563}; +var \u{32564}; +var \u{32565}; +var \u{32566}; +var \u{32567}; +var \u{32568}; +var \u{32569}; +var \u{3256A}; +var \u{3256B}; +var \u{3256C}; +var \u{3256D}; +var \u{3256E}; +var \u{3256F}; +var \u{32570}; +var \u{32571}; +var \u{32572}; +var \u{32573}; +var \u{32574}; +var \u{32575}; +var \u{32576}; +var \u{32577}; +var \u{32578}; +var \u{32579}; +var \u{3257A}; +var \u{3257B}; +var \u{3257C}; +var \u{3257D}; +var \u{3257E}; +var \u{3257F}; +var \u{32580}; +var \u{32581}; +var \u{32582}; +var \u{32583}; +var \u{32584}; +var \u{32585}; +var \u{32586}; +var \u{32587}; +var \u{32588}; +var \u{32589}; +var \u{3258A}; +var \u{3258B}; +var \u{3258C}; +var \u{3258D}; +var \u{3258E}; +var \u{3258F}; +var \u{32590}; +var \u{32591}; +var \u{32592}; +var \u{32593}; +var \u{32594}; +var \u{32595}; +var \u{32596}; +var \u{32597}; +var \u{32598}; +var \u{32599}; +var \u{3259A}; +var \u{3259B}; +var \u{3259C}; +var \u{3259D}; +var \u{3259E}; +var \u{3259F}; +var \u{325A0}; +var \u{325A1}; +var \u{325A2}; +var \u{325A3}; +var \u{325A4}; +var \u{325A5}; +var \u{325A6}; +var \u{325A7}; +var \u{325A8}; +var \u{325A9}; +var \u{325AA}; +var \u{325AB}; +var \u{325AC}; +var \u{325AD}; +var \u{325AE}; +var \u{325AF}; +var \u{325B0}; +var \u{325B1}; +var \u{325B2}; +var \u{325B3}; +var \u{325B4}; +var \u{325B5}; +var \u{325B6}; +var \u{325B7}; +var \u{325B8}; +var \u{325B9}; +var \u{325BA}; +var \u{325BB}; +var \u{325BC}; +var \u{325BD}; +var \u{325BE}; +var \u{325BF}; +var \u{325C0}; +var \u{325C1}; +var \u{325C2}; +var \u{325C3}; +var \u{325C4}; +var \u{325C5}; +var \u{325C6}; +var \u{325C7}; +var \u{325C8}; +var \u{325C9}; +var \u{325CA}; +var \u{325CB}; +var \u{325CC}; +var \u{325CD}; +var \u{325CE}; +var \u{325CF}; +var \u{325D0}; +var \u{325D1}; +var \u{325D2}; +var \u{325D3}; +var \u{325D4}; +var \u{325D5}; +var \u{325D6}; +var \u{325D7}; +var \u{325D8}; +var \u{325D9}; +var \u{325DA}; +var \u{325DB}; +var \u{325DC}; +var \u{325DD}; +var \u{325DE}; +var \u{325DF}; +var \u{325E0}; +var \u{325E1}; +var \u{325E2}; +var \u{325E3}; +var \u{325E4}; +var \u{325E5}; +var \u{325E6}; +var \u{325E7}; +var \u{325E8}; +var \u{325E9}; +var \u{325EA}; +var \u{325EB}; +var \u{325EC}; +var \u{325ED}; +var \u{325EE}; +var \u{325EF}; +var \u{325F0}; +var \u{325F1}; +var \u{325F2}; +var \u{325F3}; +var \u{325F4}; +var \u{325F5}; +var \u{325F6}; +var \u{325F7}; +var \u{325F8}; +var \u{325F9}; +var \u{325FA}; +var \u{325FB}; +var \u{325FC}; +var \u{325FD}; +var \u{325FE}; +var \u{325FF}; +var \u{32600}; +var \u{32601}; +var \u{32602}; +var \u{32603}; +var \u{32604}; +var \u{32605}; +var \u{32606}; +var \u{32607}; +var \u{32608}; +var \u{32609}; +var \u{3260A}; +var \u{3260B}; +var \u{3260C}; +var \u{3260D}; +var \u{3260E}; +var \u{3260F}; +var \u{32610}; +var \u{32611}; +var \u{32612}; +var \u{32613}; +var \u{32614}; +var \u{32615}; +var \u{32616}; +var \u{32617}; +var \u{32618}; +var \u{32619}; +var \u{3261A}; +var \u{3261B}; +var \u{3261C}; +var \u{3261D}; +var \u{3261E}; +var \u{3261F}; +var \u{32620}; +var \u{32621}; +var \u{32622}; +var \u{32623}; +var \u{32624}; +var \u{32625}; +var \u{32626}; +var \u{32627}; +var \u{32628}; +var \u{32629}; +var \u{3262A}; +var \u{3262B}; +var \u{3262C}; +var \u{3262D}; +var \u{3262E}; +var \u{3262F}; +var \u{32630}; +var \u{32631}; +var \u{32632}; +var \u{32633}; +var \u{32634}; +var \u{32635}; +var \u{32636}; +var \u{32637}; +var \u{32638}; +var \u{32639}; +var \u{3263A}; +var \u{3263B}; +var \u{3263C}; +var \u{3263D}; +var \u{3263E}; +var \u{3263F}; +var \u{32640}; +var \u{32641}; +var \u{32642}; +var \u{32643}; +var \u{32644}; +var \u{32645}; +var \u{32646}; +var \u{32647}; +var \u{32648}; +var \u{32649}; +var \u{3264A}; +var \u{3264B}; +var \u{3264C}; +var \u{3264D}; +var \u{3264E}; +var \u{3264F}; +var \u{32650}; +var \u{32651}; +var \u{32652}; +var \u{32653}; +var \u{32654}; +var \u{32655}; +var \u{32656}; +var \u{32657}; +var \u{32658}; +var \u{32659}; +var \u{3265A}; +var \u{3265B}; +var \u{3265C}; +var \u{3265D}; +var \u{3265E}; +var \u{3265F}; +var \u{32660}; +var \u{32661}; +var \u{32662}; +var \u{32663}; +var \u{32664}; +var \u{32665}; +var \u{32666}; +var \u{32667}; +var \u{32668}; +var \u{32669}; +var \u{3266A}; +var \u{3266B}; +var \u{3266C}; +var \u{3266D}; +var \u{3266E}; +var \u{3266F}; +var \u{32670}; +var \u{32671}; +var \u{32672}; +var \u{32673}; +var \u{32674}; +var \u{32675}; +var \u{32676}; +var \u{32677}; +var \u{32678}; +var \u{32679}; +var \u{3267A}; +var \u{3267B}; +var \u{3267C}; +var \u{3267D}; +var \u{3267E}; +var \u{3267F}; +var \u{32680}; +var \u{32681}; +var \u{32682}; +var \u{32683}; +var \u{32684}; +var \u{32685}; +var \u{32686}; +var \u{32687}; +var \u{32688}; +var \u{32689}; +var \u{3268A}; +var \u{3268B}; +var \u{3268C}; +var \u{3268D}; +var \u{3268E}; +var \u{3268F}; +var \u{32690}; +var \u{32691}; +var \u{32692}; +var \u{32693}; +var \u{32694}; +var \u{32695}; +var \u{32696}; +var \u{32697}; +var \u{32698}; +var \u{32699}; +var \u{3269A}; +var \u{3269B}; +var \u{3269C}; +var \u{3269D}; +var \u{3269E}; +var \u{3269F}; +var \u{326A0}; +var \u{326A1}; +var \u{326A2}; +var \u{326A3}; +var \u{326A4}; +var \u{326A5}; +var \u{326A6}; +var \u{326A7}; +var \u{326A8}; +var \u{326A9}; +var \u{326AA}; +var \u{326AB}; +var \u{326AC}; +var \u{326AD}; +var \u{326AE}; +var \u{326AF}; +var \u{326B0}; +var \u{326B1}; +var \u{326B2}; +var \u{326B3}; +var \u{326B4}; +var \u{326B5}; +var \u{326B6}; +var \u{326B7}; +var \u{326B8}; +var \u{326B9}; +var \u{326BA}; +var \u{326BB}; +var \u{326BC}; +var \u{326BD}; +var \u{326BE}; +var \u{326BF}; +var \u{326C0}; +var \u{326C1}; +var \u{326C2}; +var \u{326C3}; +var \u{326C4}; +var \u{326C5}; +var \u{326C6}; +var \u{326C7}; +var \u{326C8}; +var \u{326C9}; +var \u{326CA}; +var \u{326CB}; +var \u{326CC}; +var \u{326CD}; +var \u{326CE}; +var \u{326CF}; +var \u{326D0}; +var \u{326D1}; +var \u{326D2}; +var \u{326D3}; +var \u{326D4}; +var \u{326D5}; +var \u{326D6}; +var \u{326D7}; +var \u{326D8}; +var \u{326D9}; +var \u{326DA}; +var \u{326DB}; +var \u{326DC}; +var \u{326DD}; +var \u{326DE}; +var \u{326DF}; +var \u{326E0}; +var \u{326E1}; +var \u{326E2}; +var \u{326E3}; +var \u{326E4}; +var \u{326E5}; +var \u{326E6}; +var \u{326E7}; +var \u{326E8}; +var \u{326E9}; +var \u{326EA}; +var \u{326EB}; +var \u{326EC}; +var \u{326ED}; +var \u{326EE}; +var \u{326EF}; +var \u{326F0}; +var \u{326F1}; +var \u{326F2}; +var \u{326F3}; +var \u{326F4}; +var \u{326F5}; +var \u{326F6}; +var \u{326F7}; +var \u{326F8}; +var \u{326F9}; +var \u{326FA}; +var \u{326FB}; +var \u{326FC}; +var \u{326FD}; +var \u{326FE}; +var \u{326FF}; +var \u{32700}; +var \u{32701}; +var \u{32702}; +var \u{32703}; +var \u{32704}; +var \u{32705}; +var \u{32706}; +var \u{32707}; +var \u{32708}; +var \u{32709}; +var \u{3270A}; +var \u{3270B}; +var \u{3270C}; +var \u{3270D}; +var \u{3270E}; +var \u{3270F}; +var \u{32710}; +var \u{32711}; +var \u{32712}; +var \u{32713}; +var \u{32714}; +var \u{32715}; +var \u{32716}; +var \u{32717}; +var \u{32718}; +var \u{32719}; +var \u{3271A}; +var \u{3271B}; +var \u{3271C}; +var \u{3271D}; +var \u{3271E}; +var \u{3271F}; +var \u{32720}; +var \u{32721}; +var \u{32722}; +var \u{32723}; +var \u{32724}; +var \u{32725}; +var \u{32726}; +var \u{32727}; +var \u{32728}; +var \u{32729}; +var \u{3272A}; +var \u{3272B}; +var \u{3272C}; +var \u{3272D}; +var \u{3272E}; +var \u{3272F}; +var \u{32730}; +var \u{32731}; +var \u{32732}; +var \u{32733}; +var \u{32734}; +var \u{32735}; +var \u{32736}; +var \u{32737}; +var \u{32738}; +var \u{32739}; +var \u{3273A}; +var \u{3273B}; +var \u{3273C}; +var \u{3273D}; +var \u{3273E}; +var \u{3273F}; +var \u{32740}; +var \u{32741}; +var \u{32742}; +var \u{32743}; +var \u{32744}; +var \u{32745}; +var \u{32746}; +var \u{32747}; +var \u{32748}; +var \u{32749}; +var \u{3274A}; +var \u{3274B}; +var \u{3274C}; +var \u{3274D}; +var \u{3274E}; +var \u{3274F}; +var \u{32750}; +var \u{32751}; +var \u{32752}; +var \u{32753}; +var \u{32754}; +var \u{32755}; +var \u{32756}; +var \u{32757}; +var \u{32758}; +var \u{32759}; +var \u{3275A}; +var \u{3275B}; +var \u{3275C}; +var \u{3275D}; +var \u{3275E}; +var \u{3275F}; +var \u{32760}; +var \u{32761}; +var \u{32762}; +var \u{32763}; +var \u{32764}; +var \u{32765}; +var \u{32766}; +var \u{32767}; +var \u{32768}; +var \u{32769}; +var \u{3276A}; +var \u{3276B}; +var \u{3276C}; +var \u{3276D}; +var \u{3276E}; +var \u{3276F}; +var \u{32770}; +var \u{32771}; +var \u{32772}; +var \u{32773}; +var \u{32774}; +var \u{32775}; +var \u{32776}; +var \u{32777}; +var \u{32778}; +var \u{32779}; +var \u{3277A}; +var \u{3277B}; +var \u{3277C}; +var \u{3277D}; +var \u{3277E}; +var \u{3277F}; +var \u{32780}; +var \u{32781}; +var \u{32782}; +var \u{32783}; +var \u{32784}; +var \u{32785}; +var \u{32786}; +var \u{32787}; +var \u{32788}; +var \u{32789}; +var \u{3278A}; +var \u{3278B}; +var \u{3278C}; +var \u{3278D}; +var \u{3278E}; +var \u{3278F}; +var \u{32790}; +var \u{32791}; +var \u{32792}; +var \u{32793}; +var \u{32794}; +var \u{32795}; +var \u{32796}; +var \u{32797}; +var \u{32798}; +var \u{32799}; +var \u{3279A}; +var \u{3279B}; +var \u{3279C}; +var \u{3279D}; +var \u{3279E}; +var \u{3279F}; +var \u{327A0}; +var \u{327A1}; +var \u{327A2}; +var \u{327A3}; +var \u{327A4}; +var \u{327A5}; +var \u{327A6}; +var \u{327A7}; +var \u{327A8}; +var \u{327A9}; +var \u{327AA}; +var \u{327AB}; +var \u{327AC}; +var \u{327AD}; +var \u{327AE}; +var \u{327AF}; +var \u{327B0}; +var \u{327B1}; +var \u{327B2}; +var \u{327B3}; +var \u{327B4}; +var \u{327B5}; +var \u{327B6}; +var \u{327B7}; +var \u{327B8}; +var \u{327B9}; +var \u{327BA}; +var \u{327BB}; +var \u{327BC}; +var \u{327BD}; +var \u{327BE}; +var \u{327BF}; +var \u{327C0}; +var \u{327C1}; +var \u{327C2}; +var \u{327C3}; +var \u{327C4}; +var \u{327C5}; +var \u{327C6}; +var \u{327C7}; +var \u{327C8}; +var \u{327C9}; +var \u{327CA}; +var \u{327CB}; +var \u{327CC}; +var \u{327CD}; +var \u{327CE}; +var \u{327CF}; +var \u{327D0}; +var \u{327D1}; +var \u{327D2}; +var \u{327D3}; +var \u{327D4}; +var \u{327D5}; +var \u{327D6}; +var \u{327D7}; +var \u{327D8}; +var \u{327D9}; +var \u{327DA}; +var \u{327DB}; +var \u{327DC}; +var \u{327DD}; +var \u{327DE}; +var \u{327DF}; +var \u{327E0}; +var \u{327E1}; +var \u{327E2}; +var \u{327E3}; +var \u{327E4}; +var \u{327E5}; +var \u{327E6}; +var \u{327E7}; +var \u{327E8}; +var \u{327E9}; +var \u{327EA}; +var \u{327EB}; +var \u{327EC}; +var \u{327ED}; +var \u{327EE}; +var \u{327EF}; +var \u{327F0}; +var \u{327F1}; +var \u{327F2}; +var \u{327F3}; +var \u{327F4}; +var \u{327F5}; +var \u{327F6}; +var \u{327F7}; +var \u{327F8}; +var \u{327F9}; +var \u{327FA}; +var \u{327FB}; +var \u{327FC}; +var \u{327FD}; +var \u{327FE}; +var \u{327FF}; +var \u{32800}; +var \u{32801}; +var \u{32802}; +var \u{32803}; +var \u{32804}; +var \u{32805}; +var \u{32806}; +var \u{32807}; +var \u{32808}; +var \u{32809}; +var \u{3280A}; +var \u{3280B}; +var \u{3280C}; +var \u{3280D}; +var \u{3280E}; +var \u{3280F}; +var \u{32810}; +var \u{32811}; +var \u{32812}; +var \u{32813}; +var \u{32814}; +var \u{32815}; +var \u{32816}; +var \u{32817}; +var \u{32818}; +var \u{32819}; +var \u{3281A}; +var \u{3281B}; +var \u{3281C}; +var \u{3281D}; +var \u{3281E}; +var \u{3281F}; +var \u{32820}; +var \u{32821}; +var \u{32822}; +var \u{32823}; +var \u{32824}; +var \u{32825}; +var \u{32826}; +var \u{32827}; +var \u{32828}; +var \u{32829}; +var \u{3282A}; +var \u{3282B}; +var \u{3282C}; +var \u{3282D}; +var \u{3282E}; +var \u{3282F}; +var \u{32830}; +var \u{32831}; +var \u{32832}; +var \u{32833}; +var \u{32834}; +var \u{32835}; +var \u{32836}; +var \u{32837}; +var \u{32838}; +var \u{32839}; +var \u{3283A}; +var \u{3283B}; +var \u{3283C}; +var \u{3283D}; +var \u{3283E}; +var \u{3283F}; +var \u{32840}; +var \u{32841}; +var \u{32842}; +var \u{32843}; +var \u{32844}; +var \u{32845}; +var \u{32846}; +var \u{32847}; +var \u{32848}; +var \u{32849}; +var \u{3284A}; +var \u{3284B}; +var \u{3284C}; +var \u{3284D}; +var \u{3284E}; +var \u{3284F}; +var \u{32850}; +var \u{32851}; +var \u{32852}; +var \u{32853}; +var \u{32854}; +var \u{32855}; +var \u{32856}; +var \u{32857}; +var \u{32858}; +var \u{32859}; +var \u{3285A}; +var \u{3285B}; +var \u{3285C}; +var \u{3285D}; +var \u{3285E}; +var \u{3285F}; +var \u{32860}; +var \u{32861}; +var \u{32862}; +var \u{32863}; +var \u{32864}; +var \u{32865}; +var \u{32866}; +var \u{32867}; +var \u{32868}; +var \u{32869}; +var \u{3286A}; +var \u{3286B}; +var \u{3286C}; +var \u{3286D}; +var \u{3286E}; +var \u{3286F}; +var \u{32870}; +var \u{32871}; +var \u{32872}; +var \u{32873}; +var \u{32874}; +var \u{32875}; +var \u{32876}; +var \u{32877}; +var \u{32878}; +var \u{32879}; +var \u{3287A}; +var \u{3287B}; +var \u{3287C}; +var \u{3287D}; +var \u{3287E}; +var \u{3287F}; +var \u{32880}; +var \u{32881}; +var \u{32882}; +var \u{32883}; +var \u{32884}; +var \u{32885}; +var \u{32886}; +var \u{32887}; +var \u{32888}; +var \u{32889}; +var \u{3288A}; +var \u{3288B}; +var \u{3288C}; +var \u{3288D}; +var \u{3288E}; +var \u{3288F}; +var \u{32890}; +var \u{32891}; +var \u{32892}; +var \u{32893}; +var \u{32894}; +var \u{32895}; +var \u{32896}; +var \u{32897}; +var \u{32898}; +var \u{32899}; +var \u{3289A}; +var \u{3289B}; +var \u{3289C}; +var \u{3289D}; +var \u{3289E}; +var \u{3289F}; +var \u{328A0}; +var \u{328A1}; +var \u{328A2}; +var \u{328A3}; +var \u{328A4}; +var \u{328A5}; +var \u{328A6}; +var \u{328A7}; +var \u{328A8}; +var \u{328A9}; +var \u{328AA}; +var \u{328AB}; +var \u{328AC}; +var \u{328AD}; +var \u{328AE}; +var \u{328AF}; +var \u{328B0}; +var \u{328B1}; +var \u{328B2}; +var \u{328B3}; +var \u{328B4}; +var \u{328B5}; +var \u{328B6}; +var \u{328B7}; +var \u{328B8}; +var \u{328B9}; +var \u{328BA}; +var \u{328BB}; +var \u{328BC}; +var \u{328BD}; +var \u{328BE}; +var \u{328BF}; +var \u{328C0}; +var \u{328C1}; +var \u{328C2}; +var \u{328C3}; +var \u{328C4}; +var \u{328C5}; +var \u{328C6}; +var \u{328C7}; +var \u{328C8}; +var \u{328C9}; +var \u{328CA}; +var \u{328CB}; +var \u{328CC}; +var \u{328CD}; +var \u{328CE}; +var \u{328CF}; +var \u{328D0}; +var \u{328D1}; +var \u{328D2}; +var \u{328D3}; +var \u{328D4}; +var \u{328D5}; +var \u{328D6}; +var \u{328D7}; +var \u{328D8}; +var \u{328D9}; +var \u{328DA}; +var \u{328DB}; +var \u{328DC}; +var \u{328DD}; +var \u{328DE}; +var \u{328DF}; +var \u{328E0}; +var \u{328E1}; +var \u{328E2}; +var \u{328E3}; +var \u{328E4}; +var \u{328E5}; +var \u{328E6}; +var \u{328E7}; +var \u{328E8}; +var \u{328E9}; +var \u{328EA}; +var \u{328EB}; +var \u{328EC}; +var \u{328ED}; +var \u{328EE}; +var \u{328EF}; +var \u{328F0}; +var \u{328F1}; +var \u{328F2}; +var \u{328F3}; +var \u{328F4}; +var \u{328F5}; +var \u{328F6}; +var \u{328F7}; +var \u{328F8}; +var \u{328F9}; +var \u{328FA}; +var \u{328FB}; +var \u{328FC}; +var \u{328FD}; +var \u{328FE}; +var \u{328FF}; +var \u{32900}; +var \u{32901}; +var \u{32902}; +var \u{32903}; +var \u{32904}; +var \u{32905}; +var \u{32906}; +var \u{32907}; +var \u{32908}; +var \u{32909}; +var \u{3290A}; +var \u{3290B}; +var \u{3290C}; +var \u{3290D}; +var \u{3290E}; +var \u{3290F}; +var \u{32910}; +var \u{32911}; +var \u{32912}; +var \u{32913}; +var \u{32914}; +var \u{32915}; +var \u{32916}; +var \u{32917}; +var \u{32918}; +var \u{32919}; +var \u{3291A}; +var \u{3291B}; +var \u{3291C}; +var \u{3291D}; +var \u{3291E}; +var \u{3291F}; +var \u{32920}; +var \u{32921}; +var \u{32922}; +var \u{32923}; +var \u{32924}; +var \u{32925}; +var \u{32926}; +var \u{32927}; +var \u{32928}; +var \u{32929}; +var \u{3292A}; +var \u{3292B}; +var \u{3292C}; +var \u{3292D}; +var \u{3292E}; +var \u{3292F}; +var \u{32930}; +var \u{32931}; +var \u{32932}; +var \u{32933}; +var \u{32934}; +var \u{32935}; +var \u{32936}; +var \u{32937}; +var \u{32938}; +var \u{32939}; +var \u{3293A}; +var \u{3293B}; +var \u{3293C}; +var \u{3293D}; +var \u{3293E}; +var \u{3293F}; +var \u{32940}; +var \u{32941}; +var \u{32942}; +var \u{32943}; +var \u{32944}; +var \u{32945}; +var \u{32946}; +var \u{32947}; +var \u{32948}; +var \u{32949}; +var \u{3294A}; +var \u{3294B}; +var \u{3294C}; +var \u{3294D}; +var \u{3294E}; +var \u{3294F}; +var \u{32950}; +var \u{32951}; +var \u{32952}; +var \u{32953}; +var \u{32954}; +var \u{32955}; +var \u{32956}; +var \u{32957}; +var \u{32958}; +var \u{32959}; +var \u{3295A}; +var \u{3295B}; +var \u{3295C}; +var \u{3295D}; +var \u{3295E}; +var \u{3295F}; +var \u{32960}; +var \u{32961}; +var \u{32962}; +var \u{32963}; +var \u{32964}; +var \u{32965}; +var \u{32966}; +var \u{32967}; +var \u{32968}; +var \u{32969}; +var \u{3296A}; +var \u{3296B}; +var \u{3296C}; +var \u{3296D}; +var \u{3296E}; +var \u{3296F}; +var \u{32970}; +var \u{32971}; +var \u{32972}; +var \u{32973}; +var \u{32974}; +var \u{32975}; +var \u{32976}; +var \u{32977}; +var \u{32978}; +var \u{32979}; +var \u{3297A}; +var \u{3297B}; +var \u{3297C}; +var \u{3297D}; +var \u{3297E}; +var \u{3297F}; +var \u{32980}; +var \u{32981}; +var \u{32982}; +var \u{32983}; +var \u{32984}; +var \u{32985}; +var \u{32986}; +var \u{32987}; +var \u{32988}; +var \u{32989}; +var \u{3298A}; +var \u{3298B}; +var \u{3298C}; +var \u{3298D}; +var \u{3298E}; +var \u{3298F}; +var \u{32990}; +var \u{32991}; +var \u{32992}; +var \u{32993}; +var \u{32994}; +var \u{32995}; +var \u{32996}; +var \u{32997}; +var \u{32998}; +var \u{32999}; +var \u{3299A}; +var \u{3299B}; +var \u{3299C}; +var \u{3299D}; +var \u{3299E}; +var \u{3299F}; +var \u{329A0}; +var \u{329A1}; +var \u{329A2}; +var \u{329A3}; +var \u{329A4}; +var \u{329A5}; +var \u{329A6}; +var \u{329A7}; +var \u{329A8}; +var \u{329A9}; +var \u{329AA}; +var \u{329AB}; +var \u{329AC}; +var \u{329AD}; +var \u{329AE}; +var \u{329AF}; +var \u{329B0}; +var \u{329B1}; +var \u{329B2}; +var \u{329B3}; +var \u{329B4}; +var \u{329B5}; +var \u{329B6}; +var \u{329B7}; +var \u{329B8}; +var \u{329B9}; +var \u{329BA}; +var \u{329BB}; +var \u{329BC}; +var \u{329BD}; +var \u{329BE}; +var \u{329BF}; +var \u{329C0}; +var \u{329C1}; +var \u{329C2}; +var \u{329C3}; +var \u{329C4}; +var \u{329C5}; +var \u{329C6}; +var \u{329C7}; +var \u{329C8}; +var \u{329C9}; +var \u{329CA}; +var \u{329CB}; +var \u{329CC}; +var \u{329CD}; +var \u{329CE}; +var \u{329CF}; +var \u{329D0}; +var \u{329D1}; +var \u{329D2}; +var \u{329D3}; +var \u{329D4}; +var \u{329D5}; +var \u{329D6}; +var \u{329D7}; +var \u{329D8}; +var \u{329D9}; +var \u{329DA}; +var \u{329DB}; +var \u{329DC}; +var \u{329DD}; +var \u{329DE}; +var \u{329DF}; +var \u{329E0}; +var \u{329E1}; +var \u{329E2}; +var \u{329E3}; +var \u{329E4}; +var \u{329E5}; +var \u{329E6}; +var \u{329E7}; +var \u{329E8}; +var \u{329E9}; +var \u{329EA}; +var \u{329EB}; +var \u{329EC}; +var \u{329ED}; +var \u{329EE}; +var \u{329EF}; +var \u{329F0}; +var \u{329F1}; +var \u{329F2}; +var \u{329F3}; +var \u{329F4}; +var \u{329F5}; +var \u{329F6}; +var \u{329F7}; +var \u{329F8}; +var \u{329F9}; +var \u{329FA}; +var \u{329FB}; +var \u{329FC}; +var \u{329FD}; +var \u{329FE}; +var \u{329FF}; +var \u{32A00}; +var \u{32A01}; +var \u{32A02}; +var \u{32A03}; +var \u{32A04}; +var \u{32A05}; +var \u{32A06}; +var \u{32A07}; +var \u{32A08}; +var \u{32A09}; +var \u{32A0A}; +var \u{32A0B}; +var \u{32A0C}; +var \u{32A0D}; +var \u{32A0E}; +var \u{32A0F}; +var \u{32A10}; +var \u{32A11}; +var \u{32A12}; +var \u{32A13}; +var \u{32A14}; +var \u{32A15}; +var \u{32A16}; +var \u{32A17}; +var \u{32A18}; +var \u{32A19}; +var \u{32A1A}; +var \u{32A1B}; +var \u{32A1C}; +var \u{32A1D}; +var \u{32A1E}; +var \u{32A1F}; +var \u{32A20}; +var \u{32A21}; +var \u{32A22}; +var \u{32A23}; +var \u{32A24}; +var \u{32A25}; +var \u{32A26}; +var \u{32A27}; +var \u{32A28}; +var \u{32A29}; +var \u{32A2A}; +var \u{32A2B}; +var \u{32A2C}; +var \u{32A2D}; +var \u{32A2E}; +var \u{32A2F}; +var \u{32A30}; +var \u{32A31}; +var \u{32A32}; +var \u{32A33}; +var \u{32A34}; +var \u{32A35}; +var \u{32A36}; +var \u{32A37}; +var \u{32A38}; +var \u{32A39}; +var \u{32A3A}; +var \u{32A3B}; +var \u{32A3C}; +var \u{32A3D}; +var \u{32A3E}; +var \u{32A3F}; +var \u{32A40}; +var \u{32A41}; +var \u{32A42}; +var \u{32A43}; +var \u{32A44}; +var \u{32A45}; +var \u{32A46}; +var \u{32A47}; +var \u{32A48}; +var \u{32A49}; +var \u{32A4A}; +var \u{32A4B}; +var \u{32A4C}; +var \u{32A4D}; +var \u{32A4E}; +var \u{32A4F}; +var \u{32A50}; +var \u{32A51}; +var \u{32A52}; +var \u{32A53}; +var \u{32A54}; +var \u{32A55}; +var \u{32A56}; +var \u{32A57}; +var \u{32A58}; +var \u{32A59}; +var \u{32A5A}; +var \u{32A5B}; +var \u{32A5C}; +var \u{32A5D}; +var \u{32A5E}; +var \u{32A5F}; +var \u{32A60}; +var \u{32A61}; +var \u{32A62}; +var \u{32A63}; +var \u{32A64}; +var \u{32A65}; +var \u{32A66}; +var \u{32A67}; +var \u{32A68}; +var \u{32A69}; +var \u{32A6A}; +var \u{32A6B}; +var \u{32A6C}; +var \u{32A6D}; +var \u{32A6E}; +var \u{32A6F}; +var \u{32A70}; +var \u{32A71}; +var \u{32A72}; +var \u{32A73}; +var \u{32A74}; +var \u{32A75}; +var \u{32A76}; +var \u{32A77}; +var \u{32A78}; +var \u{32A79}; +var \u{32A7A}; +var \u{32A7B}; +var \u{32A7C}; +var \u{32A7D}; +var \u{32A7E}; +var \u{32A7F}; +var \u{32A80}; +var \u{32A81}; +var \u{32A82}; +var \u{32A83}; +var \u{32A84}; +var \u{32A85}; +var \u{32A86}; +var \u{32A87}; +var \u{32A88}; +var \u{32A89}; +var \u{32A8A}; +var \u{32A8B}; +var \u{32A8C}; +var \u{32A8D}; +var \u{32A8E}; +var \u{32A8F}; +var \u{32A90}; +var \u{32A91}; +var \u{32A92}; +var \u{32A93}; +var \u{32A94}; +var \u{32A95}; +var \u{32A96}; +var \u{32A97}; +var \u{32A98}; +var \u{32A99}; +var \u{32A9A}; +var \u{32A9B}; +var \u{32A9C}; +var \u{32A9D}; +var \u{32A9E}; +var \u{32A9F}; +var \u{32AA0}; +var \u{32AA1}; +var \u{32AA2}; +var \u{32AA3}; +var \u{32AA4}; +var \u{32AA5}; +var \u{32AA6}; +var \u{32AA7}; +var \u{32AA8}; +var \u{32AA9}; +var \u{32AAA}; +var \u{32AAB}; +var \u{32AAC}; +var \u{32AAD}; +var \u{32AAE}; +var \u{32AAF}; +var \u{32AB0}; +var \u{32AB1}; +var \u{32AB2}; +var \u{32AB3}; +var \u{32AB4}; +var \u{32AB5}; +var \u{32AB6}; +var \u{32AB7}; +var \u{32AB8}; +var \u{32AB9}; +var \u{32ABA}; +var \u{32ABB}; +var \u{32ABC}; +var \u{32ABD}; +var \u{32ABE}; +var \u{32ABF}; +var \u{32AC0}; +var \u{32AC1}; +var \u{32AC2}; +var \u{32AC3}; +var \u{32AC4}; +var \u{32AC5}; +var \u{32AC6}; +var \u{32AC7}; +var \u{32AC8}; +var \u{32AC9}; +var \u{32ACA}; +var \u{32ACB}; +var \u{32ACC}; +var \u{32ACD}; +var \u{32ACE}; +var \u{32ACF}; +var \u{32AD0}; +var \u{32AD1}; +var \u{32AD2}; +var \u{32AD3}; +var \u{32AD4}; +var \u{32AD5}; +var \u{32AD6}; +var \u{32AD7}; +var \u{32AD8}; +var \u{32AD9}; +var \u{32ADA}; +var \u{32ADB}; +var \u{32ADC}; +var \u{32ADD}; +var \u{32ADE}; +var \u{32ADF}; +var \u{32AE0}; +var \u{32AE1}; +var \u{32AE2}; +var \u{32AE3}; +var \u{32AE4}; +var \u{32AE5}; +var \u{32AE6}; +var \u{32AE7}; +var \u{32AE8}; +var \u{32AE9}; +var \u{32AEA}; +var \u{32AEB}; +var \u{32AEC}; +var \u{32AED}; +var \u{32AEE}; +var \u{32AEF}; +var \u{32AF0}; +var \u{32AF1}; +var \u{32AF2}; +var \u{32AF3}; +var \u{32AF4}; +var \u{32AF5}; +var \u{32AF6}; +var \u{32AF7}; +var \u{32AF8}; +var \u{32AF9}; +var \u{32AFA}; +var \u{32AFB}; +var \u{32AFC}; +var \u{32AFD}; +var \u{32AFE}; +var \u{32AFF}; +var \u{32B00}; +var \u{32B01}; +var \u{32B02}; +var \u{32B03}; +var \u{32B04}; +var \u{32B05}; +var \u{32B06}; +var \u{32B07}; +var \u{32B08}; +var \u{32B09}; +var \u{32B0A}; +var \u{32B0B}; +var \u{32B0C}; +var \u{32B0D}; +var \u{32B0E}; +var \u{32B0F}; +var \u{32B10}; +var \u{32B11}; +var \u{32B12}; +var \u{32B13}; +var \u{32B14}; +var \u{32B15}; +var \u{32B16}; +var \u{32B17}; +var \u{32B18}; +var \u{32B19}; +var \u{32B1A}; +var \u{32B1B}; +var \u{32B1C}; +var \u{32B1D}; +var \u{32B1E}; +var \u{32B1F}; +var \u{32B20}; +var \u{32B21}; +var \u{32B22}; +var \u{32B23}; +var \u{32B24}; +var \u{32B25}; +var \u{32B26}; +var \u{32B27}; +var \u{32B28}; +var \u{32B29}; +var \u{32B2A}; +var \u{32B2B}; +var \u{32B2C}; +var \u{32B2D}; +var \u{32B2E}; +var \u{32B2F}; +var \u{32B30}; +var \u{32B31}; +var \u{32B32}; +var \u{32B33}; +var \u{32B34}; +var \u{32B35}; +var \u{32B36}; +var \u{32B37}; +var \u{32B38}; +var \u{32B39}; +var \u{32B3A}; +var \u{32B3B}; +var \u{32B3C}; +var \u{32B3D}; +var \u{32B3E}; +var \u{32B3F}; +var \u{32B40}; +var \u{32B41}; +var \u{32B42}; +var \u{32B43}; +var \u{32B44}; +var \u{32B45}; +var \u{32B46}; +var \u{32B47}; +var \u{32B48}; +var \u{32B49}; +var \u{32B4A}; +var \u{32B4B}; +var \u{32B4C}; +var \u{32B4D}; +var \u{32B4E}; +var \u{32B4F}; +var \u{32B50}; +var \u{32B51}; +var \u{32B52}; +var \u{32B53}; +var \u{32B54}; +var \u{32B55}; +var \u{32B56}; +var \u{32B57}; +var \u{32B58}; +var \u{32B59}; +var \u{32B5A}; +var \u{32B5B}; +var \u{32B5C}; +var \u{32B5D}; +var \u{32B5E}; +var \u{32B5F}; +var \u{32B60}; +var \u{32B61}; +var \u{32B62}; +var \u{32B63}; +var \u{32B64}; +var \u{32B65}; +var \u{32B66}; +var \u{32B67}; +var \u{32B68}; +var \u{32B69}; +var \u{32B6A}; +var \u{32B6B}; +var \u{32B6C}; +var \u{32B6D}; +var \u{32B6E}; +var \u{32B6F}; +var \u{32B70}; +var \u{32B71}; +var \u{32B72}; +var \u{32B73}; +var \u{32B74}; +var \u{32B75}; +var \u{32B76}; +var \u{32B77}; +var \u{32B78}; +var \u{32B79}; +var \u{32B7A}; +var \u{32B7B}; +var \u{32B7C}; +var \u{32B7D}; +var \u{32B7E}; +var \u{32B7F}; +var \u{32B80}; +var \u{32B81}; +var \u{32B82}; +var \u{32B83}; +var \u{32B84}; +var \u{32B85}; +var \u{32B86}; +var \u{32B87}; +var \u{32B88}; +var \u{32B89}; +var \u{32B8A}; +var \u{32B8B}; +var \u{32B8C}; +var \u{32B8D}; +var \u{32B8E}; +var \u{32B8F}; +var \u{32B90}; +var \u{32B91}; +var \u{32B92}; +var \u{32B93}; +var \u{32B94}; +var \u{32B95}; +var \u{32B96}; +var \u{32B97}; +var \u{32B98}; +var \u{32B99}; +var \u{32B9A}; +var \u{32B9B}; +var \u{32B9C}; +var \u{32B9D}; +var \u{32B9E}; +var \u{32B9F}; +var \u{32BA0}; +var \u{32BA1}; +var \u{32BA2}; +var \u{32BA3}; +var \u{32BA4}; +var \u{32BA5}; +var \u{32BA6}; +var \u{32BA7}; +var \u{32BA8}; +var \u{32BA9}; +var \u{32BAA}; +var \u{32BAB}; +var \u{32BAC}; +var \u{32BAD}; +var \u{32BAE}; +var \u{32BAF}; +var \u{32BB0}; +var \u{32BB1}; +var \u{32BB2}; +var \u{32BB3}; +var \u{32BB4}; +var \u{32BB5}; +var \u{32BB6}; +var \u{32BB7}; +var \u{32BB8}; +var \u{32BB9}; +var \u{32BBA}; +var \u{32BBB}; +var \u{32BBC}; +var \u{32BBD}; +var \u{32BBE}; +var \u{32BBF}; +var \u{32BC0}; +var \u{32BC1}; +var \u{32BC2}; +var \u{32BC3}; +var \u{32BC4}; +var \u{32BC5}; +var \u{32BC6}; +var \u{32BC7}; +var \u{32BC8}; +var \u{32BC9}; +var \u{32BCA}; +var \u{32BCB}; +var \u{32BCC}; +var \u{32BCD}; +var \u{32BCE}; +var \u{32BCF}; +var \u{32BD0}; +var \u{32BD1}; +var \u{32BD2}; +var \u{32BD3}; +var \u{32BD4}; +var \u{32BD5}; +var \u{32BD6}; +var \u{32BD7}; +var \u{32BD8}; +var \u{32BD9}; +var \u{32BDA}; +var \u{32BDB}; +var \u{32BDC}; +var \u{32BDD}; +var \u{32BDE}; +var \u{32BDF}; +var \u{32BE0}; +var \u{32BE1}; +var \u{32BE2}; +var \u{32BE3}; +var \u{32BE4}; +var \u{32BE5}; +var \u{32BE6}; +var \u{32BE7}; +var \u{32BE8}; +var \u{32BE9}; +var \u{32BEA}; +var \u{32BEB}; +var \u{32BEC}; +var \u{32BED}; +var \u{32BEE}; +var \u{32BEF}; +var \u{32BF0}; +var \u{32BF1}; +var \u{32BF2}; +var \u{32BF3}; +var \u{32BF4}; +var \u{32BF5}; +var \u{32BF6}; +var \u{32BF7}; +var \u{32BF8}; +var \u{32BF9}; +var \u{32BFA}; +var \u{32BFB}; +var \u{32BFC}; +var \u{32BFD}; +var \u{32BFE}; +var \u{32BFF}; +var \u{32C00}; +var \u{32C01}; +var \u{32C02}; +var \u{32C03}; +var \u{32C04}; +var \u{32C05}; +var \u{32C06}; +var \u{32C07}; +var \u{32C08}; +var \u{32C09}; +var \u{32C0A}; +var \u{32C0B}; +var \u{32C0C}; +var \u{32C0D}; +var \u{32C0E}; +var \u{32C0F}; +var \u{32C10}; +var \u{32C11}; +var \u{32C12}; +var \u{32C13}; +var \u{32C14}; +var \u{32C15}; +var \u{32C16}; +var \u{32C17}; +var \u{32C18}; +var \u{32C19}; +var \u{32C1A}; +var \u{32C1B}; +var \u{32C1C}; +var \u{32C1D}; +var \u{32C1E}; +var \u{32C1F}; +var \u{32C20}; +var \u{32C21}; +var \u{32C22}; +var \u{32C23}; +var \u{32C24}; +var \u{32C25}; +var \u{32C26}; +var \u{32C27}; +var \u{32C28}; +var \u{32C29}; +var \u{32C2A}; +var \u{32C2B}; +var \u{32C2C}; +var \u{32C2D}; +var \u{32C2E}; +var \u{32C2F}; +var \u{32C30}; +var \u{32C31}; +var \u{32C32}; +var \u{32C33}; +var \u{32C34}; +var \u{32C35}; +var \u{32C36}; +var \u{32C37}; +var \u{32C38}; +var \u{32C39}; +var \u{32C3A}; +var \u{32C3B}; +var \u{32C3C}; +var \u{32C3D}; +var \u{32C3E}; +var \u{32C3F}; +var \u{32C40}; +var \u{32C41}; +var \u{32C42}; +var \u{32C43}; +var \u{32C44}; +var \u{32C45}; +var \u{32C46}; +var \u{32C47}; +var \u{32C48}; +var \u{32C49}; +var \u{32C4A}; +var \u{32C4B}; +var \u{32C4C}; +var \u{32C4D}; +var \u{32C4E}; +var \u{32C4F}; +var \u{32C50}; +var \u{32C51}; +var \u{32C52}; +var \u{32C53}; +var \u{32C54}; +var \u{32C55}; +var \u{32C56}; +var \u{32C57}; +var \u{32C58}; +var \u{32C59}; +var \u{32C5A}; +var \u{32C5B}; +var \u{32C5C}; +var \u{32C5D}; +var \u{32C5E}; +var \u{32C5F}; +var \u{32C60}; +var \u{32C61}; +var \u{32C62}; +var \u{32C63}; +var \u{32C64}; +var \u{32C65}; +var \u{32C66}; +var \u{32C67}; +var \u{32C68}; +var \u{32C69}; +var \u{32C6A}; +var \u{32C6B}; +var \u{32C6C}; +var \u{32C6D}; +var \u{32C6E}; +var \u{32C6F}; +var \u{32C70}; +var \u{32C71}; +var \u{32C72}; +var \u{32C73}; +var \u{32C74}; +var \u{32C75}; +var \u{32C76}; +var \u{32C77}; +var \u{32C78}; +var \u{32C79}; +var \u{32C7A}; +var \u{32C7B}; +var \u{32C7C}; +var \u{32C7D}; +var \u{32C7E}; +var \u{32C7F}; +var \u{32C80}; +var \u{32C81}; +var \u{32C82}; +var \u{32C83}; +var \u{32C84}; +var \u{32C85}; +var \u{32C86}; +var \u{32C87}; +var \u{32C88}; +var \u{32C89}; +var \u{32C8A}; +var \u{32C8B}; +var \u{32C8C}; +var \u{32C8D}; +var \u{32C8E}; +var \u{32C8F}; +var \u{32C90}; +var \u{32C91}; +var \u{32C92}; +var \u{32C93}; +var \u{32C94}; +var \u{32C95}; +var \u{32C96}; +var \u{32C97}; +var \u{32C98}; +var \u{32C99}; +var \u{32C9A}; +var \u{32C9B}; +var \u{32C9C}; +var \u{32C9D}; +var \u{32C9E}; +var \u{32C9F}; +var \u{32CA0}; +var \u{32CA1}; +var \u{32CA2}; +var \u{32CA3}; +var \u{32CA4}; +var \u{32CA5}; +var \u{32CA6}; +var \u{32CA7}; +var \u{32CA8}; +var \u{32CA9}; +var \u{32CAA}; +var \u{32CAB}; +var \u{32CAC}; +var \u{32CAD}; +var \u{32CAE}; +var \u{32CAF}; +var \u{32CB0}; +var \u{32CB1}; +var \u{32CB2}; +var \u{32CB3}; +var \u{32CB4}; +var \u{32CB5}; +var \u{32CB6}; +var \u{32CB7}; +var \u{32CB8}; +var \u{32CB9}; +var \u{32CBA}; +var \u{32CBB}; +var \u{32CBC}; +var \u{32CBD}; +var \u{32CBE}; +var \u{32CBF}; +var \u{32CC0}; +var \u{32CC1}; +var \u{32CC2}; +var \u{32CC3}; +var \u{32CC4}; +var \u{32CC5}; +var \u{32CC6}; +var \u{32CC7}; +var \u{32CC8}; +var \u{32CC9}; +var \u{32CCA}; +var \u{32CCB}; +var \u{32CCC}; +var \u{32CCD}; +var \u{32CCE}; +var \u{32CCF}; +var \u{32CD0}; +var \u{32CD1}; +var \u{32CD2}; +var \u{32CD3}; +var \u{32CD4}; +var \u{32CD5}; +var \u{32CD6}; +var \u{32CD7}; +var \u{32CD8}; +var \u{32CD9}; +var \u{32CDA}; +var \u{32CDB}; +var \u{32CDC}; +var \u{32CDD}; +var \u{32CDE}; +var \u{32CDF}; +var \u{32CE0}; +var \u{32CE1}; +var \u{32CE2}; +var \u{32CE3}; +var \u{32CE4}; +var \u{32CE5}; +var \u{32CE6}; +var \u{32CE7}; +var \u{32CE8}; +var \u{32CE9}; +var \u{32CEA}; +var \u{32CEB}; +var \u{32CEC}; +var \u{32CED}; +var \u{32CEE}; +var \u{32CEF}; +var \u{32CF0}; +var \u{32CF1}; +var \u{32CF2}; +var \u{32CF3}; +var \u{32CF4}; +var \u{32CF5}; +var \u{32CF6}; +var \u{32CF7}; +var \u{32CF8}; +var \u{32CF9}; +var \u{32CFA}; +var \u{32CFB}; +var \u{32CFC}; +var \u{32CFD}; +var \u{32CFE}; +var \u{32CFF}; +var \u{32D00}; +var \u{32D01}; +var \u{32D02}; +var \u{32D03}; +var \u{32D04}; +var \u{32D05}; +var \u{32D06}; +var \u{32D07}; +var \u{32D08}; +var \u{32D09}; +var \u{32D0A}; +var \u{32D0B}; +var \u{32D0C}; +var \u{32D0D}; +var \u{32D0E}; +var \u{32D0F}; +var \u{32D10}; +var \u{32D11}; +var \u{32D12}; +var \u{32D13}; +var \u{32D14}; +var \u{32D15}; +var \u{32D16}; +var \u{32D17}; +var \u{32D18}; +var \u{32D19}; +var \u{32D1A}; +var \u{32D1B}; +var \u{32D1C}; +var \u{32D1D}; +var \u{32D1E}; +var \u{32D1F}; +var \u{32D20}; +var \u{32D21}; +var \u{32D22}; +var \u{32D23}; +var \u{32D24}; +var \u{32D25}; +var \u{32D26}; +var \u{32D27}; +var \u{32D28}; +var \u{32D29}; +var \u{32D2A}; +var \u{32D2B}; +var \u{32D2C}; +var \u{32D2D}; +var \u{32D2E}; +var \u{32D2F}; +var \u{32D30}; +var \u{32D31}; +var \u{32D32}; +var \u{32D33}; +var \u{32D34}; +var \u{32D35}; +var \u{32D36}; +var \u{32D37}; +var \u{32D38}; +var \u{32D39}; +var \u{32D3A}; +var \u{32D3B}; +var \u{32D3C}; +var \u{32D3D}; +var \u{32D3E}; +var \u{32D3F}; +var \u{32D40}; +var \u{32D41}; +var \u{32D42}; +var \u{32D43}; +var \u{32D44}; +var \u{32D45}; +var \u{32D46}; +var \u{32D47}; +var \u{32D48}; +var \u{32D49}; +var \u{32D4A}; +var \u{32D4B}; +var \u{32D4C}; +var \u{32D4D}; +var \u{32D4E}; +var \u{32D4F}; +var \u{32D50}; +var \u{32D51}; +var \u{32D52}; +var \u{32D53}; +var \u{32D54}; +var \u{32D55}; +var \u{32D56}; +var \u{32D57}; +var \u{32D58}; +var \u{32D59}; +var \u{32D5A}; +var \u{32D5B}; +var \u{32D5C}; +var \u{32D5D}; +var \u{32D5E}; +var \u{32D5F}; +var \u{32D60}; +var \u{32D61}; +var \u{32D62}; +var \u{32D63}; +var \u{32D64}; +var \u{32D65}; +var \u{32D66}; +var \u{32D67}; +var \u{32D68}; +var \u{32D69}; +var \u{32D6A}; +var \u{32D6B}; +var \u{32D6C}; +var \u{32D6D}; +var \u{32D6E}; +var \u{32D6F}; +var \u{32D70}; +var \u{32D71}; +var \u{32D72}; +var \u{32D73}; +var \u{32D74}; +var \u{32D75}; +var \u{32D76}; +var \u{32D77}; +var \u{32D78}; +var \u{32D79}; +var \u{32D7A}; +var \u{32D7B}; +var \u{32D7C}; +var \u{32D7D}; +var \u{32D7E}; +var \u{32D7F}; +var \u{32D80}; +var \u{32D81}; +var \u{32D82}; +var \u{32D83}; +var \u{32D84}; +var \u{32D85}; +var \u{32D86}; +var \u{32D87}; +var \u{32D88}; +var \u{32D89}; +var \u{32D8A}; +var \u{32D8B}; +var \u{32D8C}; +var \u{32D8D}; +var \u{32D8E}; +var \u{32D8F}; +var \u{32D90}; +var \u{32D91}; +var \u{32D92}; +var \u{32D93}; +var \u{32D94}; +var \u{32D95}; +var \u{32D96}; +var \u{32D97}; +var \u{32D98}; +var \u{32D99}; +var \u{32D9A}; +var \u{32D9B}; +var \u{32D9C}; +var \u{32D9D}; +var \u{32D9E}; +var \u{32D9F}; +var \u{32DA0}; +var \u{32DA1}; +var \u{32DA2}; +var \u{32DA3}; +var \u{32DA4}; +var \u{32DA5}; +var \u{32DA6}; +var \u{32DA7}; +var \u{32DA8}; +var \u{32DA9}; +var \u{32DAA}; +var \u{32DAB}; +var \u{32DAC}; +var \u{32DAD}; +var \u{32DAE}; +var \u{32DAF}; +var \u{32DB0}; +var \u{32DB1}; +var \u{32DB2}; +var \u{32DB3}; +var \u{32DB4}; +var \u{32DB5}; +var \u{32DB6}; +var \u{32DB7}; +var \u{32DB8}; +var \u{32DB9}; +var \u{32DBA}; +var \u{32DBB}; +var \u{32DBC}; +var \u{32DBD}; +var \u{32DBE}; +var \u{32DBF}; +var \u{32DC0}; +var \u{32DC1}; +var \u{32DC2}; +var \u{32DC3}; +var \u{32DC4}; +var \u{32DC5}; +var \u{32DC6}; +var \u{32DC7}; +var \u{32DC8}; +var \u{32DC9}; +var \u{32DCA}; +var \u{32DCB}; +var \u{32DCC}; +var \u{32DCD}; +var \u{32DCE}; +var \u{32DCF}; +var \u{32DD0}; +var \u{32DD1}; +var \u{32DD2}; +var \u{32DD3}; +var \u{32DD4}; +var \u{32DD5}; +var \u{32DD6}; +var \u{32DD7}; +var \u{32DD8}; +var \u{32DD9}; +var \u{32DDA}; +var \u{32DDB}; +var \u{32DDC}; +var \u{32DDD}; +var \u{32DDE}; +var \u{32DDF}; +var \u{32DE0}; +var \u{32DE1}; +var \u{32DE2}; +var \u{32DE3}; +var \u{32DE4}; +var \u{32DE5}; +var \u{32DE6}; +var \u{32DE7}; +var \u{32DE8}; +var \u{32DE9}; +var \u{32DEA}; +var \u{32DEB}; +var \u{32DEC}; +var \u{32DED}; +var \u{32DEE}; +var \u{32DEF}; +var \u{32DF0}; +var \u{32DF1}; +var \u{32DF2}; +var \u{32DF3}; +var \u{32DF4}; +var \u{32DF5}; +var \u{32DF6}; +var \u{32DF7}; +var \u{32DF8}; +var \u{32DF9}; +var \u{32DFA}; +var \u{32DFB}; +var \u{32DFC}; +var \u{32DFD}; +var \u{32DFE}; +var \u{32DFF}; +var \u{32E00}; +var \u{32E01}; +var \u{32E02}; +var \u{32E03}; +var \u{32E04}; +var \u{32E05}; +var \u{32E06}; +var \u{32E07}; +var \u{32E08}; +var \u{32E09}; +var \u{32E0A}; +var \u{32E0B}; +var \u{32E0C}; +var \u{32E0D}; +var \u{32E0E}; +var \u{32E0F}; +var \u{32E10}; +var \u{32E11}; +var \u{32E12}; +var \u{32E13}; +var \u{32E14}; +var \u{32E15}; +var \u{32E16}; +var \u{32E17}; +var \u{32E18}; +var \u{32E19}; +var \u{32E1A}; +var \u{32E1B}; +var \u{32E1C}; +var \u{32E1D}; +var \u{32E1E}; +var \u{32E1F}; +var \u{32E20}; +var \u{32E21}; +var \u{32E22}; +var \u{32E23}; +var \u{32E24}; +var \u{32E25}; +var \u{32E26}; +var \u{32E27}; +var \u{32E28}; +var \u{32E29}; +var \u{32E2A}; +var \u{32E2B}; +var \u{32E2C}; +var \u{32E2D}; +var \u{32E2E}; +var \u{32E2F}; +var \u{32E30}; +var \u{32E31}; +var \u{32E32}; +var \u{32E33}; +var \u{32E34}; +var \u{32E35}; +var \u{32E36}; +var \u{32E37}; +var \u{32E38}; +var \u{32E39}; +var \u{32E3A}; +var \u{32E3B}; +var \u{32E3C}; +var \u{32E3D}; +var \u{32E3E}; +var \u{32E3F}; +var \u{32E40}; +var \u{32E41}; +var \u{32E42}; +var \u{32E43}; +var \u{32E44}; +var \u{32E45}; +var \u{32E46}; +var \u{32E47}; +var \u{32E48}; +var \u{32E49}; +var \u{32E4A}; +var \u{32E4B}; +var \u{32E4C}; +var \u{32E4D}; +var \u{32E4E}; +var \u{32E4F}; +var \u{32E50}; +var \u{32E51}; +var \u{32E52}; +var \u{32E53}; +var \u{32E54}; +var \u{32E55}; +var \u{32E56}; +var \u{32E57}; +var \u{32E58}; +var \u{32E59}; +var \u{32E5A}; +var \u{32E5B}; +var \u{32E5C}; +var \u{32E5D}; +var \u{32E5E}; +var \u{32E5F}; +var \u{32E60}; +var \u{32E61}; +var \u{32E62}; +var \u{32E63}; +var \u{32E64}; +var \u{32E65}; +var \u{32E66}; +var \u{32E67}; +var \u{32E68}; +var \u{32E69}; +var \u{32E6A}; +var \u{32E6B}; +var \u{32E6C}; +var \u{32E6D}; +var \u{32E6E}; +var \u{32E6F}; +var \u{32E70}; +var \u{32E71}; +var \u{32E72}; +var \u{32E73}; +var \u{32E74}; +var \u{32E75}; +var \u{32E76}; +var \u{32E77}; +var \u{32E78}; +var \u{32E79}; +var \u{32E7A}; +var \u{32E7B}; +var \u{32E7C}; +var \u{32E7D}; +var \u{32E7E}; +var \u{32E7F}; +var \u{32E80}; +var \u{32E81}; +var \u{32E82}; +var \u{32E83}; +var \u{32E84}; +var \u{32E85}; +var \u{32E86}; +var \u{32E87}; +var \u{32E88}; +var \u{32E89}; +var \u{32E8A}; +var \u{32E8B}; +var \u{32E8C}; +var \u{32E8D}; +var \u{32E8E}; +var \u{32E8F}; +var \u{32E90}; +var \u{32E91}; +var \u{32E92}; +var \u{32E93}; +var \u{32E94}; +var \u{32E95}; +var \u{32E96}; +var \u{32E97}; +var \u{32E98}; +var \u{32E99}; +var \u{32E9A}; +var \u{32E9B}; +var \u{32E9C}; +var \u{32E9D}; +var \u{32E9E}; +var \u{32E9F}; +var \u{32EA0}; +var \u{32EA1}; +var \u{32EA2}; +var \u{32EA3}; +var \u{32EA4}; +var \u{32EA5}; +var \u{32EA6}; +var \u{32EA7}; +var \u{32EA8}; +var \u{32EA9}; +var \u{32EAA}; +var \u{32EAB}; +var \u{32EAC}; +var \u{32EAD}; +var \u{32EAE}; +var \u{32EAF}; +var \u{32EB0}; +var \u{32EB1}; +var \u{32EB2}; +var \u{32EB3}; +var \u{32EB4}; +var \u{32EB5}; +var \u{32EB6}; +var \u{32EB7}; +var \u{32EB8}; +var \u{32EB9}; +var \u{32EBA}; +var \u{32EBB}; +var \u{32EBC}; +var \u{32EBD}; +var \u{32EBE}; +var \u{32EBF}; +var \u{32EC0}; +var \u{32EC1}; +var \u{32EC2}; +var \u{32EC3}; +var \u{32EC4}; +var \u{32EC5}; +var \u{32EC6}; +var \u{32EC7}; +var \u{32EC8}; +var \u{32EC9}; +var \u{32ECA}; +var \u{32ECB}; +var \u{32ECC}; +var \u{32ECD}; +var \u{32ECE}; +var \u{32ECF}; +var \u{32ED0}; +var \u{32ED1}; +var \u{32ED2}; +var \u{32ED3}; +var \u{32ED4}; +var \u{32ED5}; +var \u{32ED6}; +var \u{32ED7}; +var \u{32ED8}; +var \u{32ED9}; +var \u{32EDA}; +var \u{32EDB}; +var \u{32EDC}; +var \u{32EDD}; +var \u{32EDE}; +var \u{32EDF}; +var \u{32EE0}; +var \u{32EE1}; +var \u{32EE2}; +var \u{32EE3}; +var \u{32EE4}; +var \u{32EE5}; +var \u{32EE6}; +var \u{32EE7}; +var \u{32EE8}; +var \u{32EE9}; +var \u{32EEA}; +var \u{32EEB}; +var \u{32EEC}; +var \u{32EED}; +var \u{32EEE}; +var \u{32EEF}; +var \u{32EF0}; +var \u{32EF1}; +var \u{32EF2}; +var \u{32EF3}; +var \u{32EF4}; +var \u{32EF5}; +var \u{32EF6}; +var \u{32EF7}; +var \u{32EF8}; +var \u{32EF9}; +var \u{32EFA}; +var \u{32EFB}; +var \u{32EFC}; +var \u{32EFD}; +var \u{32EFE}; +var \u{32EFF}; +var \u{32F00}; +var \u{32F01}; +var \u{32F02}; +var \u{32F03}; +var \u{32F04}; +var \u{32F05}; +var \u{32F06}; +var \u{32F07}; +var \u{32F08}; +var \u{32F09}; +var \u{32F0A}; +var \u{32F0B}; +var \u{32F0C}; +var \u{32F0D}; +var \u{32F0E}; +var \u{32F0F}; +var \u{32F10}; +var \u{32F11}; +var \u{32F12}; +var \u{32F13}; +var \u{32F14}; +var \u{32F15}; +var \u{32F16}; +var \u{32F17}; +var \u{32F18}; +var \u{32F19}; +var \u{32F1A}; +var \u{32F1B}; +var \u{32F1C}; +var \u{32F1D}; +var \u{32F1E}; +var \u{32F1F}; +var \u{32F20}; +var \u{32F21}; +var \u{32F22}; +var \u{32F23}; +var \u{32F24}; +var \u{32F25}; +var \u{32F26}; +var \u{32F27}; +var \u{32F28}; +var \u{32F29}; +var \u{32F2A}; +var \u{32F2B}; +var \u{32F2C}; +var \u{32F2D}; +var \u{32F2E}; +var \u{32F2F}; +var \u{32F30}; +var \u{32F31}; +var \u{32F32}; +var \u{32F33}; +var \u{32F34}; +var \u{32F35}; +var \u{32F36}; +var \u{32F37}; +var \u{32F38}; +var \u{32F39}; +var \u{32F3A}; +var \u{32F3B}; +var \u{32F3C}; +var \u{32F3D}; +var \u{32F3E}; +var \u{32F3F}; +var \u{32F40}; +var \u{32F41}; +var \u{32F42}; +var \u{32F43}; +var \u{32F44}; +var \u{32F45}; +var \u{32F46}; +var \u{32F47}; +var \u{32F48}; +var \u{32F49}; +var \u{32F4A}; +var \u{32F4B}; +var \u{32F4C}; +var \u{32F4D}; +var \u{32F4E}; +var \u{32F4F}; +var \u{32F50}; +var \u{32F51}; +var \u{32F52}; +var \u{32F53}; +var \u{32F54}; +var \u{32F55}; +var \u{32F56}; +var \u{32F57}; +var \u{32F58}; +var \u{32F59}; +var \u{32F5A}; +var \u{32F5B}; +var \u{32F5C}; +var \u{32F5D}; +var \u{32F5E}; +var \u{32F5F}; +var \u{32F60}; +var \u{32F61}; +var \u{32F62}; +var \u{32F63}; +var \u{32F64}; +var \u{32F65}; +var \u{32F66}; +var \u{32F67}; +var \u{32F68}; +var \u{32F69}; +var \u{32F6A}; +var \u{32F6B}; +var \u{32F6C}; +var \u{32F6D}; +var \u{32F6E}; +var \u{32F6F}; +var \u{32F70}; +var \u{32F71}; +var \u{32F72}; +var \u{32F73}; +var \u{32F74}; +var \u{32F75}; +var \u{32F76}; +var \u{32F77}; +var \u{32F78}; +var \u{32F79}; +var \u{32F7A}; +var \u{32F7B}; +var \u{32F7C}; +var \u{32F7D}; +var \u{32F7E}; +var \u{32F7F}; +var \u{32F80}; +var \u{32F81}; +var \u{32F82}; +var \u{32F83}; +var \u{32F84}; +var \u{32F85}; +var \u{32F86}; +var \u{32F87}; +var \u{32F88}; +var \u{32F89}; +var \u{32F8A}; +var \u{32F8B}; +var \u{32F8C}; +var \u{32F8D}; +var \u{32F8E}; +var \u{32F8F}; +var \u{32F90}; +var \u{32F91}; +var \u{32F92}; +var \u{32F93}; +var \u{32F94}; +var \u{32F95}; +var \u{32F96}; +var \u{32F97}; +var \u{32F98}; +var \u{32F99}; +var \u{32F9A}; +var \u{32F9B}; +var \u{32F9C}; +var \u{32F9D}; +var \u{32F9E}; +var \u{32F9F}; +var \u{32FA0}; +var \u{32FA1}; +var \u{32FA2}; +var \u{32FA3}; +var \u{32FA4}; +var \u{32FA5}; +var \u{32FA6}; +var \u{32FA7}; +var \u{32FA8}; +var \u{32FA9}; +var \u{32FAA}; +var \u{32FAB}; +var \u{32FAC}; +var \u{32FAD}; +var \u{32FAE}; +var \u{32FAF}; +var \u{32FB0}; +var \u{32FB1}; +var \u{32FB2}; +var \u{32FB3}; +var \u{32FB4}; +var \u{32FB5}; +var \u{32FB6}; +var \u{32FB7}; +var \u{32FB8}; +var \u{32FB9}; +var \u{32FBA}; +var \u{32FBB}; +var \u{32FBC}; +var \u{32FBD}; +var \u{32FBE}; +var \u{32FBF}; +var \u{32FC0}; +var \u{32FC1}; +var \u{32FC2}; +var \u{32FC3}; +var \u{32FC4}; +var \u{32FC5}; +var \u{32FC6}; +var \u{32FC7}; +var \u{32FC8}; +var \u{32FC9}; +var \u{32FCA}; +var \u{32FCB}; +var \u{32FCC}; +var \u{32FCD}; +var \u{32FCE}; +var \u{32FCF}; +var \u{32FD0}; +var \u{32FD1}; +var \u{32FD2}; +var \u{32FD3}; +var \u{32FD4}; +var \u{32FD5}; +var \u{32FD6}; +var \u{32FD7}; +var \u{32FD8}; +var \u{32FD9}; +var \u{32FDA}; +var \u{32FDB}; +var \u{32FDC}; +var \u{32FDD}; +var \u{32FDE}; +var \u{32FDF}; +var \u{32FE0}; +var \u{32FE1}; +var \u{32FE2}; +var \u{32FE3}; +var \u{32FE4}; +var \u{32FE5}; +var \u{32FE6}; +var \u{32FE7}; +var \u{32FE8}; +var \u{32FE9}; +var \u{32FEA}; +var \u{32FEB}; +var \u{32FEC}; +var \u{32FED}; +var \u{32FEE}; +var \u{32FEF}; +var \u{32FF0}; +var \u{32FF1}; +var \u{32FF2}; +var \u{32FF3}; +var \u{32FF4}; +var \u{32FF5}; +var \u{32FF6}; +var \u{32FF7}; +var \u{32FF8}; +var \u{32FF9}; +var \u{32FFA}; +var \u{32FFB}; +var \u{32FFC}; +var \u{32FFD}; +var \u{32FFE}; +var \u{32FFF}; +var \u{33000}; +var \u{33001}; +var \u{33002}; +var \u{33003}; +var \u{33004}; +var \u{33005}; +var \u{33006}; +var \u{33007}; +var \u{33008}; +var \u{33009}; +var \u{3300A}; +var \u{3300B}; +var \u{3300C}; +var \u{3300D}; +var \u{3300E}; +var \u{3300F}; +var \u{33010}; +var \u{33011}; +var \u{33012}; +var \u{33013}; +var \u{33014}; +var \u{33015}; +var \u{33016}; +var \u{33017}; +var \u{33018}; +var \u{33019}; +var \u{3301A}; +var \u{3301B}; +var \u{3301C}; +var \u{3301D}; +var \u{3301E}; +var \u{3301F}; +var \u{33020}; +var \u{33021}; +var \u{33022}; +var \u{33023}; +var \u{33024}; +var \u{33025}; +var \u{33026}; +var \u{33027}; +var \u{33028}; +var \u{33029}; +var \u{3302A}; +var \u{3302B}; +var \u{3302C}; +var \u{3302D}; +var \u{3302E}; +var \u{3302F}; +var \u{33030}; +var \u{33031}; +var \u{33032}; +var \u{33033}; +var \u{33034}; +var \u{33035}; +var \u{33036}; +var \u{33037}; +var \u{33038}; +var \u{33039}; +var \u{3303A}; +var \u{3303B}; +var \u{3303C}; +var \u{3303D}; +var \u{3303E}; +var \u{3303F}; +var \u{33040}; +var \u{33041}; +var \u{33042}; +var \u{33043}; +var \u{33044}; +var \u{33045}; +var \u{33046}; +var \u{33047}; +var \u{33048}; +var \u{33049}; +var \u{3304A}; +var \u{3304B}; +var \u{3304C}; +var \u{3304D}; +var \u{3304E}; +var \u{3304F}; +var \u{33050}; +var \u{33051}; +var \u{33052}; +var \u{33053}; +var \u{33054}; +var \u{33055}; +var \u{33056}; +var \u{33057}; +var \u{33058}; +var \u{33059}; +var \u{3305A}; +var \u{3305B}; +var \u{3305C}; +var \u{3305D}; +var \u{3305E}; +var \u{3305F}; +var \u{33060}; +var \u{33061}; +var \u{33062}; +var \u{33063}; +var \u{33064}; +var \u{33065}; +var \u{33066}; +var \u{33067}; +var \u{33068}; +var \u{33069}; +var \u{3306A}; +var \u{3306B}; +var \u{3306C}; +var \u{3306D}; +var \u{3306E}; +var \u{3306F}; +var \u{33070}; +var \u{33071}; +var \u{33072}; +var \u{33073}; +var \u{33074}; +var \u{33075}; +var \u{33076}; +var \u{33077}; +var \u{33078}; +var \u{33079}; +var \u{3307A}; +var \u{3307B}; +var \u{3307C}; +var \u{3307D}; +var \u{3307E}; +var \u{3307F}; +var \u{33080}; +var \u{33081}; +var \u{33082}; +var \u{33083}; +var \u{33084}; +var \u{33085}; +var \u{33086}; +var \u{33087}; +var \u{33088}; +var \u{33089}; +var \u{3308A}; +var \u{3308B}; +var \u{3308C}; +var \u{3308D}; +var \u{3308E}; +var \u{3308F}; +var \u{33090}; +var \u{33091}; +var \u{33092}; +var \u{33093}; +var \u{33094}; +var \u{33095}; +var \u{33096}; +var \u{33097}; +var \u{33098}; +var \u{33099}; +var \u{3309A}; +var \u{3309B}; +var \u{3309C}; +var \u{3309D}; +var \u{3309E}; +var \u{3309F}; +var \u{330A0}; +var \u{330A1}; +var \u{330A2}; +var \u{330A3}; +var \u{330A4}; +var \u{330A5}; +var \u{330A6}; +var \u{330A7}; +var \u{330A8}; +var \u{330A9}; +var \u{330AA}; +var \u{330AB}; +var \u{330AC}; +var \u{330AD}; +var \u{330AE}; +var \u{330AF}; +var \u{330B0}; +var \u{330B1}; +var \u{330B2}; +var \u{330B3}; +var \u{330B4}; +var \u{330B5}; +var \u{330B6}; +var \u{330B7}; +var \u{330B8}; +var \u{330B9}; +var \u{330BA}; +var \u{330BB}; +var \u{330BC}; +var \u{330BD}; +var \u{330BE}; +var \u{330BF}; +var \u{330C0}; +var \u{330C1}; +var \u{330C2}; +var \u{330C3}; +var \u{330C4}; +var \u{330C5}; +var \u{330C6}; +var \u{330C7}; +var \u{330C8}; +var \u{330C9}; +var \u{330CA}; +var \u{330CB}; +var \u{330CC}; +var \u{330CD}; +var \u{330CE}; +var \u{330CF}; +var \u{330D0}; +var \u{330D1}; +var \u{330D2}; +var \u{330D3}; +var \u{330D4}; +var \u{330D5}; +var \u{330D6}; +var \u{330D7}; +var \u{330D8}; +var \u{330D9}; +var \u{330DA}; +var \u{330DB}; +var \u{330DC}; +var \u{330DD}; +var \u{330DE}; +var \u{330DF}; +var \u{330E0}; +var \u{330E1}; +var \u{330E2}; +var \u{330E3}; +var \u{330E4}; +var \u{330E5}; +var \u{330E6}; +var \u{330E7}; +var \u{330E8}; +var \u{330E9}; +var \u{330EA}; +var \u{330EB}; +var \u{330EC}; +var \u{330ED}; +var \u{330EE}; +var \u{330EF}; +var \u{330F0}; +var \u{330F1}; +var \u{330F2}; +var \u{330F3}; +var \u{330F4}; +var \u{330F5}; +var \u{330F6}; +var \u{330F7}; +var \u{330F8}; +var \u{330F9}; +var \u{330FA}; +var \u{330FB}; +var \u{330FC}; +var \u{330FD}; +var \u{330FE}; +var \u{330FF}; +var \u{33100}; +var \u{33101}; +var \u{33102}; +var \u{33103}; +var \u{33104}; +var \u{33105}; +var \u{33106}; +var \u{33107}; +var \u{33108}; +var \u{33109}; +var \u{3310A}; +var \u{3310B}; +var \u{3310C}; +var \u{3310D}; +var \u{3310E}; +var \u{3310F}; +var \u{33110}; +var \u{33111}; +var \u{33112}; +var \u{33113}; +var \u{33114}; +var \u{33115}; +var \u{33116}; +var \u{33117}; +var \u{33118}; +var \u{33119}; +var \u{3311A}; +var \u{3311B}; +var \u{3311C}; +var \u{3311D}; +var \u{3311E}; +var \u{3311F}; +var \u{33120}; +var \u{33121}; +var \u{33122}; +var \u{33123}; +var \u{33124}; +var \u{33125}; +var \u{33126}; +var \u{33127}; +var \u{33128}; +var \u{33129}; +var \u{3312A}; +var \u{3312B}; +var \u{3312C}; +var \u{3312D}; +var \u{3312E}; +var \u{3312F}; +var \u{33130}; +var \u{33131}; +var \u{33132}; +var \u{33133}; +var \u{33134}; +var \u{33135}; +var \u{33136}; +var \u{33137}; +var \u{33138}; +var \u{33139}; +var \u{3313A}; +var \u{3313B}; +var \u{3313C}; +var \u{3313D}; +var \u{3313E}; +var \u{3313F}; +var \u{33140}; +var \u{33141}; +var \u{33142}; +var \u{33143}; +var \u{33144}; +var \u{33145}; +var \u{33146}; +var \u{33147}; +var \u{33148}; +var \u{33149}; +var \u{3314A}; +var \u{3314B}; +var \u{3314C}; +var \u{3314D}; +var \u{3314E}; +var \u{3314F}; +var \u{33150}; +var \u{33151}; +var \u{33152}; +var \u{33153}; +var \u{33154}; +var \u{33155}; +var \u{33156}; +var \u{33157}; +var \u{33158}; +var \u{33159}; +var \u{3315A}; +var \u{3315B}; +var \u{3315C}; +var \u{3315D}; +var \u{3315E}; +var \u{3315F}; +var \u{33160}; +var \u{33161}; +var \u{33162}; +var \u{33163}; +var \u{33164}; +var \u{33165}; +var \u{33166}; +var \u{33167}; +var \u{33168}; +var \u{33169}; +var \u{3316A}; +var \u{3316B}; +var \u{3316C}; +var \u{3316D}; +var \u{3316E}; +var \u{3316F}; +var \u{33170}; +var \u{33171}; +var \u{33172}; +var \u{33173}; +var \u{33174}; +var \u{33175}; +var \u{33176}; +var \u{33177}; +var \u{33178}; +var \u{33179}; +var \u{3317A}; +var \u{3317B}; +var \u{3317C}; +var \u{3317D}; +var \u{3317E}; +var \u{3317F}; +var \u{33180}; +var \u{33181}; +var \u{33182}; +var \u{33183}; +var \u{33184}; +var \u{33185}; +var \u{33186}; +var \u{33187}; +var \u{33188}; +var \u{33189}; +var \u{3318A}; +var \u{3318B}; +var \u{3318C}; +var \u{3318D}; +var \u{3318E}; +var \u{3318F}; +var \u{33190}; +var \u{33191}; +var \u{33192}; +var \u{33193}; +var \u{33194}; +var \u{33195}; +var \u{33196}; +var \u{33197}; +var \u{33198}; +var \u{33199}; +var \u{3319A}; +var \u{3319B}; +var \u{3319C}; +var \u{3319D}; +var \u{3319E}; +var \u{3319F}; +var \u{331A0}; +var \u{331A1}; +var \u{331A2}; +var \u{331A3}; +var \u{331A4}; +var \u{331A5}; +var \u{331A6}; +var \u{331A7}; +var \u{331A8}; +var \u{331A9}; +var \u{331AA}; +var \u{331AB}; +var \u{331AC}; +var \u{331AD}; +var \u{331AE}; +var \u{331AF}; +var \u{331B0}; +var \u{331B1}; +var \u{331B2}; +var \u{331B3}; +var \u{331B4}; +var \u{331B5}; +var \u{331B6}; +var \u{331B7}; +var \u{331B8}; +var \u{331B9}; +var \u{331BA}; +var \u{331BB}; +var \u{331BC}; +var \u{331BD}; +var \u{331BE}; +var \u{331BF}; +var \u{331C0}; +var \u{331C1}; +var \u{331C2}; +var \u{331C3}; +var \u{331C4}; +var \u{331C5}; +var \u{331C6}; +var \u{331C7}; +var \u{331C8}; +var \u{331C9}; +var \u{331CA}; +var \u{331CB}; +var \u{331CC}; +var \u{331CD}; +var \u{331CE}; +var \u{331CF}; +var \u{331D0}; +var \u{331D1}; +var \u{331D2}; +var \u{331D3}; +var \u{331D4}; +var \u{331D5}; +var \u{331D6}; +var \u{331D7}; +var \u{331D8}; +var \u{331D9}; +var \u{331DA}; +var \u{331DB}; +var \u{331DC}; +var \u{331DD}; +var \u{331DE}; +var \u{331DF}; +var \u{331E0}; +var \u{331E1}; +var \u{331E2}; +var \u{331E3}; +var \u{331E4}; +var \u{331E5}; +var \u{331E6}; +var \u{331E7}; +var \u{331E8}; +var \u{331E9}; +var \u{331EA}; +var \u{331EB}; +var \u{331EC}; +var \u{331ED}; +var \u{331EE}; +var \u{331EF}; +var \u{331F0}; +var \u{331F1}; +var \u{331F2}; +var \u{331F3}; +var \u{331F4}; +var \u{331F5}; +var \u{331F6}; +var \u{331F7}; +var \u{331F8}; +var \u{331F9}; +var \u{331FA}; +var \u{331FB}; +var \u{331FC}; +var \u{331FD}; +var \u{331FE}; +var \u{331FF}; +var \u{33200}; +var \u{33201}; +var \u{33202}; +var \u{33203}; +var \u{33204}; +var \u{33205}; +var \u{33206}; +var \u{33207}; +var \u{33208}; +var \u{33209}; +var \u{3320A}; +var \u{3320B}; +var \u{3320C}; +var \u{3320D}; +var \u{3320E}; +var \u{3320F}; +var \u{33210}; +var \u{33211}; +var \u{33212}; +var \u{33213}; +var \u{33214}; +var \u{33215}; +var \u{33216}; +var \u{33217}; +var \u{33218}; +var \u{33219}; +var \u{3321A}; +var \u{3321B}; +var \u{3321C}; +var \u{3321D}; +var \u{3321E}; +var \u{3321F}; +var \u{33220}; +var \u{33221}; +var \u{33222}; +var \u{33223}; +var \u{33224}; +var \u{33225}; +var \u{33226}; +var \u{33227}; +var \u{33228}; +var \u{33229}; +var \u{3322A}; +var \u{3322B}; +var \u{3322C}; +var \u{3322D}; +var \u{3322E}; +var \u{3322F}; +var \u{33230}; +var \u{33231}; +var \u{33232}; +var \u{33233}; +var \u{33234}; +var \u{33235}; +var \u{33236}; +var \u{33237}; +var \u{33238}; +var \u{33239}; +var \u{3323A}; +var \u{3323B}; +var \u{3323C}; +var \u{3323D}; +var \u{3323E}; +var \u{3323F}; +var \u{33240}; +var \u{33241}; +var \u{33242}; +var \u{33243}; +var \u{33244}; +var \u{33245}; +var \u{33246}; +var \u{33247}; +var \u{33248}; +var \u{33249}; +var \u{3324A}; +var \u{3324B}; +var \u{3324C}; +var \u{3324D}; +var \u{3324E}; +var \u{3324F}; +var \u{33250}; +var \u{33251}; +var \u{33252}; +var \u{33253}; +var \u{33254}; +var \u{33255}; +var \u{33256}; +var \u{33257}; +var \u{33258}; +var \u{33259}; +var \u{3325A}; +var \u{3325B}; +var \u{3325C}; +var \u{3325D}; +var \u{3325E}; +var \u{3325F}; +var \u{33260}; +var \u{33261}; +var \u{33262}; +var \u{33263}; +var \u{33264}; +var \u{33265}; +var \u{33266}; +var \u{33267}; +var \u{33268}; +var \u{33269}; +var \u{3326A}; +var \u{3326B}; +var \u{3326C}; +var \u{3326D}; +var \u{3326E}; +var \u{3326F}; +var \u{33270}; +var \u{33271}; +var \u{33272}; +var \u{33273}; +var \u{33274}; +var \u{33275}; +var \u{33276}; +var \u{33277}; +var \u{33278}; +var \u{33279}; +var \u{3327A}; +var \u{3327B}; +var \u{3327C}; +var \u{3327D}; +var \u{3327E}; +var \u{3327F}; +var \u{33280}; +var \u{33281}; +var \u{33282}; +var \u{33283}; +var \u{33284}; +var \u{33285}; +var \u{33286}; +var \u{33287}; +var \u{33288}; +var \u{33289}; +var \u{3328A}; +var \u{3328B}; +var \u{3328C}; +var \u{3328D}; +var \u{3328E}; +var \u{3328F}; +var \u{33290}; +var \u{33291}; +var \u{33292}; +var \u{33293}; +var \u{33294}; +var \u{33295}; +var \u{33296}; +var \u{33297}; +var \u{33298}; +var \u{33299}; +var \u{3329A}; +var \u{3329B}; +var \u{3329C}; +var \u{3329D}; +var \u{3329E}; +var \u{3329F}; +var \u{332A0}; +var \u{332A1}; +var \u{332A2}; +var \u{332A3}; +var \u{332A4}; +var \u{332A5}; +var \u{332A6}; +var \u{332A7}; +var \u{332A8}; +var \u{332A9}; +var \u{332AA}; +var \u{332AB}; +var \u{332AC}; +var \u{332AD}; +var \u{332AE}; +var \u{332AF}; +var \u{332B0}; +var \u{332B1}; +var \u{332B2}; +var \u{332B3}; +var \u{332B4}; +var \u{332B5}; +var \u{332B6}; +var \u{332B7}; +var \u{332B8}; +var \u{332B9}; +var \u{332BA}; +var \u{332BB}; +var \u{332BC}; +var \u{332BD}; +var \u{332BE}; +var \u{332BF}; +var \u{332C0}; +var \u{332C1}; +var \u{332C2}; +var \u{332C3}; +var \u{332C4}; +var \u{332C5}; +var \u{332C6}; +var \u{332C7}; +var \u{332C8}; +var \u{332C9}; +var \u{332CA}; +var \u{332CB}; +var \u{332CC}; +var \u{332CD}; +var \u{332CE}; +var \u{332CF}; +var \u{332D0}; +var \u{332D1}; +var \u{332D2}; +var \u{332D3}; +var \u{332D4}; +var \u{332D5}; +var \u{332D6}; +var \u{332D7}; +var \u{332D8}; +var \u{332D9}; +var \u{332DA}; +var \u{332DB}; +var \u{332DC}; +var \u{332DD}; +var \u{332DE}; +var \u{332DF}; +var \u{332E0}; +var \u{332E1}; +var \u{332E2}; +var \u{332E3}; +var \u{332E4}; +var \u{332E5}; +var \u{332E6}; +var \u{332E7}; +var \u{332E8}; +var \u{332E9}; +var \u{332EA}; +var \u{332EB}; +var \u{332EC}; +var \u{332ED}; +var \u{332EE}; +var \u{332EF}; +var \u{332F0}; +var \u{332F1}; +var \u{332F2}; +var \u{332F3}; +var \u{332F4}; +var \u{332F5}; +var \u{332F6}; +var \u{332F7}; +var \u{332F8}; +var \u{332F9}; +var \u{332FA}; +var \u{332FB}; +var \u{332FC}; +var \u{332FD}; +var \u{332FE}; +var \u{332FF}; +var \u{33300}; +var \u{33301}; +var \u{33302}; +var \u{33303}; +var \u{33304}; +var \u{33305}; +var \u{33306}; +var \u{33307}; +var \u{33308}; +var \u{33309}; +var \u{3330A}; +var \u{3330B}; +var \u{3330C}; +var \u{3330D}; +var \u{3330E}; +var \u{3330F}; +var \u{33310}; +var \u{33311}; +var \u{33312}; +var \u{33313}; +var \u{33314}; +var \u{33315}; +var \u{33316}; +var \u{33317}; +var \u{33318}; +var \u{33319}; +var \u{3331A}; +var \u{3331B}; +var \u{3331C}; +var \u{3331D}; +var \u{3331E}; +var \u{3331F}; +var \u{33320}; +var \u{33321}; +var \u{33322}; +var \u{33323}; +var \u{33324}; +var \u{33325}; +var \u{33326}; +var \u{33327}; +var \u{33328}; +var \u{33329}; +var \u{3332A}; +var \u{3332B}; +var \u{3332C}; +var \u{3332D}; +var \u{3332E}; +var \u{3332F}; +var \u{33330}; +var \u{33331}; +var \u{33332}; +var \u{33333}; +var \u{33334}; +var \u{33335}; +var \u{33336}; +var \u{33337}; +var \u{33338}; +var \u{33339}; +var \u{3333A}; +var \u{3333B}; +var \u{3333C}; +var \u{3333D}; +var \u{3333E}; +var \u{3333F}; +var \u{33340}; +var \u{33341}; +var \u{33342}; +var \u{33343}; +var \u{33344}; +var \u{33345}; +var \u{33346}; +var \u{33347}; +var \u{33348}; +var \u{33349}; +var \u{3334A}; +var \u{3334B}; +var \u{3334C}; +var \u{3334D}; +var \u{3334E}; +var \u{3334F}; +var \u{33350}; +var \u{33351}; +var \u{33352}; +var \u{33353}; +var \u{33354}; +var \u{33355}; +var \u{33356}; +var \u{33357}; +var \u{33358}; +var \u{33359}; +var \u{3335A}; +var \u{3335B}; +var \u{3335C}; +var \u{3335D}; +var \u{3335E}; +var \u{3335F}; +var \u{33360}; +var \u{33361}; +var \u{33362}; +var \u{33363}; +var \u{33364}; +var \u{33365}; +var \u{33366}; +var \u{33367}; +var \u{33368}; +var \u{33369}; +var \u{3336A}; +var \u{3336B}; +var \u{3336C}; +var \u{3336D}; +var \u{3336E}; +var \u{3336F}; +var \u{33370}; +var \u{33371}; +var \u{33372}; +var \u{33373}; +var \u{33374}; +var \u{33375}; +var \u{33376}; +var \u{33377}; +var \u{33378}; +var \u{33379}; +var \u{3337A}; +var \u{3337B}; +var \u{3337C}; +var \u{3337D}; +var \u{3337E}; +var \u{3337F}; +var \u{33380}; +var \u{33381}; +var \u{33382}; +var \u{33383}; +var \u{33384}; +var \u{33385}; +var \u{33386}; +var \u{33387}; +var \u{33388}; +var \u{33389}; +var \u{3338A}; +var \u{3338B}; +var \u{3338C}; +var \u{3338D}; +var \u{3338E}; +var \u{3338F}; +var \u{33390}; +var \u{33391}; +var \u{33392}; +var \u{33393}; +var \u{33394}; +var \u{33395}; +var \u{33396}; +var \u{33397}; +var \u{33398}; +var \u{33399}; +var \u{3339A}; +var \u{3339B}; +var \u{3339C}; +var \u{3339D}; +var \u{3339E}; +var \u{3339F}; +var \u{333A0}; +var \u{333A1}; +var \u{333A2}; +var \u{333A3}; +var \u{333A4}; +var \u{333A5}; +var \u{333A6}; +var \u{333A7}; +var \u{333A8}; +var \u{333A9}; +var \u{333AA}; +var \u{333AB}; +var \u{333AC}; +var \u{333AD}; +var \u{333AE}; +var \u{333AF}; +var \u{333B0}; +var \u{333B1}; +var \u{333B2}; +var \u{333B3}; +var \u{333B4}; +var \u{333B5}; +var \u{333B6}; +var \u{333B7}; +var \u{333B8}; +var \u{333B9}; +var \u{333BA}; +var \u{333BB}; +var \u{333BC}; +var \u{333BD}; +var \u{333BE}; +var \u{333BF}; +var \u{333C0}; +var \u{333C1}; +var \u{333C2}; +var \u{333C3}; +var \u{333C4}; +var \u{333C5}; +var \u{333C6}; +var \u{333C7}; +var \u{333C8}; +var \u{333C9}; +var \u{333CA}; +var \u{333CB}; +var \u{333CC}; +var \u{333CD}; +var \u{333CE}; +var \u{333CF}; +var \u{333D0}; +var \u{333D1}; +var \u{333D2}; +var \u{333D3}; +var \u{333D4}; +var \u{333D5}; +var \u{333D6}; +var \u{333D7}; +var \u{333D8}; +var \u{333D9}; +var \u{333DA}; +var \u{333DB}; +var \u{333DC}; +var \u{333DD}; +var \u{333DE}; +var \u{333DF}; +var \u{333E0}; +var \u{333E1}; +var \u{333E2}; +var \u{333E3}; +var \u{333E4}; +var \u{333E5}; +var \u{333E6}; +var \u{333E7}; +var \u{333E8}; +var \u{333E9}; +var \u{333EA}; +var \u{333EB}; +var \u{333EC}; +var \u{333ED}; +var \u{333EE}; +var \u{333EF}; +var \u{333F0}; +var \u{333F1}; +var \u{333F2}; +var \u{333F3}; +var \u{333F4}; +var \u{333F5}; +var \u{333F6}; +var \u{333F7}; +var \u{333F8}; +var \u{333F9}; +var \u{333FA}; +var \u{333FB}; +var \u{333FC}; +var \u{333FD}; +var \u{333FE}; +var \u{333FF}; +var \u{33400}; +var \u{33401}; +var \u{33402}; +var \u{33403}; +var \u{33404}; +var \u{33405}; +var \u{33406}; +var \u{33407}; +var \u{33408}; +var \u{33409}; +var \u{3340A}; +var \u{3340B}; +var \u{3340C}; +var \u{3340D}; +var \u{3340E}; +var \u{3340F}; +var \u{33410}; +var \u{33411}; +var \u{33412}; +var \u{33413}; +var \u{33414}; +var \u{33415}; +var \u{33416}; +var \u{33417}; +var \u{33418}; +var \u{33419}; +var \u{3341A}; +var \u{3341B}; +var \u{3341C}; +var \u{3341D}; +var \u{3341E}; +var \u{3341F}; +var \u{33420}; +var \u{33421}; +var \u{33422}; +var \u{33423}; +var \u{33424}; +var \u{33425}; +var \u{33426}; +var \u{33427}; +var \u{33428}; +var \u{33429}; +var \u{3342A}; +var \u{3342B}; +var \u{3342C}; +var \u{3342D}; +var \u{3342E}; +var \u{3342F}; +var \u{33430}; +var \u{33431}; +var \u{33432}; +var \u{33433}; +var \u{33434}; +var \u{33435}; +var \u{33436}; +var \u{33437}; +var \u{33438}; +var \u{33439}; +var \u{3343A}; +var \u{3343B}; +var \u{3343C}; +var \u{3343D}; +var \u{3343E}; +var \u{3343F}; +var \u{33440}; +var \u{33441}; +var \u{33442}; +var \u{33443}; +var \u{33444}; +var \u{33445}; +var \u{33446}; +var \u{33447}; +var \u{33448}; +var \u{33449}; +var \u{3344A}; +var \u{3344B}; +var \u{3344C}; +var \u{3344D}; +var \u{3344E}; +var \u{3344F}; +var \u{33450}; +var \u{33451}; +var \u{33452}; +var \u{33453}; +var \u{33454}; +var \u{33455}; +var \u{33456}; +var \u{33457}; +var \u{33458}; +var \u{33459}; +var \u{3345A}; +var \u{3345B}; +var \u{3345C}; +var \u{3345D}; +var \u{3345E}; +var \u{3345F}; +var \u{33460}; +var \u{33461}; +var \u{33462}; +var \u{33463}; +var \u{33464}; +var \u{33465}; +var \u{33466}; +var \u{33467}; +var \u{33468}; +var \u{33469}; +var \u{3346A}; +var \u{3346B}; +var \u{3346C}; +var \u{3346D}; +var \u{3346E}; +var \u{3346F}; +var \u{33470}; +var \u{33471}; +var \u{33472}; +var \u{33473}; +var \u{33474}; +var \u{33475}; +var \u{33476}; +var \u{33477}; +var \u{33478}; +var \u{33479}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0.js new file mode 100644 index 000000000..3991ff945 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-17.0.0.js @@ -0,0 +1,4660 @@ +// Copyright 2025 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v17.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var ࢏; +var ౜; +var ೜; +var ꟎; +var ꟏; +var ꟒; +var ꟔; +var ꟱; +var 𐥀; +var 𐥁; +var 𐥂; +var 𐥃; +var 𐥄; +var 𐥅; +var 𐥆; +var 𐥇; +var 𐥈; +var 𐥉; +var 𐥊; +var 𐥋; +var 𐥌; +var 𐥍; +var 𐥎; +var 𐥏; +var 𐥐; +var 𐥑; +var 𐥒; +var 𐥓; +var 𐥔; +var 𐥕; +var 𐥖; +var 𐥗; +var 𐥘; +var 𐥙; +var 𐻅; +var 𐻆; +var 𐻇; +var 𑶰; +var 𑶱; +var 𑶲; +var 𑶳; +var 𑶴; +var 𑶵; +var 𑶶; +var 𑶷; +var 𑶸; +var 𑶹; +var 𑶺; +var 𑶻; +var 𑶼; +var 𑶽; +var 𑶾; +var 𑶿; +var 𑷀; +var 𑷁; +var 𑷂; +var 𑷃; +var 𑷄; +var 𑷅; +var 𑷆; +var 𑷇; +var 𑷈; +var 𑷉; +var 𑷊; +var 𑷋; +var 𑷌; +var 𑷍; +var 𑷎; +var 𑷏; +var 𑷐; +var 𑷑; +var 𑷒; +var 𑷓; +var 𑷔; +var 𑷕; +var 𑷖; +var 𑷗; +var 𑷘; +var 𑷙; +var 𑷚; +var 𑷛; +var 𖺠; +var 𖺡; +var 𖺢; +var 𖺣; +var 𖺤; +var 𖺥; +var 𖺦; +var 𖺧; +var 𖺨; +var 𖺩; +var 𖺪; +var 𖺫; +var 𖺬; +var 𖺭; +var 𖺮; +var 𖺯; +var 𖺰; +var 𖺱; +var 𖺲; +var 𖺳; +var 𖺴; +var 𖺵; +var 𖺶; +var 𖺷; +var 𖺸; +var 𖺻; +var 𖺼; +var 𖺽; +var 𖺾; +var 𖺿; +var 𖻀; +var 𖻁; +var 𖻂; +var 𖻃; +var 𖻄; +var 𖻅; +var 𖻆; +var 𖻇; +var 𖻈; +var 𖻉; +var 𖻊; +var 𖻋; +var 𖻌; +var 𖻍; +var 𖻎; +var 𖻏; +var 𖻐; +var 𖻑; +var 𖻒; +var 𖻓; +var 𖿲; +var 𖿳; +var 𖿴; +var 𖿵; +var 𖿶; +var 𘟸; +var 𘟹; +var 𘟺; +var 𘟻; +var 𘟼; +var 𘟽; +var 𘟾; +var 𘟿; +var 𘴉; +var 𘴊; +var 𘴋; +var 𘴌; +var 𘴍; +var 𘴎; +var 𘴏; +var 𘴐; +var 𘴑; +var 𘴒; +var 𘴓; +var 𘴔; +var 𘴕; +var 𘴖; +var 𘴗; +var 𘴘; +var 𘴙; +var 𘴚; +var 𘴛; +var 𘴜; +var 𘴝; +var 𘴞; +var 𘶀; +var 𘶁; +var 𘶂; +var 𘶃; +var 𘶄; +var 𘶅; +var 𘶆; +var 𘶇; +var 𘶈; +var 𘶉; +var 𘶊; +var 𘶋; +var 𘶌; +var 𘶍; +var 𘶎; +var 𘶏; +var 𘶐; +var 𘶑; +var 𘶒; +var 𘶓; +var 𘶔; +var 𘶕; +var 𘶖; +var 𘶗; +var 𘶘; +var 𘶙; +var 𘶚; +var 𘶛; +var 𘶜; +var 𘶝; +var 𘶞; +var 𘶟; +var 𘶠; +var 𘶡; +var 𘶢; +var 𘶣; +var 𘶤; +var 𘶥; +var 𘶦; +var 𘶧; +var 𘶨; +var 𘶩; +var 𘶪; +var 𘶫; +var 𘶬; +var 𘶭; +var 𘶮; +var 𘶯; +var 𘶰; +var 𘶱; +var 𘶲; +var 𘶳; +var 𘶴; +var 𘶵; +var 𘶶; +var 𘶷; +var 𘶸; +var 𘶹; +var 𘶺; +var 𘶻; +var 𘶼; +var 𘶽; +var 𘶾; +var 𘶿; +var 𘷀; +var 𘷁; +var 𘷂; +var 𘷃; +var 𘷄; +var 𘷅; +var 𘷆; +var 𘷇; +var 𘷈; +var 𘷉; +var 𘷊; +var 𘷋; +var 𘷌; +var 𘷍; +var 𘷎; +var 𘷏; +var 𘷐; +var 𘷑; +var 𘷒; +var 𘷓; +var 𘷔; +var 𘷕; +var 𘷖; +var 𘷗; +var 𘷘; +var 𘷙; +var 𘷚; +var 𘷛; +var 𘷜; +var 𘷝; +var 𘷞; +var 𘷟; +var 𘷠; +var 𘷡; +var 𘷢; +var 𘷣; +var 𘷤; +var 𘷥; +var 𘷦; +var 𘷧; +var 𘷨; +var 𘷩; +var 𘷪; +var 𘷫; +var 𘷬; +var 𘷭; +var 𘷮; +var 𘷯; +var 𘷰; +var 𘷱; +var 𘷲; +var 𞛀; +var 𞛁; +var 𞛂; +var 𞛃; +var 𞛄; +var 𞛅; +var 𞛆; +var 𞛇; +var 𞛈; +var 𞛉; +var 𞛊; +var 𞛋; +var 𞛌; +var 𞛍; +var 𞛎; +var 𞛏; +var 𞛐; +var 𞛑; +var 𞛒; +var 𞛓; +var 𞛔; +var 𞛕; +var 𞛖; +var 𞛗; +var 𞛘; +var 𞛙; +var 𞛚; +var 𞛛; +var 𞛜; +var 𞛝; +var 𞛞; +var 𞛠; +var 𞛡; +var 𞛢; +var 𞛤; +var 𞛥; +var 𞛧; +var 𞛨; +var 𞛩; +var 𞛪; +var 𞛫; +var 𞛬; +var 𞛭; +var 𞛰; +var 𞛱; +var 𞛲; +var 𞛳; +var 𞛴; +var 𞛾; +var 𞛿; +var 𫜺; +var 𫜻; +var 𫜼; +var 𫜽; +var 𫜾; +var 𫜿; +var 𬺢; +var 𬺣; +var 𬺤; +var 𬺥; +var 𬺦; +var 𬺧; +var 𬺨; +var 𬺩; +var 𬺪; +var 𬺫; +var 𬺬; +var 𬺭; +var 𲎰; +var 𲎱; +var 𲎲; +var 𲎳; +var 𲎴; +var 𲎵; +var 𲎶; +var 𲎷; +var 𲎸; +var 𲎹; +var 𲎺; +var 𲎻; +var 𲎼; +var 𲎽; +var 𲎾; +var 𲎿; +var 𲏀; +var 𲏁; +var 𲏂; +var 𲏃; +var 𲏄; +var 𲏅; +var 𲏆; +var 𲏇; +var 𲏈; +var 𲏉; +var 𲏊; +var 𲏋; +var 𲏌; +var 𲏍; +var 𲏎; +var 𲏏; +var 𲏐; +var 𲏑; +var 𲏒; +var 𲏓; +var 𲏔; +var 𲏕; +var 𲏖; +var 𲏗; +var 𲏘; +var 𲏙; +var 𲏚; +var 𲏛; +var 𲏜; +var 𲏝; +var 𲏞; +var 𲏟; +var 𲏠; +var 𲏡; +var 𲏢; +var 𲏣; +var 𲏤; +var 𲏥; +var 𲏦; +var 𲏧; +var 𲏨; +var 𲏩; +var 𲏪; +var 𲏫; +var 𲏬; +var 𲏭; +var 𲏮; +var 𲏯; +var 𲏰; +var 𲏱; +var 𲏲; +var 𲏳; +var 𲏴; +var 𲏵; +var 𲏶; +var 𲏷; +var 𲏸; +var 𲏹; +var 𲏺; +var 𲏻; +var 𲏼; +var 𲏽; +var 𲏾; +var 𲏿; +var 𲐀; +var 𲐁; +var 𲐂; +var 𲐃; +var 𲐄; +var 𲐅; +var 𲐆; +var 𲐇; +var 𲐈; +var 𲐉; +var 𲐊; +var 𲐋; +var 𲐌; +var 𲐍; +var 𲐎; +var 𲐏; +var 𲐐; +var 𲐑; +var 𲐒; +var 𲐓; +var 𲐔; +var 𲐕; +var 𲐖; +var 𲐗; +var 𲐘; +var 𲐙; +var 𲐚; +var 𲐛; +var 𲐜; +var 𲐝; +var 𲐞; +var 𲐟; +var 𲐠; +var 𲐡; +var 𲐢; +var 𲐣; +var 𲐤; +var 𲐥; +var 𲐦; +var 𲐧; +var 𲐨; +var 𲐩; +var 𲐪; +var 𲐫; +var 𲐬; +var 𲐭; +var 𲐮; +var 𲐯; +var 𲐰; +var 𲐱; +var 𲐲; +var 𲐳; +var 𲐴; +var 𲐵; +var 𲐶; +var 𲐷; +var 𲐸; +var 𲐹; +var 𲐺; +var 𲐻; +var 𲐼; +var 𲐽; +var 𲐾; +var 𲐿; +var 𲑀; +var 𲑁; +var 𲑂; +var 𲑃; +var 𲑄; +var 𲑅; +var 𲑆; +var 𲑇; +var 𲑈; +var 𲑉; +var 𲑊; +var 𲑋; +var 𲑌; +var 𲑍; +var 𲑎; +var 𲑏; +var 𲑐; +var 𲑑; +var 𲑒; +var 𲑓; +var 𲑔; +var 𲑕; +var 𲑖; +var 𲑗; +var 𲑘; +var 𲑙; +var 𲑚; +var 𲑛; +var 𲑜; +var 𲑝; +var 𲑞; +var 𲑟; +var 𲑠; +var 𲑡; +var 𲑢; +var 𲑣; +var 𲑤; +var 𲑥; +var 𲑦; +var 𲑧; +var 𲑨; +var 𲑩; +var 𲑪; +var 𲑫; +var 𲑬; +var 𲑭; +var 𲑮; +var 𲑯; +var 𲑰; +var 𲑱; +var 𲑲; +var 𲑳; +var 𲑴; +var 𲑵; +var 𲑶; +var 𲑷; +var 𲑸; +var 𲑹; +var 𲑺; +var 𲑻; +var 𲑼; +var 𲑽; +var 𲑾; +var 𲑿; +var 𲒀; +var 𲒁; +var 𲒂; +var 𲒃; +var 𲒄; +var 𲒅; +var 𲒆; +var 𲒇; +var 𲒈; +var 𲒉; +var 𲒊; +var 𲒋; +var 𲒌; +var 𲒍; +var 𲒎; +var 𲒏; +var 𲒐; +var 𲒑; +var 𲒒; +var 𲒓; +var 𲒔; +var 𲒕; +var 𲒖; +var 𲒗; +var 𲒘; +var 𲒙; +var 𲒚; +var 𲒛; +var 𲒜; +var 𲒝; +var 𲒞; +var 𲒟; +var 𲒠; +var 𲒡; +var 𲒢; +var 𲒣; +var 𲒤; +var 𲒥; +var 𲒦; +var 𲒧; +var 𲒨; +var 𲒩; +var 𲒪; +var 𲒫; +var 𲒬; +var 𲒭; +var 𲒮; +var 𲒯; +var 𲒰; +var 𲒱; +var 𲒲; +var 𲒳; +var 𲒴; +var 𲒵; +var 𲒶; +var 𲒷; +var 𲒸; +var 𲒹; +var 𲒺; +var 𲒻; +var 𲒼; +var 𲒽; +var 𲒾; +var 𲒿; +var 𲓀; +var 𲓁; +var 𲓂; +var 𲓃; +var 𲓄; +var 𲓅; +var 𲓆; +var 𲓇; +var 𲓈; +var 𲓉; +var 𲓊; +var 𲓋; +var 𲓌; +var 𲓍; +var 𲓎; +var 𲓏; +var 𲓐; +var 𲓑; +var 𲓒; +var 𲓓; +var 𲓔; +var 𲓕; +var 𲓖; +var 𲓗; +var 𲓘; +var 𲓙; +var 𲓚; +var 𲓛; +var 𲓜; +var 𲓝; +var 𲓞; +var 𲓟; +var 𲓠; +var 𲓡; +var 𲓢; +var 𲓣; +var 𲓤; +var 𲓥; +var 𲓦; +var 𲓧; +var 𲓨; +var 𲓩; +var 𲓪; +var 𲓫; +var 𲓬; +var 𲓭; +var 𲓮; +var 𲓯; +var 𲓰; +var 𲓱; +var 𲓲; +var 𲓳; +var 𲓴; +var 𲓵; +var 𲓶; +var 𲓷; +var 𲓸; +var 𲓹; +var 𲓺; +var 𲓻; +var 𲓼; +var 𲓽; +var 𲓾; +var 𲓿; +var 𲔀; +var 𲔁; +var 𲔂; +var 𲔃; +var 𲔄; +var 𲔅; +var 𲔆; +var 𲔇; +var 𲔈; +var 𲔉; +var 𲔊; +var 𲔋; +var 𲔌; +var 𲔍; +var 𲔎; +var 𲔏; +var 𲔐; +var 𲔑; +var 𲔒; +var 𲔓; +var 𲔔; +var 𲔕; +var 𲔖; +var 𲔗; +var 𲔘; +var 𲔙; +var 𲔚; +var 𲔛; +var 𲔜; +var 𲔝; +var 𲔞; +var 𲔟; +var 𲔠; +var 𲔡; +var 𲔢; +var 𲔣; +var 𲔤; +var 𲔥; +var 𲔦; +var 𲔧; +var 𲔨; +var 𲔩; +var 𲔪; +var 𲔫; +var 𲔬; +var 𲔭; +var 𲔮; +var 𲔯; +var 𲔰; +var 𲔱; +var 𲔲; +var 𲔳; +var 𲔴; +var 𲔵; +var 𲔶; +var 𲔷; +var 𲔸; +var 𲔹; +var 𲔺; +var 𲔻; +var 𲔼; +var 𲔽; +var 𲔾; +var 𲔿; +var 𲕀; +var 𲕁; +var 𲕂; +var 𲕃; +var 𲕄; +var 𲕅; +var 𲕆; +var 𲕇; +var 𲕈; +var 𲕉; +var 𲕊; +var 𲕋; +var 𲕌; +var 𲕍; +var 𲕎; +var 𲕏; +var 𲕐; +var 𲕑; +var 𲕒; +var 𲕓; +var 𲕔; +var 𲕕; +var 𲕖; +var 𲕗; +var 𲕘; +var 𲕙; +var 𲕚; +var 𲕛; +var 𲕜; +var 𲕝; +var 𲕞; +var 𲕟; +var 𲕠; +var 𲕡; +var 𲕢; +var 𲕣; +var 𲕤; +var 𲕥; +var 𲕦; +var 𲕧; +var 𲕨; +var 𲕩; +var 𲕪; +var 𲕫; +var 𲕬; +var 𲕭; +var 𲕮; +var 𲕯; +var 𲕰; +var 𲕱; +var 𲕲; +var 𲕳; +var 𲕴; +var 𲕵; +var 𲕶; +var 𲕷; +var 𲕸; +var 𲕹; +var 𲕺; +var 𲕻; +var 𲕼; +var 𲕽; +var 𲕾; +var 𲕿; +var 𲖀; +var 𲖁; +var 𲖂; +var 𲖃; +var 𲖄; +var 𲖅; +var 𲖆; +var 𲖇; +var 𲖈; +var 𲖉; +var 𲖊; +var 𲖋; +var 𲖌; +var 𲖍; +var 𲖎; +var 𲖏; +var 𲖐; +var 𲖑; +var 𲖒; +var 𲖓; +var 𲖔; +var 𲖕; +var 𲖖; +var 𲖗; +var 𲖘; +var 𲖙; +var 𲖚; +var 𲖛; +var 𲖜; +var 𲖝; +var 𲖞; +var 𲖟; +var 𲖠; +var 𲖡; +var 𲖢; +var 𲖣; +var 𲖤; +var 𲖥; +var 𲖦; +var 𲖧; +var 𲖨; +var 𲖩; +var 𲖪; +var 𲖫; +var 𲖬; +var 𲖭; +var 𲖮; +var 𲖯; +var 𲖰; +var 𲖱; +var 𲖲; +var 𲖳; +var 𲖴; +var 𲖵; +var 𲖶; +var 𲖷; +var 𲖸; +var 𲖹; +var 𲖺; +var 𲖻; +var 𲖼; +var 𲖽; +var 𲖾; +var 𲖿; +var 𲗀; +var 𲗁; +var 𲗂; +var 𲗃; +var 𲗄; +var 𲗅; +var 𲗆; +var 𲗇; +var 𲗈; +var 𲗉; +var 𲗊; +var 𲗋; +var 𲗌; +var 𲗍; +var 𲗎; +var 𲗏; +var 𲗐; +var 𲗑; +var 𲗒; +var 𲗓; +var 𲗔; +var 𲗕; +var 𲗖; +var 𲗗; +var 𲗘; +var 𲗙; +var 𲗚; +var 𲗛; +var 𲗜; +var 𲗝; +var 𲗞; +var 𲗟; +var 𲗠; +var 𲗡; +var 𲗢; +var 𲗣; +var 𲗤; +var 𲗥; +var 𲗦; +var 𲗧; +var 𲗨; +var 𲗩; +var 𲗪; +var 𲗫; +var 𲗬; +var 𲗭; +var 𲗮; +var 𲗯; +var 𲗰; +var 𲗱; +var 𲗲; +var 𲗳; +var 𲗴; +var 𲗵; +var 𲗶; +var 𲗷; +var 𲗸; +var 𲗹; +var 𲗺; +var 𲗻; +var 𲗼; +var 𲗽; +var 𲗾; +var 𲗿; +var 𲘀; +var 𲘁; +var 𲘂; +var 𲘃; +var 𲘄; +var 𲘅; +var 𲘆; +var 𲘇; +var 𲘈; +var 𲘉; +var 𲘊; +var 𲘋; +var 𲘌; +var 𲘍; +var 𲘎; +var 𲘏; +var 𲘐; +var 𲘑; +var 𲘒; +var 𲘓; +var 𲘔; +var 𲘕; +var 𲘖; +var 𲘗; +var 𲘘; +var 𲘙; +var 𲘚; +var 𲘛; +var 𲘜; +var 𲘝; +var 𲘞; +var 𲘟; +var 𲘠; +var 𲘡; +var 𲘢; +var 𲘣; +var 𲘤; +var 𲘥; +var 𲘦; +var 𲘧; +var 𲘨; +var 𲘩; +var 𲘪; +var 𲘫; +var 𲘬; +var 𲘭; +var 𲘮; +var 𲘯; +var 𲘰; +var 𲘱; +var 𲘲; +var 𲘳; +var 𲘴; +var 𲘵; +var 𲘶; +var 𲘷; +var 𲘸; +var 𲘹; +var 𲘺; +var 𲘻; +var 𲘼; +var 𲘽; +var 𲘾; +var 𲘿; +var 𲙀; +var 𲙁; +var 𲙂; +var 𲙃; +var 𲙄; +var 𲙅; +var 𲙆; +var 𲙇; +var 𲙈; +var 𲙉; +var 𲙊; +var 𲙋; +var 𲙌; +var 𲙍; +var 𲙎; +var 𲙏; +var 𲙐; +var 𲙑; +var 𲙒; +var 𲙓; +var 𲙔; +var 𲙕; +var 𲙖; +var 𲙗; +var 𲙘; +var 𲙙; +var 𲙚; +var 𲙛; +var 𲙜; +var 𲙝; +var 𲙞; +var 𲙟; +var 𲙠; +var 𲙡; +var 𲙢; +var 𲙣; +var 𲙤; +var 𲙥; +var 𲙦; +var 𲙧; +var 𲙨; +var 𲙩; +var 𲙪; +var 𲙫; +var 𲙬; +var 𲙭; +var 𲙮; +var 𲙯; +var 𲙰; +var 𲙱; +var 𲙲; +var 𲙳; +var 𲙴; +var 𲙵; +var 𲙶; +var 𲙷; +var 𲙸; +var 𲙹; +var 𲙺; +var 𲙻; +var 𲙼; +var 𲙽; +var 𲙾; +var 𲙿; +var 𲚀; +var 𲚁; +var 𲚂; +var 𲚃; +var 𲚄; +var 𲚅; +var 𲚆; +var 𲚇; +var 𲚈; +var 𲚉; +var 𲚊; +var 𲚋; +var 𲚌; +var 𲚍; +var 𲚎; +var 𲚏; +var 𲚐; +var 𲚑; +var 𲚒; +var 𲚓; +var 𲚔; +var 𲚕; +var 𲚖; +var 𲚗; +var 𲚘; +var 𲚙; +var 𲚚; +var 𲚛; +var 𲚜; +var 𲚝; +var 𲚞; +var 𲚟; +var 𲚠; +var 𲚡; +var 𲚢; +var 𲚣; +var 𲚤; +var 𲚥; +var 𲚦; +var 𲚧; +var 𲚨; +var 𲚩; +var 𲚪; +var 𲚫; +var 𲚬; +var 𲚭; +var 𲚮; +var 𲚯; +var 𲚰; +var 𲚱; +var 𲚲; +var 𲚳; +var 𲚴; +var 𲚵; +var 𲚶; +var 𲚷; +var 𲚸; +var 𲚹; +var 𲚺; +var 𲚻; +var 𲚼; +var 𲚽; +var 𲚾; +var 𲚿; +var 𲛀; +var 𲛁; +var 𲛂; +var 𲛃; +var 𲛄; +var 𲛅; +var 𲛆; +var 𲛇; +var 𲛈; +var 𲛉; +var 𲛊; +var 𲛋; +var 𲛌; +var 𲛍; +var 𲛎; +var 𲛏; +var 𲛐; +var 𲛑; +var 𲛒; +var 𲛓; +var 𲛔; +var 𲛕; +var 𲛖; +var 𲛗; +var 𲛘; +var 𲛙; +var 𲛚; +var 𲛛; +var 𲛜; +var 𲛝; +var 𲛞; +var 𲛟; +var 𲛠; +var 𲛡; +var 𲛢; +var 𲛣; +var 𲛤; +var 𲛥; +var 𲛦; +var 𲛧; +var 𲛨; +var 𲛩; +var 𲛪; +var 𲛫; +var 𲛬; +var 𲛭; +var 𲛮; +var 𲛯; +var 𲛰; +var 𲛱; +var 𲛲; +var 𲛳; +var 𲛴; +var 𲛵; +var 𲛶; +var 𲛷; +var 𲛸; +var 𲛹; +var 𲛺; +var 𲛻; +var 𲛼; +var 𲛽; +var 𲛾; +var 𲛿; +var 𲜀; +var 𲜁; +var 𲜂; +var 𲜃; +var 𲜄; +var 𲜅; +var 𲜆; +var 𲜇; +var 𲜈; +var 𲜉; +var 𲜊; +var 𲜋; +var 𲜌; +var 𲜍; +var 𲜎; +var 𲜏; +var 𲜐; +var 𲜑; +var 𲜒; +var 𲜓; +var 𲜔; +var 𲜕; +var 𲜖; +var 𲜗; +var 𲜘; +var 𲜙; +var 𲜚; +var 𲜛; +var 𲜜; +var 𲜝; +var 𲜞; +var 𲜟; +var 𲜠; +var 𲜡; +var 𲜢; +var 𲜣; +var 𲜤; +var 𲜥; +var 𲜦; +var 𲜧; +var 𲜨; +var 𲜩; +var 𲜪; +var 𲜫; +var 𲜬; +var 𲜭; +var 𲜮; +var 𲜯; +var 𲜰; +var 𲜱; +var 𲜲; +var 𲜳; +var 𲜴; +var 𲜵; +var 𲜶; +var 𲜷; +var 𲜸; +var 𲜹; +var 𲜺; +var 𲜻; +var 𲜼; +var 𲜽; +var 𲜾; +var 𲜿; +var 𲝀; +var 𲝁; +var 𲝂; +var 𲝃; +var 𲝄; +var 𲝅; +var 𲝆; +var 𲝇; +var 𲝈; +var 𲝉; +var 𲝊; +var 𲝋; +var 𲝌; +var 𲝍; +var 𲝎; +var 𲝏; +var 𲝐; +var 𲝑; +var 𲝒; +var 𲝓; +var 𲝔; +var 𲝕; +var 𲝖; +var 𲝗; +var 𲝘; +var 𲝙; +var 𲝚; +var 𲝛; +var 𲝜; +var 𲝝; +var 𲝞; +var 𲝟; +var 𲝠; +var 𲝡; +var 𲝢; +var 𲝣; +var 𲝤; +var 𲝥; +var 𲝦; +var 𲝧; +var 𲝨; +var 𲝩; +var 𲝪; +var 𲝫; +var 𲝬; +var 𲝭; +var 𲝮; +var 𲝯; +var 𲝰; +var 𲝱; +var 𲝲; +var 𲝳; +var 𲝴; +var 𲝵; +var 𲝶; +var 𲝷; +var 𲝸; +var 𲝹; +var 𲝺; +var 𲝻; +var 𲝼; +var 𲝽; +var 𲝾; +var 𲝿; +var 𲞀; +var 𲞁; +var 𲞂; +var 𲞃; +var 𲞄; +var 𲞅; +var 𲞆; +var 𲞇; +var 𲞈; +var 𲞉; +var 𲞊; +var 𲞋; +var 𲞌; +var 𲞍; +var 𲞎; +var 𲞏; +var 𲞐; +var 𲞑; +var 𲞒; +var 𲞓; +var 𲞔; +var 𲞕; +var 𲞖; +var 𲞗; +var 𲞘; +var 𲞙; +var 𲞚; +var 𲞛; +var 𲞜; +var 𲞝; +var 𲞞; +var 𲞟; +var 𲞠; +var 𲞡; +var 𲞢; +var 𲞣; +var 𲞤; +var 𲞥; +var 𲞦; +var 𲞧; +var 𲞨; +var 𲞩; +var 𲞪; +var 𲞫; +var 𲞬; +var 𲞭; +var 𲞮; +var 𲞯; +var 𲞰; +var 𲞱; +var 𲞲; +var 𲞳; +var 𲞴; +var 𲞵; +var 𲞶; +var 𲞷; +var 𲞸; +var 𲞹; +var 𲞺; +var 𲞻; +var 𲞼; +var 𲞽; +var 𲞾; +var 𲞿; +var 𲟀; +var 𲟁; +var 𲟂; +var 𲟃; +var 𲟄; +var 𲟅; +var 𲟆; +var 𲟇; +var 𲟈; +var 𲟉; +var 𲟊; +var 𲟋; +var 𲟌; +var 𲟍; +var 𲟎; +var 𲟏; +var 𲟐; +var 𲟑; +var 𲟒; +var 𲟓; +var 𲟔; +var 𲟕; +var 𲟖; +var 𲟗; +var 𲟘; +var 𲟙; +var 𲟚; +var 𲟛; +var 𲟜; +var 𲟝; +var 𲟞; +var 𲟟; +var 𲟠; +var 𲟡; +var 𲟢; +var 𲟣; +var 𲟤; +var 𲟥; +var 𲟦; +var 𲟧; +var 𲟨; +var 𲟩; +var 𲟪; +var 𲟫; +var 𲟬; +var 𲟭; +var 𲟮; +var 𲟯; +var 𲟰; +var 𲟱; +var 𲟲; +var 𲟳; +var 𲟴; +var 𲟵; +var 𲟶; +var 𲟷; +var 𲟸; +var 𲟹; +var 𲟺; +var 𲟻; +var 𲟼; +var 𲟽; +var 𲟾; +var 𲟿; +var 𲠀; +var 𲠁; +var 𲠂; +var 𲠃; +var 𲠄; +var 𲠅; +var 𲠆; +var 𲠇; +var 𲠈; +var 𲠉; +var 𲠊; +var 𲠋; +var 𲠌; +var 𲠍; +var 𲠎; +var 𲠏; +var 𲠐; +var 𲠑; +var 𲠒; +var 𲠓; +var 𲠔; +var 𲠕; +var 𲠖; +var 𲠗; +var 𲠘; +var 𲠙; +var 𲠚; +var 𲠛; +var 𲠜; +var 𲠝; +var 𲠞; +var 𲠟; +var 𲠠; +var 𲠡; +var 𲠢; +var 𲠣; +var 𲠤; +var 𲠥; +var 𲠦; +var 𲠧; +var 𲠨; +var 𲠩; +var 𲠪; +var 𲠫; +var 𲠬; +var 𲠭; +var 𲠮; +var 𲠯; +var 𲠰; +var 𲠱; +var 𲠲; +var 𲠳; +var 𲠴; +var 𲠵; +var 𲠶; +var 𲠷; +var 𲠸; +var 𲠹; +var 𲠺; +var 𲠻; +var 𲠼; +var 𲠽; +var 𲠾; +var 𲠿; +var 𲡀; +var 𲡁; +var 𲡂; +var 𲡃; +var 𲡄; +var 𲡅; +var 𲡆; +var 𲡇; +var 𲡈; +var 𲡉; +var 𲡊; +var 𲡋; +var 𲡌; +var 𲡍; +var 𲡎; +var 𲡏; +var 𲡐; +var 𲡑; +var 𲡒; +var 𲡓; +var 𲡔; +var 𲡕; +var 𲡖; +var 𲡗; +var 𲡘; +var 𲡙; +var 𲡚; +var 𲡛; +var 𲡜; +var 𲡝; +var 𲡞; +var 𲡟; +var 𲡠; +var 𲡡; +var 𲡢; +var 𲡣; +var 𲡤; +var 𲡥; +var 𲡦; +var 𲡧; +var 𲡨; +var 𲡩; +var 𲡪; +var 𲡫; +var 𲡬; +var 𲡭; +var 𲡮; +var 𲡯; +var 𲡰; +var 𲡱; +var 𲡲; +var 𲡳; +var 𲡴; +var 𲡵; +var 𲡶; +var 𲡷; +var 𲡸; +var 𲡹; +var 𲡺; +var 𲡻; +var 𲡼; +var 𲡽; +var 𲡾; +var 𲡿; +var 𲢀; +var 𲢁; +var 𲢂; +var 𲢃; +var 𲢄; +var 𲢅; +var 𲢆; +var 𲢇; +var 𲢈; +var 𲢉; +var 𲢊; +var 𲢋; +var 𲢌; +var 𲢍; +var 𲢎; +var 𲢏; +var 𲢐; +var 𲢑; +var 𲢒; +var 𲢓; +var 𲢔; +var 𲢕; +var 𲢖; +var 𲢗; +var 𲢘; +var 𲢙; +var 𲢚; +var 𲢛; +var 𲢜; +var 𲢝; +var 𲢞; +var 𲢟; +var 𲢠; +var 𲢡; +var 𲢢; +var 𲢣; +var 𲢤; +var 𲢥; +var 𲢦; +var 𲢧; +var 𲢨; +var 𲢩; +var 𲢪; +var 𲢫; +var 𲢬; +var 𲢭; +var 𲢮; +var 𲢯; +var 𲢰; +var 𲢱; +var 𲢲; +var 𲢳; +var 𲢴; +var 𲢵; +var 𲢶; +var 𲢷; +var 𲢸; +var 𲢹; +var 𲢺; +var 𲢻; +var 𲢼; +var 𲢽; +var 𲢾; +var 𲢿; +var 𲣀; +var 𲣁; +var 𲣂; +var 𲣃; +var 𲣄; +var 𲣅; +var 𲣆; +var 𲣇; +var 𲣈; +var 𲣉; +var 𲣊; +var 𲣋; +var 𲣌; +var 𲣍; +var 𲣎; +var 𲣏; +var 𲣐; +var 𲣑; +var 𲣒; +var 𲣓; +var 𲣔; +var 𲣕; +var 𲣖; +var 𲣗; +var 𲣘; +var 𲣙; +var 𲣚; +var 𲣛; +var 𲣜; +var 𲣝; +var 𲣞; +var 𲣟; +var 𲣠; +var 𲣡; +var 𲣢; +var 𲣣; +var 𲣤; +var 𲣥; +var 𲣦; +var 𲣧; +var 𲣨; +var 𲣩; +var 𲣪; +var 𲣫; +var 𲣬; +var 𲣭; +var 𲣮; +var 𲣯; +var 𲣰; +var 𲣱; +var 𲣲; +var 𲣳; +var 𲣴; +var 𲣵; +var 𲣶; +var 𲣷; +var 𲣸; +var 𲣹; +var 𲣺; +var 𲣻; +var 𲣼; +var 𲣽; +var 𲣾; +var 𲣿; +var 𲤀; +var 𲤁; +var 𲤂; +var 𲤃; +var 𲤄; +var 𲤅; +var 𲤆; +var 𲤇; +var 𲤈; +var 𲤉; +var 𲤊; +var 𲤋; +var 𲤌; +var 𲤍; +var 𲤎; +var 𲤏; +var 𲤐; +var 𲤑; +var 𲤒; +var 𲤓; +var 𲤔; +var 𲤕; +var 𲤖; +var 𲤗; +var 𲤘; +var 𲤙; +var 𲤚; +var 𲤛; +var 𲤜; +var 𲤝; +var 𲤞; +var 𲤟; +var 𲤠; +var 𲤡; +var 𲤢; +var 𲤣; +var 𲤤; +var 𲤥; +var 𲤦; +var 𲤧; +var 𲤨; +var 𲤩; +var 𲤪; +var 𲤫; +var 𲤬; +var 𲤭; +var 𲤮; +var 𲤯; +var 𲤰; +var 𲤱; +var 𲤲; +var 𲤳; +var 𲤴; +var 𲤵; +var 𲤶; +var 𲤷; +var 𲤸; +var 𲤹; +var 𲤺; +var 𲤻; +var 𲤼; +var 𲤽; +var 𲤾; +var 𲤿; +var 𲥀; +var 𲥁; +var 𲥂; +var 𲥃; +var 𲥄; +var 𲥅; +var 𲥆; +var 𲥇; +var 𲥈; +var 𲥉; +var 𲥊; +var 𲥋; +var 𲥌; +var 𲥍; +var 𲥎; +var 𲥏; +var 𲥐; +var 𲥑; +var 𲥒; +var 𲥓; +var 𲥔; +var 𲥕; +var 𲥖; +var 𲥗; +var 𲥘; +var 𲥙; +var 𲥚; +var 𲥛; +var 𲥜; +var 𲥝; +var 𲥞; +var 𲥟; +var 𲥠; +var 𲥡; +var 𲥢; +var 𲥣; +var 𲥤; +var 𲥥; +var 𲥦; +var 𲥧; +var 𲥨; +var 𲥩; +var 𲥪; +var 𲥫; +var 𲥬; +var 𲥭; +var 𲥮; +var 𲥯; +var 𲥰; +var 𲥱; +var 𲥲; +var 𲥳; +var 𲥴; +var 𲥵; +var 𲥶; +var 𲥷; +var 𲥸; +var 𲥹; +var 𲥺; +var 𲥻; +var 𲥼; +var 𲥽; +var 𲥾; +var 𲥿; +var 𲦀; +var 𲦁; +var 𲦂; +var 𲦃; +var 𲦄; +var 𲦅; +var 𲦆; +var 𲦇; +var 𲦈; +var 𲦉; +var 𲦊; +var 𲦋; +var 𲦌; +var 𲦍; +var 𲦎; +var 𲦏; +var 𲦐; +var 𲦑; +var 𲦒; +var 𲦓; +var 𲦔; +var 𲦕; +var 𲦖; +var 𲦗; +var 𲦘; +var 𲦙; +var 𲦚; +var 𲦛; +var 𲦜; +var 𲦝; +var 𲦞; +var 𲦟; +var 𲦠; +var 𲦡; +var 𲦢; +var 𲦣; +var 𲦤; +var 𲦥; +var 𲦦; +var 𲦧; +var 𲦨; +var 𲦩; +var 𲦪; +var 𲦫; +var 𲦬; +var 𲦭; +var 𲦮; +var 𲦯; +var 𲦰; +var 𲦱; +var 𲦲; +var 𲦳; +var 𲦴; +var 𲦵; +var 𲦶; +var 𲦷; +var 𲦸; +var 𲦹; +var 𲦺; +var 𲦻; +var 𲦼; +var 𲦽; +var 𲦾; +var 𲦿; +var 𲧀; +var 𲧁; +var 𲧂; +var 𲧃; +var 𲧄; +var 𲧅; +var 𲧆; +var 𲧇; +var 𲧈; +var 𲧉; +var 𲧊; +var 𲧋; +var 𲧌; +var 𲧍; +var 𲧎; +var 𲧏; +var 𲧐; +var 𲧑; +var 𲧒; +var 𲧓; +var 𲧔; +var 𲧕; +var 𲧖; +var 𲧗; +var 𲧘; +var 𲧙; +var 𲧚; +var 𲧛; +var 𲧜; +var 𲧝; +var 𲧞; +var 𲧟; +var 𲧠; +var 𲧡; +var 𲧢; +var 𲧣; +var 𲧤; +var 𲧥; +var 𲧦; +var 𲧧; +var 𲧨; +var 𲧩; +var 𲧪; +var 𲧫; +var 𲧬; +var 𲧭; +var 𲧮; +var 𲧯; +var 𲧰; +var 𲧱; +var 𲧲; +var 𲧳; +var 𲧴; +var 𲧵; +var 𲧶; +var 𲧷; +var 𲧸; +var 𲧹; +var 𲧺; +var 𲧻; +var 𲧼; +var 𲧽; +var 𲧾; +var 𲧿; +var 𲨀; +var 𲨁; +var 𲨂; +var 𲨃; +var 𲨄; +var 𲨅; +var 𲨆; +var 𲨇; +var 𲨈; +var 𲨉; +var 𲨊; +var 𲨋; +var 𲨌; +var 𲨍; +var 𲨎; +var 𲨏; +var 𲨐; +var 𲨑; +var 𲨒; +var 𲨓; +var 𲨔; +var 𲨕; +var 𲨖; +var 𲨗; +var 𲨘; +var 𲨙; +var 𲨚; +var 𲨛; +var 𲨜; +var 𲨝; +var 𲨞; +var 𲨟; +var 𲨠; +var 𲨡; +var 𲨢; +var 𲨣; +var 𲨤; +var 𲨥; +var 𲨦; +var 𲨧; +var 𲨨; +var 𲨩; +var 𲨪; +var 𲨫; +var 𲨬; +var 𲨭; +var 𲨮; +var 𲨯; +var 𲨰; +var 𲨱; +var 𲨲; +var 𲨳; +var 𲨴; +var 𲨵; +var 𲨶; +var 𲨷; +var 𲨸; +var 𲨹; +var 𲨺; +var 𲨻; +var 𲨼; +var 𲨽; +var 𲨾; +var 𲨿; +var 𲩀; +var 𲩁; +var 𲩂; +var 𲩃; +var 𲩄; +var 𲩅; +var 𲩆; +var 𲩇; +var 𲩈; +var 𲩉; +var 𲩊; +var 𲩋; +var 𲩌; +var 𲩍; +var 𲩎; +var 𲩏; +var 𲩐; +var 𲩑; +var 𲩒; +var 𲩓; +var 𲩔; +var 𲩕; +var 𲩖; +var 𲩗; +var 𲩘; +var 𲩙; +var 𲩚; +var 𲩛; +var 𲩜; +var 𲩝; +var 𲩞; +var 𲩟; +var 𲩠; +var 𲩡; +var 𲩢; +var 𲩣; +var 𲩤; +var 𲩥; +var 𲩦; +var 𲩧; +var 𲩨; +var 𲩩; +var 𲩪; +var 𲩫; +var 𲩬; +var 𲩭; +var 𲩮; +var 𲩯; +var 𲩰; +var 𲩱; +var 𲩲; +var 𲩳; +var 𲩴; +var 𲩵; +var 𲩶; +var 𲩷; +var 𲩸; +var 𲩹; +var 𲩺; +var 𲩻; +var 𲩼; +var 𲩽; +var 𲩾; +var 𲩿; +var 𲪀; +var 𲪁; +var 𲪂; +var 𲪃; +var 𲪄; +var 𲪅; +var 𲪆; +var 𲪇; +var 𲪈; +var 𲪉; +var 𲪊; +var 𲪋; +var 𲪌; +var 𲪍; +var 𲪎; +var 𲪏; +var 𲪐; +var 𲪑; +var 𲪒; +var 𲪓; +var 𲪔; +var 𲪕; +var 𲪖; +var 𲪗; +var 𲪘; +var 𲪙; +var 𲪚; +var 𲪛; +var 𲪜; +var 𲪝; +var 𲪞; +var 𲪟; +var 𲪠; +var 𲪡; +var 𲪢; +var 𲪣; +var 𲪤; +var 𲪥; +var 𲪦; +var 𲪧; +var 𲪨; +var 𲪩; +var 𲪪; +var 𲪫; +var 𲪬; +var 𲪭; +var 𲪮; +var 𲪯; +var 𲪰; +var 𲪱; +var 𲪲; +var 𲪳; +var 𲪴; +var 𲪵; +var 𲪶; +var 𲪷; +var 𲪸; +var 𲪹; +var 𲪺; +var 𲪻; +var 𲪼; +var 𲪽; +var 𲪾; +var 𲪿; +var 𲫀; +var 𲫁; +var 𲫂; +var 𲫃; +var 𲫄; +var 𲫅; +var 𲫆; +var 𲫇; +var 𲫈; +var 𲫉; +var 𲫊; +var 𲫋; +var 𲫌; +var 𲫍; +var 𲫎; +var 𲫏; +var 𲫐; +var 𲫑; +var 𲫒; +var 𲫓; +var 𲫔; +var 𲫕; +var 𲫖; +var 𲫗; +var 𲫘; +var 𲫙; +var 𲫚; +var 𲫛; +var 𲫜; +var 𲫝; +var 𲫞; +var 𲫟; +var 𲫠; +var 𲫡; +var 𲫢; +var 𲫣; +var 𲫤; +var 𲫥; +var 𲫦; +var 𲫧; +var 𲫨; +var 𲫩; +var 𲫪; +var 𲫫; +var 𲫬; +var 𲫭; +var 𲫮; +var 𲫯; +var 𲫰; +var 𲫱; +var 𲫲; +var 𲫳; +var 𲫴; +var 𲫵; +var 𲫶; +var 𲫷; +var 𲫸; +var 𲫹; +var 𲫺; +var 𲫻; +var 𲫼; +var 𲫽; +var 𲫾; +var 𲫿; +var 𲬀; +var 𲬁; +var 𲬂; +var 𲬃; +var 𲬄; +var 𲬅; +var 𲬆; +var 𲬇; +var 𲬈; +var 𲬉; +var 𲬊; +var 𲬋; +var 𲬌; +var 𲬍; +var 𲬎; +var 𲬏; +var 𲬐; +var 𲬑; +var 𲬒; +var 𲬓; +var 𲬔; +var 𲬕; +var 𲬖; +var 𲬗; +var 𲬘; +var 𲬙; +var 𲬚; +var 𲬛; +var 𲬜; +var 𲬝; +var 𲬞; +var 𲬟; +var 𲬠; +var 𲬡; +var 𲬢; +var 𲬣; +var 𲬤; +var 𲬥; +var 𲬦; +var 𲬧; +var 𲬨; +var 𲬩; +var 𲬪; +var 𲬫; +var 𲬬; +var 𲬭; +var 𲬮; +var 𲬯; +var 𲬰; +var 𲬱; +var 𲬲; +var 𲬳; +var 𲬴; +var 𲬵; +var 𲬶; +var 𲬷; +var 𲬸; +var 𲬹; +var 𲬺; +var 𲬻; +var 𲬼; +var 𲬽; +var 𲬾; +var 𲬿; +var 𲭀; +var 𲭁; +var 𲭂; +var 𲭃; +var 𲭄; +var 𲭅; +var 𲭆; +var 𲭇; +var 𲭈; +var 𲭉; +var 𲭊; +var 𲭋; +var 𲭌; +var 𲭍; +var 𲭎; +var 𲭏; +var 𲭐; +var 𲭑; +var 𲭒; +var 𲭓; +var 𲭔; +var 𲭕; +var 𲭖; +var 𲭗; +var 𲭘; +var 𲭙; +var 𲭚; +var 𲭛; +var 𲭜; +var 𲭝; +var 𲭞; +var 𲭟; +var 𲭠; +var 𲭡; +var 𲭢; +var 𲭣; +var 𲭤; +var 𲭥; +var 𲭦; +var 𲭧; +var 𲭨; +var 𲭩; +var 𲭪; +var 𲭫; +var 𲭬; +var 𲭭; +var 𲭮; +var 𲭯; +var 𲭰; +var 𲭱; +var 𲭲; +var 𲭳; +var 𲭴; +var 𲭵; +var 𲭶; +var 𲭷; +var 𲭸; +var 𲭹; +var 𲭺; +var 𲭻; +var 𲭼; +var 𲭽; +var 𲭾; +var 𲭿; +var 𲮀; +var 𲮁; +var 𲮂; +var 𲮃; +var 𲮄; +var 𲮅; +var 𲮆; +var 𲮇; +var 𲮈; +var 𲮉; +var 𲮊; +var 𲮋; +var 𲮌; +var 𲮍; +var 𲮎; +var 𲮏; +var 𲮐; +var 𲮑; +var 𲮒; +var 𲮓; +var 𲮔; +var 𲮕; +var 𲮖; +var 𲮗; +var 𲮘; +var 𲮙; +var 𲮚; +var 𲮛; +var 𲮜; +var 𲮝; +var 𲮞; +var 𲮟; +var 𲮠; +var 𲮡; +var 𲮢; +var 𲮣; +var 𲮤; +var 𲮥; +var 𲮦; +var 𲮧; +var 𲮨; +var 𲮩; +var 𲮪; +var 𲮫; +var 𲮬; +var 𲮭; +var 𲮮; +var 𲮯; +var 𲮰; +var 𲮱; +var 𲮲; +var 𲮳; +var 𲮴; +var 𲮵; +var 𲮶; +var 𲮷; +var 𲮸; +var 𲮹; +var 𲮺; +var 𲮻; +var 𲮼; +var 𲮽; +var 𲮾; +var 𲮿; +var 𲯀; +var 𲯁; +var 𲯂; +var 𲯃; +var 𲯄; +var 𲯅; +var 𲯆; +var 𲯇; +var 𲯈; +var 𲯉; +var 𲯊; +var 𲯋; +var 𲯌; +var 𲯍; +var 𲯎; +var 𲯏; +var 𲯐; +var 𲯑; +var 𲯒; +var 𲯓; +var 𲯔; +var 𲯕; +var 𲯖; +var 𲯗; +var 𲯘; +var 𲯙; +var 𲯚; +var 𲯛; +var 𲯜; +var 𲯝; +var 𲯞; +var 𲯟; +var 𲯠; +var 𲯡; +var 𲯢; +var 𲯣; +var 𲯤; +var 𲯥; +var 𲯦; +var 𲯧; +var 𲯨; +var 𲯩; +var 𲯪; +var 𲯫; +var 𲯬; +var 𲯭; +var 𲯮; +var 𲯯; +var 𲯰; +var 𲯱; +var 𲯲; +var 𲯳; +var 𲯴; +var 𲯵; +var 𲯶; +var 𲯷; +var 𲯸; +var 𲯹; +var 𲯺; +var 𲯻; +var 𲯼; +var 𲯽; +var 𲯾; +var 𲯿; +var 𲰀; +var 𲰁; +var 𲰂; +var 𲰃; +var 𲰄; +var 𲰅; +var 𲰆; +var 𲰇; +var 𲰈; +var 𲰉; +var 𲰊; +var 𲰋; +var 𲰌; +var 𲰍; +var 𲰎; +var 𲰏; +var 𲰐; +var 𲰑; +var 𲰒; +var 𲰓; +var 𲰔; +var 𲰕; +var 𲰖; +var 𲰗; +var 𲰘; +var 𲰙; +var 𲰚; +var 𲰛; +var 𲰜; +var 𲰝; +var 𲰞; +var 𲰟; +var 𲰠; +var 𲰡; +var 𲰢; +var 𲰣; +var 𲰤; +var 𲰥; +var 𲰦; +var 𲰧; +var 𲰨; +var 𲰩; +var 𲰪; +var 𲰫; +var 𲰬; +var 𲰭; +var 𲰮; +var 𲰯; +var 𲰰; +var 𲰱; +var 𲰲; +var 𲰳; +var 𲰴; +var 𲰵; +var 𲰶; +var 𲰷; +var 𲰸; +var 𲰹; +var 𲰺; +var 𲰻; +var 𲰼; +var 𲰽; +var 𲰾; +var 𲰿; +var 𲱀; +var 𲱁; +var 𲱂; +var 𲱃; +var 𲱄; +var 𲱅; +var 𲱆; +var 𲱇; +var 𲱈; +var 𲱉; +var 𲱊; +var 𲱋; +var 𲱌; +var 𲱍; +var 𲱎; +var 𲱏; +var 𲱐; +var 𲱑; +var 𲱒; +var 𲱓; +var 𲱔; +var 𲱕; +var 𲱖; +var 𲱗; +var 𲱘; +var 𲱙; +var 𲱚; +var 𲱛; +var 𲱜; +var 𲱝; +var 𲱞; +var 𲱟; +var 𲱠; +var 𲱡; +var 𲱢; +var 𲱣; +var 𲱤; +var 𲱥; +var 𲱦; +var 𲱧; +var 𲱨; +var 𲱩; +var 𲱪; +var 𲱫; +var 𲱬; +var 𲱭; +var 𲱮; +var 𲱯; +var 𲱰; +var 𲱱; +var 𲱲; +var 𲱳; +var 𲱴; +var 𲱵; +var 𲱶; +var 𲱷; +var 𲱸; +var 𲱹; +var 𲱺; +var 𲱻; +var 𲱼; +var 𲱽; +var 𲱾; +var 𲱿; +var 𲲀; +var 𲲁; +var 𲲂; +var 𲲃; +var 𲲄; +var 𲲅; +var 𲲆; +var 𲲇; +var 𲲈; +var 𲲉; +var 𲲊; +var 𲲋; +var 𲲌; +var 𲲍; +var 𲲎; +var 𲲏; +var 𲲐; +var 𲲑; +var 𲲒; +var 𲲓; +var 𲲔; +var 𲲕; +var 𲲖; +var 𲲗; +var 𲲘; +var 𲲙; +var 𲲚; +var 𲲛; +var 𲲜; +var 𲲝; +var 𲲞; +var 𲲟; +var 𲲠; +var 𲲡; +var 𲲢; +var 𲲣; +var 𲲤; +var 𲲥; +var 𲲦; +var 𲲧; +var 𲲨; +var 𲲩; +var 𲲪; +var 𲲫; +var 𲲬; +var 𲲭; +var 𲲮; +var 𲲯; +var 𲲰; +var 𲲱; +var 𲲲; +var 𲲳; +var 𲲴; +var 𲲵; +var 𲲶; +var 𲲷; +var 𲲸; +var 𲲹; +var 𲲺; +var 𲲻; +var 𲲼; +var 𲲽; +var 𲲾; +var 𲲿; +var 𲳀; +var 𲳁; +var 𲳂; +var 𲳃; +var 𲳄; +var 𲳅; +var 𲳆; +var 𲳇; +var 𲳈; +var 𲳉; +var 𲳊; +var 𲳋; +var 𲳌; +var 𲳍; +var 𲳎; +var 𲳏; +var 𲳐; +var 𲳑; +var 𲳒; +var 𲳓; +var 𲳔; +var 𲳕; +var 𲳖; +var 𲳗; +var 𲳘; +var 𲳙; +var 𲳚; +var 𲳛; +var 𲳜; +var 𲳝; +var 𲳞; +var 𲳟; +var 𲳠; +var 𲳡; +var 𲳢; +var 𲳣; +var 𲳤; +var 𲳥; +var 𲳦; +var 𲳧; +var 𲳨; +var 𲳩; +var 𲳪; +var 𲳫; +var 𲳬; +var 𲳭; +var 𲳮; +var 𲳯; +var 𲳰; +var 𲳱; +var 𲳲; +var 𲳳; +var 𲳴; +var 𲳵; +var 𲳶; +var 𲳷; +var 𲳸; +var 𲳹; +var 𲳺; +var 𲳻; +var 𲳼; +var 𲳽; +var 𲳾; +var 𲳿; +var 𲴀; +var 𲴁; +var 𲴂; +var 𲴃; +var 𲴄; +var 𲴅; +var 𲴆; +var 𲴇; +var 𲴈; +var 𲴉; +var 𲴊; +var 𲴋; +var 𲴌; +var 𲴍; +var 𲴎; +var 𲴏; +var 𲴐; +var 𲴑; +var 𲴒; +var 𲴓; +var 𲴔; +var 𲴕; +var 𲴖; +var 𲴗; +var 𲴘; +var 𲴙; +var 𲴚; +var 𲴛; +var 𲴜; +var 𲴝; +var 𲴞; +var 𲴟; +var 𲴠; +var 𲴡; +var 𲴢; +var 𲴣; +var 𲴤; +var 𲴥; +var 𲴦; +var 𲴧; +var 𲴨; +var 𲴩; +var 𲴪; +var 𲴫; +var 𲴬; +var 𲴭; +var 𲴮; +var 𲴯; +var 𲴰; +var 𲴱; +var 𲴲; +var 𲴳; +var 𲴴; +var 𲴵; +var 𲴶; +var 𲴷; +var 𲴸; +var 𲴹; +var 𲴺; +var 𲴻; +var 𲴼; +var 𲴽; +var 𲴾; +var 𲴿; +var 𲵀; +var 𲵁; +var 𲵂; +var 𲵃; +var 𲵄; +var 𲵅; +var 𲵆; +var 𲵇; +var 𲵈; +var 𲵉; +var 𲵊; +var 𲵋; +var 𲵌; +var 𲵍; +var 𲵎; +var 𲵏; +var 𲵐; +var 𲵑; +var 𲵒; +var 𲵓; +var 𲵔; +var 𲵕; +var 𲵖; +var 𲵗; +var 𲵘; +var 𲵙; +var 𲵚; +var 𲵛; +var 𲵜; +var 𲵝; +var 𲵞; +var 𲵟; +var 𲵠; +var 𲵡; +var 𲵢; +var 𲵣; +var 𲵤; +var 𲵥; +var 𲵦; +var 𲵧; +var 𲵨; +var 𲵩; +var 𲵪; +var 𲵫; +var 𲵬; +var 𲵭; +var 𲵮; +var 𲵯; +var 𲵰; +var 𲵱; +var 𲵲; +var 𲵳; +var 𲵴; +var 𲵵; +var 𲵶; +var 𲵷; +var 𲵸; +var 𲵹; +var 𲵺; +var 𲵻; +var 𲵼; +var 𲵽; +var 𲵾; +var 𲵿; +var 𲶀; +var 𲶁; +var 𲶂; +var 𲶃; +var 𲶄; +var 𲶅; +var 𲶆; +var 𲶇; +var 𲶈; +var 𲶉; +var 𲶊; +var 𲶋; +var 𲶌; +var 𲶍; +var 𲶎; +var 𲶏; +var 𲶐; +var 𲶑; +var 𲶒; +var 𲶓; +var 𲶔; +var 𲶕; +var 𲶖; +var 𲶗; +var 𲶘; +var 𲶙; +var 𲶚; +var 𲶛; +var 𲶜; +var 𲶝; +var 𲶞; +var 𲶟; +var 𲶠; +var 𲶡; +var 𲶢; +var 𲶣; +var 𲶤; +var 𲶥; +var 𲶦; +var 𲶧; +var 𲶨; +var 𲶩; +var 𲶪; +var 𲶫; +var 𲶬; +var 𲶭; +var 𲶮; +var 𲶯; +var 𲶰; +var 𲶱; +var 𲶲; +var 𲶳; +var 𲶴; +var 𲶵; +var 𲶶; +var 𲶷; +var 𲶸; +var 𲶹; +var 𲶺; +var 𲶻; +var 𲶼; +var 𲶽; +var 𲶾; +var 𲶿; +var 𲷀; +var 𲷁; +var 𲷂; +var 𲷃; +var 𲷄; +var 𲷅; +var 𲷆; +var 𲷇; +var 𲷈; +var 𲷉; +var 𲷊; +var 𲷋; +var 𲷌; +var 𲷍; +var 𲷎; +var 𲷏; +var 𲷐; +var 𲷑; +var 𲷒; +var 𲷓; +var 𲷔; +var 𲷕; +var 𲷖; +var 𲷗; +var 𲷘; +var 𲷙; +var 𲷚; +var 𲷛; +var 𲷜; +var 𲷝; +var 𲷞; +var 𲷟; +var 𲷠; +var 𲷡; +var 𲷢; +var 𲷣; +var 𲷤; +var 𲷥; +var 𲷦; +var 𲷧; +var 𲷨; +var 𲷩; +var 𲷪; +var 𲷫; +var 𲷬; +var 𲷭; +var 𲷮; +var 𲷯; +var 𲷰; +var 𲷱; +var 𲷲; +var 𲷳; +var 𲷴; +var 𲷵; +var 𲷶; +var 𲷷; +var 𲷸; +var 𲷹; +var 𲷺; +var 𲷻; +var 𲷼; +var 𲷽; +var 𲷾; +var 𲷿; +var 𲸀; +var 𲸁; +var 𲸂; +var 𲸃; +var 𲸄; +var 𲸅; +var 𲸆; +var 𲸇; +var 𲸈; +var 𲸉; +var 𲸊; +var 𲸋; +var 𲸌; +var 𲸍; +var 𲸎; +var 𲸏; +var 𲸐; +var 𲸑; +var 𲸒; +var 𲸓; +var 𲸔; +var 𲸕; +var 𲸖; +var 𲸗; +var 𲸘; +var 𲸙; +var 𲸚; +var 𲸛; +var 𲸜; +var 𲸝; +var 𲸞; +var 𲸟; +var 𲸠; +var 𲸡; +var 𲸢; +var 𲸣; +var 𲸤; +var 𲸥; +var 𲸦; +var 𲸧; +var 𲸨; +var 𲸩; +var 𲸪; +var 𲸫; +var 𲸬; +var 𲸭; +var 𲸮; +var 𲸯; +var 𲸰; +var 𲸱; +var 𲸲; +var 𲸳; +var 𲸴; +var 𲸵; +var 𲸶; +var 𲸷; +var 𲸸; +var 𲸹; +var 𲸺; +var 𲸻; +var 𲸼; +var 𲸽; +var 𲸾; +var 𲸿; +var 𲹀; +var 𲹁; +var 𲹂; +var 𲹃; +var 𲹄; +var 𲹅; +var 𲹆; +var 𲹇; +var 𲹈; +var 𲹉; +var 𲹊; +var 𲹋; +var 𲹌; +var 𲹍; +var 𲹎; +var 𲹏; +var 𲹐; +var 𲹑; +var 𲹒; +var 𲹓; +var 𲹔; +var 𲹕; +var 𲹖; +var 𲹗; +var 𲹘; +var 𲹙; +var 𲹚; +var 𲹛; +var 𲹜; +var 𲹝; +var 𲹞; +var 𲹟; +var 𲹠; +var 𲹡; +var 𲹢; +var 𲹣; +var 𲹤; +var 𲹥; +var 𲹦; +var 𲹧; +var 𲹨; +var 𲹩; +var 𲹪; +var 𲹫; +var 𲹬; +var 𲹭; +var 𲹮; +var 𲹯; +var 𲹰; +var 𲹱; +var 𲹲; +var 𲹳; +var 𲹴; +var 𲹵; +var 𲹶; +var 𲹷; +var 𲹸; +var 𲹹; +var 𲹺; +var 𲹻; +var 𲹼; +var 𲹽; +var 𲹾; +var 𲹿; +var 𲺀; +var 𲺁; +var 𲺂; +var 𲺃; +var 𲺄; +var 𲺅; +var 𲺆; +var 𲺇; +var 𲺈; +var 𲺉; +var 𲺊; +var 𲺋; +var 𲺌; +var 𲺍; +var 𲺎; +var 𲺏; +var 𲺐; +var 𲺑; +var 𲺒; +var 𲺓; +var 𲺔; +var 𲺕; +var 𲺖; +var 𲺗; +var 𲺘; +var 𲺙; +var 𲺚; +var 𲺛; +var 𲺜; +var 𲺝; +var 𲺞; +var 𲺟; +var 𲺠; +var 𲺡; +var 𲺢; +var 𲺣; +var 𲺤; +var 𲺥; +var 𲺦; +var 𲺧; +var 𲺨; +var 𲺩; +var 𲺪; +var 𲺫; +var 𲺬; +var 𲺭; +var 𲺮; +var 𲺯; +var 𲺰; +var 𲺱; +var 𲺲; +var 𲺳; +var 𲺴; +var 𲺵; +var 𲺶; +var 𲺷; +var 𲺸; +var 𲺹; +var 𲺺; +var 𲺻; +var 𲺼; +var 𲺽; +var 𲺾; +var 𲺿; +var 𲻀; +var 𲻁; +var 𲻂; +var 𲻃; +var 𲻄; +var 𲻅; +var 𲻆; +var 𲻇; +var 𲻈; +var 𲻉; +var 𲻊; +var 𲻋; +var 𲻌; +var 𲻍; +var 𲻎; +var 𲻏; +var 𲻐; +var 𲻑; +var 𲻒; +var 𲻓; +var 𲻔; +var 𲻕; +var 𲻖; +var 𲻗; +var 𲻘; +var 𲻙; +var 𲻚; +var 𲻛; +var 𲻜; +var 𲻝; +var 𲻞; +var 𲻟; +var 𲻠; +var 𲻡; +var 𲻢; +var 𲻣; +var 𲻤; +var 𲻥; +var 𲻦; +var 𲻧; +var 𲻨; +var 𲻩; +var 𲻪; +var 𲻫; +var 𲻬; +var 𲻭; +var 𲻮; +var 𲻯; +var 𲻰; +var 𲻱; +var 𲻲; +var 𲻳; +var 𲻴; +var 𲻵; +var 𲻶; +var 𲻷; +var 𲻸; +var 𲻹; +var 𲻺; +var 𲻻; +var 𲻼; +var 𲻽; +var 𲻾; +var 𲻿; +var 𲼀; +var 𲼁; +var 𲼂; +var 𲼃; +var 𲼄; +var 𲼅; +var 𲼆; +var 𲼇; +var 𲼈; +var 𲼉; +var 𲼊; +var 𲼋; +var 𲼌; +var 𲼍; +var 𲼎; +var 𲼏; +var 𲼐; +var 𲼑; +var 𲼒; +var 𲼓; +var 𲼔; +var 𲼕; +var 𲼖; +var 𲼗; +var 𲼘; +var 𲼙; +var 𲼚; +var 𲼛; +var 𲼜; +var 𲼝; +var 𲼞; +var 𲼟; +var 𲼠; +var 𲼡; +var 𲼢; +var 𲼣; +var 𲼤; +var 𲼥; +var 𲼦; +var 𲼧; +var 𲼨; +var 𲼩; +var 𲼪; +var 𲼫; +var 𲼬; +var 𲼭; +var 𲼮; +var 𲼯; +var 𲼰; +var 𲼱; +var 𲼲; +var 𲼳; +var 𲼴; +var 𲼵; +var 𲼶; +var 𲼷; +var 𲼸; +var 𲼹; +var 𲼺; +var 𲼻; +var 𲼼; +var 𲼽; +var 𲼾; +var 𲼿; +var 𲽀; +var 𲽁; +var 𲽂; +var 𲽃; +var 𲽄; +var 𲽅; +var 𲽆; +var 𲽇; +var 𲽈; +var 𲽉; +var 𲽊; +var 𲽋; +var 𲽌; +var 𲽍; +var 𲽎; +var 𲽏; +var 𲽐; +var 𲽑; +var 𲽒; +var 𲽓; +var 𲽔; +var 𲽕; +var 𲽖; +var 𲽗; +var 𲽘; +var 𲽙; +var 𲽚; +var 𲽛; +var 𲽜; +var 𲽝; +var 𲽞; +var 𲽟; +var 𲽠; +var 𲽡; +var 𲽢; +var 𲽣; +var 𲽤; +var 𲽥; +var 𲽦; +var 𲽧; +var 𲽨; +var 𲽩; +var 𲽪; +var 𲽫; +var 𲽬; +var 𲽭; +var 𲽮; +var 𲽯; +var 𲽰; +var 𲽱; +var 𲽲; +var 𲽳; +var 𲽴; +var 𲽵; +var 𲽶; +var 𲽷; +var 𲽸; +var 𲽹; +var 𲽺; +var 𲽻; +var 𲽼; +var 𲽽; +var 𲽾; +var 𲽿; +var 𲾀; +var 𲾁; +var 𲾂; +var 𲾃; +var 𲾄; +var 𲾅; +var 𲾆; +var 𲾇; +var 𲾈; +var 𲾉; +var 𲾊; +var 𲾋; +var 𲾌; +var 𲾍; +var 𲾎; +var 𲾏; +var 𲾐; +var 𲾑; +var 𲾒; +var 𲾓; +var 𲾔; +var 𲾕; +var 𲾖; +var 𲾗; +var 𲾘; +var 𲾙; +var 𲾚; +var 𲾛; +var 𲾜; +var 𲾝; +var 𲾞; +var 𲾟; +var 𲾠; +var 𲾡; +var 𲾢; +var 𲾣; +var 𲾤; +var 𲾥; +var 𲾦; +var 𲾧; +var 𲾨; +var 𲾩; +var 𲾪; +var 𲾫; +var 𲾬; +var 𲾭; +var 𲾮; +var 𲾯; +var 𲾰; +var 𲾱; +var 𲾲; +var 𲾳; +var 𲾴; +var 𲾵; +var 𲾶; +var 𲾷; +var 𲾸; +var 𲾹; +var 𲾺; +var 𲾻; +var 𲾼; +var 𲾽; +var 𲾾; +var 𲾿; +var 𲿀; +var 𲿁; +var 𲿂; +var 𲿃; +var 𲿄; +var 𲿅; +var 𲿆; +var 𲿇; +var 𲿈; +var 𲿉; +var 𲿊; +var 𲿋; +var 𲿌; +var 𲿍; +var 𲿎; +var 𲿏; +var 𲿐; +var 𲿑; +var 𲿒; +var 𲿓; +var 𲿔; +var 𲿕; +var 𲿖; +var 𲿗; +var 𲿘; +var 𲿙; +var 𲿚; +var 𲿛; +var 𲿜; +var 𲿝; +var 𲿞; +var 𲿟; +var 𲿠; +var 𲿡; +var 𲿢; +var 𲿣; +var 𲿤; +var 𲿥; +var 𲿦; +var 𲿧; +var 𲿨; +var 𲿩; +var 𲿪; +var 𲿫; +var 𲿬; +var 𲿭; +var 𲿮; +var 𲿯; +var 𲿰; +var 𲿱; +var 𲿲; +var 𲿳; +var 𲿴; +var 𲿵; +var 𲿶; +var 𲿷; +var 𲿸; +var 𲿹; +var 𲿺; +var 𲿻; +var 𲿼; +var 𲿽; +var 𲿾; +var 𲿿; +var 𳀀; +var 𳀁; +var 𳀂; +var 𳀃; +var 𳀄; +var 𳀅; +var 𳀆; +var 𳀇; +var 𳀈; +var 𳀉; +var 𳀊; +var 𳀋; +var 𳀌; +var 𳀍; +var 𳀎; +var 𳀏; +var 𳀐; +var 𳀑; +var 𳀒; +var 𳀓; +var 𳀔; +var 𳀕; +var 𳀖; +var 𳀗; +var 𳀘; +var 𳀙; +var 𳀚; +var 𳀛; +var 𳀜; +var 𳀝; +var 𳀞; +var 𳀟; +var 𳀠; +var 𳀡; +var 𳀢; +var 𳀣; +var 𳀤; +var 𳀥; +var 𳀦; +var 𳀧; +var 𳀨; +var 𳀩; +var 𳀪; +var 𳀫; +var 𳀬; +var 𳀭; +var 𳀮; +var 𳀯; +var 𳀰; +var 𳀱; +var 𳀲; +var 𳀳; +var 𳀴; +var 𳀵; +var 𳀶; +var 𳀷; +var 𳀸; +var 𳀹; +var 𳀺; +var 𳀻; +var 𳀼; +var 𳀽; +var 𳀾; +var 𳀿; +var 𳁀; +var 𳁁; +var 𳁂; +var 𳁃; +var 𳁄; +var 𳁅; +var 𳁆; +var 𳁇; +var 𳁈; +var 𳁉; +var 𳁊; +var 𳁋; +var 𳁌; +var 𳁍; +var 𳁎; +var 𳁏; +var 𳁐; +var 𳁑; +var 𳁒; +var 𳁓; +var 𳁔; +var 𳁕; +var 𳁖; +var 𳁗; +var 𳁘; +var 𳁙; +var 𳁚; +var 𳁛; +var 𳁜; +var 𳁝; +var 𳁞; +var 𳁟; +var 𳁠; +var 𳁡; +var 𳁢; +var 𳁣; +var 𳁤; +var 𳁥; +var 𳁦; +var 𳁧; +var 𳁨; +var 𳁩; +var 𳁪; +var 𳁫; +var 𳁬; +var 𳁭; +var 𳁮; +var 𳁯; +var 𳁰; +var 𳁱; +var 𳁲; +var 𳁳; +var 𳁴; +var 𳁵; +var 𳁶; +var 𳁷; +var 𳁸; +var 𳁹; +var 𳁺; +var 𳁻; +var 𳁼; +var 𳁽; +var 𳁾; +var 𳁿; +var 𳂀; +var 𳂁; +var 𳂂; +var 𳂃; +var 𳂄; +var 𳂅; +var 𳂆; +var 𳂇; +var 𳂈; +var 𳂉; +var 𳂊; +var 𳂋; +var 𳂌; +var 𳂍; +var 𳂎; +var 𳂏; +var 𳂐; +var 𳂑; +var 𳂒; +var 𳂓; +var 𳂔; +var 𳂕; +var 𳂖; +var 𳂗; +var 𳂘; +var 𳂙; +var 𳂚; +var 𳂛; +var 𳂜; +var 𳂝; +var 𳂞; +var 𳂟; +var 𳂠; +var 𳂡; +var 𳂢; +var 𳂣; +var 𳂤; +var 𳂥; +var 𳂦; +var 𳂧; +var 𳂨; +var 𳂩; +var 𳂪; +var 𳂫; +var 𳂬; +var 𳂭; +var 𳂮; +var 𳂯; +var 𳂰; +var 𳂱; +var 𳂲; +var 𳂳; +var 𳂴; +var 𳂵; +var 𳂶; +var 𳂷; +var 𳂸; +var 𳂹; +var 𳂺; +var 𳂻; +var 𳂼; +var 𳂽; +var 𳂾; +var 𳂿; +var 𳃀; +var 𳃁; +var 𳃂; +var 𳃃; +var 𳃄; +var 𳃅; +var 𳃆; +var 𳃇; +var 𳃈; +var 𳃉; +var 𳃊; +var 𳃋; +var 𳃌; +var 𳃍; +var 𳃎; +var 𳃏; +var 𳃐; +var 𳃑; +var 𳃒; +var 𳃓; +var 𳃔; +var 𳃕; +var 𳃖; +var 𳃗; +var 𳃘; +var 𳃙; +var 𳃚; +var 𳃛; +var 𳃜; +var 𳃝; +var 𳃞; +var 𳃟; +var 𳃠; +var 𳃡; +var 𳃢; +var 𳃣; +var 𳃤; +var 𳃥; +var 𳃦; +var 𳃧; +var 𳃨; +var 𳃩; +var 𳃪; +var 𳃫; +var 𳃬; +var 𳃭; +var 𳃮; +var 𳃯; +var 𳃰; +var 𳃱; +var 𳃲; +var 𳃳; +var 𳃴; +var 𳃵; +var 𳃶; +var 𳃷; +var 𳃸; +var 𳃹; +var 𳃺; +var 𳃻; +var 𳃼; +var 𳃽; +var 𳃾; +var 𳃿; +var 𳄀; +var 𳄁; +var 𳄂; +var 𳄃; +var 𳄄; +var 𳄅; +var 𳄆; +var 𳄇; +var 𳄈; +var 𳄉; +var 𳄊; +var 𳄋; +var 𳄌; +var 𳄍; +var 𳄎; +var 𳄏; +var 𳄐; +var 𳄑; +var 𳄒; +var 𳄓; +var 𳄔; +var 𳄕; +var 𳄖; +var 𳄗; +var 𳄘; +var 𳄙; +var 𳄚; +var 𳄛; +var 𳄜; +var 𳄝; +var 𳄞; +var 𳄟; +var 𳄠; +var 𳄡; +var 𳄢; +var 𳄣; +var 𳄤; +var 𳄥; +var 𳄦; +var 𳄧; +var 𳄨; +var 𳄩; +var 𳄪; +var 𳄫; +var 𳄬; +var 𳄭; +var 𳄮; +var 𳄯; +var 𳄰; +var 𳄱; +var 𳄲; +var 𳄳; +var 𳄴; +var 𳄵; +var 𳄶; +var 𳄷; +var 𳄸; +var 𳄹; +var 𳄺; +var 𳄻; +var 𳄼; +var 𳄽; +var 𳄾; +var 𳄿; +var 𳅀; +var 𳅁; +var 𳅂; +var 𳅃; +var 𳅄; +var 𳅅; +var 𳅆; +var 𳅇; +var 𳅈; +var 𳅉; +var 𳅊; +var 𳅋; +var 𳅌; +var 𳅍; +var 𳅎; +var 𳅏; +var 𳅐; +var 𳅑; +var 𳅒; +var 𳅓; +var 𳅔; +var 𳅕; +var 𳅖; +var 𳅗; +var 𳅘; +var 𳅙; +var 𳅚; +var 𳅛; +var 𳅜; +var 𳅝; +var 𳅞; +var 𳅟; +var 𳅠; +var 𳅡; +var 𳅢; +var 𳅣; +var 𳅤; +var 𳅥; +var 𳅦; +var 𳅧; +var 𳅨; +var 𳅩; +var 𳅪; +var 𳅫; +var 𳅬; +var 𳅭; +var 𳅮; +var 𳅯; +var 𳅰; +var 𳅱; +var 𳅲; +var 𳅳; +var 𳅴; +var 𳅵; +var 𳅶; +var 𳅷; +var 𳅸; +var 𳅹; +var 𳅺; +var 𳅻; +var 𳅼; +var 𳅽; +var 𳅾; +var 𳅿; +var 𳆀; +var 𳆁; +var 𳆂; +var 𳆃; +var 𳆄; +var 𳆅; +var 𳆆; +var 𳆇; +var 𳆈; +var 𳆉; +var 𳆊; +var 𳆋; +var 𳆌; +var 𳆍; +var 𳆎; +var 𳆏; +var 𳆐; +var 𳆑; +var 𳆒; +var 𳆓; +var 𳆔; +var 𳆕; +var 𳆖; +var 𳆗; +var 𳆘; +var 𳆙; +var 𳆚; +var 𳆛; +var 𳆜; +var 𳆝; +var 𳆞; +var 𳆟; +var 𳆠; +var 𳆡; +var 𳆢; +var 𳆣; +var 𳆤; +var 𳆥; +var 𳆦; +var 𳆧; +var 𳆨; +var 𳆩; +var 𳆪; +var 𳆫; +var 𳆬; +var 𳆭; +var 𳆮; +var 𳆯; +var 𳆰; +var 𳆱; +var 𳆲; +var 𳆳; +var 𳆴; +var 𳆵; +var 𳆶; +var 𳆷; +var 𳆸; +var 𳆹; +var 𳆺; +var 𳆻; +var 𳆼; +var 𳆽; +var 𳆾; +var 𳆿; +var 𳇀; +var 𳇁; +var 𳇂; +var 𳇃; +var 𳇄; +var 𳇅; +var 𳇆; +var 𳇇; +var 𳇈; +var 𳇉; +var 𳇊; +var 𳇋; +var 𳇌; +var 𳇍; +var 𳇎; +var 𳇏; +var 𳇐; +var 𳇑; +var 𳇒; +var 𳇓; +var 𳇔; +var 𳇕; +var 𳇖; +var 𳇗; +var 𳇘; +var 𳇙; +var 𳇚; +var 𳇛; +var 𳇜; +var 𳇝; +var 𳇞; +var 𳇟; +var 𳇠; +var 𳇡; +var 𳇢; +var 𳇣; +var 𳇤; +var 𳇥; +var 𳇦; +var 𳇧; +var 𳇨; +var 𳇩; +var 𳇪; +var 𳇫; +var 𳇬; +var 𳇭; +var 𳇮; +var 𳇯; +var 𳇰; +var 𳇱; +var 𳇲; +var 𳇳; +var 𳇴; +var 𳇵; +var 𳇶; +var 𳇷; +var 𳇸; +var 𳇹; +var 𳇺; +var 𳇻; +var 𳇼; +var 𳇽; +var 𳇾; +var 𳇿; +var 𳈀; +var 𳈁; +var 𳈂; +var 𳈃; +var 𳈄; +var 𳈅; +var 𳈆; +var 𳈇; +var 𳈈; +var 𳈉; +var 𳈊; +var 𳈋; +var 𳈌; +var 𳈍; +var 𳈎; +var 𳈏; +var 𳈐; +var 𳈑; +var 𳈒; +var 𳈓; +var 𳈔; +var 𳈕; +var 𳈖; +var 𳈗; +var 𳈘; +var 𳈙; +var 𳈚; +var 𳈛; +var 𳈜; +var 𳈝; +var 𳈞; +var 𳈟; +var 𳈠; +var 𳈡; +var 𳈢; +var 𳈣; +var 𳈤; +var 𳈥; +var 𳈦; +var 𳈧; +var 𳈨; +var 𳈩; +var 𳈪; +var 𳈫; +var 𳈬; +var 𳈭; +var 𳈮; +var 𳈯; +var 𳈰; +var 𳈱; +var 𳈲; +var 𳈳; +var 𳈴; +var 𳈵; +var 𳈶; +var 𳈷; +var 𳈸; +var 𳈹; +var 𳈺; +var 𳈻; +var 𳈼; +var 𳈽; +var 𳈾; +var 𳈿; +var 𳉀; +var 𳉁; +var 𳉂; +var 𳉃; +var 𳉄; +var 𳉅; +var 𳉆; +var 𳉇; +var 𳉈; +var 𳉉; +var 𳉊; +var 𳉋; +var 𳉌; +var 𳉍; +var 𳉎; +var 𳉏; +var 𳉐; +var 𳉑; +var 𳉒; +var 𳉓; +var 𳉔; +var 𳉕; +var 𳉖; +var 𳉗; +var 𳉘; +var 𳉙; +var 𳉚; +var 𳉛; +var 𳉜; +var 𳉝; +var 𳉞; +var 𳉟; +var 𳉠; +var 𳉡; +var 𳉢; +var 𳉣; +var 𳉤; +var 𳉥; +var 𳉦; +var 𳉧; +var 𳉨; +var 𳉩; +var 𳉪; +var 𳉫; +var 𳉬; +var 𳉭; +var 𳉮; +var 𳉯; +var 𳉰; +var 𳉱; +var 𳉲; +var 𳉳; +var 𳉴; +var 𳉵; +var 𳉶; +var 𳉷; +var 𳉸; +var 𳉹; +var 𳉺; +var 𳉻; +var 𳉼; +var 𳉽; +var 𳉾; +var 𳉿; +var 𳊀; +var 𳊁; +var 𳊂; +var 𳊃; +var 𳊄; +var 𳊅; +var 𳊆; +var 𳊇; +var 𳊈; +var 𳊉; +var 𳊊; +var 𳊋; +var 𳊌; +var 𳊍; +var 𳊎; +var 𳊏; +var 𳊐; +var 𳊑; +var 𳊒; +var 𳊓; +var 𳊔; +var 𳊕; +var 𳊖; +var 𳊗; +var 𳊘; +var 𳊙; +var 𳊚; +var 𳊛; +var 𳊜; +var 𳊝; +var 𳊞; +var 𳊟; +var 𳊠; +var 𳊡; +var 𳊢; +var 𳊣; +var 𳊤; +var 𳊥; +var 𳊦; +var 𳊧; +var 𳊨; +var 𳊩; +var 𳊪; +var 𳊫; +var 𳊬; +var 𳊭; +var 𳊮; +var 𳊯; +var 𳊰; +var 𳊱; +var 𳊲; +var 𳊳; +var 𳊴; +var 𳊵; +var 𳊶; +var 𳊷; +var 𳊸; +var 𳊹; +var 𳊺; +var 𳊻; +var 𳊼; +var 𳊽; +var 𳊾; +var 𳊿; +var 𳋀; +var 𳋁; +var 𳋂; +var 𳋃; +var 𳋄; +var 𳋅; +var 𳋆; +var 𳋇; +var 𳋈; +var 𳋉; +var 𳋊; +var 𳋋; +var 𳋌; +var 𳋍; +var 𳋎; +var 𳋏; +var 𳋐; +var 𳋑; +var 𳋒; +var 𳋓; +var 𳋔; +var 𳋕; +var 𳋖; +var 𳋗; +var 𳋘; +var 𳋙; +var 𳋚; +var 𳋛; +var 𳋜; +var 𳋝; +var 𳋞; +var 𳋟; +var 𳋠; +var 𳋡; +var 𳋢; +var 𳋣; +var 𳋤; +var 𳋥; +var 𳋦; +var 𳋧; +var 𳋨; +var 𳋩; +var 𳋪; +var 𳋫; +var 𳋬; +var 𳋭; +var 𳋮; +var 𳋯; +var 𳋰; +var 𳋱; +var 𳋲; +var 𳋳; +var 𳋴; +var 𳋵; +var 𳋶; +var 𳋷; +var 𳋸; +var 𳋹; +var 𳋺; +var 𳋻; +var 𳋼; +var 𳋽; +var 𳋾; +var 𳋿; +var 𳌀; +var 𳌁; +var 𳌂; +var 𳌃; +var 𳌄; +var 𳌅; +var 𳌆; +var 𳌇; +var 𳌈; +var 𳌉; +var 𳌊; +var 𳌋; +var 𳌌; +var 𳌍; +var 𳌎; +var 𳌏; +var 𳌐; +var 𳌑; +var 𳌒; +var 𳌓; +var 𳌔; +var 𳌕; +var 𳌖; +var 𳌗; +var 𳌘; +var 𳌙; +var 𳌚; +var 𳌛; +var 𳌜; +var 𳌝; +var 𳌞; +var 𳌟; +var 𳌠; +var 𳌡; +var 𳌢; +var 𳌣; +var 𳌤; +var 𳌥; +var 𳌦; +var 𳌧; +var 𳌨; +var 𳌩; +var 𳌪; +var 𳌫; +var 𳌬; +var 𳌭; +var 𳌮; +var 𳌯; +var 𳌰; +var 𳌱; +var 𳌲; +var 𳌳; +var 𳌴; +var 𳌵; +var 𳌶; +var 𳌷; +var 𳌸; +var 𳌹; +var 𳌺; +var 𳌻; +var 𳌼; +var 𳌽; +var 𳌾; +var 𳌿; +var 𳍀; +var 𳍁; +var 𳍂; +var 𳍃; +var 𳍄; +var 𳍅; +var 𳍆; +var 𳍇; +var 𳍈; +var 𳍉; +var 𳍊; +var 𳍋; +var 𳍌; +var 𳍍; +var 𳍎; +var 𳍏; +var 𳍐; +var 𳍑; +var 𳍒; +var 𳍓; +var 𳍔; +var 𳍕; +var 𳍖; +var 𳍗; +var 𳍘; +var 𳍙; +var 𳍚; +var 𳍛; +var 𳍜; +var 𳍝; +var 𳍞; +var 𳍟; +var 𳍠; +var 𳍡; +var 𳍢; +var 𳍣; +var 𳍤; +var 𳍥; +var 𳍦; +var 𳍧; +var 𳍨; +var 𳍩; +var 𳍪; +var 𳍫; +var 𳍬; +var 𳍭; +var 𳍮; +var 𳍯; +var 𳍰; +var 𳍱; +var 𳍲; +var 𳍳; +var 𳍴; +var 𳍵; +var 𳍶; +var 𳍷; +var 𳍸; +var 𳍹; +var 𳍺; +var 𳍻; +var 𳍼; +var 𳍽; +var 𳍾; +var 𳍿; +var 𳎀; +var 𳎁; +var 𳎂; +var 𳎃; +var 𳎄; +var 𳎅; +var 𳎆; +var 𳎇; +var 𳎈; +var 𳎉; +var 𳎊; +var 𳎋; +var 𳎌; +var 𳎍; +var 𳎎; +var 𳎏; +var 𳎐; +var 𳎑; +var 𳎒; +var 𳎓; +var 𳎔; +var 𳎕; +var 𳎖; +var 𳎗; +var 𳎘; +var 𳎙; +var 𳎚; +var 𳎛; +var 𳎜; +var 𳎝; +var 𳎞; +var 𳎟; +var 𳎠; +var 𳎡; +var 𳎢; +var 𳎣; +var 𳎤; +var 𳎥; +var 𳎦; +var 𳎧; +var 𳎨; +var 𳎩; +var 𳎪; +var 𳎫; +var 𳎬; +var 𳎭; +var 𳎮; +var 𳎯; +var 𳎰; +var 𳎱; +var 𳎲; +var 𳎳; +var 𳎴; +var 𳎵; +var 𳎶; +var 𳎷; +var 𳎸; +var 𳎹; +var 𳎺; +var 𳎻; +var 𳎼; +var 𳎽; +var 𳎾; +var 𳎿; +var 𳏀; +var 𳏁; +var 𳏂; +var 𳏃; +var 𳏄; +var 𳏅; +var 𳏆; +var 𳏇; +var 𳏈; +var 𳏉; +var 𳏊; +var 𳏋; +var 𳏌; +var 𳏍; +var 𳏎; +var 𳏏; +var 𳏐; +var 𳏑; +var 𳏒; +var 𳏓; +var 𳏔; +var 𳏕; +var 𳏖; +var 𳏗; +var 𳏘; +var 𳏙; +var 𳏚; +var 𳏛; +var 𳏜; +var 𳏝; +var 𳏞; +var 𳏟; +var 𳏠; +var 𳏡; +var 𳏢; +var 𳏣; +var 𳏤; +var 𳏥; +var 𳏦; +var 𳏧; +var 𳏨; +var 𳏩; +var 𳏪; +var 𳏫; +var 𳏬; +var 𳏭; +var 𳏮; +var 𳏯; +var 𳏰; +var 𳏱; +var 𳏲; +var 𳏳; +var 𳏴; +var 𳏵; +var 𳏶; +var 𳏷; +var 𳏸; +var 𳏹; +var 𳏺; +var 𳏻; +var 𳏼; +var 𳏽; +var 𳏾; +var 𳏿; +var 𳐀; +var 𳐁; +var 𳐂; +var 𳐃; +var 𳐄; +var 𳐅; +var 𳐆; +var 𳐇; +var 𳐈; +var 𳐉; +var 𳐊; +var 𳐋; +var 𳐌; +var 𳐍; +var 𳐎; +var 𳐏; +var 𳐐; +var 𳐑; +var 𳐒; +var 𳐓; +var 𳐔; +var 𳐕; +var 𳐖; +var 𳐗; +var 𳐘; +var 𳐙; +var 𳐚; +var 𳐛; +var 𳐜; +var 𳐝; +var 𳐞; +var 𳐟; +var 𳐠; +var 𳐡; +var 𳐢; +var 𳐣; +var 𳐤; +var 𳐥; +var 𳐦; +var 𳐧; +var 𳐨; +var 𳐩; +var 𳐪; +var 𳐫; +var 𳐬; +var 𳐭; +var 𳐮; +var 𳐯; +var 𳐰; +var 𳐱; +var 𳐲; +var 𳐳; +var 𳐴; +var 𳐵; +var 𳐶; +var 𳐷; +var 𳐸; +var 𳐹; +var 𳐺; +var 𳐻; +var 𳐼; +var 𳐽; +var 𳐾; +var 𳐿; +var 𳑀; +var 𳑁; +var 𳑂; +var 𳑃; +var 𳑄; +var 𳑅; +var 𳑆; +var 𳑇; +var 𳑈; +var 𳑉; +var 𳑊; +var 𳑋; +var 𳑌; +var 𳑍; +var 𳑎; +var 𳑏; +var 𳑐; +var 𳑑; +var 𳑒; +var 𳑓; +var 𳑔; +var 𳑕; +var 𳑖; +var 𳑗; +var 𳑘; +var 𳑙; +var 𳑚; +var 𳑛; +var 𳑜; +var 𳑝; +var 𳑞; +var 𳑟; +var 𳑠; +var 𳑡; +var 𳑢; +var 𳑣; +var 𳑤; +var 𳑥; +var 𳑦; +var 𳑧; +var 𳑨; +var 𳑩; +var 𳑪; +var 𳑫; +var 𳑬; +var 𳑭; +var 𳑮; +var 𳑯; +var 𳑰; +var 𳑱; +var 𳑲; +var 𳑳; +var 𳑴; +var 𳑵; +var 𳑶; +var 𳑷; +var 𳑸; +var 𳑹; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0-class-escaped.js new file mode 100644 index 000000000..f9b770baa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0-class-escaped.js @@ -0,0 +1,6111 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v5.2.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u0524; + #\u0525; + #\u0800; + #\u0801; + #\u0802; + #\u0803; + #\u0804; + #\u0805; + #\u0806; + #\u0807; + #\u0808; + #\u0809; + #\u080A; + #\u080B; + #\u080C; + #\u080D; + #\u080E; + #\u080F; + #\u0810; + #\u0811; + #\u0812; + #\u0813; + #\u0814; + #\u0815; + #\u081A; + #\u0824; + #\u0828; + #\u0979; + #\u097A; + #\u115A; + #\u115B; + #\u115C; + #\u115D; + #\u115E; + #\u11A3; + #\u11A4; + #\u11A5; + #\u11A6; + #\u11A7; + #\u11FA; + #\u11FB; + #\u11FC; + #\u11FD; + #\u11FE; + #\u11FF; + #\u1677; + #\u1678; + #\u1679; + #\u167A; + #\u167B; + #\u167C; + #\u167D; + #\u167E; + #\u167F; + #\u18B0; + #\u18B1; + #\u18B2; + #\u18B3; + #\u18B4; + #\u18B5; + #\u18B6; + #\u18B7; + #\u18B8; + #\u18B9; + #\u18BA; + #\u18BB; + #\u18BC; + #\u18BD; + #\u18BE; + #\u18BF; + #\u18C0; + #\u18C1; + #\u18C2; + #\u18C3; + #\u18C4; + #\u18C5; + #\u18C6; + #\u18C7; + #\u18C8; + #\u18C9; + #\u18CA; + #\u18CB; + #\u18CC; + #\u18CD; + #\u18CE; + #\u18CF; + #\u18D0; + #\u18D1; + #\u18D2; + #\u18D3; + #\u18D4; + #\u18D5; + #\u18D6; + #\u18D7; + #\u18D8; + #\u18D9; + #\u18DA; + #\u18DB; + #\u18DC; + #\u18DD; + #\u18DE; + #\u18DF; + #\u18E0; + #\u18E1; + #\u18E2; + #\u18E3; + #\u18E4; + #\u18E5; + #\u18E6; + #\u18E7; + #\u18E8; + #\u18E9; + #\u18EA; + #\u18EB; + #\u18EC; + #\u18ED; + #\u18EE; + #\u18EF; + #\u18F0; + #\u18F1; + #\u18F2; + #\u18F3; + #\u18F4; + #\u18F5; + #\u19AA; + #\u19AB; + #\u1A20; + #\u1A21; + #\u1A22; + #\u1A23; + #\u1A24; + #\u1A25; + #\u1A26; + #\u1A27; + #\u1A28; + #\u1A29; + #\u1A2A; + #\u1A2B; + #\u1A2C; + #\u1A2D; + #\u1A2E; + #\u1A2F; + #\u1A30; + #\u1A31; + #\u1A32; + #\u1A33; + #\u1A34; + #\u1A35; + #\u1A36; + #\u1A37; + #\u1A38; + #\u1A39; + #\u1A3A; + #\u1A3B; + #\u1A3C; + #\u1A3D; + #\u1A3E; + #\u1A3F; + #\u1A40; + #\u1A41; + #\u1A42; + #\u1A43; + #\u1A44; + #\u1A45; + #\u1A46; + #\u1A47; + #\u1A48; + #\u1A49; + #\u1A4A; + #\u1A4B; + #\u1A4C; + #\u1A4D; + #\u1A4E; + #\u1A4F; + #\u1A50; + #\u1A51; + #\u1A52; + #\u1A53; + #\u1A54; + #\u1AA7; + #\u1CE9; + #\u1CEA; + #\u1CEB; + #\u1CEC; + #\u1CEE; + #\u1CEF; + #\u1CF0; + #\u1CF1; + #\u2C70; + #\u2C7E; + #\u2C7F; + #\u2CEB; + #\u2CEC; + #\u2CED; + #\u2CEE; + #\u9FC4; + #\u9FC5; + #\u9FC6; + #\u9FC7; + #\u9FC8; + #\u9FC9; + #\u9FCA; + #\u9FCB; + #\uA4D0; + #\uA4D1; + #\uA4D2; + #\uA4D3; + #\uA4D4; + #\uA4D5; + #\uA4D6; + #\uA4D7; + #\uA4D8; + #\uA4D9; + #\uA4DA; + #\uA4DB; + #\uA4DC; + #\uA4DD; + #\uA4DE; + #\uA4DF; + #\uA4E0; + #\uA4E1; + #\uA4E2; + #\uA4E3; + #\uA4E4; + #\uA4E5; + #\uA4E6; + #\uA4E7; + #\uA4E8; + #\uA4E9; + #\uA4EA; + #\uA4EB; + #\uA4EC; + #\uA4ED; + #\uA4EE; + #\uA4EF; + #\uA4F0; + #\uA4F1; + #\uA4F2; + #\uA4F3; + #\uA4F4; + #\uA4F5; + #\uA4F6; + #\uA4F7; + #\uA4F8; + #\uA4F9; + #\uA4FA; + #\uA4FB; + #\uA4FC; + #\uA4FD; + #\uA6A0; + #\uA6A1; + #\uA6A2; + #\uA6A3; + #\uA6A4; + #\uA6A5; + #\uA6A6; + #\uA6A7; + #\uA6A8; + #\uA6A9; + #\uA6AA; + #\uA6AB; + #\uA6AC; + #\uA6AD; + #\uA6AE; + #\uA6AF; + #\uA6B0; + #\uA6B1; + #\uA6B2; + #\uA6B3; + #\uA6B4; + #\uA6B5; + #\uA6B6; + #\uA6B7; + #\uA6B8; + #\uA6B9; + #\uA6BA; + #\uA6BB; + #\uA6BC; + #\uA6BD; + #\uA6BE; + #\uA6BF; + #\uA6C0; + #\uA6C1; + #\uA6C2; + #\uA6C3; + #\uA6C4; + #\uA6C5; + #\uA6C6; + #\uA6C7; + #\uA6C8; + #\uA6C9; + #\uA6CA; + #\uA6CB; + #\uA6CC; + #\uA6CD; + #\uA6CE; + #\uA6CF; + #\uA6D0; + #\uA6D1; + #\uA6D2; + #\uA6D3; + #\uA6D4; + #\uA6D5; + #\uA6D6; + #\uA6D7; + #\uA6D8; + #\uA6D9; + #\uA6DA; + #\uA6DB; + #\uA6DC; + #\uA6DD; + #\uA6DE; + #\uA6DF; + #\uA6E0; + #\uA6E1; + #\uA6E2; + #\uA6E3; + #\uA6E4; + #\uA6E5; + #\uA6E6; + #\uA6E7; + #\uA6E8; + #\uA6E9; + #\uA6EA; + #\uA6EB; + #\uA6EC; + #\uA6ED; + #\uA6EE; + #\uA6EF; + #\uA8F2; + #\uA8F3; + #\uA8F4; + #\uA8F5; + #\uA8F6; + #\uA8F7; + #\uA8FB; + #\uA960; + #\uA961; + #\uA962; + #\uA963; + #\uA964; + #\uA965; + #\uA966; + #\uA967; + #\uA968; + #\uA969; + #\uA96A; + #\uA96B; + #\uA96C; + #\uA96D; + #\uA96E; + #\uA96F; + #\uA970; + #\uA971; + #\uA972; + #\uA973; + #\uA974; + #\uA975; + #\uA976; + #\uA977; + #\uA978; + #\uA979; + #\uA97A; + #\uA97B; + #\uA97C; + #\uA984; + #\uA985; + #\uA986; + #\uA987; + #\uA988; + #\uA989; + #\uA98A; + #\uA98B; + #\uA98C; + #\uA98D; + #\uA98E; + #\uA98F; + #\uA990; + #\uA991; + #\uA992; + #\uA993; + #\uA994; + #\uA995; + #\uA996; + #\uA997; + #\uA998; + #\uA999; + #\uA99A; + #\uA99B; + #\uA99C; + #\uA99D; + #\uA99E; + #\uA99F; + #\uA9A0; + #\uA9A1; + #\uA9A2; + #\uA9A3; + #\uA9A4; + #\uA9A5; + #\uA9A6; + #\uA9A7; + #\uA9A8; + #\uA9A9; + #\uA9AA; + #\uA9AB; + #\uA9AC; + #\uA9AD; + #\uA9AE; + #\uA9AF; + #\uA9B0; + #\uA9B1; + #\uA9B2; + #\uA9CF; + #\uAA60; + #\uAA61; + #\uAA62; + #\uAA63; + #\uAA64; + #\uAA65; + #\uAA66; + #\uAA67; + #\uAA68; + #\uAA69; + #\uAA6A; + #\uAA6B; + #\uAA6C; + #\uAA6D; + #\uAA6E; + #\uAA6F; + #\uAA70; + #\uAA71; + #\uAA72; + #\uAA73; + #\uAA74; + #\uAA75; + #\uAA76; + #\uAA7A; + #\uAA80; + #\uAA81; + #\uAA82; + #\uAA83; + #\uAA84; + #\uAA85; + #\uAA86; + #\uAA87; + #\uAA88; + #\uAA89; + #\uAA8A; + #\uAA8B; + #\uAA8C; + #\uAA8D; + #\uAA8E; + #\uAA8F; + #\uAA90; + #\uAA91; + #\uAA92; + #\uAA93; + #\uAA94; + #\uAA95; + #\uAA96; + #\uAA97; + #\uAA98; + #\uAA99; + #\uAA9A; + #\uAA9B; + #\uAA9C; + #\uAA9D; + #\uAA9E; + #\uAA9F; + #\uAAA0; + #\uAAA1; + #\uAAA2; + #\uAAA3; + #\uAAA4; + #\uAAA5; + #\uAAA6; + #\uAAA7; + #\uAAA8; + #\uAAA9; + #\uAAAA; + #\uAAAB; + #\uAAAC; + #\uAAAD; + #\uAAAE; + #\uAAAF; + #\uAAB1; + #\uAAB5; + #\uAAB6; + #\uAAB9; + #\uAABA; + #\uAABB; + #\uAABC; + #\uAABD; + #\uAAC0; + #\uAAC2; + #\uAADB; + #\uAADC; + #\uAADD; + #\uABC0; + #\uABC1; + #\uABC2; + #\uABC3; + #\uABC4; + #\uABC5; + #\uABC6; + #\uABC7; + #\uABC8; + #\uABC9; + #\uABCA; + #\uABCB; + #\uABCC; + #\uABCD; + #\uABCE; + #\uABCF; + #\uABD0; + #\uABD1; + #\uABD2; + #\uABD3; + #\uABD4; + #\uABD5; + #\uABD6; + #\uABD7; + #\uABD8; + #\uABD9; + #\uABDA; + #\uABDB; + #\uABDC; + #\uABDD; + #\uABDE; + #\uABDF; + #\uABE0; + #\uABE1; + #\uABE2; + #\uD7B0; + #\uD7B1; + #\uD7B2; + #\uD7B3; + #\uD7B4; + #\uD7B5; + #\uD7B6; + #\uD7B7; + #\uD7B8; + #\uD7B9; + #\uD7BA; + #\uD7BB; + #\uD7BC; + #\uD7BD; + #\uD7BE; + #\uD7BF; + #\uD7C0; + #\uD7C1; + #\uD7C2; + #\uD7C3; + #\uD7C4; + #\uD7C5; + #\uD7C6; + #\uD7CB; + #\uD7CC; + #\uD7CD; + #\uD7CE; + #\uD7CF; + #\uD7D0; + #\uD7D1; + #\uD7D2; + #\uD7D3; + #\uD7D4; + #\uD7D5; + #\uD7D6; + #\uD7D7; + #\uD7D8; + #\uD7D9; + #\uD7DA; + #\uD7DB; + #\uD7DC; + #\uD7DD; + #\uD7DE; + #\uD7DF; + #\uD7E0; + #\uD7E1; + #\uD7E2; + #\uD7E3; + #\uD7E4; + #\uD7E5; + #\uD7E6; + #\uD7E7; + #\uD7E8; + #\uD7E9; + #\uD7EA; + #\uD7EB; + #\uD7EC; + #\uD7ED; + #\uD7EE; + #\uD7EF; + #\uD7F0; + #\uD7F1; + #\uD7F2; + #\uD7F3; + #\uD7F4; + #\uD7F5; + #\uD7F6; + #\uD7F7; + #\uD7F8; + #\uD7F9; + #\uD7FA; + #\uD7FB; + #\uFA6B; + #\uFA6C; + #\uFA6D; + #\u{10840}; + #\u{10841}; + #\u{10842}; + #\u{10843}; + #\u{10844}; + #\u{10845}; + #\u{10846}; + #\u{10847}; + #\u{10848}; + #\u{10849}; + #\u{1084A}; + #\u{1084B}; + #\u{1084C}; + #\u{1084D}; + #\u{1084E}; + #\u{1084F}; + #\u{10850}; + #\u{10851}; + #\u{10852}; + #\u{10853}; + #\u{10854}; + #\u{10855}; + #\u{10A60}; + #\u{10A61}; + #\u{10A62}; + #\u{10A63}; + #\u{10A64}; + #\u{10A65}; + #\u{10A66}; + #\u{10A67}; + #\u{10A68}; + #\u{10A69}; + #\u{10A6A}; + #\u{10A6B}; + #\u{10A6C}; + #\u{10A6D}; + #\u{10A6E}; + #\u{10A6F}; + #\u{10A70}; + #\u{10A71}; + #\u{10A72}; + #\u{10A73}; + #\u{10A74}; + #\u{10A75}; + #\u{10A76}; + #\u{10A77}; + #\u{10A78}; + #\u{10A79}; + #\u{10A7A}; + #\u{10A7B}; + #\u{10A7C}; + #\u{10B00}; + #\u{10B01}; + #\u{10B02}; + #\u{10B03}; + #\u{10B04}; + #\u{10B05}; + #\u{10B06}; + #\u{10B07}; + #\u{10B08}; + #\u{10B09}; + #\u{10B0A}; + #\u{10B0B}; + #\u{10B0C}; + #\u{10B0D}; + #\u{10B0E}; + #\u{10B0F}; + #\u{10B10}; + #\u{10B11}; + #\u{10B12}; + #\u{10B13}; + #\u{10B14}; + #\u{10B15}; + #\u{10B16}; + #\u{10B17}; + #\u{10B18}; + #\u{10B19}; + #\u{10B1A}; + #\u{10B1B}; + #\u{10B1C}; + #\u{10B1D}; + #\u{10B1E}; + #\u{10B1F}; + #\u{10B20}; + #\u{10B21}; + #\u{10B22}; + #\u{10B23}; + #\u{10B24}; + #\u{10B25}; + #\u{10B26}; + #\u{10B27}; + #\u{10B28}; + #\u{10B29}; + #\u{10B2A}; + #\u{10B2B}; + #\u{10B2C}; + #\u{10B2D}; + #\u{10B2E}; + #\u{10B2F}; + #\u{10B30}; + #\u{10B31}; + #\u{10B32}; + #\u{10B33}; + #\u{10B34}; + #\u{10B35}; + #\u{10B40}; + #\u{10B41}; + #\u{10B42}; + #\u{10B43}; + #\u{10B44}; + #\u{10B45}; + #\u{10B46}; + #\u{10B47}; + #\u{10B48}; + #\u{10B49}; + #\u{10B4A}; + #\u{10B4B}; + #\u{10B4C}; + #\u{10B4D}; + #\u{10B4E}; + #\u{10B4F}; + #\u{10B50}; + #\u{10B51}; + #\u{10B52}; + #\u{10B53}; + #\u{10B54}; + #\u{10B55}; + #\u{10B60}; + #\u{10B61}; + #\u{10B62}; + #\u{10B63}; + #\u{10B64}; + #\u{10B65}; + #\u{10B66}; + #\u{10B67}; + #\u{10B68}; + #\u{10B69}; + #\u{10B6A}; + #\u{10B6B}; + #\u{10B6C}; + #\u{10B6D}; + #\u{10B6E}; + #\u{10B6F}; + #\u{10B70}; + #\u{10B71}; + #\u{10B72}; + #\u{10C00}; + #\u{10C01}; + #\u{10C02}; + #\u{10C03}; + #\u{10C04}; + #\u{10C05}; + #\u{10C06}; + #\u{10C07}; + #\u{10C08}; + #\u{10C09}; + #\u{10C0A}; + #\u{10C0B}; + #\u{10C0C}; + #\u{10C0D}; + #\u{10C0E}; + #\u{10C0F}; + #\u{10C10}; + #\u{10C11}; + #\u{10C12}; + #\u{10C13}; + #\u{10C14}; + #\u{10C15}; + #\u{10C16}; + #\u{10C17}; + #\u{10C18}; + #\u{10C19}; + #\u{10C1A}; + #\u{10C1B}; + #\u{10C1C}; + #\u{10C1D}; + #\u{10C1E}; + #\u{10C1F}; + #\u{10C20}; + #\u{10C21}; + #\u{10C22}; + #\u{10C23}; + #\u{10C24}; + #\u{10C25}; + #\u{10C26}; + #\u{10C27}; + #\u{10C28}; + #\u{10C29}; + #\u{10C2A}; + #\u{10C2B}; + #\u{10C2C}; + #\u{10C2D}; + #\u{10C2E}; + #\u{10C2F}; + #\u{10C30}; + #\u{10C31}; + #\u{10C32}; + #\u{10C33}; + #\u{10C34}; + #\u{10C35}; + #\u{10C36}; + #\u{10C37}; + #\u{10C38}; + #\u{10C39}; + #\u{10C3A}; + #\u{10C3B}; + #\u{10C3C}; + #\u{10C3D}; + #\u{10C3E}; + #\u{10C3F}; + #\u{10C40}; + #\u{10C41}; + #\u{10C42}; + #\u{10C43}; + #\u{10C44}; + #\u{10C45}; + #\u{10C46}; + #\u{10C47}; + #\u{10C48}; + #\u{11083}; + #\u{11084}; + #\u{11085}; + #\u{11086}; + #\u{11087}; + #\u{11088}; + #\u{11089}; + #\u{1108A}; + #\u{1108B}; + #\u{1108C}; + #\u{1108D}; + #\u{1108E}; + #\u{1108F}; + #\u{11090}; + #\u{11091}; + #\u{11092}; + #\u{11093}; + #\u{11094}; + #\u{11095}; + #\u{11096}; + #\u{11097}; + #\u{11098}; + #\u{11099}; + #\u{1109A}; + #\u{1109B}; + #\u{1109C}; + #\u{1109D}; + #\u{1109E}; + #\u{1109F}; + #\u{110A0}; + #\u{110A1}; + #\u{110A2}; + #\u{110A3}; + #\u{110A4}; + #\u{110A5}; + #\u{110A6}; + #\u{110A7}; + #\u{110A8}; + #\u{110A9}; + #\u{110AA}; + #\u{110AB}; + #\u{110AC}; + #\u{110AD}; + #\u{110AE}; + #\u{110AF}; + #\u{13000}; + #\u{13001}; + #\u{13002}; + #\u{13003}; + #\u{13004}; + #\u{13005}; + #\u{13006}; + #\u{13007}; + #\u{13008}; + #\u{13009}; + #\u{1300A}; + #\u{1300B}; + #\u{1300C}; + #\u{1300D}; + #\u{1300E}; + #\u{1300F}; + #\u{13010}; + #\u{13011}; + #\u{13012}; + #\u{13013}; + #\u{13014}; + #\u{13015}; + #\u{13016}; + #\u{13017}; + #\u{13018}; + #\u{13019}; + #\u{1301A}; + #\u{1301B}; + #\u{1301C}; + #\u{1301D}; + #\u{1301E}; + #\u{1301F}; + #\u{13020}; + #\u{13021}; + #\u{13022}; + #\u{13023}; + #\u{13024}; + #\u{13025}; + #\u{13026}; + #\u{13027}; + #\u{13028}; + #\u{13029}; + #\u{1302A}; + #\u{1302B}; + #\u{1302C}; + #\u{1302D}; + #\u{1302E}; + #\u{1302F}; + #\u{13030}; + #\u{13031}; + #\u{13032}; + #\u{13033}; + #\u{13034}; + #\u{13035}; + #\u{13036}; + #\u{13037}; + #\u{13038}; + #\u{13039}; + #\u{1303A}; + #\u{1303B}; + #\u{1303C}; + #\u{1303D}; + #\u{1303E}; + #\u{1303F}; + #\u{13040}; + #\u{13041}; + #\u{13042}; + #\u{13043}; + #\u{13044}; + #\u{13045}; + #\u{13046}; + #\u{13047}; + #\u{13048}; + #\u{13049}; + #\u{1304A}; + #\u{1304B}; + #\u{1304C}; + #\u{1304D}; + #\u{1304E}; + #\u{1304F}; + #\u{13050}; + #\u{13051}; + #\u{13052}; + #\u{13053}; + #\u{13054}; + #\u{13055}; + #\u{13056}; + #\u{13057}; + #\u{13058}; + #\u{13059}; + #\u{1305A}; + #\u{1305B}; + #\u{1305C}; + #\u{1305D}; + #\u{1305E}; + #\u{1305F}; + #\u{13060}; + #\u{13061}; + #\u{13062}; + #\u{13063}; + #\u{13064}; + #\u{13065}; + #\u{13066}; + #\u{13067}; + #\u{13068}; + #\u{13069}; + #\u{1306A}; + #\u{1306B}; + #\u{1306C}; + #\u{1306D}; + #\u{1306E}; + #\u{1306F}; + #\u{13070}; + #\u{13071}; + #\u{13072}; + #\u{13073}; + #\u{13074}; + #\u{13075}; + #\u{13076}; + #\u{13077}; + #\u{13078}; + #\u{13079}; + #\u{1307A}; + #\u{1307B}; + #\u{1307C}; + #\u{1307D}; + #\u{1307E}; + #\u{1307F}; + #\u{13080}; + #\u{13081}; + #\u{13082}; + #\u{13083}; + #\u{13084}; + #\u{13085}; + #\u{13086}; + #\u{13087}; + #\u{13088}; + #\u{13089}; + #\u{1308A}; + #\u{1308B}; + #\u{1308C}; + #\u{1308D}; + #\u{1308E}; + #\u{1308F}; + #\u{13090}; + #\u{13091}; + #\u{13092}; + #\u{13093}; + #\u{13094}; + #\u{13095}; + #\u{13096}; + #\u{13097}; + #\u{13098}; + #\u{13099}; + #\u{1309A}; + #\u{1309B}; + #\u{1309C}; + #\u{1309D}; + #\u{1309E}; + #\u{1309F}; + #\u{130A0}; + #\u{130A1}; + #\u{130A2}; + #\u{130A3}; + #\u{130A4}; + #\u{130A5}; + #\u{130A6}; + #\u{130A7}; + #\u{130A8}; + #\u{130A9}; + #\u{130AA}; + #\u{130AB}; + #\u{130AC}; + #\u{130AD}; + #\u{130AE}; + #\u{130AF}; + #\u{130B0}; + #\u{130B1}; + #\u{130B2}; + #\u{130B3}; + #\u{130B4}; + #\u{130B5}; + #\u{130B6}; + #\u{130B7}; + #\u{130B8}; + #\u{130B9}; + #\u{130BA}; + #\u{130BB}; + #\u{130BC}; + #\u{130BD}; + #\u{130BE}; + #\u{130BF}; + #\u{130C0}; + #\u{130C1}; + #\u{130C2}; + #\u{130C3}; + #\u{130C4}; + #\u{130C5}; + #\u{130C6}; + #\u{130C7}; + #\u{130C8}; + #\u{130C9}; + #\u{130CA}; + #\u{130CB}; + #\u{130CC}; + #\u{130CD}; + #\u{130CE}; + #\u{130CF}; + #\u{130D0}; + #\u{130D1}; + #\u{130D2}; + #\u{130D3}; + #\u{130D4}; + #\u{130D5}; + #\u{130D6}; + #\u{130D7}; + #\u{130D8}; + #\u{130D9}; + #\u{130DA}; + #\u{130DB}; + #\u{130DC}; + #\u{130DD}; + #\u{130DE}; + #\u{130DF}; + #\u{130E0}; + #\u{130E1}; + #\u{130E2}; + #\u{130E3}; + #\u{130E4}; + #\u{130E5}; + #\u{130E6}; + #\u{130E7}; + #\u{130E8}; + #\u{130E9}; + #\u{130EA}; + #\u{130EB}; + #\u{130EC}; + #\u{130ED}; + #\u{130EE}; + #\u{130EF}; + #\u{130F0}; + #\u{130F1}; + #\u{130F2}; + #\u{130F3}; + #\u{130F4}; + #\u{130F5}; + #\u{130F6}; + #\u{130F7}; + #\u{130F8}; + #\u{130F9}; + #\u{130FA}; + #\u{130FB}; + #\u{130FC}; + #\u{130FD}; + #\u{130FE}; + #\u{130FF}; + #\u{13100}; + #\u{13101}; + #\u{13102}; + #\u{13103}; + #\u{13104}; + #\u{13105}; + #\u{13106}; + #\u{13107}; + #\u{13108}; + #\u{13109}; + #\u{1310A}; + #\u{1310B}; + #\u{1310C}; + #\u{1310D}; + #\u{1310E}; + #\u{1310F}; + #\u{13110}; + #\u{13111}; + #\u{13112}; + #\u{13113}; + #\u{13114}; + #\u{13115}; + #\u{13116}; + #\u{13117}; + #\u{13118}; + #\u{13119}; + #\u{1311A}; + #\u{1311B}; + #\u{1311C}; + #\u{1311D}; + #\u{1311E}; + #\u{1311F}; + #\u{13120}; + #\u{13121}; + #\u{13122}; + #\u{13123}; + #\u{13124}; + #\u{13125}; + #\u{13126}; + #\u{13127}; + #\u{13128}; + #\u{13129}; + #\u{1312A}; + #\u{1312B}; + #\u{1312C}; + #\u{1312D}; + #\u{1312E}; + #\u{1312F}; + #\u{13130}; + #\u{13131}; + #\u{13132}; + #\u{13133}; + #\u{13134}; + #\u{13135}; + #\u{13136}; + #\u{13137}; + #\u{13138}; + #\u{13139}; + #\u{1313A}; + #\u{1313B}; + #\u{1313C}; + #\u{1313D}; + #\u{1313E}; + #\u{1313F}; + #\u{13140}; + #\u{13141}; + #\u{13142}; + #\u{13143}; + #\u{13144}; + #\u{13145}; + #\u{13146}; + #\u{13147}; + #\u{13148}; + #\u{13149}; + #\u{1314A}; + #\u{1314B}; + #\u{1314C}; + #\u{1314D}; + #\u{1314E}; + #\u{1314F}; + #\u{13150}; + #\u{13151}; + #\u{13152}; + #\u{13153}; + #\u{13154}; + #\u{13155}; + #\u{13156}; + #\u{13157}; + #\u{13158}; + #\u{13159}; + #\u{1315A}; + #\u{1315B}; + #\u{1315C}; + #\u{1315D}; + #\u{1315E}; + #\u{1315F}; + #\u{13160}; + #\u{13161}; + #\u{13162}; + #\u{13163}; + #\u{13164}; + #\u{13165}; + #\u{13166}; + #\u{13167}; + #\u{13168}; + #\u{13169}; + #\u{1316A}; + #\u{1316B}; + #\u{1316C}; + #\u{1316D}; + #\u{1316E}; + #\u{1316F}; + #\u{13170}; + #\u{13171}; + #\u{13172}; + #\u{13173}; + #\u{13174}; + #\u{13175}; + #\u{13176}; + #\u{13177}; + #\u{13178}; + #\u{13179}; + #\u{1317A}; + #\u{1317B}; + #\u{1317C}; + #\u{1317D}; + #\u{1317E}; + #\u{1317F}; + #\u{13180}; + #\u{13181}; + #\u{13182}; + #\u{13183}; + #\u{13184}; + #\u{13185}; + #\u{13186}; + #\u{13187}; + #\u{13188}; + #\u{13189}; + #\u{1318A}; + #\u{1318B}; + #\u{1318C}; + #\u{1318D}; + #\u{1318E}; + #\u{1318F}; + #\u{13190}; + #\u{13191}; + #\u{13192}; + #\u{13193}; + #\u{13194}; + #\u{13195}; + #\u{13196}; + #\u{13197}; + #\u{13198}; + #\u{13199}; + #\u{1319A}; + #\u{1319B}; + #\u{1319C}; + #\u{1319D}; + #\u{1319E}; + #\u{1319F}; + #\u{131A0}; + #\u{131A1}; + #\u{131A2}; + #\u{131A3}; + #\u{131A4}; + #\u{131A5}; + #\u{131A6}; + #\u{131A7}; + #\u{131A8}; + #\u{131A9}; + #\u{131AA}; + #\u{131AB}; + #\u{131AC}; + #\u{131AD}; + #\u{131AE}; + #\u{131AF}; + #\u{131B0}; + #\u{131B1}; + #\u{131B2}; + #\u{131B3}; + #\u{131B4}; + #\u{131B5}; + #\u{131B6}; + #\u{131B7}; + #\u{131B8}; + #\u{131B9}; + #\u{131BA}; + #\u{131BB}; + #\u{131BC}; + #\u{131BD}; + #\u{131BE}; + #\u{131BF}; + #\u{131C0}; + #\u{131C1}; + #\u{131C2}; + #\u{131C3}; + #\u{131C4}; + #\u{131C5}; + #\u{131C6}; + #\u{131C7}; + #\u{131C8}; + #\u{131C9}; + #\u{131CA}; + #\u{131CB}; + #\u{131CC}; + #\u{131CD}; + #\u{131CE}; + #\u{131CF}; + #\u{131D0}; + #\u{131D1}; + #\u{131D2}; + #\u{131D3}; + #\u{131D4}; + #\u{131D5}; + #\u{131D6}; + #\u{131D7}; + #\u{131D8}; + #\u{131D9}; + #\u{131DA}; + #\u{131DB}; + #\u{131DC}; + #\u{131DD}; + #\u{131DE}; + #\u{131DF}; + #\u{131E0}; + #\u{131E1}; + #\u{131E2}; + #\u{131E3}; + #\u{131E4}; + #\u{131E5}; + #\u{131E6}; + #\u{131E7}; + #\u{131E8}; + #\u{131E9}; + #\u{131EA}; + #\u{131EB}; + #\u{131EC}; + #\u{131ED}; + #\u{131EE}; + #\u{131EF}; + #\u{131F0}; + #\u{131F1}; + #\u{131F2}; + #\u{131F3}; + #\u{131F4}; + #\u{131F5}; + #\u{131F6}; + #\u{131F7}; + #\u{131F8}; + #\u{131F9}; + #\u{131FA}; + #\u{131FB}; + #\u{131FC}; + #\u{131FD}; + #\u{131FE}; + #\u{131FF}; + #\u{13200}; + #\u{13201}; + #\u{13202}; + #\u{13203}; + #\u{13204}; + #\u{13205}; + #\u{13206}; + #\u{13207}; + #\u{13208}; + #\u{13209}; + #\u{1320A}; + #\u{1320B}; + #\u{1320C}; + #\u{1320D}; + #\u{1320E}; + #\u{1320F}; + #\u{13210}; + #\u{13211}; + #\u{13212}; + #\u{13213}; + #\u{13214}; + #\u{13215}; + #\u{13216}; + #\u{13217}; + #\u{13218}; + #\u{13219}; + #\u{1321A}; + #\u{1321B}; + #\u{1321C}; + #\u{1321D}; + #\u{1321E}; + #\u{1321F}; + #\u{13220}; + #\u{13221}; + #\u{13222}; + #\u{13223}; + #\u{13224}; + #\u{13225}; + #\u{13226}; + #\u{13227}; + #\u{13228}; + #\u{13229}; + #\u{1322A}; + #\u{1322B}; + #\u{1322C}; + #\u{1322D}; + #\u{1322E}; + #\u{1322F}; + #\u{13230}; + #\u{13231}; + #\u{13232}; + #\u{13233}; + #\u{13234}; + #\u{13235}; + #\u{13236}; + #\u{13237}; + #\u{13238}; + #\u{13239}; + #\u{1323A}; + #\u{1323B}; + #\u{1323C}; + #\u{1323D}; + #\u{1323E}; + #\u{1323F}; + #\u{13240}; + #\u{13241}; + #\u{13242}; + #\u{13243}; + #\u{13244}; + #\u{13245}; + #\u{13246}; + #\u{13247}; + #\u{13248}; + #\u{13249}; + #\u{1324A}; + #\u{1324B}; + #\u{1324C}; + #\u{1324D}; + #\u{1324E}; + #\u{1324F}; + #\u{13250}; + #\u{13251}; + #\u{13252}; + #\u{13253}; + #\u{13254}; + #\u{13255}; + #\u{13256}; + #\u{13257}; + #\u{13258}; + #\u{13259}; + #\u{1325A}; + #\u{1325B}; + #\u{1325C}; + #\u{1325D}; + #\u{1325E}; + #\u{1325F}; + #\u{13260}; + #\u{13261}; + #\u{13262}; + #\u{13263}; + #\u{13264}; + #\u{13265}; + #\u{13266}; + #\u{13267}; + #\u{13268}; + #\u{13269}; + #\u{1326A}; + #\u{1326B}; + #\u{1326C}; + #\u{1326D}; + #\u{1326E}; + #\u{1326F}; + #\u{13270}; + #\u{13271}; + #\u{13272}; + #\u{13273}; + #\u{13274}; + #\u{13275}; + #\u{13276}; + #\u{13277}; + #\u{13278}; + #\u{13279}; + #\u{1327A}; + #\u{1327B}; + #\u{1327C}; + #\u{1327D}; + #\u{1327E}; + #\u{1327F}; + #\u{13280}; + #\u{13281}; + #\u{13282}; + #\u{13283}; + #\u{13284}; + #\u{13285}; + #\u{13286}; + #\u{13287}; + #\u{13288}; + #\u{13289}; + #\u{1328A}; + #\u{1328B}; + #\u{1328C}; + #\u{1328D}; + #\u{1328E}; + #\u{1328F}; + #\u{13290}; + #\u{13291}; + #\u{13292}; + #\u{13293}; + #\u{13294}; + #\u{13295}; + #\u{13296}; + #\u{13297}; + #\u{13298}; + #\u{13299}; + #\u{1329A}; + #\u{1329B}; + #\u{1329C}; + #\u{1329D}; + #\u{1329E}; + #\u{1329F}; + #\u{132A0}; + #\u{132A1}; + #\u{132A2}; + #\u{132A3}; + #\u{132A4}; + #\u{132A5}; + #\u{132A6}; + #\u{132A7}; + #\u{132A8}; + #\u{132A9}; + #\u{132AA}; + #\u{132AB}; + #\u{132AC}; + #\u{132AD}; + #\u{132AE}; + #\u{132AF}; + #\u{132B0}; + #\u{132B1}; + #\u{132B2}; + #\u{132B3}; + #\u{132B4}; + #\u{132B5}; + #\u{132B6}; + #\u{132B7}; + #\u{132B8}; + #\u{132B9}; + #\u{132BA}; + #\u{132BB}; + #\u{132BC}; + #\u{132BD}; + #\u{132BE}; + #\u{132BF}; + #\u{132C0}; + #\u{132C1}; + #\u{132C2}; + #\u{132C3}; + #\u{132C4}; + #\u{132C5}; + #\u{132C6}; + #\u{132C7}; + #\u{132C8}; + #\u{132C9}; + #\u{132CA}; + #\u{132CB}; + #\u{132CC}; + #\u{132CD}; + #\u{132CE}; + #\u{132CF}; + #\u{132D0}; + #\u{132D1}; + #\u{132D2}; + #\u{132D3}; + #\u{132D4}; + #\u{132D5}; + #\u{132D6}; + #\u{132D7}; + #\u{132D8}; + #\u{132D9}; + #\u{132DA}; + #\u{132DB}; + #\u{132DC}; + #\u{132DD}; + #\u{132DE}; + #\u{132DF}; + #\u{132E0}; + #\u{132E1}; + #\u{132E2}; + #\u{132E3}; + #\u{132E4}; + #\u{132E5}; + #\u{132E6}; + #\u{132E7}; + #\u{132E8}; + #\u{132E9}; + #\u{132EA}; + #\u{132EB}; + #\u{132EC}; + #\u{132ED}; + #\u{132EE}; + #\u{132EF}; + #\u{132F0}; + #\u{132F1}; + #\u{132F2}; + #\u{132F3}; + #\u{132F4}; + #\u{132F5}; + #\u{132F6}; + #\u{132F7}; + #\u{132F8}; + #\u{132F9}; + #\u{132FA}; + #\u{132FB}; + #\u{132FC}; + #\u{132FD}; + #\u{132FE}; + #\u{132FF}; + #\u{13300}; + #\u{13301}; + #\u{13302}; + #\u{13303}; + #\u{13304}; + #\u{13305}; + #\u{13306}; + #\u{13307}; + #\u{13308}; + #\u{13309}; + #\u{1330A}; + #\u{1330B}; + #\u{1330C}; + #\u{1330D}; + #\u{1330E}; + #\u{1330F}; + #\u{13310}; + #\u{13311}; + #\u{13312}; + #\u{13313}; + #\u{13314}; + #\u{13315}; + #\u{13316}; + #\u{13317}; + #\u{13318}; + #\u{13319}; + #\u{1331A}; + #\u{1331B}; + #\u{1331C}; + #\u{1331D}; + #\u{1331E}; + #\u{1331F}; + #\u{13320}; + #\u{13321}; + #\u{13322}; + #\u{13323}; + #\u{13324}; + #\u{13325}; + #\u{13326}; + #\u{13327}; + #\u{13328}; + #\u{13329}; + #\u{1332A}; + #\u{1332B}; + #\u{1332C}; + #\u{1332D}; + #\u{1332E}; + #\u{1332F}; + #\u{13330}; + #\u{13331}; + #\u{13332}; + #\u{13333}; + #\u{13334}; + #\u{13335}; + #\u{13336}; + #\u{13337}; + #\u{13338}; + #\u{13339}; + #\u{1333A}; + #\u{1333B}; + #\u{1333C}; + #\u{1333D}; + #\u{1333E}; + #\u{1333F}; + #\u{13340}; + #\u{13341}; + #\u{13342}; + #\u{13343}; + #\u{13344}; + #\u{13345}; + #\u{13346}; + #\u{13347}; + #\u{13348}; + #\u{13349}; + #\u{1334A}; + #\u{1334B}; + #\u{1334C}; + #\u{1334D}; + #\u{1334E}; + #\u{1334F}; + #\u{13350}; + #\u{13351}; + #\u{13352}; + #\u{13353}; + #\u{13354}; + #\u{13355}; + #\u{13356}; + #\u{13357}; + #\u{13358}; + #\u{13359}; + #\u{1335A}; + #\u{1335B}; + #\u{1335C}; + #\u{1335D}; + #\u{1335E}; + #\u{1335F}; + #\u{13360}; + #\u{13361}; + #\u{13362}; + #\u{13363}; + #\u{13364}; + #\u{13365}; + #\u{13366}; + #\u{13367}; + #\u{13368}; + #\u{13369}; + #\u{1336A}; + #\u{1336B}; + #\u{1336C}; + #\u{1336D}; + #\u{1336E}; + #\u{1336F}; + #\u{13370}; + #\u{13371}; + #\u{13372}; + #\u{13373}; + #\u{13374}; + #\u{13375}; + #\u{13376}; + #\u{13377}; + #\u{13378}; + #\u{13379}; + #\u{1337A}; + #\u{1337B}; + #\u{1337C}; + #\u{1337D}; + #\u{1337E}; + #\u{1337F}; + #\u{13380}; + #\u{13381}; + #\u{13382}; + #\u{13383}; + #\u{13384}; + #\u{13385}; + #\u{13386}; + #\u{13387}; + #\u{13388}; + #\u{13389}; + #\u{1338A}; + #\u{1338B}; + #\u{1338C}; + #\u{1338D}; + #\u{1338E}; + #\u{1338F}; + #\u{13390}; + #\u{13391}; + #\u{13392}; + #\u{13393}; + #\u{13394}; + #\u{13395}; + #\u{13396}; + #\u{13397}; + #\u{13398}; + #\u{13399}; + #\u{1339A}; + #\u{1339B}; + #\u{1339C}; + #\u{1339D}; + #\u{1339E}; + #\u{1339F}; + #\u{133A0}; + #\u{133A1}; + #\u{133A2}; + #\u{133A3}; + #\u{133A4}; + #\u{133A5}; + #\u{133A6}; + #\u{133A7}; + #\u{133A8}; + #\u{133A9}; + #\u{133AA}; + #\u{133AB}; + #\u{133AC}; + #\u{133AD}; + #\u{133AE}; + #\u{133AF}; + #\u{133B0}; + #\u{133B1}; + #\u{133B2}; + #\u{133B3}; + #\u{133B4}; + #\u{133B5}; + #\u{133B6}; + #\u{133B7}; + #\u{133B8}; + #\u{133B9}; + #\u{133BA}; + #\u{133BB}; + #\u{133BC}; + #\u{133BD}; + #\u{133BE}; + #\u{133BF}; + #\u{133C0}; + #\u{133C1}; + #\u{133C2}; + #\u{133C3}; + #\u{133C4}; + #\u{133C5}; + #\u{133C6}; + #\u{133C7}; + #\u{133C8}; + #\u{133C9}; + #\u{133CA}; + #\u{133CB}; + #\u{133CC}; + #\u{133CD}; + #\u{133CE}; + #\u{133CF}; + #\u{133D0}; + #\u{133D1}; + #\u{133D2}; + #\u{133D3}; + #\u{133D4}; + #\u{133D5}; + #\u{133D6}; + #\u{133D7}; + #\u{133D8}; + #\u{133D9}; + #\u{133DA}; + #\u{133DB}; + #\u{133DC}; + #\u{133DD}; + #\u{133DE}; + #\u{133DF}; + #\u{133E0}; + #\u{133E1}; + #\u{133E2}; + #\u{133E3}; + #\u{133E4}; + #\u{133E5}; + #\u{133E6}; + #\u{133E7}; + #\u{133E8}; + #\u{133E9}; + #\u{133EA}; + #\u{133EB}; + #\u{133EC}; + #\u{133ED}; + #\u{133EE}; + #\u{133EF}; + #\u{133F0}; + #\u{133F1}; + #\u{133F2}; + #\u{133F3}; + #\u{133F4}; + #\u{133F5}; + #\u{133F6}; + #\u{133F7}; + #\u{133F8}; + #\u{133F9}; + #\u{133FA}; + #\u{133FB}; + #\u{133FC}; + #\u{133FD}; + #\u{133FE}; + #\u{133FF}; + #\u{13400}; + #\u{13401}; + #\u{13402}; + #\u{13403}; + #\u{13404}; + #\u{13405}; + #\u{13406}; + #\u{13407}; + #\u{13408}; + #\u{13409}; + #\u{1340A}; + #\u{1340B}; + #\u{1340C}; + #\u{1340D}; + #\u{1340E}; + #\u{1340F}; + #\u{13410}; + #\u{13411}; + #\u{13412}; + #\u{13413}; + #\u{13414}; + #\u{13415}; + #\u{13416}; + #\u{13417}; + #\u{13418}; + #\u{13419}; + #\u{1341A}; + #\u{1341B}; + #\u{1341C}; + #\u{1341D}; + #\u{1341E}; + #\u{1341F}; + #\u{13420}; + #\u{13421}; + #\u{13422}; + #\u{13423}; + #\u{13424}; + #\u{13425}; + #\u{13426}; + #\u{13427}; + #\u{13428}; + #\u{13429}; + #\u{1342A}; + #\u{1342B}; + #\u{1342C}; + #\u{1342D}; + #\u{1342E}; + #\u{2A700}; + #\u{2A701}; + #\u{2A702}; + #\u{2A703}; + #\u{2A704}; + #\u{2A705}; + #\u{2A706}; + #\u{2A707}; + #\u{2A708}; + #\u{2A709}; + #\u{2A70A}; + #\u{2A70B}; + #\u{2A70C}; + #\u{2A70D}; + #\u{2A70E}; + #\u{2A70F}; + #\u{2A710}; + #\u{2A711}; + #\u{2A712}; + #\u{2A713}; + #\u{2A714}; + #\u{2A715}; + #\u{2A716}; + #\u{2A717}; + #\u{2A718}; + #\u{2A719}; + #\u{2A71A}; + #\u{2A71B}; + #\u{2A71C}; + #\u{2A71D}; + #\u{2A71E}; + #\u{2A71F}; + #\u{2A720}; + #\u{2A721}; + #\u{2A722}; + #\u{2A723}; + #\u{2A724}; + #\u{2A725}; + #\u{2A726}; + #\u{2A727}; + #\u{2A728}; + #\u{2A729}; + #\u{2A72A}; + #\u{2A72B}; + #\u{2A72C}; + #\u{2A72D}; + #\u{2A72E}; + #\u{2A72F}; + #\u{2A730}; + #\u{2A731}; + #\u{2A732}; + #\u{2A733}; + #\u{2A734}; + #\u{2A735}; + #\u{2A736}; + #\u{2A737}; + #\u{2A738}; + #\u{2A739}; + #\u{2A73A}; + #\u{2A73B}; + #\u{2A73C}; + #\u{2A73D}; + #\u{2A73E}; + #\u{2A73F}; + #\u{2A740}; + #\u{2A741}; + #\u{2A742}; + #\u{2A743}; + #\u{2A744}; + #\u{2A745}; + #\u{2A746}; + #\u{2A747}; + #\u{2A748}; + #\u{2A749}; + #\u{2A74A}; + #\u{2A74B}; + #\u{2A74C}; + #\u{2A74D}; + #\u{2A74E}; + #\u{2A74F}; + #\u{2A750}; + #\u{2A751}; + #\u{2A752}; + #\u{2A753}; + #\u{2A754}; + #\u{2A755}; + #\u{2A756}; + #\u{2A757}; + #\u{2A758}; + #\u{2A759}; + #\u{2A75A}; + #\u{2A75B}; + #\u{2A75C}; + #\u{2A75D}; + #\u{2A75E}; + #\u{2A75F}; + #\u{2A760}; + #\u{2A761}; + #\u{2A762}; + #\u{2A763}; + #\u{2A764}; + #\u{2A765}; + #\u{2A766}; + #\u{2A767}; + #\u{2A768}; + #\u{2A769}; + #\u{2A76A}; + #\u{2A76B}; + #\u{2A76C}; + #\u{2A76D}; + #\u{2A76E}; + #\u{2A76F}; + #\u{2A770}; + #\u{2A771}; + #\u{2A772}; + #\u{2A773}; + #\u{2A774}; + #\u{2A775}; + #\u{2A776}; + #\u{2A777}; + #\u{2A778}; + #\u{2A779}; + #\u{2A77A}; + #\u{2A77B}; + #\u{2A77C}; + #\u{2A77D}; + #\u{2A77E}; + #\u{2A77F}; + #\u{2A780}; + #\u{2A781}; + #\u{2A782}; + #\u{2A783}; + #\u{2A784}; + #\u{2A785}; + #\u{2A786}; + #\u{2A787}; + #\u{2A788}; + #\u{2A789}; + #\u{2A78A}; + #\u{2A78B}; + #\u{2A78C}; + #\u{2A78D}; + #\u{2A78E}; + #\u{2A78F}; + #\u{2A790}; + #\u{2A791}; + #\u{2A792}; + #\u{2A793}; + #\u{2A794}; + #\u{2A795}; + #\u{2A796}; + #\u{2A797}; + #\u{2A798}; + #\u{2A799}; + #\u{2A79A}; + #\u{2A79B}; + #\u{2A79C}; + #\u{2A79D}; + #\u{2A79E}; + #\u{2A79F}; + #\u{2A7A0}; + #\u{2A7A1}; + #\u{2A7A2}; + #\u{2A7A3}; + #\u{2A7A4}; + #\u{2A7A5}; + #\u{2A7A6}; + #\u{2A7A7}; + #\u{2A7A8}; + #\u{2A7A9}; + #\u{2A7AA}; + #\u{2A7AB}; + #\u{2A7AC}; + #\u{2A7AD}; + #\u{2A7AE}; + #\u{2A7AF}; + #\u{2A7B0}; + #\u{2A7B1}; + #\u{2A7B2}; + #\u{2A7B3}; + #\u{2A7B4}; + #\u{2A7B5}; + #\u{2A7B6}; + #\u{2A7B7}; + #\u{2A7B8}; + #\u{2A7B9}; + #\u{2A7BA}; + #\u{2A7BB}; + #\u{2A7BC}; + #\u{2A7BD}; + #\u{2A7BE}; + #\u{2A7BF}; + #\u{2A7C0}; + #\u{2A7C1}; + #\u{2A7C2}; + #\u{2A7C3}; + #\u{2A7C4}; + #\u{2A7C5}; + #\u{2A7C6}; + #\u{2A7C7}; + #\u{2A7C8}; + #\u{2A7C9}; + #\u{2A7CA}; + #\u{2A7CB}; + #\u{2A7CC}; + #\u{2A7CD}; + #\u{2A7CE}; + #\u{2A7CF}; + #\u{2A7D0}; + #\u{2A7D1}; + #\u{2A7D2}; + #\u{2A7D3}; + #\u{2A7D4}; + #\u{2A7D5}; + #\u{2A7D6}; + #\u{2A7D7}; + #\u{2A7D8}; + #\u{2A7D9}; + #\u{2A7DA}; + #\u{2A7DB}; + #\u{2A7DC}; + #\u{2A7DD}; + #\u{2A7DE}; + #\u{2A7DF}; + #\u{2A7E0}; + #\u{2A7E1}; + #\u{2A7E2}; + #\u{2A7E3}; + #\u{2A7E4}; + #\u{2A7E5}; + #\u{2A7E6}; + #\u{2A7E7}; + #\u{2A7E8}; + #\u{2A7E9}; + #\u{2A7EA}; + #\u{2A7EB}; + #\u{2A7EC}; + #\u{2A7ED}; + #\u{2A7EE}; + #\u{2A7EF}; + #\u{2A7F0}; + #\u{2A7F1}; + #\u{2A7F2}; + #\u{2A7F3}; + #\u{2A7F4}; + #\u{2A7F5}; + #\u{2A7F6}; + #\u{2A7F7}; + #\u{2A7F8}; + #\u{2A7F9}; + #\u{2A7FA}; + #\u{2A7FB}; + #\u{2A7FC}; + #\u{2A7FD}; + #\u{2A7FE}; + #\u{2A7FF}; + #\u{2A800}; + #\u{2A801}; + #\u{2A802}; + #\u{2A803}; + #\u{2A804}; + #\u{2A805}; + #\u{2A806}; + #\u{2A807}; + #\u{2A808}; + #\u{2A809}; + #\u{2A80A}; + #\u{2A80B}; + #\u{2A80C}; + #\u{2A80D}; + #\u{2A80E}; + #\u{2A80F}; + #\u{2A810}; + #\u{2A811}; + #\u{2A812}; + #\u{2A813}; + #\u{2A814}; + #\u{2A815}; + #\u{2A816}; + #\u{2A817}; + #\u{2A818}; + #\u{2A819}; + #\u{2A81A}; + #\u{2A81B}; + #\u{2A81C}; + #\u{2A81D}; + #\u{2A81E}; + #\u{2A81F}; + #\u{2A820}; + #\u{2A821}; + #\u{2A822}; + #\u{2A823}; + #\u{2A824}; + #\u{2A825}; + #\u{2A826}; + #\u{2A827}; + #\u{2A828}; + #\u{2A829}; + #\u{2A82A}; + #\u{2A82B}; + #\u{2A82C}; + #\u{2A82D}; + #\u{2A82E}; + #\u{2A82F}; + #\u{2A830}; + #\u{2A831}; + #\u{2A832}; + #\u{2A833}; + #\u{2A834}; + #\u{2A835}; + #\u{2A836}; + #\u{2A837}; + #\u{2A838}; + #\u{2A839}; + #\u{2A83A}; + #\u{2A83B}; + #\u{2A83C}; + #\u{2A83D}; + #\u{2A83E}; + #\u{2A83F}; + #\u{2A840}; + #\u{2A841}; + #\u{2A842}; + #\u{2A843}; + #\u{2A844}; + #\u{2A845}; + #\u{2A846}; + #\u{2A847}; + #\u{2A848}; + #\u{2A849}; + #\u{2A84A}; + #\u{2A84B}; + #\u{2A84C}; + #\u{2A84D}; + #\u{2A84E}; + #\u{2A84F}; + #\u{2A850}; + #\u{2A851}; + #\u{2A852}; + #\u{2A853}; + #\u{2A854}; + #\u{2A855}; + #\u{2A856}; + #\u{2A857}; + #\u{2A858}; + #\u{2A859}; + #\u{2A85A}; + #\u{2A85B}; + #\u{2A85C}; + #\u{2A85D}; + #\u{2A85E}; + #\u{2A85F}; + #\u{2A860}; + #\u{2A861}; + #\u{2A862}; + #\u{2A863}; + #\u{2A864}; + #\u{2A865}; + #\u{2A866}; + #\u{2A867}; + #\u{2A868}; + #\u{2A869}; + #\u{2A86A}; + #\u{2A86B}; + #\u{2A86C}; + #\u{2A86D}; + #\u{2A86E}; + #\u{2A86F}; + #\u{2A870}; + #\u{2A871}; + #\u{2A872}; + #\u{2A873}; + #\u{2A874}; + #\u{2A875}; + #\u{2A876}; + #\u{2A877}; + #\u{2A878}; + #\u{2A879}; + #\u{2A87A}; + #\u{2A87B}; + #\u{2A87C}; + #\u{2A87D}; + #\u{2A87E}; + #\u{2A87F}; + #\u{2A880}; + #\u{2A881}; + #\u{2A882}; + #\u{2A883}; + #\u{2A884}; + #\u{2A885}; + #\u{2A886}; + #\u{2A887}; + #\u{2A888}; + #\u{2A889}; + #\u{2A88A}; + #\u{2A88B}; + #\u{2A88C}; + #\u{2A88D}; + #\u{2A88E}; + #\u{2A88F}; + #\u{2A890}; + #\u{2A891}; + #\u{2A892}; + #\u{2A893}; + #\u{2A894}; + #\u{2A895}; + #\u{2A896}; + #\u{2A897}; + #\u{2A898}; + #\u{2A899}; + #\u{2A89A}; + #\u{2A89B}; + #\u{2A89C}; + #\u{2A89D}; + #\u{2A89E}; + #\u{2A89F}; + #\u{2A8A0}; + #\u{2A8A1}; + #\u{2A8A2}; + #\u{2A8A3}; + #\u{2A8A4}; + #\u{2A8A5}; + #\u{2A8A6}; + #\u{2A8A7}; + #\u{2A8A8}; + #\u{2A8A9}; + #\u{2A8AA}; + #\u{2A8AB}; + #\u{2A8AC}; + #\u{2A8AD}; + #\u{2A8AE}; + #\u{2A8AF}; + #\u{2A8B0}; + #\u{2A8B1}; + #\u{2A8B2}; + #\u{2A8B3}; + #\u{2A8B4}; + #\u{2A8B5}; + #\u{2A8B6}; + #\u{2A8B7}; + #\u{2A8B8}; + #\u{2A8B9}; + #\u{2A8BA}; + #\u{2A8BB}; + #\u{2A8BC}; + #\u{2A8BD}; + #\u{2A8BE}; + #\u{2A8BF}; + #\u{2A8C0}; + #\u{2A8C1}; + #\u{2A8C2}; + #\u{2A8C3}; + #\u{2A8C4}; + #\u{2A8C5}; + #\u{2A8C6}; + #\u{2A8C7}; + #\u{2A8C8}; + #\u{2A8C9}; + #\u{2A8CA}; + #\u{2A8CB}; + #\u{2A8CC}; + #\u{2A8CD}; + #\u{2A8CE}; + #\u{2A8CF}; + #\u{2A8D0}; + #\u{2A8D1}; + #\u{2A8D2}; + #\u{2A8D3}; + #\u{2A8D4}; + #\u{2A8D5}; + #\u{2A8D6}; + #\u{2A8D7}; + #\u{2A8D8}; + #\u{2A8D9}; + #\u{2A8DA}; + #\u{2A8DB}; + #\u{2A8DC}; + #\u{2A8DD}; + #\u{2A8DE}; + #\u{2A8DF}; + #\u{2A8E0}; + #\u{2A8E1}; + #\u{2A8E2}; + #\u{2A8E3}; + #\u{2A8E4}; + #\u{2A8E5}; + #\u{2A8E6}; + #\u{2A8E7}; + #\u{2A8E8}; + #\u{2A8E9}; + #\u{2A8EA}; + #\u{2A8EB}; + #\u{2A8EC}; + #\u{2A8ED}; + #\u{2A8EE}; + #\u{2A8EF}; + #\u{2A8F0}; + #\u{2A8F1}; + #\u{2A8F2}; + #\u{2A8F3}; + #\u{2A8F4}; + #\u{2A8F5}; + #\u{2A8F6}; + #\u{2A8F7}; + #\u{2A8F8}; + #\u{2A8F9}; + #\u{2A8FA}; + #\u{2A8FB}; + #\u{2A8FC}; + #\u{2A8FD}; + #\u{2A8FE}; + #\u{2A8FF}; + #\u{2A900}; + #\u{2A901}; + #\u{2A902}; + #\u{2A903}; + #\u{2A904}; + #\u{2A905}; + #\u{2A906}; + #\u{2A907}; + #\u{2A908}; + #\u{2A909}; + #\u{2A90A}; + #\u{2A90B}; + #\u{2A90C}; + #\u{2A90D}; + #\u{2A90E}; + #\u{2A90F}; + #\u{2A910}; + #\u{2A911}; + #\u{2A912}; + #\u{2A913}; + #\u{2A914}; + #\u{2A915}; + #\u{2A916}; + #\u{2A917}; + #\u{2A918}; + #\u{2A919}; + #\u{2A91A}; + #\u{2A91B}; + #\u{2A91C}; + #\u{2A91D}; + #\u{2A91E}; + #\u{2A91F}; + #\u{2A920}; + #\u{2A921}; + #\u{2A922}; + #\u{2A923}; + #\u{2A924}; + #\u{2A925}; + #\u{2A926}; + #\u{2A927}; + #\u{2A928}; + #\u{2A929}; + #\u{2A92A}; + #\u{2A92B}; + #\u{2A92C}; + #\u{2A92D}; + #\u{2A92E}; + #\u{2A92F}; + #\u{2A930}; + #\u{2A931}; + #\u{2A932}; + #\u{2A933}; + #\u{2A934}; + #\u{2A935}; + #\u{2A936}; + #\u{2A937}; + #\u{2A938}; + #\u{2A939}; + #\u{2A93A}; + #\u{2A93B}; + #\u{2A93C}; + #\u{2A93D}; + #\u{2A93E}; + #\u{2A93F}; + #\u{2A940}; + #\u{2A941}; + #\u{2A942}; + #\u{2A943}; + #\u{2A944}; + #\u{2A945}; + #\u{2A946}; + #\u{2A947}; + #\u{2A948}; + #\u{2A949}; + #\u{2A94A}; + #\u{2A94B}; + #\u{2A94C}; + #\u{2A94D}; + #\u{2A94E}; + #\u{2A94F}; + #\u{2A950}; + #\u{2A951}; + #\u{2A952}; + #\u{2A953}; + #\u{2A954}; + #\u{2A955}; + #\u{2A956}; + #\u{2A957}; + #\u{2A958}; + #\u{2A959}; + #\u{2A95A}; + #\u{2A95B}; + #\u{2A95C}; + #\u{2A95D}; + #\u{2A95E}; + #\u{2A95F}; + #\u{2A960}; + #\u{2A961}; + #\u{2A962}; + #\u{2A963}; + #\u{2A964}; + #\u{2A965}; + #\u{2A966}; + #\u{2A967}; + #\u{2A968}; + #\u{2A969}; + #\u{2A96A}; + #\u{2A96B}; + #\u{2A96C}; + #\u{2A96D}; + #\u{2A96E}; + #\u{2A96F}; + #\u{2A970}; + #\u{2A971}; + #\u{2A972}; + #\u{2A973}; + #\u{2A974}; + #\u{2A975}; + #\u{2A976}; + #\u{2A977}; + #\u{2A978}; + #\u{2A979}; + #\u{2A97A}; + #\u{2A97B}; + #\u{2A97C}; + #\u{2A97D}; + #\u{2A97E}; + #\u{2A97F}; + #\u{2A980}; + #\u{2A981}; + #\u{2A982}; + #\u{2A983}; + #\u{2A984}; + #\u{2A985}; + #\u{2A986}; + #\u{2A987}; + #\u{2A988}; + #\u{2A989}; + #\u{2A98A}; + #\u{2A98B}; + #\u{2A98C}; + #\u{2A98D}; + #\u{2A98E}; + #\u{2A98F}; + #\u{2A990}; + #\u{2A991}; + #\u{2A992}; + #\u{2A993}; + #\u{2A994}; + #\u{2A995}; + #\u{2A996}; + #\u{2A997}; + #\u{2A998}; + #\u{2A999}; + #\u{2A99A}; + #\u{2A99B}; + #\u{2A99C}; + #\u{2A99D}; + #\u{2A99E}; + #\u{2A99F}; + #\u{2A9A0}; + #\u{2A9A1}; + #\u{2A9A2}; + #\u{2A9A3}; + #\u{2A9A4}; + #\u{2A9A5}; + #\u{2A9A6}; + #\u{2A9A7}; + #\u{2A9A8}; + #\u{2A9A9}; + #\u{2A9AA}; + #\u{2A9AB}; + #\u{2A9AC}; + #\u{2A9AD}; + #\u{2A9AE}; + #\u{2A9AF}; + #\u{2A9B0}; + #\u{2A9B1}; + #\u{2A9B2}; + #\u{2A9B3}; + #\u{2A9B4}; + #\u{2A9B5}; + #\u{2A9B6}; + #\u{2A9B7}; + #\u{2A9B8}; + #\u{2A9B9}; + #\u{2A9BA}; + #\u{2A9BB}; + #\u{2A9BC}; + #\u{2A9BD}; + #\u{2A9BE}; + #\u{2A9BF}; + #\u{2A9C0}; + #\u{2A9C1}; + #\u{2A9C2}; + #\u{2A9C3}; + #\u{2A9C4}; + #\u{2A9C5}; + #\u{2A9C6}; + #\u{2A9C7}; + #\u{2A9C8}; + #\u{2A9C9}; + #\u{2A9CA}; + #\u{2A9CB}; + #\u{2A9CC}; + #\u{2A9CD}; + #\u{2A9CE}; + #\u{2A9CF}; + #\u{2A9D0}; + #\u{2A9D1}; + #\u{2A9D2}; + #\u{2A9D3}; + #\u{2A9D4}; + #\u{2A9D5}; + #\u{2A9D6}; + #\u{2A9D7}; + #\u{2A9D8}; + #\u{2A9D9}; + #\u{2A9DA}; + #\u{2A9DB}; + #\u{2A9DC}; + #\u{2A9DD}; + #\u{2A9DE}; + #\u{2A9DF}; + #\u{2A9E0}; + #\u{2A9E1}; + #\u{2A9E2}; + #\u{2A9E3}; + #\u{2A9E4}; + #\u{2A9E5}; + #\u{2A9E6}; + #\u{2A9E7}; + #\u{2A9E8}; + #\u{2A9E9}; + #\u{2A9EA}; + #\u{2A9EB}; + #\u{2A9EC}; + #\u{2A9ED}; + #\u{2A9EE}; + #\u{2A9EF}; + #\u{2A9F0}; + #\u{2A9F1}; + #\u{2A9F2}; + #\u{2A9F3}; + #\u{2A9F4}; + #\u{2A9F5}; + #\u{2A9F6}; + #\u{2A9F7}; + #\u{2A9F8}; + #\u{2A9F9}; + #\u{2A9FA}; + #\u{2A9FB}; + #\u{2A9FC}; + #\u{2A9FD}; + #\u{2A9FE}; + #\u{2A9FF}; + #\u{2AA00}; + #\u{2AA01}; + #\u{2AA02}; + #\u{2AA03}; + #\u{2AA04}; + #\u{2AA05}; + #\u{2AA06}; + #\u{2AA07}; + #\u{2AA08}; + #\u{2AA09}; + #\u{2AA0A}; + #\u{2AA0B}; + #\u{2AA0C}; + #\u{2AA0D}; + #\u{2AA0E}; + #\u{2AA0F}; + #\u{2AA10}; + #\u{2AA11}; + #\u{2AA12}; + #\u{2AA13}; + #\u{2AA14}; + #\u{2AA15}; + #\u{2AA16}; + #\u{2AA17}; + #\u{2AA18}; + #\u{2AA19}; + #\u{2AA1A}; + #\u{2AA1B}; + #\u{2AA1C}; + #\u{2AA1D}; + #\u{2AA1E}; + #\u{2AA1F}; + #\u{2AA20}; + #\u{2AA21}; + #\u{2AA22}; + #\u{2AA23}; + #\u{2AA24}; + #\u{2AA25}; + #\u{2AA26}; + #\u{2AA27}; + #\u{2AA28}; + #\u{2AA29}; + #\u{2AA2A}; + #\u{2AA2B}; + #\u{2AA2C}; + #\u{2AA2D}; + #\u{2AA2E}; + #\u{2AA2F}; + #\u{2AA30}; + #\u{2AA31}; + #\u{2AA32}; + #\u{2AA33}; + #\u{2AA34}; + #\u{2AA35}; + #\u{2AA36}; + #\u{2AA37}; + #\u{2AA38}; + #\u{2AA39}; + #\u{2AA3A}; + #\u{2AA3B}; + #\u{2AA3C}; + #\u{2AA3D}; + #\u{2AA3E}; + #\u{2AA3F}; + #\u{2AA40}; + #\u{2AA41}; + #\u{2AA42}; + #\u{2AA43}; + #\u{2AA44}; + #\u{2AA45}; + #\u{2AA46}; + #\u{2AA47}; + #\u{2AA48}; + #\u{2AA49}; + #\u{2AA4A}; + #\u{2AA4B}; + #\u{2AA4C}; + #\u{2AA4D}; + #\u{2AA4E}; + #\u{2AA4F}; + #\u{2AA50}; + #\u{2AA51}; + #\u{2AA52}; + #\u{2AA53}; + #\u{2AA54}; + #\u{2AA55}; + #\u{2AA56}; + #\u{2AA57}; + #\u{2AA58}; + #\u{2AA59}; + #\u{2AA5A}; + #\u{2AA5B}; + #\u{2AA5C}; + #\u{2AA5D}; + #\u{2AA5E}; + #\u{2AA5F}; + #\u{2AA60}; + #\u{2AA61}; + #\u{2AA62}; + #\u{2AA63}; + #\u{2AA64}; + #\u{2AA65}; + #\u{2AA66}; + #\u{2AA67}; + #\u{2AA68}; + #\u{2AA69}; + #\u{2AA6A}; + #\u{2AA6B}; + #\u{2AA6C}; + #\u{2AA6D}; + #\u{2AA6E}; + #\u{2AA6F}; + #\u{2AA70}; + #\u{2AA71}; + #\u{2AA72}; + #\u{2AA73}; + #\u{2AA74}; + #\u{2AA75}; + #\u{2AA76}; + #\u{2AA77}; + #\u{2AA78}; + #\u{2AA79}; + #\u{2AA7A}; + #\u{2AA7B}; + #\u{2AA7C}; + #\u{2AA7D}; + #\u{2AA7E}; + #\u{2AA7F}; + #\u{2AA80}; + #\u{2AA81}; + #\u{2AA82}; + #\u{2AA83}; + #\u{2AA84}; + #\u{2AA85}; + #\u{2AA86}; + #\u{2AA87}; + #\u{2AA88}; + #\u{2AA89}; + #\u{2AA8A}; + #\u{2AA8B}; + #\u{2AA8C}; + #\u{2AA8D}; + #\u{2AA8E}; + #\u{2AA8F}; + #\u{2AA90}; + #\u{2AA91}; + #\u{2AA92}; + #\u{2AA93}; + #\u{2AA94}; + #\u{2AA95}; + #\u{2AA96}; + #\u{2AA97}; + #\u{2AA98}; + #\u{2AA99}; + #\u{2AA9A}; + #\u{2AA9B}; + #\u{2AA9C}; + #\u{2AA9D}; + #\u{2AA9E}; + #\u{2AA9F}; + #\u{2AAA0}; + #\u{2AAA1}; + #\u{2AAA2}; + #\u{2AAA3}; + #\u{2AAA4}; + #\u{2AAA5}; + #\u{2AAA6}; + #\u{2AAA7}; + #\u{2AAA8}; + #\u{2AAA9}; + #\u{2AAAA}; + #\u{2AAAB}; + #\u{2AAAC}; + #\u{2AAAD}; + #\u{2AAAE}; + #\u{2AAAF}; + #\u{2AAB0}; + #\u{2AAB1}; + #\u{2AAB2}; + #\u{2AAB3}; + #\u{2AAB4}; + #\u{2AAB5}; + #\u{2AAB6}; + #\u{2AAB7}; + #\u{2AAB8}; + #\u{2AAB9}; + #\u{2AABA}; + #\u{2AABB}; + #\u{2AABC}; + #\u{2AABD}; + #\u{2AABE}; + #\u{2AABF}; + #\u{2AAC0}; + #\u{2AAC1}; + #\u{2AAC2}; + #\u{2AAC3}; + #\u{2AAC4}; + #\u{2AAC5}; + #\u{2AAC6}; + #\u{2AAC7}; + #\u{2AAC8}; + #\u{2AAC9}; + #\u{2AACA}; + #\u{2AACB}; + #\u{2AACC}; + #\u{2AACD}; + #\u{2AACE}; + #\u{2AACF}; + #\u{2AAD0}; + #\u{2AAD1}; + #\u{2AAD2}; + #\u{2AAD3}; + #\u{2AAD4}; + #\u{2AAD5}; + #\u{2AAD6}; + #\u{2AAD7}; + #\u{2AAD8}; + #\u{2AAD9}; + #\u{2AADA}; + #\u{2AADB}; + #\u{2AADC}; + #\u{2AADD}; + #\u{2AADE}; + #\u{2AADF}; + #\u{2AAE0}; + #\u{2AAE1}; + #\u{2AAE2}; + #\u{2AAE3}; + #\u{2AAE4}; + #\u{2AAE5}; + #\u{2AAE6}; + #\u{2AAE7}; + #\u{2AAE8}; + #\u{2AAE9}; + #\u{2AAEA}; + #\u{2AAEB}; + #\u{2AAEC}; + #\u{2AAED}; + #\u{2AAEE}; + #\u{2AAEF}; + #\u{2AAF0}; + #\u{2AAF1}; + #\u{2AAF2}; + #\u{2AAF3}; + #\u{2AAF4}; + #\u{2AAF5}; + #\u{2AAF6}; + #\u{2AAF7}; + #\u{2AAF8}; + #\u{2AAF9}; + #\u{2AAFA}; + #\u{2AAFB}; + #\u{2AAFC}; + #\u{2AAFD}; + #\u{2AAFE}; + #\u{2AAFF}; + #\u{2AB00}; + #\u{2AB01}; + #\u{2AB02}; + #\u{2AB03}; + #\u{2AB04}; + #\u{2AB05}; + #\u{2AB06}; + #\u{2AB07}; + #\u{2AB08}; + #\u{2AB09}; + #\u{2AB0A}; + #\u{2AB0B}; + #\u{2AB0C}; + #\u{2AB0D}; + #\u{2AB0E}; + #\u{2AB0F}; + #\u{2AB10}; + #\u{2AB11}; + #\u{2AB12}; + #\u{2AB13}; + #\u{2AB14}; + #\u{2AB15}; + #\u{2AB16}; + #\u{2AB17}; + #\u{2AB18}; + #\u{2AB19}; + #\u{2AB1A}; + #\u{2AB1B}; + #\u{2AB1C}; + #\u{2AB1D}; + #\u{2AB1E}; + #\u{2AB1F}; + #\u{2AB20}; + #\u{2AB21}; + #\u{2AB22}; + #\u{2AB23}; + #\u{2AB24}; + #\u{2AB25}; + #\u{2AB26}; + #\u{2AB27}; + #\u{2AB28}; + #\u{2AB29}; + #\u{2AB2A}; + #\u{2AB2B}; + #\u{2AB2C}; + #\u{2AB2D}; + #\u{2AB2E}; + #\u{2AB2F}; + #\u{2AB30}; + #\u{2AB31}; + #\u{2AB32}; + #\u{2AB33}; + #\u{2AB34}; + #\u{2AB35}; + #\u{2AB36}; + #\u{2AB37}; + #\u{2AB38}; + #\u{2AB39}; + #\u{2AB3A}; + #\u{2AB3B}; + #\u{2AB3C}; + #\u{2AB3D}; + #\u{2AB3E}; + #\u{2AB3F}; + #\u{2AB40}; + #\u{2AB41}; + #\u{2AB42}; + #\u{2AB43}; + #\u{2AB44}; + #\u{2AB45}; + #\u{2AB46}; + #\u{2AB47}; + #\u{2AB48}; + #\u{2AB49}; + #\u{2AB4A}; + #\u{2AB4B}; + #\u{2AB4C}; + #\u{2AB4D}; + #\u{2AB4E}; + #\u{2AB4F}; + #\u{2AB50}; + #\u{2AB51}; + #\u{2AB52}; + #\u{2AB53}; + #\u{2AB54}; + #\u{2AB55}; + #\u{2AB56}; + #\u{2AB57}; + #\u{2AB58}; + #\u{2AB59}; + #\u{2AB5A}; + #\u{2AB5B}; + #\u{2AB5C}; + #\u{2AB5D}; + #\u{2AB5E}; + #\u{2AB5F}; + #\u{2AB60}; + #\u{2AB61}; + #\u{2AB62}; + #\u{2AB63}; + #\u{2AB64}; + #\u{2AB65}; + #\u{2AB66}; + #\u{2AB67}; + #\u{2AB68}; + #\u{2AB69}; + #\u{2AB6A}; + #\u{2AB6B}; + #\u{2AB6C}; + #\u{2AB6D}; + #\u{2AB6E}; + #\u{2AB6F}; + #\u{2AB70}; + #\u{2AB71}; + #\u{2AB72}; + #\u{2AB73}; + #\u{2AB74}; + #\u{2AB75}; + #\u{2AB76}; + #\u{2AB77}; + #\u{2AB78}; + #\u{2AB79}; + #\u{2AB7A}; + #\u{2AB7B}; + #\u{2AB7C}; + #\u{2AB7D}; + #\u{2AB7E}; + #\u{2AB7F}; + #\u{2AB80}; + #\u{2AB81}; + #\u{2AB82}; + #\u{2AB83}; + #\u{2AB84}; + #\u{2AB85}; + #\u{2AB86}; + #\u{2AB87}; + #\u{2AB88}; + #\u{2AB89}; + #\u{2AB8A}; + #\u{2AB8B}; + #\u{2AB8C}; + #\u{2AB8D}; + #\u{2AB8E}; + #\u{2AB8F}; + #\u{2AB90}; + #\u{2AB91}; + #\u{2AB92}; + #\u{2AB93}; + #\u{2AB94}; + #\u{2AB95}; + #\u{2AB96}; + #\u{2AB97}; + #\u{2AB98}; + #\u{2AB99}; + #\u{2AB9A}; + #\u{2AB9B}; + #\u{2AB9C}; + #\u{2AB9D}; + #\u{2AB9E}; + #\u{2AB9F}; + #\u{2ABA0}; + #\u{2ABA1}; + #\u{2ABA2}; + #\u{2ABA3}; + #\u{2ABA4}; + #\u{2ABA5}; + #\u{2ABA6}; + #\u{2ABA7}; + #\u{2ABA8}; + #\u{2ABA9}; + #\u{2ABAA}; + #\u{2ABAB}; + #\u{2ABAC}; + #\u{2ABAD}; + #\u{2ABAE}; + #\u{2ABAF}; + #\u{2ABB0}; + #\u{2ABB1}; + #\u{2ABB2}; + #\u{2ABB3}; + #\u{2ABB4}; + #\u{2ABB5}; + #\u{2ABB6}; + #\u{2ABB7}; + #\u{2ABB8}; + #\u{2ABB9}; + #\u{2ABBA}; + #\u{2ABBB}; + #\u{2ABBC}; + #\u{2ABBD}; + #\u{2ABBE}; + #\u{2ABBF}; + #\u{2ABC0}; + #\u{2ABC1}; + #\u{2ABC2}; + #\u{2ABC3}; + #\u{2ABC4}; + #\u{2ABC5}; + #\u{2ABC6}; + #\u{2ABC7}; + #\u{2ABC8}; + #\u{2ABC9}; + #\u{2ABCA}; + #\u{2ABCB}; + #\u{2ABCC}; + #\u{2ABCD}; + #\u{2ABCE}; + #\u{2ABCF}; + #\u{2ABD0}; + #\u{2ABD1}; + #\u{2ABD2}; + #\u{2ABD3}; + #\u{2ABD4}; + #\u{2ABD5}; + #\u{2ABD6}; + #\u{2ABD7}; + #\u{2ABD8}; + #\u{2ABD9}; + #\u{2ABDA}; + #\u{2ABDB}; + #\u{2ABDC}; + #\u{2ABDD}; + #\u{2ABDE}; + #\u{2ABDF}; + #\u{2ABE0}; + #\u{2ABE1}; + #\u{2ABE2}; + #\u{2ABE3}; + #\u{2ABE4}; + #\u{2ABE5}; + #\u{2ABE6}; + #\u{2ABE7}; + #\u{2ABE8}; + #\u{2ABE9}; + #\u{2ABEA}; + #\u{2ABEB}; + #\u{2ABEC}; + #\u{2ABED}; + #\u{2ABEE}; + #\u{2ABEF}; + #\u{2ABF0}; + #\u{2ABF1}; + #\u{2ABF2}; + #\u{2ABF3}; + #\u{2ABF4}; + #\u{2ABF5}; + #\u{2ABF6}; + #\u{2ABF7}; + #\u{2ABF8}; + #\u{2ABF9}; + #\u{2ABFA}; + #\u{2ABFB}; + #\u{2ABFC}; + #\u{2ABFD}; + #\u{2ABFE}; + #\u{2ABFF}; + #\u{2AC00}; + #\u{2AC01}; + #\u{2AC02}; + #\u{2AC03}; + #\u{2AC04}; + #\u{2AC05}; + #\u{2AC06}; + #\u{2AC07}; + #\u{2AC08}; + #\u{2AC09}; + #\u{2AC0A}; + #\u{2AC0B}; + #\u{2AC0C}; + #\u{2AC0D}; + #\u{2AC0E}; + #\u{2AC0F}; + #\u{2AC10}; + #\u{2AC11}; + #\u{2AC12}; + #\u{2AC13}; + #\u{2AC14}; + #\u{2AC15}; + #\u{2AC16}; + #\u{2AC17}; + #\u{2AC18}; + #\u{2AC19}; + #\u{2AC1A}; + #\u{2AC1B}; + #\u{2AC1C}; + #\u{2AC1D}; + #\u{2AC1E}; + #\u{2AC1F}; + #\u{2AC20}; + #\u{2AC21}; + #\u{2AC22}; + #\u{2AC23}; + #\u{2AC24}; + #\u{2AC25}; + #\u{2AC26}; + #\u{2AC27}; + #\u{2AC28}; + #\u{2AC29}; + #\u{2AC2A}; + #\u{2AC2B}; + #\u{2AC2C}; + #\u{2AC2D}; + #\u{2AC2E}; + #\u{2AC2F}; + #\u{2AC30}; + #\u{2AC31}; + #\u{2AC32}; + #\u{2AC33}; + #\u{2AC34}; + #\u{2AC35}; + #\u{2AC36}; + #\u{2AC37}; + #\u{2AC38}; + #\u{2AC39}; + #\u{2AC3A}; + #\u{2AC3B}; + #\u{2AC3C}; + #\u{2AC3D}; + #\u{2AC3E}; + #\u{2AC3F}; + #\u{2AC40}; + #\u{2AC41}; + #\u{2AC42}; + #\u{2AC43}; + #\u{2AC44}; + #\u{2AC45}; + #\u{2AC46}; + #\u{2AC47}; + #\u{2AC48}; + #\u{2AC49}; + #\u{2AC4A}; + #\u{2AC4B}; + #\u{2AC4C}; + #\u{2AC4D}; + #\u{2AC4E}; + #\u{2AC4F}; + #\u{2AC50}; + #\u{2AC51}; + #\u{2AC52}; + #\u{2AC53}; + #\u{2AC54}; + #\u{2AC55}; + #\u{2AC56}; + #\u{2AC57}; + #\u{2AC58}; + #\u{2AC59}; + #\u{2AC5A}; + #\u{2AC5B}; + #\u{2AC5C}; + #\u{2AC5D}; + #\u{2AC5E}; + #\u{2AC5F}; + #\u{2AC60}; + #\u{2AC61}; + #\u{2AC62}; + #\u{2AC63}; + #\u{2AC64}; + #\u{2AC65}; + #\u{2AC66}; + #\u{2AC67}; + #\u{2AC68}; + #\u{2AC69}; + #\u{2AC6A}; + #\u{2AC6B}; + #\u{2AC6C}; + #\u{2AC6D}; + #\u{2AC6E}; + #\u{2AC6F}; + #\u{2AC70}; + #\u{2AC71}; + #\u{2AC72}; + #\u{2AC73}; + #\u{2AC74}; + #\u{2AC75}; + #\u{2AC76}; + #\u{2AC77}; + #\u{2AC78}; + #\u{2AC79}; + #\u{2AC7A}; + #\u{2AC7B}; + #\u{2AC7C}; + #\u{2AC7D}; + #\u{2AC7E}; + #\u{2AC7F}; + #\u{2AC80}; + #\u{2AC81}; + #\u{2AC82}; + #\u{2AC83}; + #\u{2AC84}; + #\u{2AC85}; + #\u{2AC86}; + #\u{2AC87}; + #\u{2AC88}; + #\u{2AC89}; + #\u{2AC8A}; + #\u{2AC8B}; + #\u{2AC8C}; + #\u{2AC8D}; + #\u{2AC8E}; + #\u{2AC8F}; + #\u{2AC90}; + #\u{2AC91}; + #\u{2AC92}; + #\u{2AC93}; + #\u{2AC94}; + #\u{2AC95}; + #\u{2AC96}; + #\u{2AC97}; + #\u{2AC98}; + #\u{2AC99}; + #\u{2AC9A}; + #\u{2AC9B}; + #\u{2AC9C}; + #\u{2AC9D}; + #\u{2AC9E}; + #\u{2AC9F}; + #\u{2ACA0}; + #\u{2ACA1}; + #\u{2ACA2}; + #\u{2ACA3}; + #\u{2ACA4}; + #\u{2ACA5}; + #\u{2ACA6}; + #\u{2ACA7}; + #\u{2ACA8}; + #\u{2ACA9}; + #\u{2ACAA}; + #\u{2ACAB}; + #\u{2ACAC}; + #\u{2ACAD}; + #\u{2ACAE}; + #\u{2ACAF}; + #\u{2ACB0}; + #\u{2ACB1}; + #\u{2ACB2}; + #\u{2ACB3}; + #\u{2ACB4}; + #\u{2ACB5}; + #\u{2ACB6}; + #\u{2ACB7}; + #\u{2ACB8}; + #\u{2ACB9}; + #\u{2ACBA}; + #\u{2ACBB}; + #\u{2ACBC}; + #\u{2ACBD}; + #\u{2ACBE}; + #\u{2ACBF}; + #\u{2ACC0}; + #\u{2ACC1}; + #\u{2ACC2}; + #\u{2ACC3}; + #\u{2ACC4}; + #\u{2ACC5}; + #\u{2ACC6}; + #\u{2ACC7}; + #\u{2ACC8}; + #\u{2ACC9}; + #\u{2ACCA}; + #\u{2ACCB}; + #\u{2ACCC}; + #\u{2ACCD}; + #\u{2ACCE}; + #\u{2ACCF}; + #\u{2ACD0}; + #\u{2ACD1}; + #\u{2ACD2}; + #\u{2ACD3}; + #\u{2ACD4}; + #\u{2ACD5}; + #\u{2ACD6}; + #\u{2ACD7}; + #\u{2ACD8}; + #\u{2ACD9}; + #\u{2ACDA}; + #\u{2ACDB}; + #\u{2ACDC}; + #\u{2ACDD}; + #\u{2ACDE}; + #\u{2ACDF}; + #\u{2ACE0}; + #\u{2ACE1}; + #\u{2ACE2}; + #\u{2ACE3}; + #\u{2ACE4}; + #\u{2ACE5}; + #\u{2ACE6}; + #\u{2ACE7}; + #\u{2ACE8}; + #\u{2ACE9}; + #\u{2ACEA}; + #\u{2ACEB}; + #\u{2ACEC}; + #\u{2ACED}; + #\u{2ACEE}; + #\u{2ACEF}; + #\u{2ACF0}; + #\u{2ACF1}; + #\u{2ACF2}; + #\u{2ACF3}; + #\u{2ACF4}; + #\u{2ACF5}; + #\u{2ACF6}; + #\u{2ACF7}; + #\u{2ACF8}; + #\u{2ACF9}; + #\u{2ACFA}; + #\u{2ACFB}; + #\u{2ACFC}; + #\u{2ACFD}; + #\u{2ACFE}; + #\u{2ACFF}; + #\u{2AD00}; + #\u{2AD01}; + #\u{2AD02}; + #\u{2AD03}; + #\u{2AD04}; + #\u{2AD05}; + #\u{2AD06}; + #\u{2AD07}; + #\u{2AD08}; + #\u{2AD09}; + #\u{2AD0A}; + #\u{2AD0B}; + #\u{2AD0C}; + #\u{2AD0D}; + #\u{2AD0E}; + #\u{2AD0F}; + #\u{2AD10}; + #\u{2AD11}; + #\u{2AD12}; + #\u{2AD13}; + #\u{2AD14}; + #\u{2AD15}; + #\u{2AD16}; + #\u{2AD17}; + #\u{2AD18}; + #\u{2AD19}; + #\u{2AD1A}; + #\u{2AD1B}; + #\u{2AD1C}; + #\u{2AD1D}; + #\u{2AD1E}; + #\u{2AD1F}; + #\u{2AD20}; + #\u{2AD21}; + #\u{2AD22}; + #\u{2AD23}; + #\u{2AD24}; + #\u{2AD25}; + #\u{2AD26}; + #\u{2AD27}; + #\u{2AD28}; + #\u{2AD29}; + #\u{2AD2A}; + #\u{2AD2B}; + #\u{2AD2C}; + #\u{2AD2D}; + #\u{2AD2E}; + #\u{2AD2F}; + #\u{2AD30}; + #\u{2AD31}; + #\u{2AD32}; + #\u{2AD33}; + #\u{2AD34}; + #\u{2AD35}; + #\u{2AD36}; + #\u{2AD37}; + #\u{2AD38}; + #\u{2AD39}; + #\u{2AD3A}; + #\u{2AD3B}; + #\u{2AD3C}; + #\u{2AD3D}; + #\u{2AD3E}; + #\u{2AD3F}; + #\u{2AD40}; + #\u{2AD41}; + #\u{2AD42}; + #\u{2AD43}; + #\u{2AD44}; + #\u{2AD45}; + #\u{2AD46}; + #\u{2AD47}; + #\u{2AD48}; + #\u{2AD49}; + #\u{2AD4A}; + #\u{2AD4B}; + #\u{2AD4C}; + #\u{2AD4D}; + #\u{2AD4E}; + #\u{2AD4F}; + #\u{2AD50}; + #\u{2AD51}; + #\u{2AD52}; + #\u{2AD53}; + #\u{2AD54}; + #\u{2AD55}; + #\u{2AD56}; + #\u{2AD57}; + #\u{2AD58}; + #\u{2AD59}; + #\u{2AD5A}; + #\u{2AD5B}; + #\u{2AD5C}; + #\u{2AD5D}; + #\u{2AD5E}; + #\u{2AD5F}; + #\u{2AD60}; + #\u{2AD61}; + #\u{2AD62}; + #\u{2AD63}; + #\u{2AD64}; + #\u{2AD65}; + #\u{2AD66}; + #\u{2AD67}; + #\u{2AD68}; + #\u{2AD69}; + #\u{2AD6A}; + #\u{2AD6B}; + #\u{2AD6C}; + #\u{2AD6D}; + #\u{2AD6E}; + #\u{2AD6F}; + #\u{2AD70}; + #\u{2AD71}; + #\u{2AD72}; + #\u{2AD73}; + #\u{2AD74}; + #\u{2AD75}; + #\u{2AD76}; + #\u{2AD77}; + #\u{2AD78}; + #\u{2AD79}; + #\u{2AD7A}; + #\u{2AD7B}; + #\u{2AD7C}; + #\u{2AD7D}; + #\u{2AD7E}; + #\u{2AD7F}; + #\u{2AD80}; + #\u{2AD81}; + #\u{2AD82}; + #\u{2AD83}; + #\u{2AD84}; + #\u{2AD85}; + #\u{2AD86}; + #\u{2AD87}; + #\u{2AD88}; + #\u{2AD89}; + #\u{2AD8A}; + #\u{2AD8B}; + #\u{2AD8C}; + #\u{2AD8D}; + #\u{2AD8E}; + #\u{2AD8F}; + #\u{2AD90}; + #\u{2AD91}; + #\u{2AD92}; + #\u{2AD93}; + #\u{2AD94}; + #\u{2AD95}; + #\u{2AD96}; + #\u{2AD97}; + #\u{2AD98}; + #\u{2AD99}; + #\u{2AD9A}; + #\u{2AD9B}; + #\u{2AD9C}; + #\u{2AD9D}; + #\u{2AD9E}; + #\u{2AD9F}; + #\u{2ADA0}; + #\u{2ADA1}; + #\u{2ADA2}; + #\u{2ADA3}; + #\u{2ADA4}; + #\u{2ADA5}; + #\u{2ADA6}; + #\u{2ADA7}; + #\u{2ADA8}; + #\u{2ADA9}; + #\u{2ADAA}; + #\u{2ADAB}; + #\u{2ADAC}; + #\u{2ADAD}; + #\u{2ADAE}; + #\u{2ADAF}; + #\u{2ADB0}; + #\u{2ADB1}; + #\u{2ADB2}; + #\u{2ADB3}; + #\u{2ADB4}; + #\u{2ADB5}; + #\u{2ADB6}; + #\u{2ADB7}; + #\u{2ADB8}; + #\u{2ADB9}; + #\u{2ADBA}; + #\u{2ADBB}; + #\u{2ADBC}; + #\u{2ADBD}; + #\u{2ADBE}; + #\u{2ADBF}; + #\u{2ADC0}; + #\u{2ADC1}; + #\u{2ADC2}; + #\u{2ADC3}; + #\u{2ADC4}; + #\u{2ADC5}; + #\u{2ADC6}; + #\u{2ADC7}; + #\u{2ADC8}; + #\u{2ADC9}; + #\u{2ADCA}; + #\u{2ADCB}; + #\u{2ADCC}; + #\u{2ADCD}; + #\u{2ADCE}; + #\u{2ADCF}; + #\u{2ADD0}; + #\u{2ADD1}; + #\u{2ADD2}; + #\u{2ADD3}; + #\u{2ADD4}; + #\u{2ADD5}; + #\u{2ADD6}; + #\u{2ADD7}; + #\u{2ADD8}; + #\u{2ADD9}; + #\u{2ADDA}; + #\u{2ADDB}; + #\u{2ADDC}; + #\u{2ADDD}; + #\u{2ADDE}; + #\u{2ADDF}; + #\u{2ADE0}; + #\u{2ADE1}; + #\u{2ADE2}; + #\u{2ADE3}; + #\u{2ADE4}; + #\u{2ADE5}; + #\u{2ADE6}; + #\u{2ADE7}; + #\u{2ADE8}; + #\u{2ADE9}; + #\u{2ADEA}; + #\u{2ADEB}; + #\u{2ADEC}; + #\u{2ADED}; + #\u{2ADEE}; + #\u{2ADEF}; + #\u{2ADF0}; + #\u{2ADF1}; + #\u{2ADF2}; + #\u{2ADF3}; + #\u{2ADF4}; + #\u{2ADF5}; + #\u{2ADF6}; + #\u{2ADF7}; + #\u{2ADF8}; + #\u{2ADF9}; + #\u{2ADFA}; + #\u{2ADFB}; + #\u{2ADFC}; + #\u{2ADFD}; + #\u{2ADFE}; + #\u{2ADFF}; + #\u{2AE00}; + #\u{2AE01}; + #\u{2AE02}; + #\u{2AE03}; + #\u{2AE04}; + #\u{2AE05}; + #\u{2AE06}; + #\u{2AE07}; + #\u{2AE08}; + #\u{2AE09}; + #\u{2AE0A}; + #\u{2AE0B}; + #\u{2AE0C}; + #\u{2AE0D}; + #\u{2AE0E}; + #\u{2AE0F}; + #\u{2AE10}; + #\u{2AE11}; + #\u{2AE12}; + #\u{2AE13}; + #\u{2AE14}; + #\u{2AE15}; + #\u{2AE16}; + #\u{2AE17}; + #\u{2AE18}; + #\u{2AE19}; + #\u{2AE1A}; + #\u{2AE1B}; + #\u{2AE1C}; + #\u{2AE1D}; + #\u{2AE1E}; + #\u{2AE1F}; + #\u{2AE20}; + #\u{2AE21}; + #\u{2AE22}; + #\u{2AE23}; + #\u{2AE24}; + #\u{2AE25}; + #\u{2AE26}; + #\u{2AE27}; + #\u{2AE28}; + #\u{2AE29}; + #\u{2AE2A}; + #\u{2AE2B}; + #\u{2AE2C}; + #\u{2AE2D}; + #\u{2AE2E}; + #\u{2AE2F}; + #\u{2AE30}; + #\u{2AE31}; + #\u{2AE32}; + #\u{2AE33}; + #\u{2AE34}; + #\u{2AE35}; + #\u{2AE36}; + #\u{2AE37}; + #\u{2AE38}; + #\u{2AE39}; + #\u{2AE3A}; + #\u{2AE3B}; + #\u{2AE3C}; + #\u{2AE3D}; + #\u{2AE3E}; + #\u{2AE3F}; + #\u{2AE40}; + #\u{2AE41}; + #\u{2AE42}; + #\u{2AE43}; + #\u{2AE44}; + #\u{2AE45}; + #\u{2AE46}; + #\u{2AE47}; + #\u{2AE48}; + #\u{2AE49}; + #\u{2AE4A}; + #\u{2AE4B}; + #\u{2AE4C}; + #\u{2AE4D}; + #\u{2AE4E}; + #\u{2AE4F}; + #\u{2AE50}; + #\u{2AE51}; + #\u{2AE52}; + #\u{2AE53}; + #\u{2AE54}; + #\u{2AE55}; + #\u{2AE56}; + #\u{2AE57}; + #\u{2AE58}; + #\u{2AE59}; + #\u{2AE5A}; + #\u{2AE5B}; + #\u{2AE5C}; + #\u{2AE5D}; + #\u{2AE5E}; + #\u{2AE5F}; + #\u{2AE60}; + #\u{2AE61}; + #\u{2AE62}; + #\u{2AE63}; + #\u{2AE64}; + #\u{2AE65}; + #\u{2AE66}; + #\u{2AE67}; + #\u{2AE68}; + #\u{2AE69}; + #\u{2AE6A}; + #\u{2AE6B}; + #\u{2AE6C}; + #\u{2AE6D}; + #\u{2AE6E}; + #\u{2AE6F}; + #\u{2AE70}; + #\u{2AE71}; + #\u{2AE72}; + #\u{2AE73}; + #\u{2AE74}; + #\u{2AE75}; + #\u{2AE76}; + #\u{2AE77}; + #\u{2AE78}; + #\u{2AE79}; + #\u{2AE7A}; + #\u{2AE7B}; + #\u{2AE7C}; + #\u{2AE7D}; + #\u{2AE7E}; + #\u{2AE7F}; + #\u{2AE80}; + #\u{2AE81}; + #\u{2AE82}; + #\u{2AE83}; + #\u{2AE84}; + #\u{2AE85}; + #\u{2AE86}; + #\u{2AE87}; + #\u{2AE88}; + #\u{2AE89}; + #\u{2AE8A}; + #\u{2AE8B}; + #\u{2AE8C}; + #\u{2AE8D}; + #\u{2AE8E}; + #\u{2AE8F}; + #\u{2AE90}; + #\u{2AE91}; + #\u{2AE92}; + #\u{2AE93}; + #\u{2AE94}; + #\u{2AE95}; + #\u{2AE96}; + #\u{2AE97}; + #\u{2AE98}; + #\u{2AE99}; + #\u{2AE9A}; + #\u{2AE9B}; + #\u{2AE9C}; + #\u{2AE9D}; + #\u{2AE9E}; + #\u{2AE9F}; + #\u{2AEA0}; + #\u{2AEA1}; + #\u{2AEA2}; + #\u{2AEA3}; + #\u{2AEA4}; + #\u{2AEA5}; + #\u{2AEA6}; + #\u{2AEA7}; + #\u{2AEA8}; + #\u{2AEA9}; + #\u{2AEAA}; + #\u{2AEAB}; + #\u{2AEAC}; + #\u{2AEAD}; + #\u{2AEAE}; + #\u{2AEAF}; + #\u{2AEB0}; + #\u{2AEB1}; + #\u{2AEB2}; + #\u{2AEB3}; + #\u{2AEB4}; + #\u{2AEB5}; + #\u{2AEB6}; + #\u{2AEB7}; + #\u{2AEB8}; + #\u{2AEB9}; + #\u{2AEBA}; + #\u{2AEBB}; + #\u{2AEBC}; + #\u{2AEBD}; + #\u{2AEBE}; + #\u{2AEBF}; + #\u{2AEC0}; + #\u{2AEC1}; + #\u{2AEC2}; + #\u{2AEC3}; + #\u{2AEC4}; + #\u{2AEC5}; + #\u{2AEC6}; + #\u{2AEC7}; + #\u{2AEC8}; + #\u{2AEC9}; + #\u{2AECA}; + #\u{2AECB}; + #\u{2AECC}; + #\u{2AECD}; + #\u{2AECE}; + #\u{2AECF}; + #\u{2AED0}; + #\u{2AED1}; + #\u{2AED2}; + #\u{2AED3}; + #\u{2AED4}; + #\u{2AED5}; + #\u{2AED6}; + #\u{2AED7}; + #\u{2AED8}; + #\u{2AED9}; + #\u{2AEDA}; + #\u{2AEDB}; + #\u{2AEDC}; + #\u{2AEDD}; + #\u{2AEDE}; + #\u{2AEDF}; + #\u{2AEE0}; + #\u{2AEE1}; + #\u{2AEE2}; + #\u{2AEE3}; + #\u{2AEE4}; + #\u{2AEE5}; + #\u{2AEE6}; + #\u{2AEE7}; + #\u{2AEE8}; + #\u{2AEE9}; + #\u{2AEEA}; + #\u{2AEEB}; + #\u{2AEEC}; + #\u{2AEED}; + #\u{2AEEE}; + #\u{2AEEF}; + #\u{2AEF0}; + #\u{2AEF1}; + #\u{2AEF2}; + #\u{2AEF3}; + #\u{2AEF4}; + #\u{2AEF5}; + #\u{2AEF6}; + #\u{2AEF7}; + #\u{2AEF8}; + #\u{2AEF9}; + #\u{2AEFA}; + #\u{2AEFB}; + #\u{2AEFC}; + #\u{2AEFD}; + #\u{2AEFE}; + #\u{2AEFF}; + #\u{2AF00}; + #\u{2AF01}; + #\u{2AF02}; + #\u{2AF03}; + #\u{2AF04}; + #\u{2AF05}; + #\u{2AF06}; + #\u{2AF07}; + #\u{2AF08}; + #\u{2AF09}; + #\u{2AF0A}; + #\u{2AF0B}; + #\u{2AF0C}; + #\u{2AF0D}; + #\u{2AF0E}; + #\u{2AF0F}; + #\u{2AF10}; + #\u{2AF11}; + #\u{2AF12}; + #\u{2AF13}; + #\u{2AF14}; + #\u{2AF15}; + #\u{2AF16}; + #\u{2AF17}; + #\u{2AF18}; + #\u{2AF19}; + #\u{2AF1A}; + #\u{2AF1B}; + #\u{2AF1C}; + #\u{2AF1D}; + #\u{2AF1E}; + #\u{2AF1F}; + #\u{2AF20}; + #\u{2AF21}; + #\u{2AF22}; + #\u{2AF23}; + #\u{2AF24}; + #\u{2AF25}; + #\u{2AF26}; + #\u{2AF27}; + #\u{2AF28}; + #\u{2AF29}; + #\u{2AF2A}; + #\u{2AF2B}; + #\u{2AF2C}; + #\u{2AF2D}; + #\u{2AF2E}; + #\u{2AF2F}; + #\u{2AF30}; + #\u{2AF31}; + #\u{2AF32}; + #\u{2AF33}; + #\u{2AF34}; + #\u{2AF35}; + #\u{2AF36}; + #\u{2AF37}; + #\u{2AF38}; + #\u{2AF39}; + #\u{2AF3A}; + #\u{2AF3B}; + #\u{2AF3C}; + #\u{2AF3D}; + #\u{2AF3E}; + #\u{2AF3F}; + #\u{2AF40}; + #\u{2AF41}; + #\u{2AF42}; + #\u{2AF43}; + #\u{2AF44}; + #\u{2AF45}; + #\u{2AF46}; + #\u{2AF47}; + #\u{2AF48}; + #\u{2AF49}; + #\u{2AF4A}; + #\u{2AF4B}; + #\u{2AF4C}; + #\u{2AF4D}; + #\u{2AF4E}; + #\u{2AF4F}; + #\u{2AF50}; + #\u{2AF51}; + #\u{2AF52}; + #\u{2AF53}; + #\u{2AF54}; + #\u{2AF55}; + #\u{2AF56}; + #\u{2AF57}; + #\u{2AF58}; + #\u{2AF59}; + #\u{2AF5A}; + #\u{2AF5B}; + #\u{2AF5C}; + #\u{2AF5D}; + #\u{2AF5E}; + #\u{2AF5F}; + #\u{2AF60}; + #\u{2AF61}; + #\u{2AF62}; + #\u{2AF63}; + #\u{2AF64}; + #\u{2AF65}; + #\u{2AF66}; + #\u{2AF67}; + #\u{2AF68}; + #\u{2AF69}; + #\u{2AF6A}; + #\u{2AF6B}; + #\u{2AF6C}; + #\u{2AF6D}; + #\u{2AF6E}; + #\u{2AF6F}; + #\u{2AF70}; + #\u{2AF71}; + #\u{2AF72}; + #\u{2AF73}; + #\u{2AF74}; + #\u{2AF75}; + #\u{2AF76}; + #\u{2AF77}; + #\u{2AF78}; + #\u{2AF79}; + #\u{2AF7A}; + #\u{2AF7B}; + #\u{2AF7C}; + #\u{2AF7D}; + #\u{2AF7E}; + #\u{2AF7F}; + #\u{2AF80}; + #\u{2AF81}; + #\u{2AF82}; + #\u{2AF83}; + #\u{2AF84}; + #\u{2AF85}; + #\u{2AF86}; + #\u{2AF87}; + #\u{2AF88}; + #\u{2AF89}; + #\u{2AF8A}; + #\u{2AF8B}; + #\u{2AF8C}; + #\u{2AF8D}; + #\u{2AF8E}; + #\u{2AF8F}; + #\u{2AF90}; + #\u{2AF91}; + #\u{2AF92}; + #\u{2AF93}; + #\u{2AF94}; + #\u{2AF95}; + #\u{2AF96}; + #\u{2AF97}; + #\u{2AF98}; + #\u{2AF99}; + #\u{2AF9A}; + #\u{2AF9B}; + #\u{2AF9C}; + #\u{2AF9D}; + #\u{2AF9E}; + #\u{2AF9F}; + #\u{2AFA0}; + #\u{2AFA1}; + #\u{2AFA2}; + #\u{2AFA3}; + #\u{2AFA4}; + #\u{2AFA5}; + #\u{2AFA6}; + #\u{2AFA7}; + #\u{2AFA8}; + #\u{2AFA9}; + #\u{2AFAA}; + #\u{2AFAB}; + #\u{2AFAC}; + #\u{2AFAD}; + #\u{2AFAE}; + #\u{2AFAF}; + #\u{2AFB0}; + #\u{2AFB1}; + #\u{2AFB2}; + #\u{2AFB3}; + #\u{2AFB4}; + #\u{2AFB5}; + #\u{2AFB6}; + #\u{2AFB7}; + #\u{2AFB8}; + #\u{2AFB9}; + #\u{2AFBA}; + #\u{2AFBB}; + #\u{2AFBC}; + #\u{2AFBD}; + #\u{2AFBE}; + #\u{2AFBF}; + #\u{2AFC0}; + #\u{2AFC1}; + #\u{2AFC2}; + #\u{2AFC3}; + #\u{2AFC4}; + #\u{2AFC5}; + #\u{2AFC6}; + #\u{2AFC7}; + #\u{2AFC8}; + #\u{2AFC9}; + #\u{2AFCA}; + #\u{2AFCB}; + #\u{2AFCC}; + #\u{2AFCD}; + #\u{2AFCE}; + #\u{2AFCF}; + #\u{2AFD0}; + #\u{2AFD1}; + #\u{2AFD2}; + #\u{2AFD3}; + #\u{2AFD4}; + #\u{2AFD5}; + #\u{2AFD6}; + #\u{2AFD7}; + #\u{2AFD8}; + #\u{2AFD9}; + #\u{2AFDA}; + #\u{2AFDB}; + #\u{2AFDC}; + #\u{2AFDD}; + #\u{2AFDE}; + #\u{2AFDF}; + #\u{2AFE0}; + #\u{2AFE1}; + #\u{2AFE2}; + #\u{2AFE3}; + #\u{2AFE4}; + #\u{2AFE5}; + #\u{2AFE6}; + #\u{2AFE7}; + #\u{2AFE8}; + #\u{2AFE9}; + #\u{2AFEA}; + #\u{2AFEB}; + #\u{2AFEC}; + #\u{2AFED}; + #\u{2AFEE}; + #\u{2AFEF}; + #\u{2AFF0}; + #\u{2AFF1}; + #\u{2AFF2}; + #\u{2AFF3}; + #\u{2AFF4}; + #\u{2AFF5}; + #\u{2AFF6}; + #\u{2AFF7}; + #\u{2AFF8}; + #\u{2AFF9}; + #\u{2AFFA}; + #\u{2AFFB}; + #\u{2AFFC}; + #\u{2AFFD}; + #\u{2AFFE}; + #\u{2AFFF}; + #\u{2B000}; + #\u{2B001}; + #\u{2B002}; + #\u{2B003}; + #\u{2B004}; + #\u{2B005}; + #\u{2B006}; + #\u{2B007}; + #\u{2B008}; + #\u{2B009}; + #\u{2B00A}; + #\u{2B00B}; + #\u{2B00C}; + #\u{2B00D}; + #\u{2B00E}; + #\u{2B00F}; + #\u{2B010}; + #\u{2B011}; + #\u{2B012}; + #\u{2B013}; + #\u{2B014}; + #\u{2B015}; + #\u{2B016}; + #\u{2B017}; + #\u{2B018}; + #\u{2B019}; + #\u{2B01A}; + #\u{2B01B}; + #\u{2B01C}; + #\u{2B01D}; + #\u{2B01E}; + #\u{2B01F}; + #\u{2B020}; + #\u{2B021}; + #\u{2B022}; + #\u{2B023}; + #\u{2B024}; + #\u{2B025}; + #\u{2B026}; + #\u{2B027}; + #\u{2B028}; + #\u{2B029}; + #\u{2B02A}; + #\u{2B02B}; + #\u{2B02C}; + #\u{2B02D}; + #\u{2B02E}; + #\u{2B02F}; + #\u{2B030}; + #\u{2B031}; + #\u{2B032}; + #\u{2B033}; + #\u{2B034}; + #\u{2B035}; + #\u{2B036}; + #\u{2B037}; + #\u{2B038}; + #\u{2B039}; + #\u{2B03A}; + #\u{2B03B}; + #\u{2B03C}; + #\u{2B03D}; + #\u{2B03E}; + #\u{2B03F}; + #\u{2B040}; + #\u{2B041}; + #\u{2B042}; + #\u{2B043}; + #\u{2B044}; + #\u{2B045}; + #\u{2B046}; + #\u{2B047}; + #\u{2B048}; + #\u{2B049}; + #\u{2B04A}; + #\u{2B04B}; + #\u{2B04C}; + #\u{2B04D}; + #\u{2B04E}; + #\u{2B04F}; + #\u{2B050}; + #\u{2B051}; + #\u{2B052}; + #\u{2B053}; + #\u{2B054}; + #\u{2B055}; + #\u{2B056}; + #\u{2B057}; + #\u{2B058}; + #\u{2B059}; + #\u{2B05A}; + #\u{2B05B}; + #\u{2B05C}; + #\u{2B05D}; + #\u{2B05E}; + #\u{2B05F}; + #\u{2B060}; + #\u{2B061}; + #\u{2B062}; + #\u{2B063}; + #\u{2B064}; + #\u{2B065}; + #\u{2B066}; + #\u{2B067}; + #\u{2B068}; + #\u{2B069}; + #\u{2B06A}; + #\u{2B06B}; + #\u{2B06C}; + #\u{2B06D}; + #\u{2B06E}; + #\u{2B06F}; + #\u{2B070}; + #\u{2B071}; + #\u{2B072}; + #\u{2B073}; + #\u{2B074}; + #\u{2B075}; + #\u{2B076}; + #\u{2B077}; + #\u{2B078}; + #\u{2B079}; + #\u{2B07A}; + #\u{2B07B}; + #\u{2B07C}; + #\u{2B07D}; + #\u{2B07E}; + #\u{2B07F}; + #\u{2B080}; + #\u{2B081}; + #\u{2B082}; + #\u{2B083}; + #\u{2B084}; + #\u{2B085}; + #\u{2B086}; + #\u{2B087}; + #\u{2B088}; + #\u{2B089}; + #\u{2B08A}; + #\u{2B08B}; + #\u{2B08C}; + #\u{2B08D}; + #\u{2B08E}; + #\u{2B08F}; + #\u{2B090}; + #\u{2B091}; + #\u{2B092}; + #\u{2B093}; + #\u{2B094}; + #\u{2B095}; + #\u{2B096}; + #\u{2B097}; + #\u{2B098}; + #\u{2B099}; + #\u{2B09A}; + #\u{2B09B}; + #\u{2B09C}; + #\u{2B09D}; + #\u{2B09E}; + #\u{2B09F}; + #\u{2B0A0}; + #\u{2B0A1}; + #\u{2B0A2}; + #\u{2B0A3}; + #\u{2B0A4}; + #\u{2B0A5}; + #\u{2B0A6}; + #\u{2B0A7}; + #\u{2B0A8}; + #\u{2B0A9}; + #\u{2B0AA}; + #\u{2B0AB}; + #\u{2B0AC}; + #\u{2B0AD}; + #\u{2B0AE}; + #\u{2B0AF}; + #\u{2B0B0}; + #\u{2B0B1}; + #\u{2B0B2}; + #\u{2B0B3}; + #\u{2B0B4}; + #\u{2B0B5}; + #\u{2B0B6}; + #\u{2B0B7}; + #\u{2B0B8}; + #\u{2B0B9}; + #\u{2B0BA}; + #\u{2B0BB}; + #\u{2B0BC}; + #\u{2B0BD}; + #\u{2B0BE}; + #\u{2B0BF}; + #\u{2B0C0}; + #\u{2B0C1}; + #\u{2B0C2}; + #\u{2B0C3}; + #\u{2B0C4}; + #\u{2B0C5}; + #\u{2B0C6}; + #\u{2B0C7}; + #\u{2B0C8}; + #\u{2B0C9}; + #\u{2B0CA}; + #\u{2B0CB}; + #\u{2B0CC}; + #\u{2B0CD}; + #\u{2B0CE}; + #\u{2B0CF}; + #\u{2B0D0}; + #\u{2B0D1}; + #\u{2B0D2}; + #\u{2B0D3}; + #\u{2B0D4}; + #\u{2B0D5}; + #\u{2B0D6}; + #\u{2B0D7}; + #\u{2B0D8}; + #\u{2B0D9}; + #\u{2B0DA}; + #\u{2B0DB}; + #\u{2B0DC}; + #\u{2B0DD}; + #\u{2B0DE}; + #\u{2B0DF}; + #\u{2B0E0}; + #\u{2B0E1}; + #\u{2B0E2}; + #\u{2B0E3}; + #\u{2B0E4}; + #\u{2B0E5}; + #\u{2B0E6}; + #\u{2B0E7}; + #\u{2B0E8}; + #\u{2B0E9}; + #\u{2B0EA}; + #\u{2B0EB}; + #\u{2B0EC}; + #\u{2B0ED}; + #\u{2B0EE}; + #\u{2B0EF}; + #\u{2B0F0}; + #\u{2B0F1}; + #\u{2B0F2}; + #\u{2B0F3}; + #\u{2B0F4}; + #\u{2B0F5}; + #\u{2B0F6}; + #\u{2B0F7}; + #\u{2B0F8}; + #\u{2B0F9}; + #\u{2B0FA}; + #\u{2B0FB}; + #\u{2B0FC}; + #\u{2B0FD}; + #\u{2B0FE}; + #\u{2B0FF}; + #\u{2B100}; + #\u{2B101}; + #\u{2B102}; + #\u{2B103}; + #\u{2B104}; + #\u{2B105}; + #\u{2B106}; + #\u{2B107}; + #\u{2B108}; + #\u{2B109}; + #\u{2B10A}; + #\u{2B10B}; + #\u{2B10C}; + #\u{2B10D}; + #\u{2B10E}; + #\u{2B10F}; + #\u{2B110}; + #\u{2B111}; + #\u{2B112}; + #\u{2B113}; + #\u{2B114}; + #\u{2B115}; + #\u{2B116}; + #\u{2B117}; + #\u{2B118}; + #\u{2B119}; + #\u{2B11A}; + #\u{2B11B}; + #\u{2B11C}; + #\u{2B11D}; + #\u{2B11E}; + #\u{2B11F}; + #\u{2B120}; + #\u{2B121}; + #\u{2B122}; + #\u{2B123}; + #\u{2B124}; + #\u{2B125}; + #\u{2B126}; + #\u{2B127}; + #\u{2B128}; + #\u{2B129}; + #\u{2B12A}; + #\u{2B12B}; + #\u{2B12C}; + #\u{2B12D}; + #\u{2B12E}; + #\u{2B12F}; + #\u{2B130}; + #\u{2B131}; + #\u{2B132}; + #\u{2B133}; + #\u{2B134}; + #\u{2B135}; + #\u{2B136}; + #\u{2B137}; + #\u{2B138}; + #\u{2B139}; + #\u{2B13A}; + #\u{2B13B}; + #\u{2B13C}; + #\u{2B13D}; + #\u{2B13E}; + #\u{2B13F}; + #\u{2B140}; + #\u{2B141}; + #\u{2B142}; + #\u{2B143}; + #\u{2B144}; + #\u{2B145}; + #\u{2B146}; + #\u{2B147}; + #\u{2B148}; + #\u{2B149}; + #\u{2B14A}; + #\u{2B14B}; + #\u{2B14C}; + #\u{2B14D}; + #\u{2B14E}; + #\u{2B14F}; + #\u{2B150}; + #\u{2B151}; + #\u{2B152}; + #\u{2B153}; + #\u{2B154}; + #\u{2B155}; + #\u{2B156}; + #\u{2B157}; + #\u{2B158}; + #\u{2B159}; + #\u{2B15A}; + #\u{2B15B}; + #\u{2B15C}; + #\u{2B15D}; + #\u{2B15E}; + #\u{2B15F}; + #\u{2B160}; + #\u{2B161}; + #\u{2B162}; + #\u{2B163}; + #\u{2B164}; + #\u{2B165}; + #\u{2B166}; + #\u{2B167}; + #\u{2B168}; + #\u{2B169}; + #\u{2B16A}; + #\u{2B16B}; + #\u{2B16C}; + #\u{2B16D}; + #\u{2B16E}; + #\u{2B16F}; + #\u{2B170}; + #\u{2B171}; + #\u{2B172}; + #\u{2B173}; + #\u{2B174}; + #\u{2B175}; + #\u{2B176}; + #\u{2B177}; + #\u{2B178}; + #\u{2B179}; + #\u{2B17A}; + #\u{2B17B}; + #\u{2B17C}; + #\u{2B17D}; + #\u{2B17E}; + #\u{2B17F}; + #\u{2B180}; + #\u{2B181}; + #\u{2B182}; + #\u{2B183}; + #\u{2B184}; + #\u{2B185}; + #\u{2B186}; + #\u{2B187}; + #\u{2B188}; + #\u{2B189}; + #\u{2B18A}; + #\u{2B18B}; + #\u{2B18C}; + #\u{2B18D}; + #\u{2B18E}; + #\u{2B18F}; + #\u{2B190}; + #\u{2B191}; + #\u{2B192}; + #\u{2B193}; + #\u{2B194}; + #\u{2B195}; + #\u{2B196}; + #\u{2B197}; + #\u{2B198}; + #\u{2B199}; + #\u{2B19A}; + #\u{2B19B}; + #\u{2B19C}; + #\u{2B19D}; + #\u{2B19E}; + #\u{2B19F}; + #\u{2B1A0}; + #\u{2B1A1}; + #\u{2B1A2}; + #\u{2B1A3}; + #\u{2B1A4}; + #\u{2B1A5}; + #\u{2B1A6}; + #\u{2B1A7}; + #\u{2B1A8}; + #\u{2B1A9}; + #\u{2B1AA}; + #\u{2B1AB}; + #\u{2B1AC}; + #\u{2B1AD}; + #\u{2B1AE}; + #\u{2B1AF}; + #\u{2B1B0}; + #\u{2B1B1}; + #\u{2B1B2}; + #\u{2B1B3}; + #\u{2B1B4}; + #\u{2B1B5}; + #\u{2B1B6}; + #\u{2B1B7}; + #\u{2B1B8}; + #\u{2B1B9}; + #\u{2B1BA}; + #\u{2B1BB}; + #\u{2B1BC}; + #\u{2B1BD}; + #\u{2B1BE}; + #\u{2B1BF}; + #\u{2B1C0}; + #\u{2B1C1}; + #\u{2B1C2}; + #\u{2B1C3}; + #\u{2B1C4}; + #\u{2B1C5}; + #\u{2B1C6}; + #\u{2B1C7}; + #\u{2B1C8}; + #\u{2B1C9}; + #\u{2B1CA}; + #\u{2B1CB}; + #\u{2B1CC}; + #\u{2B1CD}; + #\u{2B1CE}; + #\u{2B1CF}; + #\u{2B1D0}; + #\u{2B1D1}; + #\u{2B1D2}; + #\u{2B1D3}; + #\u{2B1D4}; + #\u{2B1D5}; + #\u{2B1D6}; + #\u{2B1D7}; + #\u{2B1D8}; + #\u{2B1D9}; + #\u{2B1DA}; + #\u{2B1DB}; + #\u{2B1DC}; + #\u{2B1DD}; + #\u{2B1DE}; + #\u{2B1DF}; + #\u{2B1E0}; + #\u{2B1E1}; + #\u{2B1E2}; + #\u{2B1E3}; + #\u{2B1E4}; + #\u{2B1E5}; + #\u{2B1E6}; + #\u{2B1E7}; + #\u{2B1E8}; + #\u{2B1E9}; + #\u{2B1EA}; + #\u{2B1EB}; + #\u{2B1EC}; + #\u{2B1ED}; + #\u{2B1EE}; + #\u{2B1EF}; + #\u{2B1F0}; + #\u{2B1F1}; + #\u{2B1F2}; + #\u{2B1F3}; + #\u{2B1F4}; + #\u{2B1F5}; + #\u{2B1F6}; + #\u{2B1F7}; + #\u{2B1F8}; + #\u{2B1F9}; + #\u{2B1FA}; + #\u{2B1FB}; + #\u{2B1FC}; + #\u{2B1FD}; + #\u{2B1FE}; + #\u{2B1FF}; + #\u{2B200}; + #\u{2B201}; + #\u{2B202}; + #\u{2B203}; + #\u{2B204}; + #\u{2B205}; + #\u{2B206}; + #\u{2B207}; + #\u{2B208}; + #\u{2B209}; + #\u{2B20A}; + #\u{2B20B}; + #\u{2B20C}; + #\u{2B20D}; + #\u{2B20E}; + #\u{2B20F}; + #\u{2B210}; + #\u{2B211}; + #\u{2B212}; + #\u{2B213}; + #\u{2B214}; + #\u{2B215}; + #\u{2B216}; + #\u{2B217}; + #\u{2B218}; + #\u{2B219}; + #\u{2B21A}; + #\u{2B21B}; + #\u{2B21C}; + #\u{2B21D}; + #\u{2B21E}; + #\u{2B21F}; + #\u{2B220}; + #\u{2B221}; + #\u{2B222}; + #\u{2B223}; + #\u{2B224}; + #\u{2B225}; + #\u{2B226}; + #\u{2B227}; + #\u{2B228}; + #\u{2B229}; + #\u{2B22A}; + #\u{2B22B}; + #\u{2B22C}; + #\u{2B22D}; + #\u{2B22E}; + #\u{2B22F}; + #\u{2B230}; + #\u{2B231}; + #\u{2B232}; + #\u{2B233}; + #\u{2B234}; + #\u{2B235}; + #\u{2B236}; + #\u{2B237}; + #\u{2B238}; + #\u{2B239}; + #\u{2B23A}; + #\u{2B23B}; + #\u{2B23C}; + #\u{2B23D}; + #\u{2B23E}; + #\u{2B23F}; + #\u{2B240}; + #\u{2B241}; + #\u{2B242}; + #\u{2B243}; + #\u{2B244}; + #\u{2B245}; + #\u{2B246}; + #\u{2B247}; + #\u{2B248}; + #\u{2B249}; + #\u{2B24A}; + #\u{2B24B}; + #\u{2B24C}; + #\u{2B24D}; + #\u{2B24E}; + #\u{2B24F}; + #\u{2B250}; + #\u{2B251}; + #\u{2B252}; + #\u{2B253}; + #\u{2B254}; + #\u{2B255}; + #\u{2B256}; + #\u{2B257}; + #\u{2B258}; + #\u{2B259}; + #\u{2B25A}; + #\u{2B25B}; + #\u{2B25C}; + #\u{2B25D}; + #\u{2B25E}; + #\u{2B25F}; + #\u{2B260}; + #\u{2B261}; + #\u{2B262}; + #\u{2B263}; + #\u{2B264}; + #\u{2B265}; + #\u{2B266}; + #\u{2B267}; + #\u{2B268}; + #\u{2B269}; + #\u{2B26A}; + #\u{2B26B}; + #\u{2B26C}; + #\u{2B26D}; + #\u{2B26E}; + #\u{2B26F}; + #\u{2B270}; + #\u{2B271}; + #\u{2B272}; + #\u{2B273}; + #\u{2B274}; + #\u{2B275}; + #\u{2B276}; + #\u{2B277}; + #\u{2B278}; + #\u{2B279}; + #\u{2B27A}; + #\u{2B27B}; + #\u{2B27C}; + #\u{2B27D}; + #\u{2B27E}; + #\u{2B27F}; + #\u{2B280}; + #\u{2B281}; + #\u{2B282}; + #\u{2B283}; + #\u{2B284}; + #\u{2B285}; + #\u{2B286}; + #\u{2B287}; + #\u{2B288}; + #\u{2B289}; + #\u{2B28A}; + #\u{2B28B}; + #\u{2B28C}; + #\u{2B28D}; + #\u{2B28E}; + #\u{2B28F}; + #\u{2B290}; + #\u{2B291}; + #\u{2B292}; + #\u{2B293}; + #\u{2B294}; + #\u{2B295}; + #\u{2B296}; + #\u{2B297}; + #\u{2B298}; + #\u{2B299}; + #\u{2B29A}; + #\u{2B29B}; + #\u{2B29C}; + #\u{2B29D}; + #\u{2B29E}; + #\u{2B29F}; + #\u{2B2A0}; + #\u{2B2A1}; + #\u{2B2A2}; + #\u{2B2A3}; + #\u{2B2A4}; + #\u{2B2A5}; + #\u{2B2A6}; + #\u{2B2A7}; + #\u{2B2A8}; + #\u{2B2A9}; + #\u{2B2AA}; + #\u{2B2AB}; + #\u{2B2AC}; + #\u{2B2AD}; + #\u{2B2AE}; + #\u{2B2AF}; + #\u{2B2B0}; + #\u{2B2B1}; + #\u{2B2B2}; + #\u{2B2B3}; + #\u{2B2B4}; + #\u{2B2B5}; + #\u{2B2B6}; + #\u{2B2B7}; + #\u{2B2B8}; + #\u{2B2B9}; + #\u{2B2BA}; + #\u{2B2BB}; + #\u{2B2BC}; + #\u{2B2BD}; + #\u{2B2BE}; + #\u{2B2BF}; + #\u{2B2C0}; + #\u{2B2C1}; + #\u{2B2C2}; + #\u{2B2C3}; + #\u{2B2C4}; + #\u{2B2C5}; + #\u{2B2C6}; + #\u{2B2C7}; + #\u{2B2C8}; + #\u{2B2C9}; + #\u{2B2CA}; + #\u{2B2CB}; + #\u{2B2CC}; + #\u{2B2CD}; + #\u{2B2CE}; + #\u{2B2CF}; + #\u{2B2D0}; + #\u{2B2D1}; + #\u{2B2D2}; + #\u{2B2D3}; + #\u{2B2D4}; + #\u{2B2D5}; + #\u{2B2D6}; + #\u{2B2D7}; + #\u{2B2D8}; + #\u{2B2D9}; + #\u{2B2DA}; + #\u{2B2DB}; + #\u{2B2DC}; + #\u{2B2DD}; + #\u{2B2DE}; + #\u{2B2DF}; + #\u{2B2E0}; + #\u{2B2E1}; + #\u{2B2E2}; + #\u{2B2E3}; + #\u{2B2E4}; + #\u{2B2E5}; + #\u{2B2E6}; + #\u{2B2E7}; + #\u{2B2E8}; + #\u{2B2E9}; + #\u{2B2EA}; + #\u{2B2EB}; + #\u{2B2EC}; + #\u{2B2ED}; + #\u{2B2EE}; + #\u{2B2EF}; + #\u{2B2F0}; + #\u{2B2F1}; + #\u{2B2F2}; + #\u{2B2F3}; + #\u{2B2F4}; + #\u{2B2F5}; + #\u{2B2F6}; + #\u{2B2F7}; + #\u{2B2F8}; + #\u{2B2F9}; + #\u{2B2FA}; + #\u{2B2FB}; + #\u{2B2FC}; + #\u{2B2FD}; + #\u{2B2FE}; + #\u{2B2FF}; + #\u{2B300}; + #\u{2B301}; + #\u{2B302}; + #\u{2B303}; + #\u{2B304}; + #\u{2B305}; + #\u{2B306}; + #\u{2B307}; + #\u{2B308}; + #\u{2B309}; + #\u{2B30A}; + #\u{2B30B}; + #\u{2B30C}; + #\u{2B30D}; + #\u{2B30E}; + #\u{2B30F}; + #\u{2B310}; + #\u{2B311}; + #\u{2B312}; + #\u{2B313}; + #\u{2B314}; + #\u{2B315}; + #\u{2B316}; + #\u{2B317}; + #\u{2B318}; + #\u{2B319}; + #\u{2B31A}; + #\u{2B31B}; + #\u{2B31C}; + #\u{2B31D}; + #\u{2B31E}; + #\u{2B31F}; + #\u{2B320}; + #\u{2B321}; + #\u{2B322}; + #\u{2B323}; + #\u{2B324}; + #\u{2B325}; + #\u{2B326}; + #\u{2B327}; + #\u{2B328}; + #\u{2B329}; + #\u{2B32A}; + #\u{2B32B}; + #\u{2B32C}; + #\u{2B32D}; + #\u{2B32E}; + #\u{2B32F}; + #\u{2B330}; + #\u{2B331}; + #\u{2B332}; + #\u{2B333}; + #\u{2B334}; + #\u{2B335}; + #\u{2B336}; + #\u{2B337}; + #\u{2B338}; + #\u{2B339}; + #\u{2B33A}; + #\u{2B33B}; + #\u{2B33C}; + #\u{2B33D}; + #\u{2B33E}; + #\u{2B33F}; + #\u{2B340}; + #\u{2B341}; + #\u{2B342}; + #\u{2B343}; + #\u{2B344}; + #\u{2B345}; + #\u{2B346}; + #\u{2B347}; + #\u{2B348}; + #\u{2B349}; + #\u{2B34A}; + #\u{2B34B}; + #\u{2B34C}; + #\u{2B34D}; + #\u{2B34E}; + #\u{2B34F}; + #\u{2B350}; + #\u{2B351}; + #\u{2B352}; + #\u{2B353}; + #\u{2B354}; + #\u{2B355}; + #\u{2B356}; + #\u{2B357}; + #\u{2B358}; + #\u{2B359}; + #\u{2B35A}; + #\u{2B35B}; + #\u{2B35C}; + #\u{2B35D}; + #\u{2B35E}; + #\u{2B35F}; + #\u{2B360}; + #\u{2B361}; + #\u{2B362}; + #\u{2B363}; + #\u{2B364}; + #\u{2B365}; + #\u{2B366}; + #\u{2B367}; + #\u{2B368}; + #\u{2B369}; + #\u{2B36A}; + #\u{2B36B}; + #\u{2B36C}; + #\u{2B36D}; + #\u{2B36E}; + #\u{2B36F}; + #\u{2B370}; + #\u{2B371}; + #\u{2B372}; + #\u{2B373}; + #\u{2B374}; + #\u{2B375}; + #\u{2B376}; + #\u{2B377}; + #\u{2B378}; + #\u{2B379}; + #\u{2B37A}; + #\u{2B37B}; + #\u{2B37C}; + #\u{2B37D}; + #\u{2B37E}; + #\u{2B37F}; + #\u{2B380}; + #\u{2B381}; + #\u{2B382}; + #\u{2B383}; + #\u{2B384}; + #\u{2B385}; + #\u{2B386}; + #\u{2B387}; + #\u{2B388}; + #\u{2B389}; + #\u{2B38A}; + #\u{2B38B}; + #\u{2B38C}; + #\u{2B38D}; + #\u{2B38E}; + #\u{2B38F}; + #\u{2B390}; + #\u{2B391}; + #\u{2B392}; + #\u{2B393}; + #\u{2B394}; + #\u{2B395}; + #\u{2B396}; + #\u{2B397}; + #\u{2B398}; + #\u{2B399}; + #\u{2B39A}; + #\u{2B39B}; + #\u{2B39C}; + #\u{2B39D}; + #\u{2B39E}; + #\u{2B39F}; + #\u{2B3A0}; + #\u{2B3A1}; + #\u{2B3A2}; + #\u{2B3A3}; + #\u{2B3A4}; + #\u{2B3A5}; + #\u{2B3A6}; + #\u{2B3A7}; + #\u{2B3A8}; + #\u{2B3A9}; + #\u{2B3AA}; + #\u{2B3AB}; + #\u{2B3AC}; + #\u{2B3AD}; + #\u{2B3AE}; + #\u{2B3AF}; + #\u{2B3B0}; + #\u{2B3B1}; + #\u{2B3B2}; + #\u{2B3B3}; + #\u{2B3B4}; + #\u{2B3B5}; + #\u{2B3B6}; + #\u{2B3B7}; + #\u{2B3B8}; + #\u{2B3B9}; + #\u{2B3BA}; + #\u{2B3BB}; + #\u{2B3BC}; + #\u{2B3BD}; + #\u{2B3BE}; + #\u{2B3BF}; + #\u{2B3C0}; + #\u{2B3C1}; + #\u{2B3C2}; + #\u{2B3C3}; + #\u{2B3C4}; + #\u{2B3C5}; + #\u{2B3C6}; + #\u{2B3C7}; + #\u{2B3C8}; + #\u{2B3C9}; + #\u{2B3CA}; + #\u{2B3CB}; + #\u{2B3CC}; + #\u{2B3CD}; + #\u{2B3CE}; + #\u{2B3CF}; + #\u{2B3D0}; + #\u{2B3D1}; + #\u{2B3D2}; + #\u{2B3D3}; + #\u{2B3D4}; + #\u{2B3D5}; + #\u{2B3D6}; + #\u{2B3D7}; + #\u{2B3D8}; + #\u{2B3D9}; + #\u{2B3DA}; + #\u{2B3DB}; + #\u{2B3DC}; + #\u{2B3DD}; + #\u{2B3DE}; + #\u{2B3DF}; + #\u{2B3E0}; + #\u{2B3E1}; + #\u{2B3E2}; + #\u{2B3E3}; + #\u{2B3E4}; + #\u{2B3E5}; + #\u{2B3E6}; + #\u{2B3E7}; + #\u{2B3E8}; + #\u{2B3E9}; + #\u{2B3EA}; + #\u{2B3EB}; + #\u{2B3EC}; + #\u{2B3ED}; + #\u{2B3EE}; + #\u{2B3EF}; + #\u{2B3F0}; + #\u{2B3F1}; + #\u{2B3F2}; + #\u{2B3F3}; + #\u{2B3F4}; + #\u{2B3F5}; + #\u{2B3F6}; + #\u{2B3F7}; + #\u{2B3F8}; + #\u{2B3F9}; + #\u{2B3FA}; + #\u{2B3FB}; + #\u{2B3FC}; + #\u{2B3FD}; + #\u{2B3FE}; + #\u{2B3FF}; + #\u{2B400}; + #\u{2B401}; + #\u{2B402}; + #\u{2B403}; + #\u{2B404}; + #\u{2B405}; + #\u{2B406}; + #\u{2B407}; + #\u{2B408}; + #\u{2B409}; + #\u{2B40A}; + #\u{2B40B}; + #\u{2B40C}; + #\u{2B40D}; + #\u{2B40E}; + #\u{2B40F}; + #\u{2B410}; + #\u{2B411}; + #\u{2B412}; + #\u{2B413}; + #\u{2B414}; + #\u{2B415}; + #\u{2B416}; + #\u{2B417}; + #\u{2B418}; + #\u{2B419}; + #\u{2B41A}; + #\u{2B41B}; + #\u{2B41C}; + #\u{2B41D}; + #\u{2B41E}; + #\u{2B41F}; + #\u{2B420}; + #\u{2B421}; + #\u{2B422}; + #\u{2B423}; + #\u{2B424}; + #\u{2B425}; + #\u{2B426}; + #\u{2B427}; + #\u{2B428}; + #\u{2B429}; + #\u{2B42A}; + #\u{2B42B}; + #\u{2B42C}; + #\u{2B42D}; + #\u{2B42E}; + #\u{2B42F}; + #\u{2B430}; + #\u{2B431}; + #\u{2B432}; + #\u{2B433}; + #\u{2B434}; + #\u{2B435}; + #\u{2B436}; + #\u{2B437}; + #\u{2B438}; + #\u{2B439}; + #\u{2B43A}; + #\u{2B43B}; + #\u{2B43C}; + #\u{2B43D}; + #\u{2B43E}; + #\u{2B43F}; + #\u{2B440}; + #\u{2B441}; + #\u{2B442}; + #\u{2B443}; + #\u{2B444}; + #\u{2B445}; + #\u{2B446}; + #\u{2B447}; + #\u{2B448}; + #\u{2B449}; + #\u{2B44A}; + #\u{2B44B}; + #\u{2B44C}; + #\u{2B44D}; + #\u{2B44E}; + #\u{2B44F}; + #\u{2B450}; + #\u{2B451}; + #\u{2B452}; + #\u{2B453}; + #\u{2B454}; + #\u{2B455}; + #\u{2B456}; + #\u{2B457}; + #\u{2B458}; + #\u{2B459}; + #\u{2B45A}; + #\u{2B45B}; + #\u{2B45C}; + #\u{2B45D}; + #\u{2B45E}; + #\u{2B45F}; + #\u{2B460}; + #\u{2B461}; + #\u{2B462}; + #\u{2B463}; + #\u{2B464}; + #\u{2B465}; + #\u{2B466}; + #\u{2B467}; + #\u{2B468}; + #\u{2B469}; + #\u{2B46A}; + #\u{2B46B}; + #\u{2B46C}; + #\u{2B46D}; + #\u{2B46E}; + #\u{2B46F}; + #\u{2B470}; + #\u{2B471}; + #\u{2B472}; + #\u{2B473}; + #\u{2B474}; + #\u{2B475}; + #\u{2B476}; + #\u{2B477}; + #\u{2B478}; + #\u{2B479}; + #\u{2B47A}; + #\u{2B47B}; + #\u{2B47C}; + #\u{2B47D}; + #\u{2B47E}; + #\u{2B47F}; + #\u{2B480}; + #\u{2B481}; + #\u{2B482}; + #\u{2B483}; + #\u{2B484}; + #\u{2B485}; + #\u{2B486}; + #\u{2B487}; + #\u{2B488}; + #\u{2B489}; + #\u{2B48A}; + #\u{2B48B}; + #\u{2B48C}; + #\u{2B48D}; + #\u{2B48E}; + #\u{2B48F}; + #\u{2B490}; + #\u{2B491}; + #\u{2B492}; + #\u{2B493}; + #\u{2B494}; + #\u{2B495}; + #\u{2B496}; + #\u{2B497}; + #\u{2B498}; + #\u{2B499}; + #\u{2B49A}; + #\u{2B49B}; + #\u{2B49C}; + #\u{2B49D}; + #\u{2B49E}; + #\u{2B49F}; + #\u{2B4A0}; + #\u{2B4A1}; + #\u{2B4A2}; + #\u{2B4A3}; + #\u{2B4A4}; + #\u{2B4A5}; + #\u{2B4A6}; + #\u{2B4A7}; + #\u{2B4A8}; + #\u{2B4A9}; + #\u{2B4AA}; + #\u{2B4AB}; + #\u{2B4AC}; + #\u{2B4AD}; + #\u{2B4AE}; + #\u{2B4AF}; + #\u{2B4B0}; + #\u{2B4B1}; + #\u{2B4B2}; + #\u{2B4B3}; + #\u{2B4B4}; + #\u{2B4B5}; + #\u{2B4B6}; + #\u{2B4B7}; + #\u{2B4B8}; + #\u{2B4B9}; + #\u{2B4BA}; + #\u{2B4BB}; + #\u{2B4BC}; + #\u{2B4BD}; + #\u{2B4BE}; + #\u{2B4BF}; + #\u{2B4C0}; + #\u{2B4C1}; + #\u{2B4C2}; + #\u{2B4C3}; + #\u{2B4C4}; + #\u{2B4C5}; + #\u{2B4C6}; + #\u{2B4C7}; + #\u{2B4C8}; + #\u{2B4C9}; + #\u{2B4CA}; + #\u{2B4CB}; + #\u{2B4CC}; + #\u{2B4CD}; + #\u{2B4CE}; + #\u{2B4CF}; + #\u{2B4D0}; + #\u{2B4D1}; + #\u{2B4D2}; + #\u{2B4D3}; + #\u{2B4D4}; + #\u{2B4D5}; + #\u{2B4D6}; + #\u{2B4D7}; + #\u{2B4D8}; + #\u{2B4D9}; + #\u{2B4DA}; + #\u{2B4DB}; + #\u{2B4DC}; + #\u{2B4DD}; + #\u{2B4DE}; + #\u{2B4DF}; + #\u{2B4E0}; + #\u{2B4E1}; + #\u{2B4E2}; + #\u{2B4E3}; + #\u{2B4E4}; + #\u{2B4E5}; + #\u{2B4E6}; + #\u{2B4E7}; + #\u{2B4E8}; + #\u{2B4E9}; + #\u{2B4EA}; + #\u{2B4EB}; + #\u{2B4EC}; + #\u{2B4ED}; + #\u{2B4EE}; + #\u{2B4EF}; + #\u{2B4F0}; + #\u{2B4F1}; + #\u{2B4F2}; + #\u{2B4F3}; + #\u{2B4F4}; + #\u{2B4F5}; + #\u{2B4F6}; + #\u{2B4F7}; + #\u{2B4F8}; + #\u{2B4F9}; + #\u{2B4FA}; + #\u{2B4FB}; + #\u{2B4FC}; + #\u{2B4FD}; + #\u{2B4FE}; + #\u{2B4FF}; + #\u{2B500}; + #\u{2B501}; + #\u{2B502}; + #\u{2B503}; + #\u{2B504}; + #\u{2B505}; + #\u{2B506}; + #\u{2B507}; + #\u{2B508}; + #\u{2B509}; + #\u{2B50A}; + #\u{2B50B}; + #\u{2B50C}; + #\u{2B50D}; + #\u{2B50E}; + #\u{2B50F}; + #\u{2B510}; + #\u{2B511}; + #\u{2B512}; + #\u{2B513}; + #\u{2B514}; + #\u{2B515}; + #\u{2B516}; + #\u{2B517}; + #\u{2B518}; + #\u{2B519}; + #\u{2B51A}; + #\u{2B51B}; + #\u{2B51C}; + #\u{2B51D}; + #\u{2B51E}; + #\u{2B51F}; + #\u{2B520}; + #\u{2B521}; + #\u{2B522}; + #\u{2B523}; + #\u{2B524}; + #\u{2B525}; + #\u{2B526}; + #\u{2B527}; + #\u{2B528}; + #\u{2B529}; + #\u{2B52A}; + #\u{2B52B}; + #\u{2B52C}; + #\u{2B52D}; + #\u{2B52E}; + #\u{2B52F}; + #\u{2B530}; + #\u{2B531}; + #\u{2B532}; + #\u{2B533}; + #\u{2B534}; + #\u{2B535}; + #\u{2B536}; + #\u{2B537}; + #\u{2B538}; + #\u{2B539}; + #\u{2B53A}; + #\u{2B53B}; + #\u{2B53C}; + #\u{2B53D}; + #\u{2B53E}; + #\u{2B53F}; + #\u{2B540}; + #\u{2B541}; + #\u{2B542}; + #\u{2B543}; + #\u{2B544}; + #\u{2B545}; + #\u{2B546}; + #\u{2B547}; + #\u{2B548}; + #\u{2B549}; + #\u{2B54A}; + #\u{2B54B}; + #\u{2B54C}; + #\u{2B54D}; + #\u{2B54E}; + #\u{2B54F}; + #\u{2B550}; + #\u{2B551}; + #\u{2B552}; + #\u{2B553}; + #\u{2B554}; + #\u{2B555}; + #\u{2B556}; + #\u{2B557}; + #\u{2B558}; + #\u{2B559}; + #\u{2B55A}; + #\u{2B55B}; + #\u{2B55C}; + #\u{2B55D}; + #\u{2B55E}; + #\u{2B55F}; + #\u{2B560}; + #\u{2B561}; + #\u{2B562}; + #\u{2B563}; + #\u{2B564}; + #\u{2B565}; + #\u{2B566}; + #\u{2B567}; + #\u{2B568}; + #\u{2B569}; + #\u{2B56A}; + #\u{2B56B}; + #\u{2B56C}; + #\u{2B56D}; + #\u{2B56E}; + #\u{2B56F}; + #\u{2B570}; + #\u{2B571}; + #\u{2B572}; + #\u{2B573}; + #\u{2B574}; + #\u{2B575}; + #\u{2B576}; + #\u{2B577}; + #\u{2B578}; + #\u{2B579}; + #\u{2B57A}; + #\u{2B57B}; + #\u{2B57C}; + #\u{2B57D}; + #\u{2B57E}; + #\u{2B57F}; + #\u{2B580}; + #\u{2B581}; + #\u{2B582}; + #\u{2B583}; + #\u{2B584}; + #\u{2B585}; + #\u{2B586}; + #\u{2B587}; + #\u{2B588}; + #\u{2B589}; + #\u{2B58A}; + #\u{2B58B}; + #\u{2B58C}; + #\u{2B58D}; + #\u{2B58E}; + #\u{2B58F}; + #\u{2B590}; + #\u{2B591}; + #\u{2B592}; + #\u{2B593}; + #\u{2B594}; + #\u{2B595}; + #\u{2B596}; + #\u{2B597}; + #\u{2B598}; + #\u{2B599}; + #\u{2B59A}; + #\u{2B59B}; + #\u{2B59C}; + #\u{2B59D}; + #\u{2B59E}; + #\u{2B59F}; + #\u{2B5A0}; + #\u{2B5A1}; + #\u{2B5A2}; + #\u{2B5A3}; + #\u{2B5A4}; + #\u{2B5A5}; + #\u{2B5A6}; + #\u{2B5A7}; + #\u{2B5A8}; + #\u{2B5A9}; + #\u{2B5AA}; + #\u{2B5AB}; + #\u{2B5AC}; + #\u{2B5AD}; + #\u{2B5AE}; + #\u{2B5AF}; + #\u{2B5B0}; + #\u{2B5B1}; + #\u{2B5B2}; + #\u{2B5B3}; + #\u{2B5B4}; + #\u{2B5B5}; + #\u{2B5B6}; + #\u{2B5B7}; + #\u{2B5B8}; + #\u{2B5B9}; + #\u{2B5BA}; + #\u{2B5BB}; + #\u{2B5BC}; + #\u{2B5BD}; + #\u{2B5BE}; + #\u{2B5BF}; + #\u{2B5C0}; + #\u{2B5C1}; + #\u{2B5C2}; + #\u{2B5C3}; + #\u{2B5C4}; + #\u{2B5C5}; + #\u{2B5C6}; + #\u{2B5C7}; + #\u{2B5C8}; + #\u{2B5C9}; + #\u{2B5CA}; + #\u{2B5CB}; + #\u{2B5CC}; + #\u{2B5CD}; + #\u{2B5CE}; + #\u{2B5CF}; + #\u{2B5D0}; + #\u{2B5D1}; + #\u{2B5D2}; + #\u{2B5D3}; + #\u{2B5D4}; + #\u{2B5D5}; + #\u{2B5D6}; + #\u{2B5D7}; + #\u{2B5D8}; + #\u{2B5D9}; + #\u{2B5DA}; + #\u{2B5DB}; + #\u{2B5DC}; + #\u{2B5DD}; + #\u{2B5DE}; + #\u{2B5DF}; + #\u{2B5E0}; + #\u{2B5E1}; + #\u{2B5E2}; + #\u{2B5E3}; + #\u{2B5E4}; + #\u{2B5E5}; + #\u{2B5E6}; + #\u{2B5E7}; + #\u{2B5E8}; + #\u{2B5E9}; + #\u{2B5EA}; + #\u{2B5EB}; + #\u{2B5EC}; + #\u{2B5ED}; + #\u{2B5EE}; + #\u{2B5EF}; + #\u{2B5F0}; + #\u{2B5F1}; + #\u{2B5F2}; + #\u{2B5F3}; + #\u{2B5F4}; + #\u{2B5F5}; + #\u{2B5F6}; + #\u{2B5F7}; + #\u{2B5F8}; + #\u{2B5F9}; + #\u{2B5FA}; + #\u{2B5FB}; + #\u{2B5FC}; + #\u{2B5FD}; + #\u{2B5FE}; + #\u{2B5FF}; + #\u{2B600}; + #\u{2B601}; + #\u{2B602}; + #\u{2B603}; + #\u{2B604}; + #\u{2B605}; + #\u{2B606}; + #\u{2B607}; + #\u{2B608}; + #\u{2B609}; + #\u{2B60A}; + #\u{2B60B}; + #\u{2B60C}; + #\u{2B60D}; + #\u{2B60E}; + #\u{2B60F}; + #\u{2B610}; + #\u{2B611}; + #\u{2B612}; + #\u{2B613}; + #\u{2B614}; + #\u{2B615}; + #\u{2B616}; + #\u{2B617}; + #\u{2B618}; + #\u{2B619}; + #\u{2B61A}; + #\u{2B61B}; + #\u{2B61C}; + #\u{2B61D}; + #\u{2B61E}; + #\u{2B61F}; + #\u{2B620}; + #\u{2B621}; + #\u{2B622}; + #\u{2B623}; + #\u{2B624}; + #\u{2B625}; + #\u{2B626}; + #\u{2B627}; + #\u{2B628}; + #\u{2B629}; + #\u{2B62A}; + #\u{2B62B}; + #\u{2B62C}; + #\u{2B62D}; + #\u{2B62E}; + #\u{2B62F}; + #\u{2B630}; + #\u{2B631}; + #\u{2B632}; + #\u{2B633}; + #\u{2B634}; + #\u{2B635}; + #\u{2B636}; + #\u{2B637}; + #\u{2B638}; + #\u{2B639}; + #\u{2B63A}; + #\u{2B63B}; + #\u{2B63C}; + #\u{2B63D}; + #\u{2B63E}; + #\u{2B63F}; + #\u{2B640}; + #\u{2B641}; + #\u{2B642}; + #\u{2B643}; + #\u{2B644}; + #\u{2B645}; + #\u{2B646}; + #\u{2B647}; + #\u{2B648}; + #\u{2B649}; + #\u{2B64A}; + #\u{2B64B}; + #\u{2B64C}; + #\u{2B64D}; + #\u{2B64E}; + #\u{2B64F}; + #\u{2B650}; + #\u{2B651}; + #\u{2B652}; + #\u{2B653}; + #\u{2B654}; + #\u{2B655}; + #\u{2B656}; + #\u{2B657}; + #\u{2B658}; + #\u{2B659}; + #\u{2B65A}; + #\u{2B65B}; + #\u{2B65C}; + #\u{2B65D}; + #\u{2B65E}; + #\u{2B65F}; + #\u{2B660}; + #\u{2B661}; + #\u{2B662}; + #\u{2B663}; + #\u{2B664}; + #\u{2B665}; + #\u{2B666}; + #\u{2B667}; + #\u{2B668}; + #\u{2B669}; + #\u{2B66A}; + #\u{2B66B}; + #\u{2B66C}; + #\u{2B66D}; + #\u{2B66E}; + #\u{2B66F}; + #\u{2B670}; + #\u{2B671}; + #\u{2B672}; + #\u{2B673}; + #\u{2B674}; + #\u{2B675}; + #\u{2B676}; + #\u{2B677}; + #\u{2B678}; + #\u{2B679}; + #\u{2B67A}; + #\u{2B67B}; + #\u{2B67C}; + #\u{2B67D}; + #\u{2B67E}; + #\u{2B67F}; + #\u{2B680}; + #\u{2B681}; + #\u{2B682}; + #\u{2B683}; + #\u{2B684}; + #\u{2B685}; + #\u{2B686}; + #\u{2B687}; + #\u{2B688}; + #\u{2B689}; + #\u{2B68A}; + #\u{2B68B}; + #\u{2B68C}; + #\u{2B68D}; + #\u{2B68E}; + #\u{2B68F}; + #\u{2B690}; + #\u{2B691}; + #\u{2B692}; + #\u{2B693}; + #\u{2B694}; + #\u{2B695}; + #\u{2B696}; + #\u{2B697}; + #\u{2B698}; + #\u{2B699}; + #\u{2B69A}; + #\u{2B69B}; + #\u{2B69C}; + #\u{2B69D}; + #\u{2B69E}; + #\u{2B69F}; + #\u{2B6A0}; + #\u{2B6A1}; + #\u{2B6A2}; + #\u{2B6A3}; + #\u{2B6A4}; + #\u{2B6A5}; + #\u{2B6A6}; + #\u{2B6A7}; + #\u{2B6A8}; + #\u{2B6A9}; + #\u{2B6AA}; + #\u{2B6AB}; + #\u{2B6AC}; + #\u{2B6AD}; + #\u{2B6AE}; + #\u{2B6AF}; + #\u{2B6B0}; + #\u{2B6B1}; + #\u{2B6B2}; + #\u{2B6B3}; + #\u{2B6B4}; + #\u{2B6B5}; + #\u{2B6B6}; + #\u{2B6B7}; + #\u{2B6B8}; + #\u{2B6B9}; + #\u{2B6BA}; + #\u{2B6BB}; + #\u{2B6BC}; + #\u{2B6BD}; + #\u{2B6BE}; + #\u{2B6BF}; + #\u{2B6C0}; + #\u{2B6C1}; + #\u{2B6C2}; + #\u{2B6C3}; + #\u{2B6C4}; + #\u{2B6C5}; + #\u{2B6C6}; + #\u{2B6C7}; + #\u{2B6C8}; + #\u{2B6C9}; + #\u{2B6CA}; + #\u{2B6CB}; + #\u{2B6CC}; + #\u{2B6CD}; + #\u{2B6CE}; + #\u{2B6CF}; + #\u{2B6D0}; + #\u{2B6D1}; + #\u{2B6D2}; + #\u{2B6D3}; + #\u{2B6D4}; + #\u{2B6D5}; + #\u{2B6D6}; + #\u{2B6D7}; + #\u{2B6D8}; + #\u{2B6D9}; + #\u{2B6DA}; + #\u{2B6DB}; + #\u{2B6DC}; + #\u{2B6DD}; + #\u{2B6DE}; + #\u{2B6DF}; + #\u{2B6E0}; + #\u{2B6E1}; + #\u{2B6E2}; + #\u{2B6E3}; + #\u{2B6E4}; + #\u{2B6E5}; + #\u{2B6E6}; + #\u{2B6E7}; + #\u{2B6E8}; + #\u{2B6E9}; + #\u{2B6EA}; + #\u{2B6EB}; + #\u{2B6EC}; + #\u{2B6ED}; + #\u{2B6EE}; + #\u{2B6EF}; + #\u{2B6F0}; + #\u{2B6F1}; + #\u{2B6F2}; + #\u{2B6F3}; + #\u{2B6F4}; + #\u{2B6F5}; + #\u{2B6F6}; + #\u{2B6F7}; + #\u{2B6F8}; + #\u{2B6F9}; + #\u{2B6FA}; + #\u{2B6FB}; + #\u{2B6FC}; + #\u{2B6FD}; + #\u{2B6FE}; + #\u{2B6FF}; + #\u{2B700}; + #\u{2B701}; + #\u{2B702}; + #\u{2B703}; + #\u{2B704}; + #\u{2B705}; + #\u{2B706}; + #\u{2B707}; + #\u{2B708}; + #\u{2B709}; + #\u{2B70A}; + #\u{2B70B}; + #\u{2B70C}; + #\u{2B70D}; + #\u{2B70E}; + #\u{2B70F}; + #\u{2B710}; + #\u{2B711}; + #\u{2B712}; + #\u{2B713}; + #\u{2B714}; + #\u{2B715}; + #\u{2B716}; + #\u{2B717}; + #\u{2B718}; + #\u{2B719}; + #\u{2B71A}; + #\u{2B71B}; + #\u{2B71C}; + #\u{2B71D}; + #\u{2B71E}; + #\u{2B71F}; + #\u{2B720}; + #\u{2B721}; + #\u{2B722}; + #\u{2B723}; + #\u{2B724}; + #\u{2B725}; + #\u{2B726}; + #\u{2B727}; + #\u{2B728}; + #\u{2B729}; + #\u{2B72A}; + #\u{2B72B}; + #\u{2B72C}; + #\u{2B72D}; + #\u{2B72E}; + #\u{2B72F}; + #\u{2B730}; + #\u{2B731}; + #\u{2B732}; + #\u{2B733}; + #\u{2B734}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0-class.js new file mode 100644 index 000000000..b30c5feb1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0-class.js @@ -0,0 +1,6108 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v5.2.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #Ԥ; + #ԥ; + #ࠀ; + #ࠁ; + #ࠂ; + #ࠃ; + #ࠄ; + #ࠅ; + #ࠆ; + #ࠇ; + #ࠈ; + #ࠉ; + #ࠊ; + #ࠋ; + #ࠌ; + #ࠍ; + #ࠎ; + #ࠏ; + #ࠐ; + #ࠑ; + #ࠒ; + #ࠓ; + #ࠔ; + #ࠕ; + #ࠚ; + #ࠤ; + #ࠨ; + #ॹ; + #ॺ; + #ᅚ; + #ᅛ; + #ᅜ; + #ᅝ; + #ᅞ; + #ᆣ; + #ᆤ; + #ᆥ; + #ᆦ; + #ᆧ; + #ᇺ; + #ᇻ; + #ᇼ; + #ᇽ; + #ᇾ; + #ᇿ; + #ᙷ; + #ᙸ; + #ᙹ; + #ᙺ; + #ᙻ; + #ᙼ; + #ᙽ; + #ᙾ; + #ᙿ; + #ᢰ; + #ᢱ; + #ᢲ; + #ᢳ; + #ᢴ; + #ᢵ; + #ᢶ; + #ᢷ; + #ᢸ; + #ᢹ; + #ᢺ; + #ᢻ; + #ᢼ; + #ᢽ; + #ᢾ; + #ᢿ; + #ᣀ; + #ᣁ; + #ᣂ; + #ᣃ; + #ᣄ; + #ᣅ; + #ᣆ; + #ᣇ; + #ᣈ; + #ᣉ; + #ᣊ; + #ᣋ; + #ᣌ; + #ᣍ; + #ᣎ; + #ᣏ; + #ᣐ; + #ᣑ; + #ᣒ; + #ᣓ; + #ᣔ; + #ᣕ; + #ᣖ; + #ᣗ; + #ᣘ; + #ᣙ; + #ᣚ; + #ᣛ; + #ᣜ; + #ᣝ; + #ᣞ; + #ᣟ; + #ᣠ; + #ᣡ; + #ᣢ; + #ᣣ; + #ᣤ; + #ᣥ; + #ᣦ; + #ᣧ; + #ᣨ; + #ᣩ; + #ᣪ; + #ᣫ; + #ᣬ; + #ᣭ; + #ᣮ; + #ᣯ; + #ᣰ; + #ᣱ; + #ᣲ; + #ᣳ; + #ᣴ; + #ᣵ; + #ᦪ; + #ᦫ; + #ᨠ; + #ᨡ; + #ᨢ; + #ᨣ; + #ᨤ; + #ᨥ; + #ᨦ; + #ᨧ; + #ᨨ; + #ᨩ; + #ᨪ; + #ᨫ; + #ᨬ; + #ᨭ; + #ᨮ; + #ᨯ; + #ᨰ; + #ᨱ; + #ᨲ; + #ᨳ; + #ᨴ; + #ᨵ; + #ᨶ; + #ᨷ; + #ᨸ; + #ᨹ; + #ᨺ; + #ᨻ; + #ᨼ; + #ᨽ; + #ᨾ; + #ᨿ; + #ᩀ; + #ᩁ; + #ᩂ; + #ᩃ; + #ᩄ; + #ᩅ; + #ᩆ; + #ᩇ; + #ᩈ; + #ᩉ; + #ᩊ; + #ᩋ; + #ᩌ; + #ᩍ; + #ᩎ; + #ᩏ; + #ᩐ; + #ᩑ; + #ᩒ; + #ᩓ; + #ᩔ; + #ᪧ; + #ᳩ; + #ᳪ; + #ᳫ; + #ᳬ; + #ᳮ; + #ᳯ; + #ᳰ; + #ᳱ; + #Ɒ; + #Ȿ; + #Ɀ; + #Ⳬ; + #ⳬ; + #Ⳮ; + #ⳮ; + #鿄; + #鿅; + #鿆; + #鿇; + #鿈; + #鿉; + #鿊; + #鿋; + #ꓐ; + #ꓑ; + #ꓒ; + #ꓓ; + #ꓔ; + #ꓕ; + #ꓖ; + #ꓗ; + #ꓘ; + #ꓙ; + #ꓚ; + #ꓛ; + #ꓜ; + #ꓝ; + #ꓞ; + #ꓟ; + #ꓠ; + #ꓡ; + #ꓢ; + #ꓣ; + #ꓤ; + #ꓥ; + #ꓦ; + #ꓧ; + #ꓨ; + #ꓩ; + #ꓪ; + #ꓫ; + #ꓬ; + #ꓭ; + #ꓮ; + #ꓯ; + #ꓰ; + #ꓱ; + #ꓲ; + #ꓳ; + #ꓴ; + #ꓵ; + #ꓶ; + #ꓷ; + #ꓸ; + #ꓹ; + #ꓺ; + #ꓻ; + #ꓼ; + #ꓽ; + #ꚠ; + #ꚡ; + #ꚢ; + #ꚣ; + #ꚤ; + #ꚥ; + #ꚦ; + #ꚧ; + #ꚨ; + #ꚩ; + #ꚪ; + #ꚫ; + #ꚬ; + #ꚭ; + #ꚮ; + #ꚯ; + #ꚰ; + #ꚱ; + #ꚲ; + #ꚳ; + #ꚴ; + #ꚵ; + #ꚶ; + #ꚷ; + #ꚸ; + #ꚹ; + #ꚺ; + #ꚻ; + #ꚼ; + #ꚽ; + #ꚾ; + #ꚿ; + #ꛀ; + #ꛁ; + #ꛂ; + #ꛃ; + #ꛄ; + #ꛅ; + #ꛆ; + #ꛇ; + #ꛈ; + #ꛉ; + #ꛊ; + #ꛋ; + #ꛌ; + #ꛍ; + #ꛎ; + #ꛏ; + #ꛐ; + #ꛑ; + #ꛒ; + #ꛓ; + #ꛔ; + #ꛕ; + #ꛖ; + #ꛗ; + #ꛘ; + #ꛙ; + #ꛚ; + #ꛛ; + #ꛜ; + #ꛝ; + #ꛞ; + #ꛟ; + #ꛠ; + #ꛡ; + #ꛢ; + #ꛣ; + #ꛤ; + #ꛥ; + #ꛦ; + #ꛧ; + #ꛨ; + #ꛩ; + #ꛪ; + #ꛫ; + #ꛬ; + #ꛭ; + #ꛮ; + #ꛯ; + #ꣲ; + #ꣳ; + #ꣴ; + #ꣵ; + #ꣶ; + #ꣷ; + #ꣻ; + #ꥠ; + #ꥡ; + #ꥢ; + #ꥣ; + #ꥤ; + #ꥥ; + #ꥦ; + #ꥧ; + #ꥨ; + #ꥩ; + #ꥪ; + #ꥫ; + #ꥬ; + #ꥭ; + #ꥮ; + #ꥯ; + #ꥰ; + #ꥱ; + #ꥲ; + #ꥳ; + #ꥴ; + #ꥵ; + #ꥶ; + #ꥷ; + #ꥸ; + #ꥹ; + #ꥺ; + #ꥻ; + #ꥼ; + #ꦄ; + #ꦅ; + #ꦆ; + #ꦇ; + #ꦈ; + #ꦉ; + #ꦊ; + #ꦋ; + #ꦌ; + #ꦍ; + #ꦎ; + #ꦏ; + #ꦐ; + #ꦑ; + #ꦒ; + #ꦓ; + #ꦔ; + #ꦕ; + #ꦖ; + #ꦗ; + #ꦘ; + #ꦙ; + #ꦚ; + #ꦛ; + #ꦜ; + #ꦝ; + #ꦞ; + #ꦟ; + #ꦠ; + #ꦡ; + #ꦢ; + #ꦣ; + #ꦤ; + #ꦥ; + #ꦦ; + #ꦧ; + #ꦨ; + #ꦩ; + #ꦪ; + #ꦫ; + #ꦬ; + #ꦭ; + #ꦮ; + #ꦯ; + #ꦰ; + #ꦱ; + #ꦲ; + #ꧏ; + #ꩠ; + #ꩡ; + #ꩢ; + #ꩣ; + #ꩤ; + #ꩥ; + #ꩦ; + #ꩧ; + #ꩨ; + #ꩩ; + #ꩪ; + #ꩫ; + #ꩬ; + #ꩭ; + #ꩮ; + #ꩯ; + #ꩰ; + #ꩱ; + #ꩲ; + #ꩳ; + #ꩴ; + #ꩵ; + #ꩶ; + #ꩺ; + #ꪀ; + #ꪁ; + #ꪂ; + #ꪃ; + #ꪄ; + #ꪅ; + #ꪆ; + #ꪇ; + #ꪈ; + #ꪉ; + #ꪊ; + #ꪋ; + #ꪌ; + #ꪍ; + #ꪎ; + #ꪏ; + #ꪐ; + #ꪑ; + #ꪒ; + #ꪓ; + #ꪔ; + #ꪕ; + #ꪖ; + #ꪗ; + #ꪘ; + #ꪙ; + #ꪚ; + #ꪛ; + #ꪜ; + #ꪝ; + #ꪞ; + #ꪟ; + #ꪠ; + #ꪡ; + #ꪢ; + #ꪣ; + #ꪤ; + #ꪥ; + #ꪦ; + #ꪧ; + #ꪨ; + #ꪩ; + #ꪪ; + #ꪫ; + #ꪬ; + #ꪭ; + #ꪮ; + #ꪯ; + #ꪱ; + #ꪵ; + #ꪶ; + #ꪹ; + #ꪺ; + #ꪻ; + #ꪼ; + #ꪽ; + #ꫀ; + #ꫂ; + #ꫛ; + #ꫜ; + #ꫝ; + #ꯀ; + #ꯁ; + #ꯂ; + #ꯃ; + #ꯄ; + #ꯅ; + #ꯆ; + #ꯇ; + #ꯈ; + #ꯉ; + #ꯊ; + #ꯋ; + #ꯌ; + #ꯍ; + #ꯎ; + #ꯏ; + #ꯐ; + #ꯑ; + #ꯒ; + #ꯓ; + #ꯔ; + #ꯕ; + #ꯖ; + #ꯗ; + #ꯘ; + #ꯙ; + #ꯚ; + #ꯛ; + #ꯜ; + #ꯝ; + #ꯞ; + #ꯟ; + #ꯠ; + #ꯡ; + #ꯢ; + #ힰ; + #ힱ; + #ힲ; + #ힳ; + #ힴ; + #ힵ; + #ힶ; + #ힷ; + #ힸ; + #ힹ; + #ힺ; + #ힻ; + #ힼ; + #ힽ; + #ힾ; + #ힿ; + #ퟀ; + #ퟁ; + #ퟂ; + #ퟃ; + #ퟄ; + #ퟅ; + #ퟆ; + #ퟋ; + #ퟌ; + #ퟍ; + #ퟎ; + #ퟏ; + #ퟐ; + #ퟑ; + #ퟒ; + #ퟓ; + #ퟔ; + #ퟕ; + #ퟖ; + #ퟗ; + #ퟘ; + #ퟙ; + #ퟚ; + #ퟛ; + #ퟜ; + #ퟝ; + #ퟞ; + #ퟟ; + #ퟠ; + #ퟡ; + #ퟢ; + #ퟣ; + #ퟤ; + #ퟥ; + #ퟦ; + #ퟧ; + #ퟨ; + #ퟩ; + #ퟪ; + #ퟫ; + #ퟬ; + #ퟭ; + #ퟮ; + #ퟯ; + #ퟰ; + #ퟱ; + #ퟲ; + #ퟳ; + #ퟴ; + #ퟵ; + #ퟶ; + #ퟷ; + #ퟸ; + #ퟹ; + #ퟺ; + #ퟻ; + #恵; + #𤋮; + #舘; + #𐡀; + #𐡁; + #𐡂; + #𐡃; + #𐡄; + #𐡅; + #𐡆; + #𐡇; + #𐡈; + #𐡉; + #𐡊; + #𐡋; + #𐡌; + #𐡍; + #𐡎; + #𐡏; + #𐡐; + #𐡑; + #𐡒; + #𐡓; + #𐡔; + #𐡕; + #𐩠; + #𐩡; + #𐩢; + #𐩣; + #𐩤; + #𐩥; + #𐩦; + #𐩧; + #𐩨; + #𐩩; + #𐩪; + #𐩫; + #𐩬; + #𐩭; + #𐩮; + #𐩯; + #𐩰; + #𐩱; + #𐩲; + #𐩳; + #𐩴; + #𐩵; + #𐩶; + #𐩷; + #𐩸; + #𐩹; + #𐩺; + #𐩻; + #𐩼; + #𐬀; + #𐬁; + #𐬂; + #𐬃; + #𐬄; + #𐬅; + #𐬆; + #𐬇; + #𐬈; + #𐬉; + #𐬊; + #𐬋; + #𐬌; + #𐬍; + #𐬎; + #𐬏; + #𐬐; + #𐬑; + #𐬒; + #𐬓; + #𐬔; + #𐬕; + #𐬖; + #𐬗; + #𐬘; + #𐬙; + #𐬚; + #𐬛; + #𐬜; + #𐬝; + #𐬞; + #𐬟; + #𐬠; + #𐬡; + #𐬢; + #𐬣; + #𐬤; + #𐬥; + #𐬦; + #𐬧; + #𐬨; + #𐬩; + #𐬪; + #𐬫; + #𐬬; + #𐬭; + #𐬮; + #𐬯; + #𐬰; + #𐬱; + #𐬲; + #𐬳; + #𐬴; + #𐬵; + #𐭀; + #𐭁; + #𐭂; + #𐭃; + #𐭄; + #𐭅; + #𐭆; + #𐭇; + #𐭈; + #𐭉; + #𐭊; + #𐭋; + #𐭌; + #𐭍; + #𐭎; + #𐭏; + #𐭐; + #𐭑; + #𐭒; + #𐭓; + #𐭔; + #𐭕; + #𐭠; + #𐭡; + #𐭢; + #𐭣; + #𐭤; + #𐭥; + #𐭦; + #𐭧; + #𐭨; + #𐭩; + #𐭪; + #𐭫; + #𐭬; + #𐭭; + #𐭮; + #𐭯; + #𐭰; + #𐭱; + #𐭲; + #𐰀; + #𐰁; + #𐰂; + #𐰃; + #𐰄; + #𐰅; + #𐰆; + #𐰇; + #𐰈; + #𐰉; + #𐰊; + #𐰋; + #𐰌; + #𐰍; + #𐰎; + #𐰏; + #𐰐; + #𐰑; + #𐰒; + #𐰓; + #𐰔; + #𐰕; + #𐰖; + #𐰗; + #𐰘; + #𐰙; + #𐰚; + #𐰛; + #𐰜; + #𐰝; + #𐰞; + #𐰟; + #𐰠; + #𐰡; + #𐰢; + #𐰣; + #𐰤; + #𐰥; + #𐰦; + #𐰧; + #𐰨; + #𐰩; + #𐰪; + #𐰫; + #𐰬; + #𐰭; + #𐰮; + #𐰯; + #𐰰; + #𐰱; + #𐰲; + #𐰳; + #𐰴; + #𐰵; + #𐰶; + #𐰷; + #𐰸; + #𐰹; + #𐰺; + #𐰻; + #𐰼; + #𐰽; + #𐰾; + #𐰿; + #𐱀; + #𐱁; + #𐱂; + #𐱃; + #𐱄; + #𐱅; + #𐱆; + #𐱇; + #𐱈; + #𑂃; + #𑂄; + #𑂅; + #𑂆; + #𑂇; + #𑂈; + #𑂉; + #𑂊; + #𑂋; + #𑂌; + #𑂍; + #𑂎; + #𑂏; + #𑂐; + #𑂑; + #𑂒; + #𑂓; + #𑂔; + #𑂕; + #𑂖; + #𑂗; + #𑂘; + #𑂙; + #𑂚; + #𑂛; + #𑂜; + #𑂝; + #𑂞; + #𑂟; + #𑂠; + #𑂡; + #𑂢; + #𑂣; + #𑂤; + #𑂥; + #𑂦; + #𑂧; + #𑂨; + #𑂩; + #𑂪; + #𑂫; + #𑂬; + #𑂭; + #𑂮; + #𑂯; + #𓀀; + #𓀁; + #𓀂; + #𓀃; + #𓀄; + #𓀅; + #𓀆; + #𓀇; + #𓀈; + #𓀉; + #𓀊; + #𓀋; + #𓀌; + #𓀍; + #𓀎; + #𓀏; + #𓀐; + #𓀑; + #𓀒; + #𓀓; + #𓀔; + #𓀕; + #𓀖; + #𓀗; + #𓀘; + #𓀙; + #𓀚; + #𓀛; + #𓀜; + #𓀝; + #𓀞; + #𓀟; + #𓀠; + #𓀡; + #𓀢; + #𓀣; + #𓀤; + #𓀥; + #𓀦; + #𓀧; + #𓀨; + #𓀩; + #𓀪; + #𓀫; + #𓀬; + #𓀭; + #𓀮; + #𓀯; + #𓀰; + #𓀱; + #𓀲; + #𓀳; + #𓀴; + #𓀵; + #𓀶; + #𓀷; + #𓀸; + #𓀹; + #𓀺; + #𓀻; + #𓀼; + #𓀽; + #𓀾; + #𓀿; + #𓁀; + #𓁁; + #𓁂; + #𓁃; + #𓁄; + #𓁅; + #𓁆; + #𓁇; + #𓁈; + #𓁉; + #𓁊; + #𓁋; + #𓁌; + #𓁍; + #𓁎; + #𓁏; + #𓁐; + #𓁑; + #𓁒; + #𓁓; + #𓁔; + #𓁕; + #𓁖; + #𓁗; + #𓁘; + #𓁙; + #𓁚; + #𓁛; + #𓁜; + #𓁝; + #𓁞; + #𓁟; + #𓁠; + #𓁡; + #𓁢; + #𓁣; + #𓁤; + #𓁥; + #𓁦; + #𓁧; + #𓁨; + #𓁩; + #𓁪; + #𓁫; + #𓁬; + #𓁭; + #𓁮; + #𓁯; + #𓁰; + #𓁱; + #𓁲; + #𓁳; + #𓁴; + #𓁵; + #𓁶; + #𓁷; + #𓁸; + #𓁹; + #𓁺; + #𓁻; + #𓁼; + #𓁽; + #𓁾; + #𓁿; + #𓂀; + #𓂁; + #𓂂; + #𓂃; + #𓂄; + #𓂅; + #𓂆; + #𓂇; + #𓂈; + #𓂉; + #𓂊; + #𓂋; + #𓂌; + #𓂍; + #𓂎; + #𓂏; + #𓂐; + #𓂑; + #𓂒; + #𓂓; + #𓂔; + #𓂕; + #𓂖; + #𓂗; + #𓂘; + #𓂙; + #𓂚; + #𓂛; + #𓂜; + #𓂝; + #𓂞; + #𓂟; + #𓂠; + #𓂡; + #𓂢; + #𓂣; + #𓂤; + #𓂥; + #𓂦; + #𓂧; + #𓂨; + #𓂩; + #𓂪; + #𓂫; + #𓂬; + #𓂭; + #𓂮; + #𓂯; + #𓂰; + #𓂱; + #𓂲; + #𓂳; + #𓂴; + #𓂵; + #𓂶; + #𓂷; + #𓂸; + #𓂹; + #𓂺; + #𓂻; + #𓂼; + #𓂽; + #𓂾; + #𓂿; + #𓃀; + #𓃁; + #𓃂; + #𓃃; + #𓃄; + #𓃅; + #𓃆; + #𓃇; + #𓃈; + #𓃉; + #𓃊; + #𓃋; + #𓃌; + #𓃍; + #𓃎; + #𓃏; + #𓃐; + #𓃑; + #𓃒; + #𓃓; + #𓃔; + #𓃕; + #𓃖; + #𓃗; + #𓃘; + #𓃙; + #𓃚; + #𓃛; + #𓃜; + #𓃝; + #𓃞; + #𓃟; + #𓃠; + #𓃡; + #𓃢; + #𓃣; + #𓃤; + #𓃥; + #𓃦; + #𓃧; + #𓃨; + #𓃩; + #𓃪; + #𓃫; + #𓃬; + #𓃭; + #𓃮; + #𓃯; + #𓃰; + #𓃱; + #𓃲; + #𓃳; + #𓃴; + #𓃵; + #𓃶; + #𓃷; + #𓃸; + #𓃹; + #𓃺; + #𓃻; + #𓃼; + #𓃽; + #𓃾; + #𓃿; + #𓄀; + #𓄁; + #𓄂; + #𓄃; + #𓄄; + #𓄅; + #𓄆; + #𓄇; + #𓄈; + #𓄉; + #𓄊; + #𓄋; + #𓄌; + #𓄍; + #𓄎; + #𓄏; + #𓄐; + #𓄑; + #𓄒; + #𓄓; + #𓄔; + #𓄕; + #𓄖; + #𓄗; + #𓄘; + #𓄙; + #𓄚; + #𓄛; + #𓄜; + #𓄝; + #𓄞; + #𓄟; + #𓄠; + #𓄡; + #𓄢; + #𓄣; + #𓄤; + #𓄥; + #𓄦; + #𓄧; + #𓄨; + #𓄩; + #𓄪; + #𓄫; + #𓄬; + #𓄭; + #𓄮; + #𓄯; + #𓄰; + #𓄱; + #𓄲; + #𓄳; + #𓄴; + #𓄵; + #𓄶; + #𓄷; + #𓄸; + #𓄹; + #𓄺; + #𓄻; + #𓄼; + #𓄽; + #𓄾; + #𓄿; + #𓅀; + #𓅁; + #𓅂; + #𓅃; + #𓅄; + #𓅅; + #𓅆; + #𓅇; + #𓅈; + #𓅉; + #𓅊; + #𓅋; + #𓅌; + #𓅍; + #𓅎; + #𓅏; + #𓅐; + #𓅑; + #𓅒; + #𓅓; + #𓅔; + #𓅕; + #𓅖; + #𓅗; + #𓅘; + #𓅙; + #𓅚; + #𓅛; + #𓅜; + #𓅝; + #𓅞; + #𓅟; + #𓅠; + #𓅡; + #𓅢; + #𓅣; + #𓅤; + #𓅥; + #𓅦; + #𓅧; + #𓅨; + #𓅩; + #𓅪; + #𓅫; + #𓅬; + #𓅭; + #𓅮; + #𓅯; + #𓅰; + #𓅱; + #𓅲; + #𓅳; + #𓅴; + #𓅵; + #𓅶; + #𓅷; + #𓅸; + #𓅹; + #𓅺; + #𓅻; + #𓅼; + #𓅽; + #𓅾; + #𓅿; + #𓆀; + #𓆁; + #𓆂; + #𓆃; + #𓆄; + #𓆅; + #𓆆; + #𓆇; + #𓆈; + #𓆉; + #𓆊; + #𓆋; + #𓆌; + #𓆍; + #𓆎; + #𓆏; + #𓆐; + #𓆑; + #𓆒; + #𓆓; + #𓆔; + #𓆕; + #𓆖; + #𓆗; + #𓆘; + #𓆙; + #𓆚; + #𓆛; + #𓆜; + #𓆝; + #𓆞; + #𓆟; + #𓆠; + #𓆡; + #𓆢; + #𓆣; + #𓆤; + #𓆥; + #𓆦; + #𓆧; + #𓆨; + #𓆩; + #𓆪; + #𓆫; + #𓆬; + #𓆭; + #𓆮; + #𓆯; + #𓆰; + #𓆱; + #𓆲; + #𓆳; + #𓆴; + #𓆵; + #𓆶; + #𓆷; + #𓆸; + #𓆹; + #𓆺; + #𓆻; + #𓆼; + #𓆽; + #𓆾; + #𓆿; + #𓇀; + #𓇁; + #𓇂; + #𓇃; + #𓇄; + #𓇅; + #𓇆; + #𓇇; + #𓇈; + #𓇉; + #𓇊; + #𓇋; + #𓇌; + #𓇍; + #𓇎; + #𓇏; + #𓇐; + #𓇑; + #𓇒; + #𓇓; + #𓇔; + #𓇕; + #𓇖; + #𓇗; + #𓇘; + #𓇙; + #𓇚; + #𓇛; + #𓇜; + #𓇝; + #𓇞; + #𓇟; + #𓇠; + #𓇡; + #𓇢; + #𓇣; + #𓇤; + #𓇥; + #𓇦; + #𓇧; + #𓇨; + #𓇩; + #𓇪; + #𓇫; + #𓇬; + #𓇭; + #𓇮; + #𓇯; + #𓇰; + #𓇱; + #𓇲; + #𓇳; + #𓇴; + #𓇵; + #𓇶; + #𓇷; + #𓇸; + #𓇹; + #𓇺; + #𓇻; + #𓇼; + #𓇽; + #𓇾; + #𓇿; + #𓈀; + #𓈁; + #𓈂; + #𓈃; + #𓈄; + #𓈅; + #𓈆; + #𓈇; + #𓈈; + #𓈉; + #𓈊; + #𓈋; + #𓈌; + #𓈍; + #𓈎; + #𓈏; + #𓈐; + #𓈑; + #𓈒; + #𓈓; + #𓈔; + #𓈕; + #𓈖; + #𓈗; + #𓈘; + #𓈙; + #𓈚; + #𓈛; + #𓈜; + #𓈝; + #𓈞; + #𓈟; + #𓈠; + #𓈡; + #𓈢; + #𓈣; + #𓈤; + #𓈥; + #𓈦; + #𓈧; + #𓈨; + #𓈩; + #𓈪; + #𓈫; + #𓈬; + #𓈭; + #𓈮; + #𓈯; + #𓈰; + #𓈱; + #𓈲; + #𓈳; + #𓈴; + #𓈵; + #𓈶; + #𓈷; + #𓈸; + #𓈹; + #𓈺; + #𓈻; + #𓈼; + #𓈽; + #𓈾; + #𓈿; + #𓉀; + #𓉁; + #𓉂; + #𓉃; + #𓉄; + #𓉅; + #𓉆; + #𓉇; + #𓉈; + #𓉉; + #𓉊; + #𓉋; + #𓉌; + #𓉍; + #𓉎; + #𓉏; + #𓉐; + #𓉑; + #𓉒; + #𓉓; + #𓉔; + #𓉕; + #𓉖; + #𓉗; + #𓉘; + #𓉙; + #𓉚; + #𓉛; + #𓉜; + #𓉝; + #𓉞; + #𓉟; + #𓉠; + #𓉡; + #𓉢; + #𓉣; + #𓉤; + #𓉥; + #𓉦; + #𓉧; + #𓉨; + #𓉩; + #𓉪; + #𓉫; + #𓉬; + #𓉭; + #𓉮; + #𓉯; + #𓉰; + #𓉱; + #𓉲; + #𓉳; + #𓉴; + #𓉵; + #𓉶; + #𓉷; + #𓉸; + #𓉹; + #𓉺; + #𓉻; + #𓉼; + #𓉽; + #𓉾; + #𓉿; + #𓊀; + #𓊁; + #𓊂; + #𓊃; + #𓊄; + #𓊅; + #𓊆; + #𓊇; + #𓊈; + #𓊉; + #𓊊; + #𓊋; + #𓊌; + #𓊍; + #𓊎; + #𓊏; + #𓊐; + #𓊑; + #𓊒; + #𓊓; + #𓊔; + #𓊕; + #𓊖; + #𓊗; + #𓊘; + #𓊙; + #𓊚; + #𓊛; + #𓊜; + #𓊝; + #𓊞; + #𓊟; + #𓊠; + #𓊡; + #𓊢; + #𓊣; + #𓊤; + #𓊥; + #𓊦; + #𓊧; + #𓊨; + #𓊩; + #𓊪; + #𓊫; + #𓊬; + #𓊭; + #𓊮; + #𓊯; + #𓊰; + #𓊱; + #𓊲; + #𓊳; + #𓊴; + #𓊵; + #𓊶; + #𓊷; + #𓊸; + #𓊹; + #𓊺; + #𓊻; + #𓊼; + #𓊽; + #𓊾; + #𓊿; + #𓋀; + #𓋁; + #𓋂; + #𓋃; + #𓋄; + #𓋅; + #𓋆; + #𓋇; + #𓋈; + #𓋉; + #𓋊; + #𓋋; + #𓋌; + #𓋍; + #𓋎; + #𓋏; + #𓋐; + #𓋑; + #𓋒; + #𓋓; + #𓋔; + #𓋕; + #𓋖; + #𓋗; + #𓋘; + #𓋙; + #𓋚; + #𓋛; + #𓋜; + #𓋝; + #𓋞; + #𓋟; + #𓋠; + #𓋡; + #𓋢; + #𓋣; + #𓋤; + #𓋥; + #𓋦; + #𓋧; + #𓋨; + #𓋩; + #𓋪; + #𓋫; + #𓋬; + #𓋭; + #𓋮; + #𓋯; + #𓋰; + #𓋱; + #𓋲; + #𓋳; + #𓋴; + #𓋵; + #𓋶; + #𓋷; + #𓋸; + #𓋹; + #𓋺; + #𓋻; + #𓋼; + #𓋽; + #𓋾; + #𓋿; + #𓌀; + #𓌁; + #𓌂; + #𓌃; + #𓌄; + #𓌅; + #𓌆; + #𓌇; + #𓌈; + #𓌉; + #𓌊; + #𓌋; + #𓌌; + #𓌍; + #𓌎; + #𓌏; + #𓌐; + #𓌑; + #𓌒; + #𓌓; + #𓌔; + #𓌕; + #𓌖; + #𓌗; + #𓌘; + #𓌙; + #𓌚; + #𓌛; + #𓌜; + #𓌝; + #𓌞; + #𓌟; + #𓌠; + #𓌡; + #𓌢; + #𓌣; + #𓌤; + #𓌥; + #𓌦; + #𓌧; + #𓌨; + #𓌩; + #𓌪; + #𓌫; + #𓌬; + #𓌭; + #𓌮; + #𓌯; + #𓌰; + #𓌱; + #𓌲; + #𓌳; + #𓌴; + #𓌵; + #𓌶; + #𓌷; + #𓌸; + #𓌹; + #𓌺; + #𓌻; + #𓌼; + #𓌽; + #𓌾; + #𓌿; + #𓍀; + #𓍁; + #𓍂; + #𓍃; + #𓍄; + #𓍅; + #𓍆; + #𓍇; + #𓍈; + #𓍉; + #𓍊; + #𓍋; + #𓍌; + #𓍍; + #𓍎; + #𓍏; + #𓍐; + #𓍑; + #𓍒; + #𓍓; + #𓍔; + #𓍕; + #𓍖; + #𓍗; + #𓍘; + #𓍙; + #𓍚; + #𓍛; + #𓍜; + #𓍝; + #𓍞; + #𓍟; + #𓍠; + #𓍡; + #𓍢; + #𓍣; + #𓍤; + #𓍥; + #𓍦; + #𓍧; + #𓍨; + #𓍩; + #𓍪; + #𓍫; + #𓍬; + #𓍭; + #𓍮; + #𓍯; + #𓍰; + #𓍱; + #𓍲; + #𓍳; + #𓍴; + #𓍵; + #𓍶; + #𓍷; + #𓍸; + #𓍹; + #𓍺; + #𓍻; + #𓍼; + #𓍽; + #𓍾; + #𓍿; + #𓎀; + #𓎁; + #𓎂; + #𓎃; + #𓎄; + #𓎅; + #𓎆; + #𓎇; + #𓎈; + #𓎉; + #𓎊; + #𓎋; + #𓎌; + #𓎍; + #𓎎; + #𓎏; + #𓎐; + #𓎑; + #𓎒; + #𓎓; + #𓎔; + #𓎕; + #𓎖; + #𓎗; + #𓎘; + #𓎙; + #𓎚; + #𓎛; + #𓎜; + #𓎝; + #𓎞; + #𓎟; + #𓎠; + #𓎡; + #𓎢; + #𓎣; + #𓎤; + #𓎥; + #𓎦; + #𓎧; + #𓎨; + #𓎩; + #𓎪; + #𓎫; + #𓎬; + #𓎭; + #𓎮; + #𓎯; + #𓎰; + #𓎱; + #𓎲; + #𓎳; + #𓎴; + #𓎵; + #𓎶; + #𓎷; + #𓎸; + #𓎹; + #𓎺; + #𓎻; + #𓎼; + #𓎽; + #𓎾; + #𓎿; + #𓏀; + #𓏁; + #𓏂; + #𓏃; + #𓏄; + #𓏅; + #𓏆; + #𓏇; + #𓏈; + #𓏉; + #𓏊; + #𓏋; + #𓏌; + #𓏍; + #𓏎; + #𓏏; + #𓏐; + #𓏑; + #𓏒; + #𓏓; + #𓏔; + #𓏕; + #𓏖; + #𓏗; + #𓏘; + #𓏙; + #𓏚; + #𓏛; + #𓏜; + #𓏝; + #𓏞; + #𓏟; + #𓏠; + #𓏡; + #𓏢; + #𓏣; + #𓏤; + #𓏥; + #𓏦; + #𓏧; + #𓏨; + #𓏩; + #𓏪; + #𓏫; + #𓏬; + #𓏭; + #𓏮; + #𓏯; + #𓏰; + #𓏱; + #𓏲; + #𓏳; + #𓏴; + #𓏵; + #𓏶; + #𓏷; + #𓏸; + #𓏹; + #𓏺; + #𓏻; + #𓏼; + #𓏽; + #𓏾; + #𓏿; + #𓐀; + #𓐁; + #𓐂; + #𓐃; + #𓐄; + #𓐅; + #𓐆; + #𓐇; + #𓐈; + #𓐉; + #𓐊; + #𓐋; + #𓐌; + #𓐍; + #𓐎; + #𓐏; + #𓐐; + #𓐑; + #𓐒; + #𓐓; + #𓐔; + #𓐕; + #𓐖; + #𓐗; + #𓐘; + #𓐙; + #𓐚; + #𓐛; + #𓐜; + #𓐝; + #𓐞; + #𓐟; + #𓐠; + #𓐡; + #𓐢; + #𓐣; + #𓐤; + #𓐥; + #𓐦; + #𓐧; + #𓐨; + #𓐩; + #𓐪; + #𓐫; + #𓐬; + #𓐭; + #𓐮; + #𪜀; + #𪜁; + #𪜂; + #𪜃; + #𪜄; + #𪜅; + #𪜆; + #𪜇; + #𪜈; + #𪜉; + #𪜊; + #𪜋; + #𪜌; + #𪜍; + #𪜎; + #𪜏; + #𪜐; + #𪜑; + #𪜒; + #𪜓; + #𪜔; + #𪜕; + #𪜖; + #𪜗; + #𪜘; + #𪜙; + #𪜚; + #𪜛; + #𪜜; + #𪜝; + #𪜞; + #𪜟; + #𪜠; + #𪜡; + #𪜢; + #𪜣; + #𪜤; + #𪜥; + #𪜦; + #𪜧; + #𪜨; + #𪜩; + #𪜪; + #𪜫; + #𪜬; + #𪜭; + #𪜮; + #𪜯; + #𪜰; + #𪜱; + #𪜲; + #𪜳; + #𪜴; + #𪜵; + #𪜶; + #𪜷; + #𪜸; + #𪜹; + #𪜺; + #𪜻; + #𪜼; + #𪜽; + #𪜾; + #𪜿; + #𪝀; + #𪝁; + #𪝂; + #𪝃; + #𪝄; + #𪝅; + #𪝆; + #𪝇; + #𪝈; + #𪝉; + #𪝊; + #𪝋; + #𪝌; + #𪝍; + #𪝎; + #𪝏; + #𪝐; + #𪝑; + #𪝒; + #𪝓; + #𪝔; + #𪝕; + #𪝖; + #𪝗; + #𪝘; + #𪝙; + #𪝚; + #𪝛; + #𪝜; + #𪝝; + #𪝞; + #𪝟; + #𪝠; + #𪝡; + #𪝢; + #𪝣; + #𪝤; + #𪝥; + #𪝦; + #𪝧; + #𪝨; + #𪝩; + #𪝪; + #𪝫; + #𪝬; + #𪝭; + #𪝮; + #𪝯; + #𪝰; + #𪝱; + #𪝲; + #𪝳; + #𪝴; + #𪝵; + #𪝶; + #𪝷; + #𪝸; + #𪝹; + #𪝺; + #𪝻; + #𪝼; + #𪝽; + #𪝾; + #𪝿; + #𪞀; + #𪞁; + #𪞂; + #𪞃; + #𪞄; + #𪞅; + #𪞆; + #𪞇; + #𪞈; + #𪞉; + #𪞊; + #𪞋; + #𪞌; + #𪞍; + #𪞎; + #𪞏; + #𪞐; + #𪞑; + #𪞒; + #𪞓; + #𪞔; + #𪞕; + #𪞖; + #𪞗; + #𪞘; + #𪞙; + #𪞚; + #𪞛; + #𪞜; + #𪞝; + #𪞞; + #𪞟; + #𪞠; + #𪞡; + #𪞢; + #𪞣; + #𪞤; + #𪞥; + #𪞦; + #𪞧; + #𪞨; + #𪞩; + #𪞪; + #𪞫; + #𪞬; + #𪞭; + #𪞮; + #𪞯; + #𪞰; + #𪞱; + #𪞲; + #𪞳; + #𪞴; + #𪞵; + #𪞶; + #𪞷; + #𪞸; + #𪞹; + #𪞺; + #𪞻; + #𪞼; + #𪞽; + #𪞾; + #𪞿; + #𪟀; + #𪟁; + #𪟂; + #𪟃; + #𪟄; + #𪟅; + #𪟆; + #𪟇; + #𪟈; + #𪟉; + #𪟊; + #𪟋; + #𪟌; + #𪟍; + #𪟎; + #𪟏; + #𪟐; + #𪟑; + #𪟒; + #𪟓; + #𪟔; + #𪟕; + #𪟖; + #𪟗; + #𪟘; + #𪟙; + #𪟚; + #𪟛; + #𪟜; + #𪟝; + #𪟞; + #𪟟; + #𪟠; + #𪟡; + #𪟢; + #𪟣; + #𪟤; + #𪟥; + #𪟦; + #𪟧; + #𪟨; + #𪟩; + #𪟪; + #𪟫; + #𪟬; + #𪟭; + #𪟮; + #𪟯; + #𪟰; + #𪟱; + #𪟲; + #𪟳; + #𪟴; + #𪟵; + #𪟶; + #𪟷; + #𪟸; + #𪟹; + #𪟺; + #𪟻; + #𪟼; + #𪟽; + #𪟾; + #𪟿; + #𪠀; + #𪠁; + #𪠂; + #𪠃; + #𪠄; + #𪠅; + #𪠆; + #𪠇; + #𪠈; + #𪠉; + #𪠊; + #𪠋; + #𪠌; + #𪠍; + #𪠎; + #𪠏; + #𪠐; + #𪠑; + #𪠒; + #𪠓; + #𪠔; + #𪠕; + #𪠖; + #𪠗; + #𪠘; + #𪠙; + #𪠚; + #𪠛; + #𪠜; + #𪠝; + #𪠞; + #𪠟; + #𪠠; + #𪠡; + #𪠢; + #𪠣; + #𪠤; + #𪠥; + #𪠦; + #𪠧; + #𪠨; + #𪠩; + #𪠪; + #𪠫; + #𪠬; + #𪠭; + #𪠮; + #𪠯; + #𪠰; + #𪠱; + #𪠲; + #𪠳; + #𪠴; + #𪠵; + #𪠶; + #𪠷; + #𪠸; + #𪠹; + #𪠺; + #𪠻; + #𪠼; + #𪠽; + #𪠾; + #𪠿; + #𪡀; + #𪡁; + #𪡂; + #𪡃; + #𪡄; + #𪡅; + #𪡆; + #𪡇; + #𪡈; + #𪡉; + #𪡊; + #𪡋; + #𪡌; + #𪡍; + #𪡎; + #𪡏; + #𪡐; + #𪡑; + #𪡒; + #𪡓; + #𪡔; + #𪡕; + #𪡖; + #𪡗; + #𪡘; + #𪡙; + #𪡚; + #𪡛; + #𪡜; + #𪡝; + #𪡞; + #𪡟; + #𪡠; + #𪡡; + #𪡢; + #𪡣; + #𪡤; + #𪡥; + #𪡦; + #𪡧; + #𪡨; + #𪡩; + #𪡪; + #𪡫; + #𪡬; + #𪡭; + #𪡮; + #𪡯; + #𪡰; + #𪡱; + #𪡲; + #𪡳; + #𪡴; + #𪡵; + #𪡶; + #𪡷; + #𪡸; + #𪡹; + #𪡺; + #𪡻; + #𪡼; + #𪡽; + #𪡾; + #𪡿; + #𪢀; + #𪢁; + #𪢂; + #𪢃; + #𪢄; + #𪢅; + #𪢆; + #𪢇; + #𪢈; + #𪢉; + #𪢊; + #𪢋; + #𪢌; + #𪢍; + #𪢎; + #𪢏; + #𪢐; + #𪢑; + #𪢒; + #𪢓; + #𪢔; + #𪢕; + #𪢖; + #𪢗; + #𪢘; + #𪢙; + #𪢚; + #𪢛; + #𪢜; + #𪢝; + #𪢞; + #𪢟; + #𪢠; + #𪢡; + #𪢢; + #𪢣; + #𪢤; + #𪢥; + #𪢦; + #𪢧; + #𪢨; + #𪢩; + #𪢪; + #𪢫; + #𪢬; + #𪢭; + #𪢮; + #𪢯; + #𪢰; + #𪢱; + #𪢲; + #𪢳; + #𪢴; + #𪢵; + #𪢶; + #𪢷; + #𪢸; + #𪢹; + #𪢺; + #𪢻; + #𪢼; + #𪢽; + #𪢾; + #𪢿; + #𪣀; + #𪣁; + #𪣂; + #𪣃; + #𪣄; + #𪣅; + #𪣆; + #𪣇; + #𪣈; + #𪣉; + #𪣊; + #𪣋; + #𪣌; + #𪣍; + #𪣎; + #𪣏; + #𪣐; + #𪣑; + #𪣒; + #𪣓; + #𪣔; + #𪣕; + #𪣖; + #𪣗; + #𪣘; + #𪣙; + #𪣚; + #𪣛; + #𪣜; + #𪣝; + #𪣞; + #𪣟; + #𪣠; + #𪣡; + #𪣢; + #𪣣; + #𪣤; + #𪣥; + #𪣦; + #𪣧; + #𪣨; + #𪣩; + #𪣪; + #𪣫; + #𪣬; + #𪣭; + #𪣮; + #𪣯; + #𪣰; + #𪣱; + #𪣲; + #𪣳; + #𪣴; + #𪣵; + #𪣶; + #𪣷; + #𪣸; + #𪣹; + #𪣺; + #𪣻; + #𪣼; + #𪣽; + #𪣾; + #𪣿; + #𪤀; + #𪤁; + #𪤂; + #𪤃; + #𪤄; + #𪤅; + #𪤆; + #𪤇; + #𪤈; + #𪤉; + #𪤊; + #𪤋; + #𪤌; + #𪤍; + #𪤎; + #𪤏; + #𪤐; + #𪤑; + #𪤒; + #𪤓; + #𪤔; + #𪤕; + #𪤖; + #𪤗; + #𪤘; + #𪤙; + #𪤚; + #𪤛; + #𪤜; + #𪤝; + #𪤞; + #𪤟; + #𪤠; + #𪤡; + #𪤢; + #𪤣; + #𪤤; + #𪤥; + #𪤦; + #𪤧; + #𪤨; + #𪤩; + #𪤪; + #𪤫; + #𪤬; + #𪤭; + #𪤮; + #𪤯; + #𪤰; + #𪤱; + #𪤲; + #𪤳; + #𪤴; + #𪤵; + #𪤶; + #𪤷; + #𪤸; + #𪤹; + #𪤺; + #𪤻; + #𪤼; + #𪤽; + #𪤾; + #𪤿; + #𪥀; + #𪥁; + #𪥂; + #𪥃; + #𪥄; + #𪥅; + #𪥆; + #𪥇; + #𪥈; + #𪥉; + #𪥊; + #𪥋; + #𪥌; + #𪥍; + #𪥎; + #𪥏; + #𪥐; + #𪥑; + #𪥒; + #𪥓; + #𪥔; + #𪥕; + #𪥖; + #𪥗; + #𪥘; + #𪥙; + #𪥚; + #𪥛; + #𪥜; + #𪥝; + #𪥞; + #𪥟; + #𪥠; + #𪥡; + #𪥢; + #𪥣; + #𪥤; + #𪥥; + #𪥦; + #𪥧; + #𪥨; + #𪥩; + #𪥪; + #𪥫; + #𪥬; + #𪥭; + #𪥮; + #𪥯; + #𪥰; + #𪥱; + #𪥲; + #𪥳; + #𪥴; + #𪥵; + #𪥶; + #𪥷; + #𪥸; + #𪥹; + #𪥺; + #𪥻; + #𪥼; + #𪥽; + #𪥾; + #𪥿; + #𪦀; + #𪦁; + #𪦂; + #𪦃; + #𪦄; + #𪦅; + #𪦆; + #𪦇; + #𪦈; + #𪦉; + #𪦊; + #𪦋; + #𪦌; + #𪦍; + #𪦎; + #𪦏; + #𪦐; + #𪦑; + #𪦒; + #𪦓; + #𪦔; + #𪦕; + #𪦖; + #𪦗; + #𪦘; + #𪦙; + #𪦚; + #𪦛; + #𪦜; + #𪦝; + #𪦞; + #𪦟; + #𪦠; + #𪦡; + #𪦢; + #𪦣; + #𪦤; + #𪦥; + #𪦦; + #𪦧; + #𪦨; + #𪦩; + #𪦪; + #𪦫; + #𪦬; + #𪦭; + #𪦮; + #𪦯; + #𪦰; + #𪦱; + #𪦲; + #𪦳; + #𪦴; + #𪦵; + #𪦶; + #𪦷; + #𪦸; + #𪦹; + #𪦺; + #𪦻; + #𪦼; + #𪦽; + #𪦾; + #𪦿; + #𪧀; + #𪧁; + #𪧂; + #𪧃; + #𪧄; + #𪧅; + #𪧆; + #𪧇; + #𪧈; + #𪧉; + #𪧊; + #𪧋; + #𪧌; + #𪧍; + #𪧎; + #𪧏; + #𪧐; + #𪧑; + #𪧒; + #𪧓; + #𪧔; + #𪧕; + #𪧖; + #𪧗; + #𪧘; + #𪧙; + #𪧚; + #𪧛; + #𪧜; + #𪧝; + #𪧞; + #𪧟; + #𪧠; + #𪧡; + #𪧢; + #𪧣; + #𪧤; + #𪧥; + #𪧦; + #𪧧; + #𪧨; + #𪧩; + #𪧪; + #𪧫; + #𪧬; + #𪧭; + #𪧮; + #𪧯; + #𪧰; + #𪧱; + #𪧲; + #𪧳; + #𪧴; + #𪧵; + #𪧶; + #𪧷; + #𪧸; + #𪧹; + #𪧺; + #𪧻; + #𪧼; + #𪧽; + #𪧾; + #𪧿; + #𪨀; + #𪨁; + #𪨂; + #𪨃; + #𪨄; + #𪨅; + #𪨆; + #𪨇; + #𪨈; + #𪨉; + #𪨊; + #𪨋; + #𪨌; + #𪨍; + #𪨎; + #𪨏; + #𪨐; + #𪨑; + #𪨒; + #𪨓; + #𪨔; + #𪨕; + #𪨖; + #𪨗; + #𪨘; + #𪨙; + #𪨚; + #𪨛; + #𪨜; + #𪨝; + #𪨞; + #𪨟; + #𪨠; + #𪨡; + #𪨢; + #𪨣; + #𪨤; + #𪨥; + #𪨦; + #𪨧; + #𪨨; + #𪨩; + #𪨪; + #𪨫; + #𪨬; + #𪨭; + #𪨮; + #𪨯; + #𪨰; + #𪨱; + #𪨲; + #𪨳; + #𪨴; + #𪨵; + #𪨶; + #𪨷; + #𪨸; + #𪨹; + #𪨺; + #𪨻; + #𪨼; + #𪨽; + #𪨾; + #𪨿; + #𪩀; + #𪩁; + #𪩂; + #𪩃; + #𪩄; + #𪩅; + #𪩆; + #𪩇; + #𪩈; + #𪩉; + #𪩊; + #𪩋; + #𪩌; + #𪩍; + #𪩎; + #𪩏; + #𪩐; + #𪩑; + #𪩒; + #𪩓; + #𪩔; + #𪩕; + #𪩖; + #𪩗; + #𪩘; + #𪩙; + #𪩚; + #𪩛; + #𪩜; + #𪩝; + #𪩞; + #𪩟; + #𪩠; + #𪩡; + #𪩢; + #𪩣; + #𪩤; + #𪩥; + #𪩦; + #𪩧; + #𪩨; + #𪩩; + #𪩪; + #𪩫; + #𪩬; + #𪩭; + #𪩮; + #𪩯; + #𪩰; + #𪩱; + #𪩲; + #𪩳; + #𪩴; + #𪩵; + #𪩶; + #𪩷; + #𪩸; + #𪩹; + #𪩺; + #𪩻; + #𪩼; + #𪩽; + #𪩾; + #𪩿; + #𪪀; + #𪪁; + #𪪂; + #𪪃; + #𪪄; + #𪪅; + #𪪆; + #𪪇; + #𪪈; + #𪪉; + #𪪊; + #𪪋; + #𪪌; + #𪪍; + #𪪎; + #𪪏; + #𪪐; + #𪪑; + #𪪒; + #𪪓; + #𪪔; + #𪪕; + #𪪖; + #𪪗; + #𪪘; + #𪪙; + #𪪚; + #𪪛; + #𪪜; + #𪪝; + #𪪞; + #𪪟; + #𪪠; + #𪪡; + #𪪢; + #𪪣; + #𪪤; + #𪪥; + #𪪦; + #𪪧; + #𪪨; + #𪪩; + #𪪪; + #𪪫; + #𪪬; + #𪪭; + #𪪮; + #𪪯; + #𪪰; + #𪪱; + #𪪲; + #𪪳; + #𪪴; + #𪪵; + #𪪶; + #𪪷; + #𪪸; + #𪪹; + #𪪺; + #𪪻; + #𪪼; + #𪪽; + #𪪾; + #𪪿; + #𪫀; + #𪫁; + #𪫂; + #𪫃; + #𪫄; + #𪫅; + #𪫆; + #𪫇; + #𪫈; + #𪫉; + #𪫊; + #𪫋; + #𪫌; + #𪫍; + #𪫎; + #𪫏; + #𪫐; + #𪫑; + #𪫒; + #𪫓; + #𪫔; + #𪫕; + #𪫖; + #𪫗; + #𪫘; + #𪫙; + #𪫚; + #𪫛; + #𪫜; + #𪫝; + #𪫞; + #𪫟; + #𪫠; + #𪫡; + #𪫢; + #𪫣; + #𪫤; + #𪫥; + #𪫦; + #𪫧; + #𪫨; + #𪫩; + #𪫪; + #𪫫; + #𪫬; + #𪫭; + #𪫮; + #𪫯; + #𪫰; + #𪫱; + #𪫲; + #𪫳; + #𪫴; + #𪫵; + #𪫶; + #𪫷; + #𪫸; + #𪫹; + #𪫺; + #𪫻; + #𪫼; + #𪫽; + #𪫾; + #𪫿; + #𪬀; + #𪬁; + #𪬂; + #𪬃; + #𪬄; + #𪬅; + #𪬆; + #𪬇; + #𪬈; + #𪬉; + #𪬊; + #𪬋; + #𪬌; + #𪬍; + #𪬎; + #𪬏; + #𪬐; + #𪬑; + #𪬒; + #𪬓; + #𪬔; + #𪬕; + #𪬖; + #𪬗; + #𪬘; + #𪬙; + #𪬚; + #𪬛; + #𪬜; + #𪬝; + #𪬞; + #𪬟; + #𪬠; + #𪬡; + #𪬢; + #𪬣; + #𪬤; + #𪬥; + #𪬦; + #𪬧; + #𪬨; + #𪬩; + #𪬪; + #𪬫; + #𪬬; + #𪬭; + #𪬮; + #𪬯; + #𪬰; + #𪬱; + #𪬲; + #𪬳; + #𪬴; + #𪬵; + #𪬶; + #𪬷; + #𪬸; + #𪬹; + #𪬺; + #𪬻; + #𪬼; + #𪬽; + #𪬾; + #𪬿; + #𪭀; + #𪭁; + #𪭂; + #𪭃; + #𪭄; + #𪭅; + #𪭆; + #𪭇; + #𪭈; + #𪭉; + #𪭊; + #𪭋; + #𪭌; + #𪭍; + #𪭎; + #𪭏; + #𪭐; + #𪭑; + #𪭒; + #𪭓; + #𪭔; + #𪭕; + #𪭖; + #𪭗; + #𪭘; + #𪭙; + #𪭚; + #𪭛; + #𪭜; + #𪭝; + #𪭞; + #𪭟; + #𪭠; + #𪭡; + #𪭢; + #𪭣; + #𪭤; + #𪭥; + #𪭦; + #𪭧; + #𪭨; + #𪭩; + #𪭪; + #𪭫; + #𪭬; + #𪭭; + #𪭮; + #𪭯; + #𪭰; + #𪭱; + #𪭲; + #𪭳; + #𪭴; + #𪭵; + #𪭶; + #𪭷; + #𪭸; + #𪭹; + #𪭺; + #𪭻; + #𪭼; + #𪭽; + #𪭾; + #𪭿; + #𪮀; + #𪮁; + #𪮂; + #𪮃; + #𪮄; + #𪮅; + #𪮆; + #𪮇; + #𪮈; + #𪮉; + #𪮊; + #𪮋; + #𪮌; + #𪮍; + #𪮎; + #𪮏; + #𪮐; + #𪮑; + #𪮒; + #𪮓; + #𪮔; + #𪮕; + #𪮖; + #𪮗; + #𪮘; + #𪮙; + #𪮚; + #𪮛; + #𪮜; + #𪮝; + #𪮞; + #𪮟; + #𪮠; + #𪮡; + #𪮢; + #𪮣; + #𪮤; + #𪮥; + #𪮦; + #𪮧; + #𪮨; + #𪮩; + #𪮪; + #𪮫; + #𪮬; + #𪮭; + #𪮮; + #𪮯; + #𪮰; + #𪮱; + #𪮲; + #𪮳; + #𪮴; + #𪮵; + #𪮶; + #𪮷; + #𪮸; + #𪮹; + #𪮺; + #𪮻; + #𪮼; + #𪮽; + #𪮾; + #𪮿; + #𪯀; + #𪯁; + #𪯂; + #𪯃; + #𪯄; + #𪯅; + #𪯆; + #𪯇; + #𪯈; + #𪯉; + #𪯊; + #𪯋; + #𪯌; + #𪯍; + #𪯎; + #𪯏; + #𪯐; + #𪯑; + #𪯒; + #𪯓; + #𪯔; + #𪯕; + #𪯖; + #𪯗; + #𪯘; + #𪯙; + #𪯚; + #𪯛; + #𪯜; + #𪯝; + #𪯞; + #𪯟; + #𪯠; + #𪯡; + #𪯢; + #𪯣; + #𪯤; + #𪯥; + #𪯦; + #𪯧; + #𪯨; + #𪯩; + #𪯪; + #𪯫; + #𪯬; + #𪯭; + #𪯮; + #𪯯; + #𪯰; + #𪯱; + #𪯲; + #𪯳; + #𪯴; + #𪯵; + #𪯶; + #𪯷; + #𪯸; + #𪯹; + #𪯺; + #𪯻; + #𪯼; + #𪯽; + #𪯾; + #𪯿; + #𪰀; + #𪰁; + #𪰂; + #𪰃; + #𪰄; + #𪰅; + #𪰆; + #𪰇; + #𪰈; + #𪰉; + #𪰊; + #𪰋; + #𪰌; + #𪰍; + #𪰎; + #𪰏; + #𪰐; + #𪰑; + #𪰒; + #𪰓; + #𪰔; + #𪰕; + #𪰖; + #𪰗; + #𪰘; + #𪰙; + #𪰚; + #𪰛; + #𪰜; + #𪰝; + #𪰞; + #𪰟; + #𪰠; + #𪰡; + #𪰢; + #𪰣; + #𪰤; + #𪰥; + #𪰦; + #𪰧; + #𪰨; + #𪰩; + #𪰪; + #𪰫; + #𪰬; + #𪰭; + #𪰮; + #𪰯; + #𪰰; + #𪰱; + #𪰲; + #𪰳; + #𪰴; + #𪰵; + #𪰶; + #𪰷; + #𪰸; + #𪰹; + #𪰺; + #𪰻; + #𪰼; + #𪰽; + #𪰾; + #𪰿; + #𪱀; + #𪱁; + #𪱂; + #𪱃; + #𪱄; + #𪱅; + #𪱆; + #𪱇; + #𪱈; + #𪱉; + #𪱊; + #𪱋; + #𪱌; + #𪱍; + #𪱎; + #𪱏; + #𪱐; + #𪱑; + #𪱒; + #𪱓; + #𪱔; + #𪱕; + #𪱖; + #𪱗; + #𪱘; + #𪱙; + #𪱚; + #𪱛; + #𪱜; + #𪱝; + #𪱞; + #𪱟; + #𪱠; + #𪱡; + #𪱢; + #𪱣; + #𪱤; + #𪱥; + #𪱦; + #𪱧; + #𪱨; + #𪱩; + #𪱪; + #𪱫; + #𪱬; + #𪱭; + #𪱮; + #𪱯; + #𪱰; + #𪱱; + #𪱲; + #𪱳; + #𪱴; + #𪱵; + #𪱶; + #𪱷; + #𪱸; + #𪱹; + #𪱺; + #𪱻; + #𪱼; + #𪱽; + #𪱾; + #𪱿; + #𪲀; + #𪲁; + #𪲂; + #𪲃; + #𪲄; + #𪲅; + #𪲆; + #𪲇; + #𪲈; + #𪲉; + #𪲊; + #𪲋; + #𪲌; + #𪲍; + #𪲎; + #𪲏; + #𪲐; + #𪲑; + #𪲒; + #𪲓; + #𪲔; + #𪲕; + #𪲖; + #𪲗; + #𪲘; + #𪲙; + #𪲚; + #𪲛; + #𪲜; + #𪲝; + #𪲞; + #𪲟; + #𪲠; + #𪲡; + #𪲢; + #𪲣; + #𪲤; + #𪲥; + #𪲦; + #𪲧; + #𪲨; + #𪲩; + #𪲪; + #𪲫; + #𪲬; + #𪲭; + #𪲮; + #𪲯; + #𪲰; + #𪲱; + #𪲲; + #𪲳; + #𪲴; + #𪲵; + #𪲶; + #𪲷; + #𪲸; + #𪲹; + #𪲺; + #𪲻; + #𪲼; + #𪲽; + #𪲾; + #𪲿; + #𪳀; + #𪳁; + #𪳂; + #𪳃; + #𪳄; + #𪳅; + #𪳆; + #𪳇; + #𪳈; + #𪳉; + #𪳊; + #𪳋; + #𪳌; + #𪳍; + #𪳎; + #𪳏; + #𪳐; + #𪳑; + #𪳒; + #𪳓; + #𪳔; + #𪳕; + #𪳖; + #𪳗; + #𪳘; + #𪳙; + #𪳚; + #𪳛; + #𪳜; + #𪳝; + #𪳞; + #𪳟; + #𪳠; + #𪳡; + #𪳢; + #𪳣; + #𪳤; + #𪳥; + #𪳦; + #𪳧; + #𪳨; + #𪳩; + #𪳪; + #𪳫; + #𪳬; + #𪳭; + #𪳮; + #𪳯; + #𪳰; + #𪳱; + #𪳲; + #𪳳; + #𪳴; + #𪳵; + #𪳶; + #𪳷; + #𪳸; + #𪳹; + #𪳺; + #𪳻; + #𪳼; + #𪳽; + #𪳾; + #𪳿; + #𪴀; + #𪴁; + #𪴂; + #𪴃; + #𪴄; + #𪴅; + #𪴆; + #𪴇; + #𪴈; + #𪴉; + #𪴊; + #𪴋; + #𪴌; + #𪴍; + #𪴎; + #𪴏; + #𪴐; + #𪴑; + #𪴒; + #𪴓; + #𪴔; + #𪴕; + #𪴖; + #𪴗; + #𪴘; + #𪴙; + #𪴚; + #𪴛; + #𪴜; + #𪴝; + #𪴞; + #𪴟; + #𪴠; + #𪴡; + #𪴢; + #𪴣; + #𪴤; + #𪴥; + #𪴦; + #𪴧; + #𪴨; + #𪴩; + #𪴪; + #𪴫; + #𪴬; + #𪴭; + #𪴮; + #𪴯; + #𪴰; + #𪴱; + #𪴲; + #𪴳; + #𪴴; + #𪴵; + #𪴶; + #𪴷; + #𪴸; + #𪴹; + #𪴺; + #𪴻; + #𪴼; + #𪴽; + #𪴾; + #𪴿; + #𪵀; + #𪵁; + #𪵂; + #𪵃; + #𪵄; + #𪵅; + #𪵆; + #𪵇; + #𪵈; + #𪵉; + #𪵊; + #𪵋; + #𪵌; + #𪵍; + #𪵎; + #𪵏; + #𪵐; + #𪵑; + #𪵒; + #𪵓; + #𪵔; + #𪵕; + #𪵖; + #𪵗; + #𪵘; + #𪵙; + #𪵚; + #𪵛; + #𪵜; + #𪵝; + #𪵞; + #𪵟; + #𪵠; + #𪵡; + #𪵢; + #𪵣; + #𪵤; + #𪵥; + #𪵦; + #𪵧; + #𪵨; + #𪵩; + #𪵪; + #𪵫; + #𪵬; + #𪵭; + #𪵮; + #𪵯; + #𪵰; + #𪵱; + #𪵲; + #𪵳; + #𪵴; + #𪵵; + #𪵶; + #𪵷; + #𪵸; + #𪵹; + #𪵺; + #𪵻; + #𪵼; + #𪵽; + #𪵾; + #𪵿; + #𪶀; + #𪶁; + #𪶂; + #𪶃; + #𪶄; + #𪶅; + #𪶆; + #𪶇; + #𪶈; + #𪶉; + #𪶊; + #𪶋; + #𪶌; + #𪶍; + #𪶎; + #𪶏; + #𪶐; + #𪶑; + #𪶒; + #𪶓; + #𪶔; + #𪶕; + #𪶖; + #𪶗; + #𪶘; + #𪶙; + #𪶚; + #𪶛; + #𪶜; + #𪶝; + #𪶞; + #𪶟; + #𪶠; + #𪶡; + #𪶢; + #𪶣; + #𪶤; + #𪶥; + #𪶦; + #𪶧; + #𪶨; + #𪶩; + #𪶪; + #𪶫; + #𪶬; + #𪶭; + #𪶮; + #𪶯; + #𪶰; + #𪶱; + #𪶲; + #𪶳; + #𪶴; + #𪶵; + #𪶶; + #𪶷; + #𪶸; + #𪶹; + #𪶺; + #𪶻; + #𪶼; + #𪶽; + #𪶾; + #𪶿; + #𪷀; + #𪷁; + #𪷂; + #𪷃; + #𪷄; + #𪷅; + #𪷆; + #𪷇; + #𪷈; + #𪷉; + #𪷊; + #𪷋; + #𪷌; + #𪷍; + #𪷎; + #𪷏; + #𪷐; + #𪷑; + #𪷒; + #𪷓; + #𪷔; + #𪷕; + #𪷖; + #𪷗; + #𪷘; + #𪷙; + #𪷚; + #𪷛; + #𪷜; + #𪷝; + #𪷞; + #𪷟; + #𪷠; + #𪷡; + #𪷢; + #𪷣; + #𪷤; + #𪷥; + #𪷦; + #𪷧; + #𪷨; + #𪷩; + #𪷪; + #𪷫; + #𪷬; + #𪷭; + #𪷮; + #𪷯; + #𪷰; + #𪷱; + #𪷲; + #𪷳; + #𪷴; + #𪷵; + #𪷶; + #𪷷; + #𪷸; + #𪷹; + #𪷺; + #𪷻; + #𪷼; + #𪷽; + #𪷾; + #𪷿; + #𪸀; + #𪸁; + #𪸂; + #𪸃; + #𪸄; + #𪸅; + #𪸆; + #𪸇; + #𪸈; + #𪸉; + #𪸊; + #𪸋; + #𪸌; + #𪸍; + #𪸎; + #𪸏; + #𪸐; + #𪸑; + #𪸒; + #𪸓; + #𪸔; + #𪸕; + #𪸖; + #𪸗; + #𪸘; + #𪸙; + #𪸚; + #𪸛; + #𪸜; + #𪸝; + #𪸞; + #𪸟; + #𪸠; + #𪸡; + #𪸢; + #𪸣; + #𪸤; + #𪸥; + #𪸦; + #𪸧; + #𪸨; + #𪸩; + #𪸪; + #𪸫; + #𪸬; + #𪸭; + #𪸮; + #𪸯; + #𪸰; + #𪸱; + #𪸲; + #𪸳; + #𪸴; + #𪸵; + #𪸶; + #𪸷; + #𪸸; + #𪸹; + #𪸺; + #𪸻; + #𪸼; + #𪸽; + #𪸾; + #𪸿; + #𪹀; + #𪹁; + #𪹂; + #𪹃; + #𪹄; + #𪹅; + #𪹆; + #𪹇; + #𪹈; + #𪹉; + #𪹊; + #𪹋; + #𪹌; + #𪹍; + #𪹎; + #𪹏; + #𪹐; + #𪹑; + #𪹒; + #𪹓; + #𪹔; + #𪹕; + #𪹖; + #𪹗; + #𪹘; + #𪹙; + #𪹚; + #𪹛; + #𪹜; + #𪹝; + #𪹞; + #𪹟; + #𪹠; + #𪹡; + #𪹢; + #𪹣; + #𪹤; + #𪹥; + #𪹦; + #𪹧; + #𪹨; + #𪹩; + #𪹪; + #𪹫; + #𪹬; + #𪹭; + #𪹮; + #𪹯; + #𪹰; + #𪹱; + #𪹲; + #𪹳; + #𪹴; + #𪹵; + #𪹶; + #𪹷; + #𪹸; + #𪹹; + #𪹺; + #𪹻; + #𪹼; + #𪹽; + #𪹾; + #𪹿; + #𪺀; + #𪺁; + #𪺂; + #𪺃; + #𪺄; + #𪺅; + #𪺆; + #𪺇; + #𪺈; + #𪺉; + #𪺊; + #𪺋; + #𪺌; + #𪺍; + #𪺎; + #𪺏; + #𪺐; + #𪺑; + #𪺒; + #𪺓; + #𪺔; + #𪺕; + #𪺖; + #𪺗; + #𪺘; + #𪺙; + #𪺚; + #𪺛; + #𪺜; + #𪺝; + #𪺞; + #𪺟; + #𪺠; + #𪺡; + #𪺢; + #𪺣; + #𪺤; + #𪺥; + #𪺦; + #𪺧; + #𪺨; + #𪺩; + #𪺪; + #𪺫; + #𪺬; + #𪺭; + #𪺮; + #𪺯; + #𪺰; + #𪺱; + #𪺲; + #𪺳; + #𪺴; + #𪺵; + #𪺶; + #𪺷; + #𪺸; + #𪺹; + #𪺺; + #𪺻; + #𪺼; + #𪺽; + #𪺾; + #𪺿; + #𪻀; + #𪻁; + #𪻂; + #𪻃; + #𪻄; + #𪻅; + #𪻆; + #𪻇; + #𪻈; + #𪻉; + #𪻊; + #𪻋; + #𪻌; + #𪻍; + #𪻎; + #𪻏; + #𪻐; + #𪻑; + #𪻒; + #𪻓; + #𪻔; + #𪻕; + #𪻖; + #𪻗; + #𪻘; + #𪻙; + #𪻚; + #𪻛; + #𪻜; + #𪻝; + #𪻞; + #𪻟; + #𪻠; + #𪻡; + #𪻢; + #𪻣; + #𪻤; + #𪻥; + #𪻦; + #𪻧; + #𪻨; + #𪻩; + #𪻪; + #𪻫; + #𪻬; + #𪻭; + #𪻮; + #𪻯; + #𪻰; + #𪻱; + #𪻲; + #𪻳; + #𪻴; + #𪻵; + #𪻶; + #𪻷; + #𪻸; + #𪻹; + #𪻺; + #𪻻; + #𪻼; + #𪻽; + #𪻾; + #𪻿; + #𪼀; + #𪼁; + #𪼂; + #𪼃; + #𪼄; + #𪼅; + #𪼆; + #𪼇; + #𪼈; + #𪼉; + #𪼊; + #𪼋; + #𪼌; + #𪼍; + #𪼎; + #𪼏; + #𪼐; + #𪼑; + #𪼒; + #𪼓; + #𪼔; + #𪼕; + #𪼖; + #𪼗; + #𪼘; + #𪼙; + #𪼚; + #𪼛; + #𪼜; + #𪼝; + #𪼞; + #𪼟; + #𪼠; + #𪼡; + #𪼢; + #𪼣; + #𪼤; + #𪼥; + #𪼦; + #𪼧; + #𪼨; + #𪼩; + #𪼪; + #𪼫; + #𪼬; + #𪼭; + #𪼮; + #𪼯; + #𪼰; + #𪼱; + #𪼲; + #𪼳; + #𪼴; + #𪼵; + #𪼶; + #𪼷; + #𪼸; + #𪼹; + #𪼺; + #𪼻; + #𪼼; + #𪼽; + #𪼾; + #𪼿; + #𪽀; + #𪽁; + #𪽂; + #𪽃; + #𪽄; + #𪽅; + #𪽆; + #𪽇; + #𪽈; + #𪽉; + #𪽊; + #𪽋; + #𪽌; + #𪽍; + #𪽎; + #𪽏; + #𪽐; + #𪽑; + #𪽒; + #𪽓; + #𪽔; + #𪽕; + #𪽖; + #𪽗; + #𪽘; + #𪽙; + #𪽚; + #𪽛; + #𪽜; + #𪽝; + #𪽞; + #𪽟; + #𪽠; + #𪽡; + #𪽢; + #𪽣; + #𪽤; + #𪽥; + #𪽦; + #𪽧; + #𪽨; + #𪽩; + #𪽪; + #𪽫; + #𪽬; + #𪽭; + #𪽮; + #𪽯; + #𪽰; + #𪽱; + #𪽲; + #𪽳; + #𪽴; + #𪽵; + #𪽶; + #𪽷; + #𪽸; + #𪽹; + #𪽺; + #𪽻; + #𪽼; + #𪽽; + #𪽾; + #𪽿; + #𪾀; + #𪾁; + #𪾂; + #𪾃; + #𪾄; + #𪾅; + #𪾆; + #𪾇; + #𪾈; + #𪾉; + #𪾊; + #𪾋; + #𪾌; + #𪾍; + #𪾎; + #𪾏; + #𪾐; + #𪾑; + #𪾒; + #𪾓; + #𪾔; + #𪾕; + #𪾖; + #𪾗; + #𪾘; + #𪾙; + #𪾚; + #𪾛; + #𪾜; + #𪾝; + #𪾞; + #𪾟; + #𪾠; + #𪾡; + #𪾢; + #𪾣; + #𪾤; + #𪾥; + #𪾦; + #𪾧; + #𪾨; + #𪾩; + #𪾪; + #𪾫; + #𪾬; + #𪾭; + #𪾮; + #𪾯; + #𪾰; + #𪾱; + #𪾲; + #𪾳; + #𪾴; + #𪾵; + #𪾶; + #𪾷; + #𪾸; + #𪾹; + #𪾺; + #𪾻; + #𪾼; + #𪾽; + #𪾾; + #𪾿; + #𪿀; + #𪿁; + #𪿂; + #𪿃; + #𪿄; + #𪿅; + #𪿆; + #𪿇; + #𪿈; + #𪿉; + #𪿊; + #𪿋; + #𪿌; + #𪿍; + #𪿎; + #𪿏; + #𪿐; + #𪿑; + #𪿒; + #𪿓; + #𪿔; + #𪿕; + #𪿖; + #𪿗; + #𪿘; + #𪿙; + #𪿚; + #𪿛; + #𪿜; + #𪿝; + #𪿞; + #𪿟; + #𪿠; + #𪿡; + #𪿢; + #𪿣; + #𪿤; + #𪿥; + #𪿦; + #𪿧; + #𪿨; + #𪿩; + #𪿪; + #𪿫; + #𪿬; + #𪿭; + #𪿮; + #𪿯; + #𪿰; + #𪿱; + #𪿲; + #𪿳; + #𪿴; + #𪿵; + #𪿶; + #𪿷; + #𪿸; + #𪿹; + #𪿺; + #𪿻; + #𪿼; + #𪿽; + #𪿾; + #𪿿; + #𫀀; + #𫀁; + #𫀂; + #𫀃; + #𫀄; + #𫀅; + #𫀆; + #𫀇; + #𫀈; + #𫀉; + #𫀊; + #𫀋; + #𫀌; + #𫀍; + #𫀎; + #𫀏; + #𫀐; + #𫀑; + #𫀒; + #𫀓; + #𫀔; + #𫀕; + #𫀖; + #𫀗; + #𫀘; + #𫀙; + #𫀚; + #𫀛; + #𫀜; + #𫀝; + #𫀞; + #𫀟; + #𫀠; + #𫀡; + #𫀢; + #𫀣; + #𫀤; + #𫀥; + #𫀦; + #𫀧; + #𫀨; + #𫀩; + #𫀪; + #𫀫; + #𫀬; + #𫀭; + #𫀮; + #𫀯; + #𫀰; + #𫀱; + #𫀲; + #𫀳; + #𫀴; + #𫀵; + #𫀶; + #𫀷; + #𫀸; + #𫀹; + #𫀺; + #𫀻; + #𫀼; + #𫀽; + #𫀾; + #𫀿; + #𫁀; + #𫁁; + #𫁂; + #𫁃; + #𫁄; + #𫁅; + #𫁆; + #𫁇; + #𫁈; + #𫁉; + #𫁊; + #𫁋; + #𫁌; + #𫁍; + #𫁎; + #𫁏; + #𫁐; + #𫁑; + #𫁒; + #𫁓; + #𫁔; + #𫁕; + #𫁖; + #𫁗; + #𫁘; + #𫁙; + #𫁚; + #𫁛; + #𫁜; + #𫁝; + #𫁞; + #𫁟; + #𫁠; + #𫁡; + #𫁢; + #𫁣; + #𫁤; + #𫁥; + #𫁦; + #𫁧; + #𫁨; + #𫁩; + #𫁪; + #𫁫; + #𫁬; + #𫁭; + #𫁮; + #𫁯; + #𫁰; + #𫁱; + #𫁲; + #𫁳; + #𫁴; + #𫁵; + #𫁶; + #𫁷; + #𫁸; + #𫁹; + #𫁺; + #𫁻; + #𫁼; + #𫁽; + #𫁾; + #𫁿; + #𫂀; + #𫂁; + #𫂂; + #𫂃; + #𫂄; + #𫂅; + #𫂆; + #𫂇; + #𫂈; + #𫂉; + #𫂊; + #𫂋; + #𫂌; + #𫂍; + #𫂎; + #𫂏; + #𫂐; + #𫂑; + #𫂒; + #𫂓; + #𫂔; + #𫂕; + #𫂖; + #𫂗; + #𫂘; + #𫂙; + #𫂚; + #𫂛; + #𫂜; + #𫂝; + #𫂞; + #𫂟; + #𫂠; + #𫂡; + #𫂢; + #𫂣; + #𫂤; + #𫂥; + #𫂦; + #𫂧; + #𫂨; + #𫂩; + #𫂪; + #𫂫; + #𫂬; + #𫂭; + #𫂮; + #𫂯; + #𫂰; + #𫂱; + #𫂲; + #𫂳; + #𫂴; + #𫂵; + #𫂶; + #𫂷; + #𫂸; + #𫂹; + #𫂺; + #𫂻; + #𫂼; + #𫂽; + #𫂾; + #𫂿; + #𫃀; + #𫃁; + #𫃂; + #𫃃; + #𫃄; + #𫃅; + #𫃆; + #𫃇; + #𫃈; + #𫃉; + #𫃊; + #𫃋; + #𫃌; + #𫃍; + #𫃎; + #𫃏; + #𫃐; + #𫃑; + #𫃒; + #𫃓; + #𫃔; + #𫃕; + #𫃖; + #𫃗; + #𫃘; + #𫃙; + #𫃚; + #𫃛; + #𫃜; + #𫃝; + #𫃞; + #𫃟; + #𫃠; + #𫃡; + #𫃢; + #𫃣; + #𫃤; + #𫃥; + #𫃦; + #𫃧; + #𫃨; + #𫃩; + #𫃪; + #𫃫; + #𫃬; + #𫃭; + #𫃮; + #𫃯; + #𫃰; + #𫃱; + #𫃲; + #𫃳; + #𫃴; + #𫃵; + #𫃶; + #𫃷; + #𫃸; + #𫃹; + #𫃺; + #𫃻; + #𫃼; + #𫃽; + #𫃾; + #𫃿; + #𫄀; + #𫄁; + #𫄂; + #𫄃; + #𫄄; + #𫄅; + #𫄆; + #𫄇; + #𫄈; + #𫄉; + #𫄊; + #𫄋; + #𫄌; + #𫄍; + #𫄎; + #𫄏; + #𫄐; + #𫄑; + #𫄒; + #𫄓; + #𫄔; + #𫄕; + #𫄖; + #𫄗; + #𫄘; + #𫄙; + #𫄚; + #𫄛; + #𫄜; + #𫄝; + #𫄞; + #𫄟; + #𫄠; + #𫄡; + #𫄢; + #𫄣; + #𫄤; + #𫄥; + #𫄦; + #𫄧; + #𫄨; + #𫄩; + #𫄪; + #𫄫; + #𫄬; + #𫄭; + #𫄮; + #𫄯; + #𫄰; + #𫄱; + #𫄲; + #𫄳; + #𫄴; + #𫄵; + #𫄶; + #𫄷; + #𫄸; + #𫄹; + #𫄺; + #𫄻; + #𫄼; + #𫄽; + #𫄾; + #𫄿; + #𫅀; + #𫅁; + #𫅂; + #𫅃; + #𫅄; + #𫅅; + #𫅆; + #𫅇; + #𫅈; + #𫅉; + #𫅊; + #𫅋; + #𫅌; + #𫅍; + #𫅎; + #𫅏; + #𫅐; + #𫅑; + #𫅒; + #𫅓; + #𫅔; + #𫅕; + #𫅖; + #𫅗; + #𫅘; + #𫅙; + #𫅚; + #𫅛; + #𫅜; + #𫅝; + #𫅞; + #𫅟; + #𫅠; + #𫅡; + #𫅢; + #𫅣; + #𫅤; + #𫅥; + #𫅦; + #𫅧; + #𫅨; + #𫅩; + #𫅪; + #𫅫; + #𫅬; + #𫅭; + #𫅮; + #𫅯; + #𫅰; + #𫅱; + #𫅲; + #𫅳; + #𫅴; + #𫅵; + #𫅶; + #𫅷; + #𫅸; + #𫅹; + #𫅺; + #𫅻; + #𫅼; + #𫅽; + #𫅾; + #𫅿; + #𫆀; + #𫆁; + #𫆂; + #𫆃; + #𫆄; + #𫆅; + #𫆆; + #𫆇; + #𫆈; + #𫆉; + #𫆊; + #𫆋; + #𫆌; + #𫆍; + #𫆎; + #𫆏; + #𫆐; + #𫆑; + #𫆒; + #𫆓; + #𫆔; + #𫆕; + #𫆖; + #𫆗; + #𫆘; + #𫆙; + #𫆚; + #𫆛; + #𫆜; + #𫆝; + #𫆞; + #𫆟; + #𫆠; + #𫆡; + #𫆢; + #𫆣; + #𫆤; + #𫆥; + #𫆦; + #𫆧; + #𫆨; + #𫆩; + #𫆪; + #𫆫; + #𫆬; + #𫆭; + #𫆮; + #𫆯; + #𫆰; + #𫆱; + #𫆲; + #𫆳; + #𫆴; + #𫆵; + #𫆶; + #𫆷; + #𫆸; + #𫆹; + #𫆺; + #𫆻; + #𫆼; + #𫆽; + #𫆾; + #𫆿; + #𫇀; + #𫇁; + #𫇂; + #𫇃; + #𫇄; + #𫇅; + #𫇆; + #𫇇; + #𫇈; + #𫇉; + #𫇊; + #𫇋; + #𫇌; + #𫇍; + #𫇎; + #𫇏; + #𫇐; + #𫇑; + #𫇒; + #𫇓; + #𫇔; + #𫇕; + #𫇖; + #𫇗; + #𫇘; + #𫇙; + #𫇚; + #𫇛; + #𫇜; + #𫇝; + #𫇞; + #𫇟; + #𫇠; + #𫇡; + #𫇢; + #𫇣; + #𫇤; + #𫇥; + #𫇦; + #𫇧; + #𫇨; + #𫇩; + #𫇪; + #𫇫; + #𫇬; + #𫇭; + #𫇮; + #𫇯; + #𫇰; + #𫇱; + #𫇲; + #𫇳; + #𫇴; + #𫇵; + #𫇶; + #𫇷; + #𫇸; + #𫇹; + #𫇺; + #𫇻; + #𫇼; + #𫇽; + #𫇾; + #𫇿; + #𫈀; + #𫈁; + #𫈂; + #𫈃; + #𫈄; + #𫈅; + #𫈆; + #𫈇; + #𫈈; + #𫈉; + #𫈊; + #𫈋; + #𫈌; + #𫈍; + #𫈎; + #𫈏; + #𫈐; + #𫈑; + #𫈒; + #𫈓; + #𫈔; + #𫈕; + #𫈖; + #𫈗; + #𫈘; + #𫈙; + #𫈚; + #𫈛; + #𫈜; + #𫈝; + #𫈞; + #𫈟; + #𫈠; + #𫈡; + #𫈢; + #𫈣; + #𫈤; + #𫈥; + #𫈦; + #𫈧; + #𫈨; + #𫈩; + #𫈪; + #𫈫; + #𫈬; + #𫈭; + #𫈮; + #𫈯; + #𫈰; + #𫈱; + #𫈲; + #𫈳; + #𫈴; + #𫈵; + #𫈶; + #𫈷; + #𫈸; + #𫈹; + #𫈺; + #𫈻; + #𫈼; + #𫈽; + #𫈾; + #𫈿; + #𫉀; + #𫉁; + #𫉂; + #𫉃; + #𫉄; + #𫉅; + #𫉆; + #𫉇; + #𫉈; + #𫉉; + #𫉊; + #𫉋; + #𫉌; + #𫉍; + #𫉎; + #𫉏; + #𫉐; + #𫉑; + #𫉒; + #𫉓; + #𫉔; + #𫉕; + #𫉖; + #𫉗; + #𫉘; + #𫉙; + #𫉚; + #𫉛; + #𫉜; + #𫉝; + #𫉞; + #𫉟; + #𫉠; + #𫉡; + #𫉢; + #𫉣; + #𫉤; + #𫉥; + #𫉦; + #𫉧; + #𫉨; + #𫉩; + #𫉪; + #𫉫; + #𫉬; + #𫉭; + #𫉮; + #𫉯; + #𫉰; + #𫉱; + #𫉲; + #𫉳; + #𫉴; + #𫉵; + #𫉶; + #𫉷; + #𫉸; + #𫉹; + #𫉺; + #𫉻; + #𫉼; + #𫉽; + #𫉾; + #𫉿; + #𫊀; + #𫊁; + #𫊂; + #𫊃; + #𫊄; + #𫊅; + #𫊆; + #𫊇; + #𫊈; + #𫊉; + #𫊊; + #𫊋; + #𫊌; + #𫊍; + #𫊎; + #𫊏; + #𫊐; + #𫊑; + #𫊒; + #𫊓; + #𫊔; + #𫊕; + #𫊖; + #𫊗; + #𫊘; + #𫊙; + #𫊚; + #𫊛; + #𫊜; + #𫊝; + #𫊞; + #𫊟; + #𫊠; + #𫊡; + #𫊢; + #𫊣; + #𫊤; + #𫊥; + #𫊦; + #𫊧; + #𫊨; + #𫊩; + #𫊪; + #𫊫; + #𫊬; + #𫊭; + #𫊮; + #𫊯; + #𫊰; + #𫊱; + #𫊲; + #𫊳; + #𫊴; + #𫊵; + #𫊶; + #𫊷; + #𫊸; + #𫊹; + #𫊺; + #𫊻; + #𫊼; + #𫊽; + #𫊾; + #𫊿; + #𫋀; + #𫋁; + #𫋂; + #𫋃; + #𫋄; + #𫋅; + #𫋆; + #𫋇; + #𫋈; + #𫋉; + #𫋊; + #𫋋; + #𫋌; + #𫋍; + #𫋎; + #𫋏; + #𫋐; + #𫋑; + #𫋒; + #𫋓; + #𫋔; + #𫋕; + #𫋖; + #𫋗; + #𫋘; + #𫋙; + #𫋚; + #𫋛; + #𫋜; + #𫋝; + #𫋞; + #𫋟; + #𫋠; + #𫋡; + #𫋢; + #𫋣; + #𫋤; + #𫋥; + #𫋦; + #𫋧; + #𫋨; + #𫋩; + #𫋪; + #𫋫; + #𫋬; + #𫋭; + #𫋮; + #𫋯; + #𫋰; + #𫋱; + #𫋲; + #𫋳; + #𫋴; + #𫋵; + #𫋶; + #𫋷; + #𫋸; + #𫋹; + #𫋺; + #𫋻; + #𫋼; + #𫋽; + #𫋾; + #𫋿; + #𫌀; + #𫌁; + #𫌂; + #𫌃; + #𫌄; + #𫌅; + #𫌆; + #𫌇; + #𫌈; + #𫌉; + #𫌊; + #𫌋; + #𫌌; + #𫌍; + #𫌎; + #𫌏; + #𫌐; + #𫌑; + #𫌒; + #𫌓; + #𫌔; + #𫌕; + #𫌖; + #𫌗; + #𫌘; + #𫌙; + #𫌚; + #𫌛; + #𫌜; + #𫌝; + #𫌞; + #𫌟; + #𫌠; + #𫌡; + #𫌢; + #𫌣; + #𫌤; + #𫌥; + #𫌦; + #𫌧; + #𫌨; + #𫌩; + #𫌪; + #𫌫; + #𫌬; + #𫌭; + #𫌮; + #𫌯; + #𫌰; + #𫌱; + #𫌲; + #𫌳; + #𫌴; + #𫌵; + #𫌶; + #𫌷; + #𫌸; + #𫌹; + #𫌺; + #𫌻; + #𫌼; + #𫌽; + #𫌾; + #𫌿; + #𫍀; + #𫍁; + #𫍂; + #𫍃; + #𫍄; + #𫍅; + #𫍆; + #𫍇; + #𫍈; + #𫍉; + #𫍊; + #𫍋; + #𫍌; + #𫍍; + #𫍎; + #𫍏; + #𫍐; + #𫍑; + #𫍒; + #𫍓; + #𫍔; + #𫍕; + #𫍖; + #𫍗; + #𫍘; + #𫍙; + #𫍚; + #𫍛; + #𫍜; + #𫍝; + #𫍞; + #𫍟; + #𫍠; + #𫍡; + #𫍢; + #𫍣; + #𫍤; + #𫍥; + #𫍦; + #𫍧; + #𫍨; + #𫍩; + #𫍪; + #𫍫; + #𫍬; + #𫍭; + #𫍮; + #𫍯; + #𫍰; + #𫍱; + #𫍲; + #𫍳; + #𫍴; + #𫍵; + #𫍶; + #𫍷; + #𫍸; + #𫍹; + #𫍺; + #𫍻; + #𫍼; + #𫍽; + #𫍾; + #𫍿; + #𫎀; + #𫎁; + #𫎂; + #𫎃; + #𫎄; + #𫎅; + #𫎆; + #𫎇; + #𫎈; + #𫎉; + #𫎊; + #𫎋; + #𫎌; + #𫎍; + #𫎎; + #𫎏; + #𫎐; + #𫎑; + #𫎒; + #𫎓; + #𫎔; + #𫎕; + #𫎖; + #𫎗; + #𫎘; + #𫎙; + #𫎚; + #𫎛; + #𫎜; + #𫎝; + #𫎞; + #𫎟; + #𫎠; + #𫎡; + #𫎢; + #𫎣; + #𫎤; + #𫎥; + #𫎦; + #𫎧; + #𫎨; + #𫎩; + #𫎪; + #𫎫; + #𫎬; + #𫎭; + #𫎮; + #𫎯; + #𫎰; + #𫎱; + #𫎲; + #𫎳; + #𫎴; + #𫎵; + #𫎶; + #𫎷; + #𫎸; + #𫎹; + #𫎺; + #𫎻; + #𫎼; + #𫎽; + #𫎾; + #𫎿; + #𫏀; + #𫏁; + #𫏂; + #𫏃; + #𫏄; + #𫏅; + #𫏆; + #𫏇; + #𫏈; + #𫏉; + #𫏊; + #𫏋; + #𫏌; + #𫏍; + #𫏎; + #𫏏; + #𫏐; + #𫏑; + #𫏒; + #𫏓; + #𫏔; + #𫏕; + #𫏖; + #𫏗; + #𫏘; + #𫏙; + #𫏚; + #𫏛; + #𫏜; + #𫏝; + #𫏞; + #𫏟; + #𫏠; + #𫏡; + #𫏢; + #𫏣; + #𫏤; + #𫏥; + #𫏦; + #𫏧; + #𫏨; + #𫏩; + #𫏪; + #𫏫; + #𫏬; + #𫏭; + #𫏮; + #𫏯; + #𫏰; + #𫏱; + #𫏲; + #𫏳; + #𫏴; + #𫏵; + #𫏶; + #𫏷; + #𫏸; + #𫏹; + #𫏺; + #𫏻; + #𫏼; + #𫏽; + #𫏾; + #𫏿; + #𫐀; + #𫐁; + #𫐂; + #𫐃; + #𫐄; + #𫐅; + #𫐆; + #𫐇; + #𫐈; + #𫐉; + #𫐊; + #𫐋; + #𫐌; + #𫐍; + #𫐎; + #𫐏; + #𫐐; + #𫐑; + #𫐒; + #𫐓; + #𫐔; + #𫐕; + #𫐖; + #𫐗; + #𫐘; + #𫐙; + #𫐚; + #𫐛; + #𫐜; + #𫐝; + #𫐞; + #𫐟; + #𫐠; + #𫐡; + #𫐢; + #𫐣; + #𫐤; + #𫐥; + #𫐦; + #𫐧; + #𫐨; + #𫐩; + #𫐪; + #𫐫; + #𫐬; + #𫐭; + #𫐮; + #𫐯; + #𫐰; + #𫐱; + #𫐲; + #𫐳; + #𫐴; + #𫐵; + #𫐶; + #𫐷; + #𫐸; + #𫐹; + #𫐺; + #𫐻; + #𫐼; + #𫐽; + #𫐾; + #𫐿; + #𫑀; + #𫑁; + #𫑂; + #𫑃; + #𫑄; + #𫑅; + #𫑆; + #𫑇; + #𫑈; + #𫑉; + #𫑊; + #𫑋; + #𫑌; + #𫑍; + #𫑎; + #𫑏; + #𫑐; + #𫑑; + #𫑒; + #𫑓; + #𫑔; + #𫑕; + #𫑖; + #𫑗; + #𫑘; + #𫑙; + #𫑚; + #𫑛; + #𫑜; + #𫑝; + #𫑞; + #𫑟; + #𫑠; + #𫑡; + #𫑢; + #𫑣; + #𫑤; + #𫑥; + #𫑦; + #𫑧; + #𫑨; + #𫑩; + #𫑪; + #𫑫; + #𫑬; + #𫑭; + #𫑮; + #𫑯; + #𫑰; + #𫑱; + #𫑲; + #𫑳; + #𫑴; + #𫑵; + #𫑶; + #𫑷; + #𫑸; + #𫑹; + #𫑺; + #𫑻; + #𫑼; + #𫑽; + #𫑾; + #𫑿; + #𫒀; + #𫒁; + #𫒂; + #𫒃; + #𫒄; + #𫒅; + #𫒆; + #𫒇; + #𫒈; + #𫒉; + #𫒊; + #𫒋; + #𫒌; + #𫒍; + #𫒎; + #𫒏; + #𫒐; + #𫒑; + #𫒒; + #𫒓; + #𫒔; + #𫒕; + #𫒖; + #𫒗; + #𫒘; + #𫒙; + #𫒚; + #𫒛; + #𫒜; + #𫒝; + #𫒞; + #𫒟; + #𫒠; + #𫒡; + #𫒢; + #𫒣; + #𫒤; + #𫒥; + #𫒦; + #𫒧; + #𫒨; + #𫒩; + #𫒪; + #𫒫; + #𫒬; + #𫒭; + #𫒮; + #𫒯; + #𫒰; + #𫒱; + #𫒲; + #𫒳; + #𫒴; + #𫒵; + #𫒶; + #𫒷; + #𫒸; + #𫒹; + #𫒺; + #𫒻; + #𫒼; + #𫒽; + #𫒾; + #𫒿; + #𫓀; + #𫓁; + #𫓂; + #𫓃; + #𫓄; + #𫓅; + #𫓆; + #𫓇; + #𫓈; + #𫓉; + #𫓊; + #𫓋; + #𫓌; + #𫓍; + #𫓎; + #𫓏; + #𫓐; + #𫓑; + #𫓒; + #𫓓; + #𫓔; + #𫓕; + #𫓖; + #𫓗; + #𫓘; + #𫓙; + #𫓚; + #𫓛; + #𫓜; + #𫓝; + #𫓞; + #𫓟; + #𫓠; + #𫓡; + #𫓢; + #𫓣; + #𫓤; + #𫓥; + #𫓦; + #𫓧; + #𫓨; + #𫓩; + #𫓪; + #𫓫; + #𫓬; + #𫓭; + #𫓮; + #𫓯; + #𫓰; + #𫓱; + #𫓲; + #𫓳; + #𫓴; + #𫓵; + #𫓶; + #𫓷; + #𫓸; + #𫓹; + #𫓺; + #𫓻; + #𫓼; + #𫓽; + #𫓾; + #𫓿; + #𫔀; + #𫔁; + #𫔂; + #𫔃; + #𫔄; + #𫔅; + #𫔆; + #𫔇; + #𫔈; + #𫔉; + #𫔊; + #𫔋; + #𫔌; + #𫔍; + #𫔎; + #𫔏; + #𫔐; + #𫔑; + #𫔒; + #𫔓; + #𫔔; + #𫔕; + #𫔖; + #𫔗; + #𫔘; + #𫔙; + #𫔚; + #𫔛; + #𫔜; + #𫔝; + #𫔞; + #𫔟; + #𫔠; + #𫔡; + #𫔢; + #𫔣; + #𫔤; + #𫔥; + #𫔦; + #𫔧; + #𫔨; + #𫔩; + #𫔪; + #𫔫; + #𫔬; + #𫔭; + #𫔮; + #𫔯; + #𫔰; + #𫔱; + #𫔲; + #𫔳; + #𫔴; + #𫔵; + #𫔶; + #𫔷; + #𫔸; + #𫔹; + #𫔺; + #𫔻; + #𫔼; + #𫔽; + #𫔾; + #𫔿; + #𫕀; + #𫕁; + #𫕂; + #𫕃; + #𫕄; + #𫕅; + #𫕆; + #𫕇; + #𫕈; + #𫕉; + #𫕊; + #𫕋; + #𫕌; + #𫕍; + #𫕎; + #𫕏; + #𫕐; + #𫕑; + #𫕒; + #𫕓; + #𫕔; + #𫕕; + #𫕖; + #𫕗; + #𫕘; + #𫕙; + #𫕚; + #𫕛; + #𫕜; + #𫕝; + #𫕞; + #𫕟; + #𫕠; + #𫕡; + #𫕢; + #𫕣; + #𫕤; + #𫕥; + #𫕦; + #𫕧; + #𫕨; + #𫕩; + #𫕪; + #𫕫; + #𫕬; + #𫕭; + #𫕮; + #𫕯; + #𫕰; + #𫕱; + #𫕲; + #𫕳; + #𫕴; + #𫕵; + #𫕶; + #𫕷; + #𫕸; + #𫕹; + #𫕺; + #𫕻; + #𫕼; + #𫕽; + #𫕾; + #𫕿; + #𫖀; + #𫖁; + #𫖂; + #𫖃; + #𫖄; + #𫖅; + #𫖆; + #𫖇; + #𫖈; + #𫖉; + #𫖊; + #𫖋; + #𫖌; + #𫖍; + #𫖎; + #𫖏; + #𫖐; + #𫖑; + #𫖒; + #𫖓; + #𫖔; + #𫖕; + #𫖖; + #𫖗; + #𫖘; + #𫖙; + #𫖚; + #𫖛; + #𫖜; + #𫖝; + #𫖞; + #𫖟; + #𫖠; + #𫖡; + #𫖢; + #𫖣; + #𫖤; + #𫖥; + #𫖦; + #𫖧; + #𫖨; + #𫖩; + #𫖪; + #𫖫; + #𫖬; + #𫖭; + #𫖮; + #𫖯; + #𫖰; + #𫖱; + #𫖲; + #𫖳; + #𫖴; + #𫖵; + #𫖶; + #𫖷; + #𫖸; + #𫖹; + #𫖺; + #𫖻; + #𫖼; + #𫖽; + #𫖾; + #𫖿; + #𫗀; + #𫗁; + #𫗂; + #𫗃; + #𫗄; + #𫗅; + #𫗆; + #𫗇; + #𫗈; + #𫗉; + #𫗊; + #𫗋; + #𫗌; + #𫗍; + #𫗎; + #𫗏; + #𫗐; + #𫗑; + #𫗒; + #𫗓; + #𫗔; + #𫗕; + #𫗖; + #𫗗; + #𫗘; + #𫗙; + #𫗚; + #𫗛; + #𫗜; + #𫗝; + #𫗞; + #𫗟; + #𫗠; + #𫗡; + #𫗢; + #𫗣; + #𫗤; + #𫗥; + #𫗦; + #𫗧; + #𫗨; + #𫗩; + #𫗪; + #𫗫; + #𫗬; + #𫗭; + #𫗮; + #𫗯; + #𫗰; + #𫗱; + #𫗲; + #𫗳; + #𫗴; + #𫗵; + #𫗶; + #𫗷; + #𫗸; + #𫗹; + #𫗺; + #𫗻; + #𫗼; + #𫗽; + #𫗾; + #𫗿; + #𫘀; + #𫘁; + #𫘂; + #𫘃; + #𫘄; + #𫘅; + #𫘆; + #𫘇; + #𫘈; + #𫘉; + #𫘊; + #𫘋; + #𫘌; + #𫘍; + #𫘎; + #𫘏; + #𫘐; + #𫘑; + #𫘒; + #𫘓; + #𫘔; + #𫘕; + #𫘖; + #𫘗; + #𫘘; + #𫘙; + #𫘚; + #𫘛; + #𫘜; + #𫘝; + #𫘞; + #𫘟; + #𫘠; + #𫘡; + #𫘢; + #𫘣; + #𫘤; + #𫘥; + #𫘦; + #𫘧; + #𫘨; + #𫘩; + #𫘪; + #𫘫; + #𫘬; + #𫘭; + #𫘮; + #𫘯; + #𫘰; + #𫘱; + #𫘲; + #𫘳; + #𫘴; + #𫘵; + #𫘶; + #𫘷; + #𫘸; + #𫘹; + #𫘺; + #𫘻; + #𫘼; + #𫘽; + #𫘾; + #𫘿; + #𫙀; + #𫙁; + #𫙂; + #𫙃; + #𫙄; + #𫙅; + #𫙆; + #𫙇; + #𫙈; + #𫙉; + #𫙊; + #𫙋; + #𫙌; + #𫙍; + #𫙎; + #𫙏; + #𫙐; + #𫙑; + #𫙒; + #𫙓; + #𫙔; + #𫙕; + #𫙖; + #𫙗; + #𫙘; + #𫙙; + #𫙚; + #𫙛; + #𫙜; + #𫙝; + #𫙞; + #𫙟; + #𫙠; + #𫙡; + #𫙢; + #𫙣; + #𫙤; + #𫙥; + #𫙦; + #𫙧; + #𫙨; + #𫙩; + #𫙪; + #𫙫; + #𫙬; + #𫙭; + #𫙮; + #𫙯; + #𫙰; + #𫙱; + #𫙲; + #𫙳; + #𫙴; + #𫙵; + #𫙶; + #𫙷; + #𫙸; + #𫙹; + #𫙺; + #𫙻; + #𫙼; + #𫙽; + #𫙾; + #𫙿; + #𫚀; + #𫚁; + #𫚂; + #𫚃; + #𫚄; + #𫚅; + #𫚆; + #𫚇; + #𫚈; + #𫚉; + #𫚊; + #𫚋; + #𫚌; + #𫚍; + #𫚎; + #𫚏; + #𫚐; + #𫚑; + #𫚒; + #𫚓; + #𫚔; + #𫚕; + #𫚖; + #𫚗; + #𫚘; + #𫚙; + #𫚚; + #𫚛; + #𫚜; + #𫚝; + #𫚞; + #𫚟; + #𫚠; + #𫚡; + #𫚢; + #𫚣; + #𫚤; + #𫚥; + #𫚦; + #𫚧; + #𫚨; + #𫚩; + #𫚪; + #𫚫; + #𫚬; + #𫚭; + #𫚮; + #𫚯; + #𫚰; + #𫚱; + #𫚲; + #𫚳; + #𫚴; + #𫚵; + #𫚶; + #𫚷; + #𫚸; + #𫚹; + #𫚺; + #𫚻; + #𫚼; + #𫚽; + #𫚾; + #𫚿; + #𫛀; + #𫛁; + #𫛂; + #𫛃; + #𫛄; + #𫛅; + #𫛆; + #𫛇; + #𫛈; + #𫛉; + #𫛊; + #𫛋; + #𫛌; + #𫛍; + #𫛎; + #𫛏; + #𫛐; + #𫛑; + #𫛒; + #𫛓; + #𫛔; + #𫛕; + #𫛖; + #𫛗; + #𫛘; + #𫛙; + #𫛚; + #𫛛; + #𫛜; + #𫛝; + #𫛞; + #𫛟; + #𫛠; + #𫛡; + #𫛢; + #𫛣; + #𫛤; + #𫛥; + #𫛦; + #𫛧; + #𫛨; + #𫛩; + #𫛪; + #𫛫; + #𫛬; + #𫛭; + #𫛮; + #𫛯; + #𫛰; + #𫛱; + #𫛲; + #𫛳; + #𫛴; + #𫛵; + #𫛶; + #𫛷; + #𫛸; + #𫛹; + #𫛺; + #𫛻; + #𫛼; + #𫛽; + #𫛾; + #𫛿; + #𫜀; + #𫜁; + #𫜂; + #𫜃; + #𫜄; + #𫜅; + #𫜆; + #𫜇; + #𫜈; + #𫜉; + #𫜊; + #𫜋; + #𫜌; + #𫜍; + #𫜎; + #𫜏; + #𫜐; + #𫜑; + #𫜒; + #𫜓; + #𫜔; + #𫜕; + #𫜖; + #𫜗; + #𫜘; + #𫜙; + #𫜚; + #𫜛; + #𫜜; + #𫜝; + #𫜞; + #𫜟; + #𫜠; + #𫜡; + #𫜢; + #𫜣; + #𫜤; + #𫜥; + #𫜦; + #𫜧; + #𫜨; + #𫜩; + #𫜪; + #𫜫; + #𫜬; + #𫜭; + #𫜮; + #𫜯; + #𫜰; + #𫜱; + #𫜲; + #𫜳; + #𫜴; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0-escaped.js new file mode 100644 index 000000000..39da44910 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0-escaped.js @@ -0,0 +1,6107 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v5.2.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u0524; +var \u0525; +var \u0800; +var \u0801; +var \u0802; +var \u0803; +var \u0804; +var \u0805; +var \u0806; +var \u0807; +var \u0808; +var \u0809; +var \u080A; +var \u080B; +var \u080C; +var \u080D; +var \u080E; +var \u080F; +var \u0810; +var \u0811; +var \u0812; +var \u0813; +var \u0814; +var \u0815; +var \u081A; +var \u0824; +var \u0828; +var \u0979; +var \u097A; +var \u115A; +var \u115B; +var \u115C; +var \u115D; +var \u115E; +var \u11A3; +var \u11A4; +var \u11A5; +var \u11A6; +var \u11A7; +var \u11FA; +var \u11FB; +var \u11FC; +var \u11FD; +var \u11FE; +var \u11FF; +var \u1677; +var \u1678; +var \u1679; +var \u167A; +var \u167B; +var \u167C; +var \u167D; +var \u167E; +var \u167F; +var \u18B0; +var \u18B1; +var \u18B2; +var \u18B3; +var \u18B4; +var \u18B5; +var \u18B6; +var \u18B7; +var \u18B8; +var \u18B9; +var \u18BA; +var \u18BB; +var \u18BC; +var \u18BD; +var \u18BE; +var \u18BF; +var \u18C0; +var \u18C1; +var \u18C2; +var \u18C3; +var \u18C4; +var \u18C5; +var \u18C6; +var \u18C7; +var \u18C8; +var \u18C9; +var \u18CA; +var \u18CB; +var \u18CC; +var \u18CD; +var \u18CE; +var \u18CF; +var \u18D0; +var \u18D1; +var \u18D2; +var \u18D3; +var \u18D4; +var \u18D5; +var \u18D6; +var \u18D7; +var \u18D8; +var \u18D9; +var \u18DA; +var \u18DB; +var \u18DC; +var \u18DD; +var \u18DE; +var \u18DF; +var \u18E0; +var \u18E1; +var \u18E2; +var \u18E3; +var \u18E4; +var \u18E5; +var \u18E6; +var \u18E7; +var \u18E8; +var \u18E9; +var \u18EA; +var \u18EB; +var \u18EC; +var \u18ED; +var \u18EE; +var \u18EF; +var \u18F0; +var \u18F1; +var \u18F2; +var \u18F3; +var \u18F4; +var \u18F5; +var \u19AA; +var \u19AB; +var \u1A20; +var \u1A21; +var \u1A22; +var \u1A23; +var \u1A24; +var \u1A25; +var \u1A26; +var \u1A27; +var \u1A28; +var \u1A29; +var \u1A2A; +var \u1A2B; +var \u1A2C; +var \u1A2D; +var \u1A2E; +var \u1A2F; +var \u1A30; +var \u1A31; +var \u1A32; +var \u1A33; +var \u1A34; +var \u1A35; +var \u1A36; +var \u1A37; +var \u1A38; +var \u1A39; +var \u1A3A; +var \u1A3B; +var \u1A3C; +var \u1A3D; +var \u1A3E; +var \u1A3F; +var \u1A40; +var \u1A41; +var \u1A42; +var \u1A43; +var \u1A44; +var \u1A45; +var \u1A46; +var \u1A47; +var \u1A48; +var \u1A49; +var \u1A4A; +var \u1A4B; +var \u1A4C; +var \u1A4D; +var \u1A4E; +var \u1A4F; +var \u1A50; +var \u1A51; +var \u1A52; +var \u1A53; +var \u1A54; +var \u1AA7; +var \u1CE9; +var \u1CEA; +var \u1CEB; +var \u1CEC; +var \u1CEE; +var \u1CEF; +var \u1CF0; +var \u1CF1; +var \u2C70; +var \u2C7E; +var \u2C7F; +var \u2CEB; +var \u2CEC; +var \u2CED; +var \u2CEE; +var \u9FC4; +var \u9FC5; +var \u9FC6; +var \u9FC7; +var \u9FC8; +var \u9FC9; +var \u9FCA; +var \u9FCB; +var \uA4D0; +var \uA4D1; +var \uA4D2; +var \uA4D3; +var \uA4D4; +var \uA4D5; +var \uA4D6; +var \uA4D7; +var \uA4D8; +var \uA4D9; +var \uA4DA; +var \uA4DB; +var \uA4DC; +var \uA4DD; +var \uA4DE; +var \uA4DF; +var \uA4E0; +var \uA4E1; +var \uA4E2; +var \uA4E3; +var \uA4E4; +var \uA4E5; +var \uA4E6; +var \uA4E7; +var \uA4E8; +var \uA4E9; +var \uA4EA; +var \uA4EB; +var \uA4EC; +var \uA4ED; +var \uA4EE; +var \uA4EF; +var \uA4F0; +var \uA4F1; +var \uA4F2; +var \uA4F3; +var \uA4F4; +var \uA4F5; +var \uA4F6; +var \uA4F7; +var \uA4F8; +var \uA4F9; +var \uA4FA; +var \uA4FB; +var \uA4FC; +var \uA4FD; +var \uA6A0; +var \uA6A1; +var \uA6A2; +var \uA6A3; +var \uA6A4; +var \uA6A5; +var \uA6A6; +var \uA6A7; +var \uA6A8; +var \uA6A9; +var \uA6AA; +var \uA6AB; +var \uA6AC; +var \uA6AD; +var \uA6AE; +var \uA6AF; +var \uA6B0; +var \uA6B1; +var \uA6B2; +var \uA6B3; +var \uA6B4; +var \uA6B5; +var \uA6B6; +var \uA6B7; +var \uA6B8; +var \uA6B9; +var \uA6BA; +var \uA6BB; +var \uA6BC; +var \uA6BD; +var \uA6BE; +var \uA6BF; +var \uA6C0; +var \uA6C1; +var \uA6C2; +var \uA6C3; +var \uA6C4; +var \uA6C5; +var \uA6C6; +var \uA6C7; +var \uA6C8; +var \uA6C9; +var \uA6CA; +var \uA6CB; +var \uA6CC; +var \uA6CD; +var \uA6CE; +var \uA6CF; +var \uA6D0; +var \uA6D1; +var \uA6D2; +var \uA6D3; +var \uA6D4; +var \uA6D5; +var \uA6D6; +var \uA6D7; +var \uA6D8; +var \uA6D9; +var \uA6DA; +var \uA6DB; +var \uA6DC; +var \uA6DD; +var \uA6DE; +var \uA6DF; +var \uA6E0; +var \uA6E1; +var \uA6E2; +var \uA6E3; +var \uA6E4; +var \uA6E5; +var \uA6E6; +var \uA6E7; +var \uA6E8; +var \uA6E9; +var \uA6EA; +var \uA6EB; +var \uA6EC; +var \uA6ED; +var \uA6EE; +var \uA6EF; +var \uA8F2; +var \uA8F3; +var \uA8F4; +var \uA8F5; +var \uA8F6; +var \uA8F7; +var \uA8FB; +var \uA960; +var \uA961; +var \uA962; +var \uA963; +var \uA964; +var \uA965; +var \uA966; +var \uA967; +var \uA968; +var \uA969; +var \uA96A; +var \uA96B; +var \uA96C; +var \uA96D; +var \uA96E; +var \uA96F; +var \uA970; +var \uA971; +var \uA972; +var \uA973; +var \uA974; +var \uA975; +var \uA976; +var \uA977; +var \uA978; +var \uA979; +var \uA97A; +var \uA97B; +var \uA97C; +var \uA984; +var \uA985; +var \uA986; +var \uA987; +var \uA988; +var \uA989; +var \uA98A; +var \uA98B; +var \uA98C; +var \uA98D; +var \uA98E; +var \uA98F; +var \uA990; +var \uA991; +var \uA992; +var \uA993; +var \uA994; +var \uA995; +var \uA996; +var \uA997; +var \uA998; +var \uA999; +var \uA99A; +var \uA99B; +var \uA99C; +var \uA99D; +var \uA99E; +var \uA99F; +var \uA9A0; +var \uA9A1; +var \uA9A2; +var \uA9A3; +var \uA9A4; +var \uA9A5; +var \uA9A6; +var \uA9A7; +var \uA9A8; +var \uA9A9; +var \uA9AA; +var \uA9AB; +var \uA9AC; +var \uA9AD; +var \uA9AE; +var \uA9AF; +var \uA9B0; +var \uA9B1; +var \uA9B2; +var \uA9CF; +var \uAA60; +var \uAA61; +var \uAA62; +var \uAA63; +var \uAA64; +var \uAA65; +var \uAA66; +var \uAA67; +var \uAA68; +var \uAA69; +var \uAA6A; +var \uAA6B; +var \uAA6C; +var \uAA6D; +var \uAA6E; +var \uAA6F; +var \uAA70; +var \uAA71; +var \uAA72; +var \uAA73; +var \uAA74; +var \uAA75; +var \uAA76; +var \uAA7A; +var \uAA80; +var \uAA81; +var \uAA82; +var \uAA83; +var \uAA84; +var \uAA85; +var \uAA86; +var \uAA87; +var \uAA88; +var \uAA89; +var \uAA8A; +var \uAA8B; +var \uAA8C; +var \uAA8D; +var \uAA8E; +var \uAA8F; +var \uAA90; +var \uAA91; +var \uAA92; +var \uAA93; +var \uAA94; +var \uAA95; +var \uAA96; +var \uAA97; +var \uAA98; +var \uAA99; +var \uAA9A; +var \uAA9B; +var \uAA9C; +var \uAA9D; +var \uAA9E; +var \uAA9F; +var \uAAA0; +var \uAAA1; +var \uAAA2; +var \uAAA3; +var \uAAA4; +var \uAAA5; +var \uAAA6; +var \uAAA7; +var \uAAA8; +var \uAAA9; +var \uAAAA; +var \uAAAB; +var \uAAAC; +var \uAAAD; +var \uAAAE; +var \uAAAF; +var \uAAB1; +var \uAAB5; +var \uAAB6; +var \uAAB9; +var \uAABA; +var \uAABB; +var \uAABC; +var \uAABD; +var \uAAC0; +var \uAAC2; +var \uAADB; +var \uAADC; +var \uAADD; +var \uABC0; +var \uABC1; +var \uABC2; +var \uABC3; +var \uABC4; +var \uABC5; +var \uABC6; +var \uABC7; +var \uABC8; +var \uABC9; +var \uABCA; +var \uABCB; +var \uABCC; +var \uABCD; +var \uABCE; +var \uABCF; +var \uABD0; +var \uABD1; +var \uABD2; +var \uABD3; +var \uABD4; +var \uABD5; +var \uABD6; +var \uABD7; +var \uABD8; +var \uABD9; +var \uABDA; +var \uABDB; +var \uABDC; +var \uABDD; +var \uABDE; +var \uABDF; +var \uABE0; +var \uABE1; +var \uABE2; +var \uD7B0; +var \uD7B1; +var \uD7B2; +var \uD7B3; +var \uD7B4; +var \uD7B5; +var \uD7B6; +var \uD7B7; +var \uD7B8; +var \uD7B9; +var \uD7BA; +var \uD7BB; +var \uD7BC; +var \uD7BD; +var \uD7BE; +var \uD7BF; +var \uD7C0; +var \uD7C1; +var \uD7C2; +var \uD7C3; +var \uD7C4; +var \uD7C5; +var \uD7C6; +var \uD7CB; +var \uD7CC; +var \uD7CD; +var \uD7CE; +var \uD7CF; +var \uD7D0; +var \uD7D1; +var \uD7D2; +var \uD7D3; +var \uD7D4; +var \uD7D5; +var \uD7D6; +var \uD7D7; +var \uD7D8; +var \uD7D9; +var \uD7DA; +var \uD7DB; +var \uD7DC; +var \uD7DD; +var \uD7DE; +var \uD7DF; +var \uD7E0; +var \uD7E1; +var \uD7E2; +var \uD7E3; +var \uD7E4; +var \uD7E5; +var \uD7E6; +var \uD7E7; +var \uD7E8; +var \uD7E9; +var \uD7EA; +var \uD7EB; +var \uD7EC; +var \uD7ED; +var \uD7EE; +var \uD7EF; +var \uD7F0; +var \uD7F1; +var \uD7F2; +var \uD7F3; +var \uD7F4; +var \uD7F5; +var \uD7F6; +var \uD7F7; +var \uD7F8; +var \uD7F9; +var \uD7FA; +var \uD7FB; +var \uFA6B; +var \uFA6C; +var \uFA6D; +var \u{10840}; +var \u{10841}; +var \u{10842}; +var \u{10843}; +var \u{10844}; +var \u{10845}; +var \u{10846}; +var \u{10847}; +var \u{10848}; +var \u{10849}; +var \u{1084A}; +var \u{1084B}; +var \u{1084C}; +var \u{1084D}; +var \u{1084E}; +var \u{1084F}; +var \u{10850}; +var \u{10851}; +var \u{10852}; +var \u{10853}; +var \u{10854}; +var \u{10855}; +var \u{10A60}; +var \u{10A61}; +var \u{10A62}; +var \u{10A63}; +var \u{10A64}; +var \u{10A65}; +var \u{10A66}; +var \u{10A67}; +var \u{10A68}; +var \u{10A69}; +var \u{10A6A}; +var \u{10A6B}; +var \u{10A6C}; +var \u{10A6D}; +var \u{10A6E}; +var \u{10A6F}; +var \u{10A70}; +var \u{10A71}; +var \u{10A72}; +var \u{10A73}; +var \u{10A74}; +var \u{10A75}; +var \u{10A76}; +var \u{10A77}; +var \u{10A78}; +var \u{10A79}; +var \u{10A7A}; +var \u{10A7B}; +var \u{10A7C}; +var \u{10B00}; +var \u{10B01}; +var \u{10B02}; +var \u{10B03}; +var \u{10B04}; +var \u{10B05}; +var \u{10B06}; +var \u{10B07}; +var \u{10B08}; +var \u{10B09}; +var \u{10B0A}; +var \u{10B0B}; +var \u{10B0C}; +var \u{10B0D}; +var \u{10B0E}; +var \u{10B0F}; +var \u{10B10}; +var \u{10B11}; +var \u{10B12}; +var \u{10B13}; +var \u{10B14}; +var \u{10B15}; +var \u{10B16}; +var \u{10B17}; +var \u{10B18}; +var \u{10B19}; +var \u{10B1A}; +var \u{10B1B}; +var \u{10B1C}; +var \u{10B1D}; +var \u{10B1E}; +var \u{10B1F}; +var \u{10B20}; +var \u{10B21}; +var \u{10B22}; +var \u{10B23}; +var \u{10B24}; +var \u{10B25}; +var \u{10B26}; +var \u{10B27}; +var \u{10B28}; +var \u{10B29}; +var \u{10B2A}; +var \u{10B2B}; +var \u{10B2C}; +var \u{10B2D}; +var \u{10B2E}; +var \u{10B2F}; +var \u{10B30}; +var \u{10B31}; +var \u{10B32}; +var \u{10B33}; +var \u{10B34}; +var \u{10B35}; +var \u{10B40}; +var \u{10B41}; +var \u{10B42}; +var \u{10B43}; +var \u{10B44}; +var \u{10B45}; +var \u{10B46}; +var \u{10B47}; +var \u{10B48}; +var \u{10B49}; +var \u{10B4A}; +var \u{10B4B}; +var \u{10B4C}; +var \u{10B4D}; +var \u{10B4E}; +var \u{10B4F}; +var \u{10B50}; +var \u{10B51}; +var \u{10B52}; +var \u{10B53}; +var \u{10B54}; +var \u{10B55}; +var \u{10B60}; +var \u{10B61}; +var \u{10B62}; +var \u{10B63}; +var \u{10B64}; +var \u{10B65}; +var \u{10B66}; +var \u{10B67}; +var \u{10B68}; +var \u{10B69}; +var \u{10B6A}; +var \u{10B6B}; +var \u{10B6C}; +var \u{10B6D}; +var \u{10B6E}; +var \u{10B6F}; +var \u{10B70}; +var \u{10B71}; +var \u{10B72}; +var \u{10C00}; +var \u{10C01}; +var \u{10C02}; +var \u{10C03}; +var \u{10C04}; +var \u{10C05}; +var \u{10C06}; +var \u{10C07}; +var \u{10C08}; +var \u{10C09}; +var \u{10C0A}; +var \u{10C0B}; +var \u{10C0C}; +var \u{10C0D}; +var \u{10C0E}; +var \u{10C0F}; +var \u{10C10}; +var \u{10C11}; +var \u{10C12}; +var \u{10C13}; +var \u{10C14}; +var \u{10C15}; +var \u{10C16}; +var \u{10C17}; +var \u{10C18}; +var \u{10C19}; +var \u{10C1A}; +var \u{10C1B}; +var \u{10C1C}; +var \u{10C1D}; +var \u{10C1E}; +var \u{10C1F}; +var \u{10C20}; +var \u{10C21}; +var \u{10C22}; +var \u{10C23}; +var \u{10C24}; +var \u{10C25}; +var \u{10C26}; +var \u{10C27}; +var \u{10C28}; +var \u{10C29}; +var \u{10C2A}; +var \u{10C2B}; +var \u{10C2C}; +var \u{10C2D}; +var \u{10C2E}; +var \u{10C2F}; +var \u{10C30}; +var \u{10C31}; +var \u{10C32}; +var \u{10C33}; +var \u{10C34}; +var \u{10C35}; +var \u{10C36}; +var \u{10C37}; +var \u{10C38}; +var \u{10C39}; +var \u{10C3A}; +var \u{10C3B}; +var \u{10C3C}; +var \u{10C3D}; +var \u{10C3E}; +var \u{10C3F}; +var \u{10C40}; +var \u{10C41}; +var \u{10C42}; +var \u{10C43}; +var \u{10C44}; +var \u{10C45}; +var \u{10C46}; +var \u{10C47}; +var \u{10C48}; +var \u{11083}; +var \u{11084}; +var \u{11085}; +var \u{11086}; +var \u{11087}; +var \u{11088}; +var \u{11089}; +var \u{1108A}; +var \u{1108B}; +var \u{1108C}; +var \u{1108D}; +var \u{1108E}; +var \u{1108F}; +var \u{11090}; +var \u{11091}; +var \u{11092}; +var \u{11093}; +var \u{11094}; +var \u{11095}; +var \u{11096}; +var \u{11097}; +var \u{11098}; +var \u{11099}; +var \u{1109A}; +var \u{1109B}; +var \u{1109C}; +var \u{1109D}; +var \u{1109E}; +var \u{1109F}; +var \u{110A0}; +var \u{110A1}; +var \u{110A2}; +var \u{110A3}; +var \u{110A4}; +var \u{110A5}; +var \u{110A6}; +var \u{110A7}; +var \u{110A8}; +var \u{110A9}; +var \u{110AA}; +var \u{110AB}; +var \u{110AC}; +var \u{110AD}; +var \u{110AE}; +var \u{110AF}; +var \u{13000}; +var \u{13001}; +var \u{13002}; +var \u{13003}; +var \u{13004}; +var \u{13005}; +var \u{13006}; +var \u{13007}; +var \u{13008}; +var \u{13009}; +var \u{1300A}; +var \u{1300B}; +var \u{1300C}; +var \u{1300D}; +var \u{1300E}; +var \u{1300F}; +var \u{13010}; +var \u{13011}; +var \u{13012}; +var \u{13013}; +var \u{13014}; +var \u{13015}; +var \u{13016}; +var \u{13017}; +var \u{13018}; +var \u{13019}; +var \u{1301A}; +var \u{1301B}; +var \u{1301C}; +var \u{1301D}; +var \u{1301E}; +var \u{1301F}; +var \u{13020}; +var \u{13021}; +var \u{13022}; +var \u{13023}; +var \u{13024}; +var \u{13025}; +var \u{13026}; +var \u{13027}; +var \u{13028}; +var \u{13029}; +var \u{1302A}; +var \u{1302B}; +var \u{1302C}; +var \u{1302D}; +var \u{1302E}; +var \u{1302F}; +var \u{13030}; +var \u{13031}; +var \u{13032}; +var \u{13033}; +var \u{13034}; +var \u{13035}; +var \u{13036}; +var \u{13037}; +var \u{13038}; +var \u{13039}; +var \u{1303A}; +var \u{1303B}; +var \u{1303C}; +var \u{1303D}; +var \u{1303E}; +var \u{1303F}; +var \u{13040}; +var \u{13041}; +var \u{13042}; +var \u{13043}; +var \u{13044}; +var \u{13045}; +var \u{13046}; +var \u{13047}; +var \u{13048}; +var \u{13049}; +var \u{1304A}; +var \u{1304B}; +var \u{1304C}; +var \u{1304D}; +var \u{1304E}; +var \u{1304F}; +var \u{13050}; +var \u{13051}; +var \u{13052}; +var \u{13053}; +var \u{13054}; +var \u{13055}; +var \u{13056}; +var \u{13057}; +var \u{13058}; +var \u{13059}; +var \u{1305A}; +var \u{1305B}; +var \u{1305C}; +var \u{1305D}; +var \u{1305E}; +var \u{1305F}; +var \u{13060}; +var \u{13061}; +var \u{13062}; +var \u{13063}; +var \u{13064}; +var \u{13065}; +var \u{13066}; +var \u{13067}; +var \u{13068}; +var \u{13069}; +var \u{1306A}; +var \u{1306B}; +var \u{1306C}; +var \u{1306D}; +var \u{1306E}; +var \u{1306F}; +var \u{13070}; +var \u{13071}; +var \u{13072}; +var \u{13073}; +var \u{13074}; +var \u{13075}; +var \u{13076}; +var \u{13077}; +var \u{13078}; +var \u{13079}; +var \u{1307A}; +var \u{1307B}; +var \u{1307C}; +var \u{1307D}; +var \u{1307E}; +var \u{1307F}; +var \u{13080}; +var \u{13081}; +var \u{13082}; +var \u{13083}; +var \u{13084}; +var \u{13085}; +var \u{13086}; +var \u{13087}; +var \u{13088}; +var \u{13089}; +var \u{1308A}; +var \u{1308B}; +var \u{1308C}; +var \u{1308D}; +var \u{1308E}; +var \u{1308F}; +var \u{13090}; +var \u{13091}; +var \u{13092}; +var \u{13093}; +var \u{13094}; +var \u{13095}; +var \u{13096}; +var \u{13097}; +var \u{13098}; +var \u{13099}; +var \u{1309A}; +var \u{1309B}; +var \u{1309C}; +var \u{1309D}; +var \u{1309E}; +var \u{1309F}; +var \u{130A0}; +var \u{130A1}; +var \u{130A2}; +var \u{130A3}; +var \u{130A4}; +var \u{130A5}; +var \u{130A6}; +var \u{130A7}; +var \u{130A8}; +var \u{130A9}; +var \u{130AA}; +var \u{130AB}; +var \u{130AC}; +var \u{130AD}; +var \u{130AE}; +var \u{130AF}; +var \u{130B0}; +var \u{130B1}; +var \u{130B2}; +var \u{130B3}; +var \u{130B4}; +var \u{130B5}; +var \u{130B6}; +var \u{130B7}; +var \u{130B8}; +var \u{130B9}; +var \u{130BA}; +var \u{130BB}; +var \u{130BC}; +var \u{130BD}; +var \u{130BE}; +var \u{130BF}; +var \u{130C0}; +var \u{130C1}; +var \u{130C2}; +var \u{130C3}; +var \u{130C4}; +var \u{130C5}; +var \u{130C6}; +var \u{130C7}; +var \u{130C8}; +var \u{130C9}; +var \u{130CA}; +var \u{130CB}; +var \u{130CC}; +var \u{130CD}; +var \u{130CE}; +var \u{130CF}; +var \u{130D0}; +var \u{130D1}; +var \u{130D2}; +var \u{130D3}; +var \u{130D4}; +var \u{130D5}; +var \u{130D6}; +var \u{130D7}; +var \u{130D8}; +var \u{130D9}; +var \u{130DA}; +var \u{130DB}; +var \u{130DC}; +var \u{130DD}; +var \u{130DE}; +var \u{130DF}; +var \u{130E0}; +var \u{130E1}; +var \u{130E2}; +var \u{130E3}; +var \u{130E4}; +var \u{130E5}; +var \u{130E6}; +var \u{130E7}; +var \u{130E8}; +var \u{130E9}; +var \u{130EA}; +var \u{130EB}; +var \u{130EC}; +var \u{130ED}; +var \u{130EE}; +var \u{130EF}; +var \u{130F0}; +var \u{130F1}; +var \u{130F2}; +var \u{130F3}; +var \u{130F4}; +var \u{130F5}; +var \u{130F6}; +var \u{130F7}; +var \u{130F8}; +var \u{130F9}; +var \u{130FA}; +var \u{130FB}; +var \u{130FC}; +var \u{130FD}; +var \u{130FE}; +var \u{130FF}; +var \u{13100}; +var \u{13101}; +var \u{13102}; +var \u{13103}; +var \u{13104}; +var \u{13105}; +var \u{13106}; +var \u{13107}; +var \u{13108}; +var \u{13109}; +var \u{1310A}; +var \u{1310B}; +var \u{1310C}; +var \u{1310D}; +var \u{1310E}; +var \u{1310F}; +var \u{13110}; +var \u{13111}; +var \u{13112}; +var \u{13113}; +var \u{13114}; +var \u{13115}; +var \u{13116}; +var \u{13117}; +var \u{13118}; +var \u{13119}; +var \u{1311A}; +var \u{1311B}; +var \u{1311C}; +var \u{1311D}; +var \u{1311E}; +var \u{1311F}; +var \u{13120}; +var \u{13121}; +var \u{13122}; +var \u{13123}; +var \u{13124}; +var \u{13125}; +var \u{13126}; +var \u{13127}; +var \u{13128}; +var \u{13129}; +var \u{1312A}; +var \u{1312B}; +var \u{1312C}; +var \u{1312D}; +var \u{1312E}; +var \u{1312F}; +var \u{13130}; +var \u{13131}; +var \u{13132}; +var \u{13133}; +var \u{13134}; +var \u{13135}; +var \u{13136}; +var \u{13137}; +var \u{13138}; +var \u{13139}; +var \u{1313A}; +var \u{1313B}; +var \u{1313C}; +var \u{1313D}; +var \u{1313E}; +var \u{1313F}; +var \u{13140}; +var \u{13141}; +var \u{13142}; +var \u{13143}; +var \u{13144}; +var \u{13145}; +var \u{13146}; +var \u{13147}; +var \u{13148}; +var \u{13149}; +var \u{1314A}; +var \u{1314B}; +var \u{1314C}; +var \u{1314D}; +var \u{1314E}; +var \u{1314F}; +var \u{13150}; +var \u{13151}; +var \u{13152}; +var \u{13153}; +var \u{13154}; +var \u{13155}; +var \u{13156}; +var \u{13157}; +var \u{13158}; +var \u{13159}; +var \u{1315A}; +var \u{1315B}; +var \u{1315C}; +var \u{1315D}; +var \u{1315E}; +var \u{1315F}; +var \u{13160}; +var \u{13161}; +var \u{13162}; +var \u{13163}; +var \u{13164}; +var \u{13165}; +var \u{13166}; +var \u{13167}; +var \u{13168}; +var \u{13169}; +var \u{1316A}; +var \u{1316B}; +var \u{1316C}; +var \u{1316D}; +var \u{1316E}; +var \u{1316F}; +var \u{13170}; +var \u{13171}; +var \u{13172}; +var \u{13173}; +var \u{13174}; +var \u{13175}; +var \u{13176}; +var \u{13177}; +var \u{13178}; +var \u{13179}; +var \u{1317A}; +var \u{1317B}; +var \u{1317C}; +var \u{1317D}; +var \u{1317E}; +var \u{1317F}; +var \u{13180}; +var \u{13181}; +var \u{13182}; +var \u{13183}; +var \u{13184}; +var \u{13185}; +var \u{13186}; +var \u{13187}; +var \u{13188}; +var \u{13189}; +var \u{1318A}; +var \u{1318B}; +var \u{1318C}; +var \u{1318D}; +var \u{1318E}; +var \u{1318F}; +var \u{13190}; +var \u{13191}; +var \u{13192}; +var \u{13193}; +var \u{13194}; +var \u{13195}; +var \u{13196}; +var \u{13197}; +var \u{13198}; +var \u{13199}; +var \u{1319A}; +var \u{1319B}; +var \u{1319C}; +var \u{1319D}; +var \u{1319E}; +var \u{1319F}; +var \u{131A0}; +var \u{131A1}; +var \u{131A2}; +var \u{131A3}; +var \u{131A4}; +var \u{131A5}; +var \u{131A6}; +var \u{131A7}; +var \u{131A8}; +var \u{131A9}; +var \u{131AA}; +var \u{131AB}; +var \u{131AC}; +var \u{131AD}; +var \u{131AE}; +var \u{131AF}; +var \u{131B0}; +var \u{131B1}; +var \u{131B2}; +var \u{131B3}; +var \u{131B4}; +var \u{131B5}; +var \u{131B6}; +var \u{131B7}; +var \u{131B8}; +var \u{131B9}; +var \u{131BA}; +var \u{131BB}; +var \u{131BC}; +var \u{131BD}; +var \u{131BE}; +var \u{131BF}; +var \u{131C0}; +var \u{131C1}; +var \u{131C2}; +var \u{131C3}; +var \u{131C4}; +var \u{131C5}; +var \u{131C6}; +var \u{131C7}; +var \u{131C8}; +var \u{131C9}; +var \u{131CA}; +var \u{131CB}; +var \u{131CC}; +var \u{131CD}; +var \u{131CE}; +var \u{131CF}; +var \u{131D0}; +var \u{131D1}; +var \u{131D2}; +var \u{131D3}; +var \u{131D4}; +var \u{131D5}; +var \u{131D6}; +var \u{131D7}; +var \u{131D8}; +var \u{131D9}; +var \u{131DA}; +var \u{131DB}; +var \u{131DC}; +var \u{131DD}; +var \u{131DE}; +var \u{131DF}; +var \u{131E0}; +var \u{131E1}; +var \u{131E2}; +var \u{131E3}; +var \u{131E4}; +var \u{131E5}; +var \u{131E6}; +var \u{131E7}; +var \u{131E8}; +var \u{131E9}; +var \u{131EA}; +var \u{131EB}; +var \u{131EC}; +var \u{131ED}; +var \u{131EE}; +var \u{131EF}; +var \u{131F0}; +var \u{131F1}; +var \u{131F2}; +var \u{131F3}; +var \u{131F4}; +var \u{131F5}; +var \u{131F6}; +var \u{131F7}; +var \u{131F8}; +var \u{131F9}; +var \u{131FA}; +var \u{131FB}; +var \u{131FC}; +var \u{131FD}; +var \u{131FE}; +var \u{131FF}; +var \u{13200}; +var \u{13201}; +var \u{13202}; +var \u{13203}; +var \u{13204}; +var \u{13205}; +var \u{13206}; +var \u{13207}; +var \u{13208}; +var \u{13209}; +var \u{1320A}; +var \u{1320B}; +var \u{1320C}; +var \u{1320D}; +var \u{1320E}; +var \u{1320F}; +var \u{13210}; +var \u{13211}; +var \u{13212}; +var \u{13213}; +var \u{13214}; +var \u{13215}; +var \u{13216}; +var \u{13217}; +var \u{13218}; +var \u{13219}; +var \u{1321A}; +var \u{1321B}; +var \u{1321C}; +var \u{1321D}; +var \u{1321E}; +var \u{1321F}; +var \u{13220}; +var \u{13221}; +var \u{13222}; +var \u{13223}; +var \u{13224}; +var \u{13225}; +var \u{13226}; +var \u{13227}; +var \u{13228}; +var \u{13229}; +var \u{1322A}; +var \u{1322B}; +var \u{1322C}; +var \u{1322D}; +var \u{1322E}; +var \u{1322F}; +var \u{13230}; +var \u{13231}; +var \u{13232}; +var \u{13233}; +var \u{13234}; +var \u{13235}; +var \u{13236}; +var \u{13237}; +var \u{13238}; +var \u{13239}; +var \u{1323A}; +var \u{1323B}; +var \u{1323C}; +var \u{1323D}; +var \u{1323E}; +var \u{1323F}; +var \u{13240}; +var \u{13241}; +var \u{13242}; +var \u{13243}; +var \u{13244}; +var \u{13245}; +var \u{13246}; +var \u{13247}; +var \u{13248}; +var \u{13249}; +var \u{1324A}; +var \u{1324B}; +var \u{1324C}; +var \u{1324D}; +var \u{1324E}; +var \u{1324F}; +var \u{13250}; +var \u{13251}; +var \u{13252}; +var \u{13253}; +var \u{13254}; +var \u{13255}; +var \u{13256}; +var \u{13257}; +var \u{13258}; +var \u{13259}; +var \u{1325A}; +var \u{1325B}; +var \u{1325C}; +var \u{1325D}; +var \u{1325E}; +var \u{1325F}; +var \u{13260}; +var \u{13261}; +var \u{13262}; +var \u{13263}; +var \u{13264}; +var \u{13265}; +var \u{13266}; +var \u{13267}; +var \u{13268}; +var \u{13269}; +var \u{1326A}; +var \u{1326B}; +var \u{1326C}; +var \u{1326D}; +var \u{1326E}; +var \u{1326F}; +var \u{13270}; +var \u{13271}; +var \u{13272}; +var \u{13273}; +var \u{13274}; +var \u{13275}; +var \u{13276}; +var \u{13277}; +var \u{13278}; +var \u{13279}; +var \u{1327A}; +var \u{1327B}; +var \u{1327C}; +var \u{1327D}; +var \u{1327E}; +var \u{1327F}; +var \u{13280}; +var \u{13281}; +var \u{13282}; +var \u{13283}; +var \u{13284}; +var \u{13285}; +var \u{13286}; +var \u{13287}; +var \u{13288}; +var \u{13289}; +var \u{1328A}; +var \u{1328B}; +var \u{1328C}; +var \u{1328D}; +var \u{1328E}; +var \u{1328F}; +var \u{13290}; +var \u{13291}; +var \u{13292}; +var \u{13293}; +var \u{13294}; +var \u{13295}; +var \u{13296}; +var \u{13297}; +var \u{13298}; +var \u{13299}; +var \u{1329A}; +var \u{1329B}; +var \u{1329C}; +var \u{1329D}; +var \u{1329E}; +var \u{1329F}; +var \u{132A0}; +var \u{132A1}; +var \u{132A2}; +var \u{132A3}; +var \u{132A4}; +var \u{132A5}; +var \u{132A6}; +var \u{132A7}; +var \u{132A8}; +var \u{132A9}; +var \u{132AA}; +var \u{132AB}; +var \u{132AC}; +var \u{132AD}; +var \u{132AE}; +var \u{132AF}; +var \u{132B0}; +var \u{132B1}; +var \u{132B2}; +var \u{132B3}; +var \u{132B4}; +var \u{132B5}; +var \u{132B6}; +var \u{132B7}; +var \u{132B8}; +var \u{132B9}; +var \u{132BA}; +var \u{132BB}; +var \u{132BC}; +var \u{132BD}; +var \u{132BE}; +var \u{132BF}; +var \u{132C0}; +var \u{132C1}; +var \u{132C2}; +var \u{132C3}; +var \u{132C4}; +var \u{132C5}; +var \u{132C6}; +var \u{132C7}; +var \u{132C8}; +var \u{132C9}; +var \u{132CA}; +var \u{132CB}; +var \u{132CC}; +var \u{132CD}; +var \u{132CE}; +var \u{132CF}; +var \u{132D0}; +var \u{132D1}; +var \u{132D2}; +var \u{132D3}; +var \u{132D4}; +var \u{132D5}; +var \u{132D6}; +var \u{132D7}; +var \u{132D8}; +var \u{132D9}; +var \u{132DA}; +var \u{132DB}; +var \u{132DC}; +var \u{132DD}; +var \u{132DE}; +var \u{132DF}; +var \u{132E0}; +var \u{132E1}; +var \u{132E2}; +var \u{132E3}; +var \u{132E4}; +var \u{132E5}; +var \u{132E6}; +var \u{132E7}; +var \u{132E8}; +var \u{132E9}; +var \u{132EA}; +var \u{132EB}; +var \u{132EC}; +var \u{132ED}; +var \u{132EE}; +var \u{132EF}; +var \u{132F0}; +var \u{132F1}; +var \u{132F2}; +var \u{132F3}; +var \u{132F4}; +var \u{132F5}; +var \u{132F6}; +var \u{132F7}; +var \u{132F8}; +var \u{132F9}; +var \u{132FA}; +var \u{132FB}; +var \u{132FC}; +var \u{132FD}; +var \u{132FE}; +var \u{132FF}; +var \u{13300}; +var \u{13301}; +var \u{13302}; +var \u{13303}; +var \u{13304}; +var \u{13305}; +var \u{13306}; +var \u{13307}; +var \u{13308}; +var \u{13309}; +var \u{1330A}; +var \u{1330B}; +var \u{1330C}; +var \u{1330D}; +var \u{1330E}; +var \u{1330F}; +var \u{13310}; +var \u{13311}; +var \u{13312}; +var \u{13313}; +var \u{13314}; +var \u{13315}; +var \u{13316}; +var \u{13317}; +var \u{13318}; +var \u{13319}; +var \u{1331A}; +var \u{1331B}; +var \u{1331C}; +var \u{1331D}; +var \u{1331E}; +var \u{1331F}; +var \u{13320}; +var \u{13321}; +var \u{13322}; +var \u{13323}; +var \u{13324}; +var \u{13325}; +var \u{13326}; +var \u{13327}; +var \u{13328}; +var \u{13329}; +var \u{1332A}; +var \u{1332B}; +var \u{1332C}; +var \u{1332D}; +var \u{1332E}; +var \u{1332F}; +var \u{13330}; +var \u{13331}; +var \u{13332}; +var \u{13333}; +var \u{13334}; +var \u{13335}; +var \u{13336}; +var \u{13337}; +var \u{13338}; +var \u{13339}; +var \u{1333A}; +var \u{1333B}; +var \u{1333C}; +var \u{1333D}; +var \u{1333E}; +var \u{1333F}; +var \u{13340}; +var \u{13341}; +var \u{13342}; +var \u{13343}; +var \u{13344}; +var \u{13345}; +var \u{13346}; +var \u{13347}; +var \u{13348}; +var \u{13349}; +var \u{1334A}; +var \u{1334B}; +var \u{1334C}; +var \u{1334D}; +var \u{1334E}; +var \u{1334F}; +var \u{13350}; +var \u{13351}; +var \u{13352}; +var \u{13353}; +var \u{13354}; +var \u{13355}; +var \u{13356}; +var \u{13357}; +var \u{13358}; +var \u{13359}; +var \u{1335A}; +var \u{1335B}; +var \u{1335C}; +var \u{1335D}; +var \u{1335E}; +var \u{1335F}; +var \u{13360}; +var \u{13361}; +var \u{13362}; +var \u{13363}; +var \u{13364}; +var \u{13365}; +var \u{13366}; +var \u{13367}; +var \u{13368}; +var \u{13369}; +var \u{1336A}; +var \u{1336B}; +var \u{1336C}; +var \u{1336D}; +var \u{1336E}; +var \u{1336F}; +var \u{13370}; +var \u{13371}; +var \u{13372}; +var \u{13373}; +var \u{13374}; +var \u{13375}; +var \u{13376}; +var \u{13377}; +var \u{13378}; +var \u{13379}; +var \u{1337A}; +var \u{1337B}; +var \u{1337C}; +var \u{1337D}; +var \u{1337E}; +var \u{1337F}; +var \u{13380}; +var \u{13381}; +var \u{13382}; +var \u{13383}; +var \u{13384}; +var \u{13385}; +var \u{13386}; +var \u{13387}; +var \u{13388}; +var \u{13389}; +var \u{1338A}; +var \u{1338B}; +var \u{1338C}; +var \u{1338D}; +var \u{1338E}; +var \u{1338F}; +var \u{13390}; +var \u{13391}; +var \u{13392}; +var \u{13393}; +var \u{13394}; +var \u{13395}; +var \u{13396}; +var \u{13397}; +var \u{13398}; +var \u{13399}; +var \u{1339A}; +var \u{1339B}; +var \u{1339C}; +var \u{1339D}; +var \u{1339E}; +var \u{1339F}; +var \u{133A0}; +var \u{133A1}; +var \u{133A2}; +var \u{133A3}; +var \u{133A4}; +var \u{133A5}; +var \u{133A6}; +var \u{133A7}; +var \u{133A8}; +var \u{133A9}; +var \u{133AA}; +var \u{133AB}; +var \u{133AC}; +var \u{133AD}; +var \u{133AE}; +var \u{133AF}; +var \u{133B0}; +var \u{133B1}; +var \u{133B2}; +var \u{133B3}; +var \u{133B4}; +var \u{133B5}; +var \u{133B6}; +var \u{133B7}; +var \u{133B8}; +var \u{133B9}; +var \u{133BA}; +var \u{133BB}; +var \u{133BC}; +var \u{133BD}; +var \u{133BE}; +var \u{133BF}; +var \u{133C0}; +var \u{133C1}; +var \u{133C2}; +var \u{133C3}; +var \u{133C4}; +var \u{133C5}; +var \u{133C6}; +var \u{133C7}; +var \u{133C8}; +var \u{133C9}; +var \u{133CA}; +var \u{133CB}; +var \u{133CC}; +var \u{133CD}; +var \u{133CE}; +var \u{133CF}; +var \u{133D0}; +var \u{133D1}; +var \u{133D2}; +var \u{133D3}; +var \u{133D4}; +var \u{133D5}; +var \u{133D6}; +var \u{133D7}; +var \u{133D8}; +var \u{133D9}; +var \u{133DA}; +var \u{133DB}; +var \u{133DC}; +var \u{133DD}; +var \u{133DE}; +var \u{133DF}; +var \u{133E0}; +var \u{133E1}; +var \u{133E2}; +var \u{133E3}; +var \u{133E4}; +var \u{133E5}; +var \u{133E6}; +var \u{133E7}; +var \u{133E8}; +var \u{133E9}; +var \u{133EA}; +var \u{133EB}; +var \u{133EC}; +var \u{133ED}; +var \u{133EE}; +var \u{133EF}; +var \u{133F0}; +var \u{133F1}; +var \u{133F2}; +var \u{133F3}; +var \u{133F4}; +var \u{133F5}; +var \u{133F6}; +var \u{133F7}; +var \u{133F8}; +var \u{133F9}; +var \u{133FA}; +var \u{133FB}; +var \u{133FC}; +var \u{133FD}; +var \u{133FE}; +var \u{133FF}; +var \u{13400}; +var \u{13401}; +var \u{13402}; +var \u{13403}; +var \u{13404}; +var \u{13405}; +var \u{13406}; +var \u{13407}; +var \u{13408}; +var \u{13409}; +var \u{1340A}; +var \u{1340B}; +var \u{1340C}; +var \u{1340D}; +var \u{1340E}; +var \u{1340F}; +var \u{13410}; +var \u{13411}; +var \u{13412}; +var \u{13413}; +var \u{13414}; +var \u{13415}; +var \u{13416}; +var \u{13417}; +var \u{13418}; +var \u{13419}; +var \u{1341A}; +var \u{1341B}; +var \u{1341C}; +var \u{1341D}; +var \u{1341E}; +var \u{1341F}; +var \u{13420}; +var \u{13421}; +var \u{13422}; +var \u{13423}; +var \u{13424}; +var \u{13425}; +var \u{13426}; +var \u{13427}; +var \u{13428}; +var \u{13429}; +var \u{1342A}; +var \u{1342B}; +var \u{1342C}; +var \u{1342D}; +var \u{1342E}; +var \u{2A700}; +var \u{2A701}; +var \u{2A702}; +var \u{2A703}; +var \u{2A704}; +var \u{2A705}; +var \u{2A706}; +var \u{2A707}; +var \u{2A708}; +var \u{2A709}; +var \u{2A70A}; +var \u{2A70B}; +var \u{2A70C}; +var \u{2A70D}; +var \u{2A70E}; +var \u{2A70F}; +var \u{2A710}; +var \u{2A711}; +var \u{2A712}; +var \u{2A713}; +var \u{2A714}; +var \u{2A715}; +var \u{2A716}; +var \u{2A717}; +var \u{2A718}; +var \u{2A719}; +var \u{2A71A}; +var \u{2A71B}; +var \u{2A71C}; +var \u{2A71D}; +var \u{2A71E}; +var \u{2A71F}; +var \u{2A720}; +var \u{2A721}; +var \u{2A722}; +var \u{2A723}; +var \u{2A724}; +var \u{2A725}; +var \u{2A726}; +var \u{2A727}; +var \u{2A728}; +var \u{2A729}; +var \u{2A72A}; +var \u{2A72B}; +var \u{2A72C}; +var \u{2A72D}; +var \u{2A72E}; +var \u{2A72F}; +var \u{2A730}; +var \u{2A731}; +var \u{2A732}; +var \u{2A733}; +var \u{2A734}; +var \u{2A735}; +var \u{2A736}; +var \u{2A737}; +var \u{2A738}; +var \u{2A739}; +var \u{2A73A}; +var \u{2A73B}; +var \u{2A73C}; +var \u{2A73D}; +var \u{2A73E}; +var \u{2A73F}; +var \u{2A740}; +var \u{2A741}; +var \u{2A742}; +var \u{2A743}; +var \u{2A744}; +var \u{2A745}; +var \u{2A746}; +var \u{2A747}; +var \u{2A748}; +var \u{2A749}; +var \u{2A74A}; +var \u{2A74B}; +var \u{2A74C}; +var \u{2A74D}; +var \u{2A74E}; +var \u{2A74F}; +var \u{2A750}; +var \u{2A751}; +var \u{2A752}; +var \u{2A753}; +var \u{2A754}; +var \u{2A755}; +var \u{2A756}; +var \u{2A757}; +var \u{2A758}; +var \u{2A759}; +var \u{2A75A}; +var \u{2A75B}; +var \u{2A75C}; +var \u{2A75D}; +var \u{2A75E}; +var \u{2A75F}; +var \u{2A760}; +var \u{2A761}; +var \u{2A762}; +var \u{2A763}; +var \u{2A764}; +var \u{2A765}; +var \u{2A766}; +var \u{2A767}; +var \u{2A768}; +var \u{2A769}; +var \u{2A76A}; +var \u{2A76B}; +var \u{2A76C}; +var \u{2A76D}; +var \u{2A76E}; +var \u{2A76F}; +var \u{2A770}; +var \u{2A771}; +var \u{2A772}; +var \u{2A773}; +var \u{2A774}; +var \u{2A775}; +var \u{2A776}; +var \u{2A777}; +var \u{2A778}; +var \u{2A779}; +var \u{2A77A}; +var \u{2A77B}; +var \u{2A77C}; +var \u{2A77D}; +var \u{2A77E}; +var \u{2A77F}; +var \u{2A780}; +var \u{2A781}; +var \u{2A782}; +var \u{2A783}; +var \u{2A784}; +var \u{2A785}; +var \u{2A786}; +var \u{2A787}; +var \u{2A788}; +var \u{2A789}; +var \u{2A78A}; +var \u{2A78B}; +var \u{2A78C}; +var \u{2A78D}; +var \u{2A78E}; +var \u{2A78F}; +var \u{2A790}; +var \u{2A791}; +var \u{2A792}; +var \u{2A793}; +var \u{2A794}; +var \u{2A795}; +var \u{2A796}; +var \u{2A797}; +var \u{2A798}; +var \u{2A799}; +var \u{2A79A}; +var \u{2A79B}; +var \u{2A79C}; +var \u{2A79D}; +var \u{2A79E}; +var \u{2A79F}; +var \u{2A7A0}; +var \u{2A7A1}; +var \u{2A7A2}; +var \u{2A7A3}; +var \u{2A7A4}; +var \u{2A7A5}; +var \u{2A7A6}; +var \u{2A7A7}; +var \u{2A7A8}; +var \u{2A7A9}; +var \u{2A7AA}; +var \u{2A7AB}; +var \u{2A7AC}; +var \u{2A7AD}; +var \u{2A7AE}; +var \u{2A7AF}; +var \u{2A7B0}; +var \u{2A7B1}; +var \u{2A7B2}; +var \u{2A7B3}; +var \u{2A7B4}; +var \u{2A7B5}; +var \u{2A7B6}; +var \u{2A7B7}; +var \u{2A7B8}; +var \u{2A7B9}; +var \u{2A7BA}; +var \u{2A7BB}; +var \u{2A7BC}; +var \u{2A7BD}; +var \u{2A7BE}; +var \u{2A7BF}; +var \u{2A7C0}; +var \u{2A7C1}; +var \u{2A7C2}; +var \u{2A7C3}; +var \u{2A7C4}; +var \u{2A7C5}; +var \u{2A7C6}; +var \u{2A7C7}; +var \u{2A7C8}; +var \u{2A7C9}; +var \u{2A7CA}; +var \u{2A7CB}; +var \u{2A7CC}; +var \u{2A7CD}; +var \u{2A7CE}; +var \u{2A7CF}; +var \u{2A7D0}; +var \u{2A7D1}; +var \u{2A7D2}; +var \u{2A7D3}; +var \u{2A7D4}; +var \u{2A7D5}; +var \u{2A7D6}; +var \u{2A7D7}; +var \u{2A7D8}; +var \u{2A7D9}; +var \u{2A7DA}; +var \u{2A7DB}; +var \u{2A7DC}; +var \u{2A7DD}; +var \u{2A7DE}; +var \u{2A7DF}; +var \u{2A7E0}; +var \u{2A7E1}; +var \u{2A7E2}; +var \u{2A7E3}; +var \u{2A7E4}; +var \u{2A7E5}; +var \u{2A7E6}; +var \u{2A7E7}; +var \u{2A7E8}; +var \u{2A7E9}; +var \u{2A7EA}; +var \u{2A7EB}; +var \u{2A7EC}; +var \u{2A7ED}; +var \u{2A7EE}; +var \u{2A7EF}; +var \u{2A7F0}; +var \u{2A7F1}; +var \u{2A7F2}; +var \u{2A7F3}; +var \u{2A7F4}; +var \u{2A7F5}; +var \u{2A7F6}; +var \u{2A7F7}; +var \u{2A7F8}; +var \u{2A7F9}; +var \u{2A7FA}; +var \u{2A7FB}; +var \u{2A7FC}; +var \u{2A7FD}; +var \u{2A7FE}; +var \u{2A7FF}; +var \u{2A800}; +var \u{2A801}; +var \u{2A802}; +var \u{2A803}; +var \u{2A804}; +var \u{2A805}; +var \u{2A806}; +var \u{2A807}; +var \u{2A808}; +var \u{2A809}; +var \u{2A80A}; +var \u{2A80B}; +var \u{2A80C}; +var \u{2A80D}; +var \u{2A80E}; +var \u{2A80F}; +var \u{2A810}; +var \u{2A811}; +var \u{2A812}; +var \u{2A813}; +var \u{2A814}; +var \u{2A815}; +var \u{2A816}; +var \u{2A817}; +var \u{2A818}; +var \u{2A819}; +var \u{2A81A}; +var \u{2A81B}; +var \u{2A81C}; +var \u{2A81D}; +var \u{2A81E}; +var \u{2A81F}; +var \u{2A820}; +var \u{2A821}; +var \u{2A822}; +var \u{2A823}; +var \u{2A824}; +var \u{2A825}; +var \u{2A826}; +var \u{2A827}; +var \u{2A828}; +var \u{2A829}; +var \u{2A82A}; +var \u{2A82B}; +var \u{2A82C}; +var \u{2A82D}; +var \u{2A82E}; +var \u{2A82F}; +var \u{2A830}; +var \u{2A831}; +var \u{2A832}; +var \u{2A833}; +var \u{2A834}; +var \u{2A835}; +var \u{2A836}; +var \u{2A837}; +var \u{2A838}; +var \u{2A839}; +var \u{2A83A}; +var \u{2A83B}; +var \u{2A83C}; +var \u{2A83D}; +var \u{2A83E}; +var \u{2A83F}; +var \u{2A840}; +var \u{2A841}; +var \u{2A842}; +var \u{2A843}; +var \u{2A844}; +var \u{2A845}; +var \u{2A846}; +var \u{2A847}; +var \u{2A848}; +var \u{2A849}; +var \u{2A84A}; +var \u{2A84B}; +var \u{2A84C}; +var \u{2A84D}; +var \u{2A84E}; +var \u{2A84F}; +var \u{2A850}; +var \u{2A851}; +var \u{2A852}; +var \u{2A853}; +var \u{2A854}; +var \u{2A855}; +var \u{2A856}; +var \u{2A857}; +var \u{2A858}; +var \u{2A859}; +var \u{2A85A}; +var \u{2A85B}; +var \u{2A85C}; +var \u{2A85D}; +var \u{2A85E}; +var \u{2A85F}; +var \u{2A860}; +var \u{2A861}; +var \u{2A862}; +var \u{2A863}; +var \u{2A864}; +var \u{2A865}; +var \u{2A866}; +var \u{2A867}; +var \u{2A868}; +var \u{2A869}; +var \u{2A86A}; +var \u{2A86B}; +var \u{2A86C}; +var \u{2A86D}; +var \u{2A86E}; +var \u{2A86F}; +var \u{2A870}; +var \u{2A871}; +var \u{2A872}; +var \u{2A873}; +var \u{2A874}; +var \u{2A875}; +var \u{2A876}; +var \u{2A877}; +var \u{2A878}; +var \u{2A879}; +var \u{2A87A}; +var \u{2A87B}; +var \u{2A87C}; +var \u{2A87D}; +var \u{2A87E}; +var \u{2A87F}; +var \u{2A880}; +var \u{2A881}; +var \u{2A882}; +var \u{2A883}; +var \u{2A884}; +var \u{2A885}; +var \u{2A886}; +var \u{2A887}; +var \u{2A888}; +var \u{2A889}; +var \u{2A88A}; +var \u{2A88B}; +var \u{2A88C}; +var \u{2A88D}; +var \u{2A88E}; +var \u{2A88F}; +var \u{2A890}; +var \u{2A891}; +var \u{2A892}; +var \u{2A893}; +var \u{2A894}; +var \u{2A895}; +var \u{2A896}; +var \u{2A897}; +var \u{2A898}; +var \u{2A899}; +var \u{2A89A}; +var \u{2A89B}; +var \u{2A89C}; +var \u{2A89D}; +var \u{2A89E}; +var \u{2A89F}; +var \u{2A8A0}; +var \u{2A8A1}; +var \u{2A8A2}; +var \u{2A8A3}; +var \u{2A8A4}; +var \u{2A8A5}; +var \u{2A8A6}; +var \u{2A8A7}; +var \u{2A8A8}; +var \u{2A8A9}; +var \u{2A8AA}; +var \u{2A8AB}; +var \u{2A8AC}; +var \u{2A8AD}; +var \u{2A8AE}; +var \u{2A8AF}; +var \u{2A8B0}; +var \u{2A8B1}; +var \u{2A8B2}; +var \u{2A8B3}; +var \u{2A8B4}; +var \u{2A8B5}; +var \u{2A8B6}; +var \u{2A8B7}; +var \u{2A8B8}; +var \u{2A8B9}; +var \u{2A8BA}; +var \u{2A8BB}; +var \u{2A8BC}; +var \u{2A8BD}; +var \u{2A8BE}; +var \u{2A8BF}; +var \u{2A8C0}; +var \u{2A8C1}; +var \u{2A8C2}; +var \u{2A8C3}; +var \u{2A8C4}; +var \u{2A8C5}; +var \u{2A8C6}; +var \u{2A8C7}; +var \u{2A8C8}; +var \u{2A8C9}; +var \u{2A8CA}; +var \u{2A8CB}; +var \u{2A8CC}; +var \u{2A8CD}; +var \u{2A8CE}; +var \u{2A8CF}; +var \u{2A8D0}; +var \u{2A8D1}; +var \u{2A8D2}; +var \u{2A8D3}; +var \u{2A8D4}; +var \u{2A8D5}; +var \u{2A8D6}; +var \u{2A8D7}; +var \u{2A8D8}; +var \u{2A8D9}; +var \u{2A8DA}; +var \u{2A8DB}; +var \u{2A8DC}; +var \u{2A8DD}; +var \u{2A8DE}; +var \u{2A8DF}; +var \u{2A8E0}; +var \u{2A8E1}; +var \u{2A8E2}; +var \u{2A8E3}; +var \u{2A8E4}; +var \u{2A8E5}; +var \u{2A8E6}; +var \u{2A8E7}; +var \u{2A8E8}; +var \u{2A8E9}; +var \u{2A8EA}; +var \u{2A8EB}; +var \u{2A8EC}; +var \u{2A8ED}; +var \u{2A8EE}; +var \u{2A8EF}; +var \u{2A8F0}; +var \u{2A8F1}; +var \u{2A8F2}; +var \u{2A8F3}; +var \u{2A8F4}; +var \u{2A8F5}; +var \u{2A8F6}; +var \u{2A8F7}; +var \u{2A8F8}; +var \u{2A8F9}; +var \u{2A8FA}; +var \u{2A8FB}; +var \u{2A8FC}; +var \u{2A8FD}; +var \u{2A8FE}; +var \u{2A8FF}; +var \u{2A900}; +var \u{2A901}; +var \u{2A902}; +var \u{2A903}; +var \u{2A904}; +var \u{2A905}; +var \u{2A906}; +var \u{2A907}; +var \u{2A908}; +var \u{2A909}; +var \u{2A90A}; +var \u{2A90B}; +var \u{2A90C}; +var \u{2A90D}; +var \u{2A90E}; +var \u{2A90F}; +var \u{2A910}; +var \u{2A911}; +var \u{2A912}; +var \u{2A913}; +var \u{2A914}; +var \u{2A915}; +var \u{2A916}; +var \u{2A917}; +var \u{2A918}; +var \u{2A919}; +var \u{2A91A}; +var \u{2A91B}; +var \u{2A91C}; +var \u{2A91D}; +var \u{2A91E}; +var \u{2A91F}; +var \u{2A920}; +var \u{2A921}; +var \u{2A922}; +var \u{2A923}; +var \u{2A924}; +var \u{2A925}; +var \u{2A926}; +var \u{2A927}; +var \u{2A928}; +var \u{2A929}; +var \u{2A92A}; +var \u{2A92B}; +var \u{2A92C}; +var \u{2A92D}; +var \u{2A92E}; +var \u{2A92F}; +var \u{2A930}; +var \u{2A931}; +var \u{2A932}; +var \u{2A933}; +var \u{2A934}; +var \u{2A935}; +var \u{2A936}; +var \u{2A937}; +var \u{2A938}; +var \u{2A939}; +var \u{2A93A}; +var \u{2A93B}; +var \u{2A93C}; +var \u{2A93D}; +var \u{2A93E}; +var \u{2A93F}; +var \u{2A940}; +var \u{2A941}; +var \u{2A942}; +var \u{2A943}; +var \u{2A944}; +var \u{2A945}; +var \u{2A946}; +var \u{2A947}; +var \u{2A948}; +var \u{2A949}; +var \u{2A94A}; +var \u{2A94B}; +var \u{2A94C}; +var \u{2A94D}; +var \u{2A94E}; +var \u{2A94F}; +var \u{2A950}; +var \u{2A951}; +var \u{2A952}; +var \u{2A953}; +var \u{2A954}; +var \u{2A955}; +var \u{2A956}; +var \u{2A957}; +var \u{2A958}; +var \u{2A959}; +var \u{2A95A}; +var \u{2A95B}; +var \u{2A95C}; +var \u{2A95D}; +var \u{2A95E}; +var \u{2A95F}; +var \u{2A960}; +var \u{2A961}; +var \u{2A962}; +var \u{2A963}; +var \u{2A964}; +var \u{2A965}; +var \u{2A966}; +var \u{2A967}; +var \u{2A968}; +var \u{2A969}; +var \u{2A96A}; +var \u{2A96B}; +var \u{2A96C}; +var \u{2A96D}; +var \u{2A96E}; +var \u{2A96F}; +var \u{2A970}; +var \u{2A971}; +var \u{2A972}; +var \u{2A973}; +var \u{2A974}; +var \u{2A975}; +var \u{2A976}; +var \u{2A977}; +var \u{2A978}; +var \u{2A979}; +var \u{2A97A}; +var \u{2A97B}; +var \u{2A97C}; +var \u{2A97D}; +var \u{2A97E}; +var \u{2A97F}; +var \u{2A980}; +var \u{2A981}; +var \u{2A982}; +var \u{2A983}; +var \u{2A984}; +var \u{2A985}; +var \u{2A986}; +var \u{2A987}; +var \u{2A988}; +var \u{2A989}; +var \u{2A98A}; +var \u{2A98B}; +var \u{2A98C}; +var \u{2A98D}; +var \u{2A98E}; +var \u{2A98F}; +var \u{2A990}; +var \u{2A991}; +var \u{2A992}; +var \u{2A993}; +var \u{2A994}; +var \u{2A995}; +var \u{2A996}; +var \u{2A997}; +var \u{2A998}; +var \u{2A999}; +var \u{2A99A}; +var \u{2A99B}; +var \u{2A99C}; +var \u{2A99D}; +var \u{2A99E}; +var \u{2A99F}; +var \u{2A9A0}; +var \u{2A9A1}; +var \u{2A9A2}; +var \u{2A9A3}; +var \u{2A9A4}; +var \u{2A9A5}; +var \u{2A9A6}; +var \u{2A9A7}; +var \u{2A9A8}; +var \u{2A9A9}; +var \u{2A9AA}; +var \u{2A9AB}; +var \u{2A9AC}; +var \u{2A9AD}; +var \u{2A9AE}; +var \u{2A9AF}; +var \u{2A9B0}; +var \u{2A9B1}; +var \u{2A9B2}; +var \u{2A9B3}; +var \u{2A9B4}; +var \u{2A9B5}; +var \u{2A9B6}; +var \u{2A9B7}; +var \u{2A9B8}; +var \u{2A9B9}; +var \u{2A9BA}; +var \u{2A9BB}; +var \u{2A9BC}; +var \u{2A9BD}; +var \u{2A9BE}; +var \u{2A9BF}; +var \u{2A9C0}; +var \u{2A9C1}; +var \u{2A9C2}; +var \u{2A9C3}; +var \u{2A9C4}; +var \u{2A9C5}; +var \u{2A9C6}; +var \u{2A9C7}; +var \u{2A9C8}; +var \u{2A9C9}; +var \u{2A9CA}; +var \u{2A9CB}; +var \u{2A9CC}; +var \u{2A9CD}; +var \u{2A9CE}; +var \u{2A9CF}; +var \u{2A9D0}; +var \u{2A9D1}; +var \u{2A9D2}; +var \u{2A9D3}; +var \u{2A9D4}; +var \u{2A9D5}; +var \u{2A9D6}; +var \u{2A9D7}; +var \u{2A9D8}; +var \u{2A9D9}; +var \u{2A9DA}; +var \u{2A9DB}; +var \u{2A9DC}; +var \u{2A9DD}; +var \u{2A9DE}; +var \u{2A9DF}; +var \u{2A9E0}; +var \u{2A9E1}; +var \u{2A9E2}; +var \u{2A9E3}; +var \u{2A9E4}; +var \u{2A9E5}; +var \u{2A9E6}; +var \u{2A9E7}; +var \u{2A9E8}; +var \u{2A9E9}; +var \u{2A9EA}; +var \u{2A9EB}; +var \u{2A9EC}; +var \u{2A9ED}; +var \u{2A9EE}; +var \u{2A9EF}; +var \u{2A9F0}; +var \u{2A9F1}; +var \u{2A9F2}; +var \u{2A9F3}; +var \u{2A9F4}; +var \u{2A9F5}; +var \u{2A9F6}; +var \u{2A9F7}; +var \u{2A9F8}; +var \u{2A9F9}; +var \u{2A9FA}; +var \u{2A9FB}; +var \u{2A9FC}; +var \u{2A9FD}; +var \u{2A9FE}; +var \u{2A9FF}; +var \u{2AA00}; +var \u{2AA01}; +var \u{2AA02}; +var \u{2AA03}; +var \u{2AA04}; +var \u{2AA05}; +var \u{2AA06}; +var \u{2AA07}; +var \u{2AA08}; +var \u{2AA09}; +var \u{2AA0A}; +var \u{2AA0B}; +var \u{2AA0C}; +var \u{2AA0D}; +var \u{2AA0E}; +var \u{2AA0F}; +var \u{2AA10}; +var \u{2AA11}; +var \u{2AA12}; +var \u{2AA13}; +var \u{2AA14}; +var \u{2AA15}; +var \u{2AA16}; +var \u{2AA17}; +var \u{2AA18}; +var \u{2AA19}; +var \u{2AA1A}; +var \u{2AA1B}; +var \u{2AA1C}; +var \u{2AA1D}; +var \u{2AA1E}; +var \u{2AA1F}; +var \u{2AA20}; +var \u{2AA21}; +var \u{2AA22}; +var \u{2AA23}; +var \u{2AA24}; +var \u{2AA25}; +var \u{2AA26}; +var \u{2AA27}; +var \u{2AA28}; +var \u{2AA29}; +var \u{2AA2A}; +var \u{2AA2B}; +var \u{2AA2C}; +var \u{2AA2D}; +var \u{2AA2E}; +var \u{2AA2F}; +var \u{2AA30}; +var \u{2AA31}; +var \u{2AA32}; +var \u{2AA33}; +var \u{2AA34}; +var \u{2AA35}; +var \u{2AA36}; +var \u{2AA37}; +var \u{2AA38}; +var \u{2AA39}; +var \u{2AA3A}; +var \u{2AA3B}; +var \u{2AA3C}; +var \u{2AA3D}; +var \u{2AA3E}; +var \u{2AA3F}; +var \u{2AA40}; +var \u{2AA41}; +var \u{2AA42}; +var \u{2AA43}; +var \u{2AA44}; +var \u{2AA45}; +var \u{2AA46}; +var \u{2AA47}; +var \u{2AA48}; +var \u{2AA49}; +var \u{2AA4A}; +var \u{2AA4B}; +var \u{2AA4C}; +var \u{2AA4D}; +var \u{2AA4E}; +var \u{2AA4F}; +var \u{2AA50}; +var \u{2AA51}; +var \u{2AA52}; +var \u{2AA53}; +var \u{2AA54}; +var \u{2AA55}; +var \u{2AA56}; +var \u{2AA57}; +var \u{2AA58}; +var \u{2AA59}; +var \u{2AA5A}; +var \u{2AA5B}; +var \u{2AA5C}; +var \u{2AA5D}; +var \u{2AA5E}; +var \u{2AA5F}; +var \u{2AA60}; +var \u{2AA61}; +var \u{2AA62}; +var \u{2AA63}; +var \u{2AA64}; +var \u{2AA65}; +var \u{2AA66}; +var \u{2AA67}; +var \u{2AA68}; +var \u{2AA69}; +var \u{2AA6A}; +var \u{2AA6B}; +var \u{2AA6C}; +var \u{2AA6D}; +var \u{2AA6E}; +var \u{2AA6F}; +var \u{2AA70}; +var \u{2AA71}; +var \u{2AA72}; +var \u{2AA73}; +var \u{2AA74}; +var \u{2AA75}; +var \u{2AA76}; +var \u{2AA77}; +var \u{2AA78}; +var \u{2AA79}; +var \u{2AA7A}; +var \u{2AA7B}; +var \u{2AA7C}; +var \u{2AA7D}; +var \u{2AA7E}; +var \u{2AA7F}; +var \u{2AA80}; +var \u{2AA81}; +var \u{2AA82}; +var \u{2AA83}; +var \u{2AA84}; +var \u{2AA85}; +var \u{2AA86}; +var \u{2AA87}; +var \u{2AA88}; +var \u{2AA89}; +var \u{2AA8A}; +var \u{2AA8B}; +var \u{2AA8C}; +var \u{2AA8D}; +var \u{2AA8E}; +var \u{2AA8F}; +var \u{2AA90}; +var \u{2AA91}; +var \u{2AA92}; +var \u{2AA93}; +var \u{2AA94}; +var \u{2AA95}; +var \u{2AA96}; +var \u{2AA97}; +var \u{2AA98}; +var \u{2AA99}; +var \u{2AA9A}; +var \u{2AA9B}; +var \u{2AA9C}; +var \u{2AA9D}; +var \u{2AA9E}; +var \u{2AA9F}; +var \u{2AAA0}; +var \u{2AAA1}; +var \u{2AAA2}; +var \u{2AAA3}; +var \u{2AAA4}; +var \u{2AAA5}; +var \u{2AAA6}; +var \u{2AAA7}; +var \u{2AAA8}; +var \u{2AAA9}; +var \u{2AAAA}; +var \u{2AAAB}; +var \u{2AAAC}; +var \u{2AAAD}; +var \u{2AAAE}; +var \u{2AAAF}; +var \u{2AAB0}; +var \u{2AAB1}; +var \u{2AAB2}; +var \u{2AAB3}; +var \u{2AAB4}; +var \u{2AAB5}; +var \u{2AAB6}; +var \u{2AAB7}; +var \u{2AAB8}; +var \u{2AAB9}; +var \u{2AABA}; +var \u{2AABB}; +var \u{2AABC}; +var \u{2AABD}; +var \u{2AABE}; +var \u{2AABF}; +var \u{2AAC0}; +var \u{2AAC1}; +var \u{2AAC2}; +var \u{2AAC3}; +var \u{2AAC4}; +var \u{2AAC5}; +var \u{2AAC6}; +var \u{2AAC7}; +var \u{2AAC8}; +var \u{2AAC9}; +var \u{2AACA}; +var \u{2AACB}; +var \u{2AACC}; +var \u{2AACD}; +var \u{2AACE}; +var \u{2AACF}; +var \u{2AAD0}; +var \u{2AAD1}; +var \u{2AAD2}; +var \u{2AAD3}; +var \u{2AAD4}; +var \u{2AAD5}; +var \u{2AAD6}; +var \u{2AAD7}; +var \u{2AAD8}; +var \u{2AAD9}; +var \u{2AADA}; +var \u{2AADB}; +var \u{2AADC}; +var \u{2AADD}; +var \u{2AADE}; +var \u{2AADF}; +var \u{2AAE0}; +var \u{2AAE1}; +var \u{2AAE2}; +var \u{2AAE3}; +var \u{2AAE4}; +var \u{2AAE5}; +var \u{2AAE6}; +var \u{2AAE7}; +var \u{2AAE8}; +var \u{2AAE9}; +var \u{2AAEA}; +var \u{2AAEB}; +var \u{2AAEC}; +var \u{2AAED}; +var \u{2AAEE}; +var \u{2AAEF}; +var \u{2AAF0}; +var \u{2AAF1}; +var \u{2AAF2}; +var \u{2AAF3}; +var \u{2AAF4}; +var \u{2AAF5}; +var \u{2AAF6}; +var \u{2AAF7}; +var \u{2AAF8}; +var \u{2AAF9}; +var \u{2AAFA}; +var \u{2AAFB}; +var \u{2AAFC}; +var \u{2AAFD}; +var \u{2AAFE}; +var \u{2AAFF}; +var \u{2AB00}; +var \u{2AB01}; +var \u{2AB02}; +var \u{2AB03}; +var \u{2AB04}; +var \u{2AB05}; +var \u{2AB06}; +var \u{2AB07}; +var \u{2AB08}; +var \u{2AB09}; +var \u{2AB0A}; +var \u{2AB0B}; +var \u{2AB0C}; +var \u{2AB0D}; +var \u{2AB0E}; +var \u{2AB0F}; +var \u{2AB10}; +var \u{2AB11}; +var \u{2AB12}; +var \u{2AB13}; +var \u{2AB14}; +var \u{2AB15}; +var \u{2AB16}; +var \u{2AB17}; +var \u{2AB18}; +var \u{2AB19}; +var \u{2AB1A}; +var \u{2AB1B}; +var \u{2AB1C}; +var \u{2AB1D}; +var \u{2AB1E}; +var \u{2AB1F}; +var \u{2AB20}; +var \u{2AB21}; +var \u{2AB22}; +var \u{2AB23}; +var \u{2AB24}; +var \u{2AB25}; +var \u{2AB26}; +var \u{2AB27}; +var \u{2AB28}; +var \u{2AB29}; +var \u{2AB2A}; +var \u{2AB2B}; +var \u{2AB2C}; +var \u{2AB2D}; +var \u{2AB2E}; +var \u{2AB2F}; +var \u{2AB30}; +var \u{2AB31}; +var \u{2AB32}; +var \u{2AB33}; +var \u{2AB34}; +var \u{2AB35}; +var \u{2AB36}; +var \u{2AB37}; +var \u{2AB38}; +var \u{2AB39}; +var \u{2AB3A}; +var \u{2AB3B}; +var \u{2AB3C}; +var \u{2AB3D}; +var \u{2AB3E}; +var \u{2AB3F}; +var \u{2AB40}; +var \u{2AB41}; +var \u{2AB42}; +var \u{2AB43}; +var \u{2AB44}; +var \u{2AB45}; +var \u{2AB46}; +var \u{2AB47}; +var \u{2AB48}; +var \u{2AB49}; +var \u{2AB4A}; +var \u{2AB4B}; +var \u{2AB4C}; +var \u{2AB4D}; +var \u{2AB4E}; +var \u{2AB4F}; +var \u{2AB50}; +var \u{2AB51}; +var \u{2AB52}; +var \u{2AB53}; +var \u{2AB54}; +var \u{2AB55}; +var \u{2AB56}; +var \u{2AB57}; +var \u{2AB58}; +var \u{2AB59}; +var \u{2AB5A}; +var \u{2AB5B}; +var \u{2AB5C}; +var \u{2AB5D}; +var \u{2AB5E}; +var \u{2AB5F}; +var \u{2AB60}; +var \u{2AB61}; +var \u{2AB62}; +var \u{2AB63}; +var \u{2AB64}; +var \u{2AB65}; +var \u{2AB66}; +var \u{2AB67}; +var \u{2AB68}; +var \u{2AB69}; +var \u{2AB6A}; +var \u{2AB6B}; +var \u{2AB6C}; +var \u{2AB6D}; +var \u{2AB6E}; +var \u{2AB6F}; +var \u{2AB70}; +var \u{2AB71}; +var \u{2AB72}; +var \u{2AB73}; +var \u{2AB74}; +var \u{2AB75}; +var \u{2AB76}; +var \u{2AB77}; +var \u{2AB78}; +var \u{2AB79}; +var \u{2AB7A}; +var \u{2AB7B}; +var \u{2AB7C}; +var \u{2AB7D}; +var \u{2AB7E}; +var \u{2AB7F}; +var \u{2AB80}; +var \u{2AB81}; +var \u{2AB82}; +var \u{2AB83}; +var \u{2AB84}; +var \u{2AB85}; +var \u{2AB86}; +var \u{2AB87}; +var \u{2AB88}; +var \u{2AB89}; +var \u{2AB8A}; +var \u{2AB8B}; +var \u{2AB8C}; +var \u{2AB8D}; +var \u{2AB8E}; +var \u{2AB8F}; +var \u{2AB90}; +var \u{2AB91}; +var \u{2AB92}; +var \u{2AB93}; +var \u{2AB94}; +var \u{2AB95}; +var \u{2AB96}; +var \u{2AB97}; +var \u{2AB98}; +var \u{2AB99}; +var \u{2AB9A}; +var \u{2AB9B}; +var \u{2AB9C}; +var \u{2AB9D}; +var \u{2AB9E}; +var \u{2AB9F}; +var \u{2ABA0}; +var \u{2ABA1}; +var \u{2ABA2}; +var \u{2ABA3}; +var \u{2ABA4}; +var \u{2ABA5}; +var \u{2ABA6}; +var \u{2ABA7}; +var \u{2ABA8}; +var \u{2ABA9}; +var \u{2ABAA}; +var \u{2ABAB}; +var \u{2ABAC}; +var \u{2ABAD}; +var \u{2ABAE}; +var \u{2ABAF}; +var \u{2ABB0}; +var \u{2ABB1}; +var \u{2ABB2}; +var \u{2ABB3}; +var \u{2ABB4}; +var \u{2ABB5}; +var \u{2ABB6}; +var \u{2ABB7}; +var \u{2ABB8}; +var \u{2ABB9}; +var \u{2ABBA}; +var \u{2ABBB}; +var \u{2ABBC}; +var \u{2ABBD}; +var \u{2ABBE}; +var \u{2ABBF}; +var \u{2ABC0}; +var \u{2ABC1}; +var \u{2ABC2}; +var \u{2ABC3}; +var \u{2ABC4}; +var \u{2ABC5}; +var \u{2ABC6}; +var \u{2ABC7}; +var \u{2ABC8}; +var \u{2ABC9}; +var \u{2ABCA}; +var \u{2ABCB}; +var \u{2ABCC}; +var \u{2ABCD}; +var \u{2ABCE}; +var \u{2ABCF}; +var \u{2ABD0}; +var \u{2ABD1}; +var \u{2ABD2}; +var \u{2ABD3}; +var \u{2ABD4}; +var \u{2ABD5}; +var \u{2ABD6}; +var \u{2ABD7}; +var \u{2ABD8}; +var \u{2ABD9}; +var \u{2ABDA}; +var \u{2ABDB}; +var \u{2ABDC}; +var \u{2ABDD}; +var \u{2ABDE}; +var \u{2ABDF}; +var \u{2ABE0}; +var \u{2ABE1}; +var \u{2ABE2}; +var \u{2ABE3}; +var \u{2ABE4}; +var \u{2ABE5}; +var \u{2ABE6}; +var \u{2ABE7}; +var \u{2ABE8}; +var \u{2ABE9}; +var \u{2ABEA}; +var \u{2ABEB}; +var \u{2ABEC}; +var \u{2ABED}; +var \u{2ABEE}; +var \u{2ABEF}; +var \u{2ABF0}; +var \u{2ABF1}; +var \u{2ABF2}; +var \u{2ABF3}; +var \u{2ABF4}; +var \u{2ABF5}; +var \u{2ABF6}; +var \u{2ABF7}; +var \u{2ABF8}; +var \u{2ABF9}; +var \u{2ABFA}; +var \u{2ABFB}; +var \u{2ABFC}; +var \u{2ABFD}; +var \u{2ABFE}; +var \u{2ABFF}; +var \u{2AC00}; +var \u{2AC01}; +var \u{2AC02}; +var \u{2AC03}; +var \u{2AC04}; +var \u{2AC05}; +var \u{2AC06}; +var \u{2AC07}; +var \u{2AC08}; +var \u{2AC09}; +var \u{2AC0A}; +var \u{2AC0B}; +var \u{2AC0C}; +var \u{2AC0D}; +var \u{2AC0E}; +var \u{2AC0F}; +var \u{2AC10}; +var \u{2AC11}; +var \u{2AC12}; +var \u{2AC13}; +var \u{2AC14}; +var \u{2AC15}; +var \u{2AC16}; +var \u{2AC17}; +var \u{2AC18}; +var \u{2AC19}; +var \u{2AC1A}; +var \u{2AC1B}; +var \u{2AC1C}; +var \u{2AC1D}; +var \u{2AC1E}; +var \u{2AC1F}; +var \u{2AC20}; +var \u{2AC21}; +var \u{2AC22}; +var \u{2AC23}; +var \u{2AC24}; +var \u{2AC25}; +var \u{2AC26}; +var \u{2AC27}; +var \u{2AC28}; +var \u{2AC29}; +var \u{2AC2A}; +var \u{2AC2B}; +var \u{2AC2C}; +var \u{2AC2D}; +var \u{2AC2E}; +var \u{2AC2F}; +var \u{2AC30}; +var \u{2AC31}; +var \u{2AC32}; +var \u{2AC33}; +var \u{2AC34}; +var \u{2AC35}; +var \u{2AC36}; +var \u{2AC37}; +var \u{2AC38}; +var \u{2AC39}; +var \u{2AC3A}; +var \u{2AC3B}; +var \u{2AC3C}; +var \u{2AC3D}; +var \u{2AC3E}; +var \u{2AC3F}; +var \u{2AC40}; +var \u{2AC41}; +var \u{2AC42}; +var \u{2AC43}; +var \u{2AC44}; +var \u{2AC45}; +var \u{2AC46}; +var \u{2AC47}; +var \u{2AC48}; +var \u{2AC49}; +var \u{2AC4A}; +var \u{2AC4B}; +var \u{2AC4C}; +var \u{2AC4D}; +var \u{2AC4E}; +var \u{2AC4F}; +var \u{2AC50}; +var \u{2AC51}; +var \u{2AC52}; +var \u{2AC53}; +var \u{2AC54}; +var \u{2AC55}; +var \u{2AC56}; +var \u{2AC57}; +var \u{2AC58}; +var \u{2AC59}; +var \u{2AC5A}; +var \u{2AC5B}; +var \u{2AC5C}; +var \u{2AC5D}; +var \u{2AC5E}; +var \u{2AC5F}; +var \u{2AC60}; +var \u{2AC61}; +var \u{2AC62}; +var \u{2AC63}; +var \u{2AC64}; +var \u{2AC65}; +var \u{2AC66}; +var \u{2AC67}; +var \u{2AC68}; +var \u{2AC69}; +var \u{2AC6A}; +var \u{2AC6B}; +var \u{2AC6C}; +var \u{2AC6D}; +var \u{2AC6E}; +var \u{2AC6F}; +var \u{2AC70}; +var \u{2AC71}; +var \u{2AC72}; +var \u{2AC73}; +var \u{2AC74}; +var \u{2AC75}; +var \u{2AC76}; +var \u{2AC77}; +var \u{2AC78}; +var \u{2AC79}; +var \u{2AC7A}; +var \u{2AC7B}; +var \u{2AC7C}; +var \u{2AC7D}; +var \u{2AC7E}; +var \u{2AC7F}; +var \u{2AC80}; +var \u{2AC81}; +var \u{2AC82}; +var \u{2AC83}; +var \u{2AC84}; +var \u{2AC85}; +var \u{2AC86}; +var \u{2AC87}; +var \u{2AC88}; +var \u{2AC89}; +var \u{2AC8A}; +var \u{2AC8B}; +var \u{2AC8C}; +var \u{2AC8D}; +var \u{2AC8E}; +var \u{2AC8F}; +var \u{2AC90}; +var \u{2AC91}; +var \u{2AC92}; +var \u{2AC93}; +var \u{2AC94}; +var \u{2AC95}; +var \u{2AC96}; +var \u{2AC97}; +var \u{2AC98}; +var \u{2AC99}; +var \u{2AC9A}; +var \u{2AC9B}; +var \u{2AC9C}; +var \u{2AC9D}; +var \u{2AC9E}; +var \u{2AC9F}; +var \u{2ACA0}; +var \u{2ACA1}; +var \u{2ACA2}; +var \u{2ACA3}; +var \u{2ACA4}; +var \u{2ACA5}; +var \u{2ACA6}; +var \u{2ACA7}; +var \u{2ACA8}; +var \u{2ACA9}; +var \u{2ACAA}; +var \u{2ACAB}; +var \u{2ACAC}; +var \u{2ACAD}; +var \u{2ACAE}; +var \u{2ACAF}; +var \u{2ACB0}; +var \u{2ACB1}; +var \u{2ACB2}; +var \u{2ACB3}; +var \u{2ACB4}; +var \u{2ACB5}; +var \u{2ACB6}; +var \u{2ACB7}; +var \u{2ACB8}; +var \u{2ACB9}; +var \u{2ACBA}; +var \u{2ACBB}; +var \u{2ACBC}; +var \u{2ACBD}; +var \u{2ACBE}; +var \u{2ACBF}; +var \u{2ACC0}; +var \u{2ACC1}; +var \u{2ACC2}; +var \u{2ACC3}; +var \u{2ACC4}; +var \u{2ACC5}; +var \u{2ACC6}; +var \u{2ACC7}; +var \u{2ACC8}; +var \u{2ACC9}; +var \u{2ACCA}; +var \u{2ACCB}; +var \u{2ACCC}; +var \u{2ACCD}; +var \u{2ACCE}; +var \u{2ACCF}; +var \u{2ACD0}; +var \u{2ACD1}; +var \u{2ACD2}; +var \u{2ACD3}; +var \u{2ACD4}; +var \u{2ACD5}; +var \u{2ACD6}; +var \u{2ACD7}; +var \u{2ACD8}; +var \u{2ACD9}; +var \u{2ACDA}; +var \u{2ACDB}; +var \u{2ACDC}; +var \u{2ACDD}; +var \u{2ACDE}; +var \u{2ACDF}; +var \u{2ACE0}; +var \u{2ACE1}; +var \u{2ACE2}; +var \u{2ACE3}; +var \u{2ACE4}; +var \u{2ACE5}; +var \u{2ACE6}; +var \u{2ACE7}; +var \u{2ACE8}; +var \u{2ACE9}; +var \u{2ACEA}; +var \u{2ACEB}; +var \u{2ACEC}; +var \u{2ACED}; +var \u{2ACEE}; +var \u{2ACEF}; +var \u{2ACF0}; +var \u{2ACF1}; +var \u{2ACF2}; +var \u{2ACF3}; +var \u{2ACF4}; +var \u{2ACF5}; +var \u{2ACF6}; +var \u{2ACF7}; +var \u{2ACF8}; +var \u{2ACF9}; +var \u{2ACFA}; +var \u{2ACFB}; +var \u{2ACFC}; +var \u{2ACFD}; +var \u{2ACFE}; +var \u{2ACFF}; +var \u{2AD00}; +var \u{2AD01}; +var \u{2AD02}; +var \u{2AD03}; +var \u{2AD04}; +var \u{2AD05}; +var \u{2AD06}; +var \u{2AD07}; +var \u{2AD08}; +var \u{2AD09}; +var \u{2AD0A}; +var \u{2AD0B}; +var \u{2AD0C}; +var \u{2AD0D}; +var \u{2AD0E}; +var \u{2AD0F}; +var \u{2AD10}; +var \u{2AD11}; +var \u{2AD12}; +var \u{2AD13}; +var \u{2AD14}; +var \u{2AD15}; +var \u{2AD16}; +var \u{2AD17}; +var \u{2AD18}; +var \u{2AD19}; +var \u{2AD1A}; +var \u{2AD1B}; +var \u{2AD1C}; +var \u{2AD1D}; +var \u{2AD1E}; +var \u{2AD1F}; +var \u{2AD20}; +var \u{2AD21}; +var \u{2AD22}; +var \u{2AD23}; +var \u{2AD24}; +var \u{2AD25}; +var \u{2AD26}; +var \u{2AD27}; +var \u{2AD28}; +var \u{2AD29}; +var \u{2AD2A}; +var \u{2AD2B}; +var \u{2AD2C}; +var \u{2AD2D}; +var \u{2AD2E}; +var \u{2AD2F}; +var \u{2AD30}; +var \u{2AD31}; +var \u{2AD32}; +var \u{2AD33}; +var \u{2AD34}; +var \u{2AD35}; +var \u{2AD36}; +var \u{2AD37}; +var \u{2AD38}; +var \u{2AD39}; +var \u{2AD3A}; +var \u{2AD3B}; +var \u{2AD3C}; +var \u{2AD3D}; +var \u{2AD3E}; +var \u{2AD3F}; +var \u{2AD40}; +var \u{2AD41}; +var \u{2AD42}; +var \u{2AD43}; +var \u{2AD44}; +var \u{2AD45}; +var \u{2AD46}; +var \u{2AD47}; +var \u{2AD48}; +var \u{2AD49}; +var \u{2AD4A}; +var \u{2AD4B}; +var \u{2AD4C}; +var \u{2AD4D}; +var \u{2AD4E}; +var \u{2AD4F}; +var \u{2AD50}; +var \u{2AD51}; +var \u{2AD52}; +var \u{2AD53}; +var \u{2AD54}; +var \u{2AD55}; +var \u{2AD56}; +var \u{2AD57}; +var \u{2AD58}; +var \u{2AD59}; +var \u{2AD5A}; +var \u{2AD5B}; +var \u{2AD5C}; +var \u{2AD5D}; +var \u{2AD5E}; +var \u{2AD5F}; +var \u{2AD60}; +var \u{2AD61}; +var \u{2AD62}; +var \u{2AD63}; +var \u{2AD64}; +var \u{2AD65}; +var \u{2AD66}; +var \u{2AD67}; +var \u{2AD68}; +var \u{2AD69}; +var \u{2AD6A}; +var \u{2AD6B}; +var \u{2AD6C}; +var \u{2AD6D}; +var \u{2AD6E}; +var \u{2AD6F}; +var \u{2AD70}; +var \u{2AD71}; +var \u{2AD72}; +var \u{2AD73}; +var \u{2AD74}; +var \u{2AD75}; +var \u{2AD76}; +var \u{2AD77}; +var \u{2AD78}; +var \u{2AD79}; +var \u{2AD7A}; +var \u{2AD7B}; +var \u{2AD7C}; +var \u{2AD7D}; +var \u{2AD7E}; +var \u{2AD7F}; +var \u{2AD80}; +var \u{2AD81}; +var \u{2AD82}; +var \u{2AD83}; +var \u{2AD84}; +var \u{2AD85}; +var \u{2AD86}; +var \u{2AD87}; +var \u{2AD88}; +var \u{2AD89}; +var \u{2AD8A}; +var \u{2AD8B}; +var \u{2AD8C}; +var \u{2AD8D}; +var \u{2AD8E}; +var \u{2AD8F}; +var \u{2AD90}; +var \u{2AD91}; +var \u{2AD92}; +var \u{2AD93}; +var \u{2AD94}; +var \u{2AD95}; +var \u{2AD96}; +var \u{2AD97}; +var \u{2AD98}; +var \u{2AD99}; +var \u{2AD9A}; +var \u{2AD9B}; +var \u{2AD9C}; +var \u{2AD9D}; +var \u{2AD9E}; +var \u{2AD9F}; +var \u{2ADA0}; +var \u{2ADA1}; +var \u{2ADA2}; +var \u{2ADA3}; +var \u{2ADA4}; +var \u{2ADA5}; +var \u{2ADA6}; +var \u{2ADA7}; +var \u{2ADA8}; +var \u{2ADA9}; +var \u{2ADAA}; +var \u{2ADAB}; +var \u{2ADAC}; +var \u{2ADAD}; +var \u{2ADAE}; +var \u{2ADAF}; +var \u{2ADB0}; +var \u{2ADB1}; +var \u{2ADB2}; +var \u{2ADB3}; +var \u{2ADB4}; +var \u{2ADB5}; +var \u{2ADB6}; +var \u{2ADB7}; +var \u{2ADB8}; +var \u{2ADB9}; +var \u{2ADBA}; +var \u{2ADBB}; +var \u{2ADBC}; +var \u{2ADBD}; +var \u{2ADBE}; +var \u{2ADBF}; +var \u{2ADC0}; +var \u{2ADC1}; +var \u{2ADC2}; +var \u{2ADC3}; +var \u{2ADC4}; +var \u{2ADC5}; +var \u{2ADC6}; +var \u{2ADC7}; +var \u{2ADC8}; +var \u{2ADC9}; +var \u{2ADCA}; +var \u{2ADCB}; +var \u{2ADCC}; +var \u{2ADCD}; +var \u{2ADCE}; +var \u{2ADCF}; +var \u{2ADD0}; +var \u{2ADD1}; +var \u{2ADD2}; +var \u{2ADD3}; +var \u{2ADD4}; +var \u{2ADD5}; +var \u{2ADD6}; +var \u{2ADD7}; +var \u{2ADD8}; +var \u{2ADD9}; +var \u{2ADDA}; +var \u{2ADDB}; +var \u{2ADDC}; +var \u{2ADDD}; +var \u{2ADDE}; +var \u{2ADDF}; +var \u{2ADE0}; +var \u{2ADE1}; +var \u{2ADE2}; +var \u{2ADE3}; +var \u{2ADE4}; +var \u{2ADE5}; +var \u{2ADE6}; +var \u{2ADE7}; +var \u{2ADE8}; +var \u{2ADE9}; +var \u{2ADEA}; +var \u{2ADEB}; +var \u{2ADEC}; +var \u{2ADED}; +var \u{2ADEE}; +var \u{2ADEF}; +var \u{2ADF0}; +var \u{2ADF1}; +var \u{2ADF2}; +var \u{2ADF3}; +var \u{2ADF4}; +var \u{2ADF5}; +var \u{2ADF6}; +var \u{2ADF7}; +var \u{2ADF8}; +var \u{2ADF9}; +var \u{2ADFA}; +var \u{2ADFB}; +var \u{2ADFC}; +var \u{2ADFD}; +var \u{2ADFE}; +var \u{2ADFF}; +var \u{2AE00}; +var \u{2AE01}; +var \u{2AE02}; +var \u{2AE03}; +var \u{2AE04}; +var \u{2AE05}; +var \u{2AE06}; +var \u{2AE07}; +var \u{2AE08}; +var \u{2AE09}; +var \u{2AE0A}; +var \u{2AE0B}; +var \u{2AE0C}; +var \u{2AE0D}; +var \u{2AE0E}; +var \u{2AE0F}; +var \u{2AE10}; +var \u{2AE11}; +var \u{2AE12}; +var \u{2AE13}; +var \u{2AE14}; +var \u{2AE15}; +var \u{2AE16}; +var \u{2AE17}; +var \u{2AE18}; +var \u{2AE19}; +var \u{2AE1A}; +var \u{2AE1B}; +var \u{2AE1C}; +var \u{2AE1D}; +var \u{2AE1E}; +var \u{2AE1F}; +var \u{2AE20}; +var \u{2AE21}; +var \u{2AE22}; +var \u{2AE23}; +var \u{2AE24}; +var \u{2AE25}; +var \u{2AE26}; +var \u{2AE27}; +var \u{2AE28}; +var \u{2AE29}; +var \u{2AE2A}; +var \u{2AE2B}; +var \u{2AE2C}; +var \u{2AE2D}; +var \u{2AE2E}; +var \u{2AE2F}; +var \u{2AE30}; +var \u{2AE31}; +var \u{2AE32}; +var \u{2AE33}; +var \u{2AE34}; +var \u{2AE35}; +var \u{2AE36}; +var \u{2AE37}; +var \u{2AE38}; +var \u{2AE39}; +var \u{2AE3A}; +var \u{2AE3B}; +var \u{2AE3C}; +var \u{2AE3D}; +var \u{2AE3E}; +var \u{2AE3F}; +var \u{2AE40}; +var \u{2AE41}; +var \u{2AE42}; +var \u{2AE43}; +var \u{2AE44}; +var \u{2AE45}; +var \u{2AE46}; +var \u{2AE47}; +var \u{2AE48}; +var \u{2AE49}; +var \u{2AE4A}; +var \u{2AE4B}; +var \u{2AE4C}; +var \u{2AE4D}; +var \u{2AE4E}; +var \u{2AE4F}; +var \u{2AE50}; +var \u{2AE51}; +var \u{2AE52}; +var \u{2AE53}; +var \u{2AE54}; +var \u{2AE55}; +var \u{2AE56}; +var \u{2AE57}; +var \u{2AE58}; +var \u{2AE59}; +var \u{2AE5A}; +var \u{2AE5B}; +var \u{2AE5C}; +var \u{2AE5D}; +var \u{2AE5E}; +var \u{2AE5F}; +var \u{2AE60}; +var \u{2AE61}; +var \u{2AE62}; +var \u{2AE63}; +var \u{2AE64}; +var \u{2AE65}; +var \u{2AE66}; +var \u{2AE67}; +var \u{2AE68}; +var \u{2AE69}; +var \u{2AE6A}; +var \u{2AE6B}; +var \u{2AE6C}; +var \u{2AE6D}; +var \u{2AE6E}; +var \u{2AE6F}; +var \u{2AE70}; +var \u{2AE71}; +var \u{2AE72}; +var \u{2AE73}; +var \u{2AE74}; +var \u{2AE75}; +var \u{2AE76}; +var \u{2AE77}; +var \u{2AE78}; +var \u{2AE79}; +var \u{2AE7A}; +var \u{2AE7B}; +var \u{2AE7C}; +var \u{2AE7D}; +var \u{2AE7E}; +var \u{2AE7F}; +var \u{2AE80}; +var \u{2AE81}; +var \u{2AE82}; +var \u{2AE83}; +var \u{2AE84}; +var \u{2AE85}; +var \u{2AE86}; +var \u{2AE87}; +var \u{2AE88}; +var \u{2AE89}; +var \u{2AE8A}; +var \u{2AE8B}; +var \u{2AE8C}; +var \u{2AE8D}; +var \u{2AE8E}; +var \u{2AE8F}; +var \u{2AE90}; +var \u{2AE91}; +var \u{2AE92}; +var \u{2AE93}; +var \u{2AE94}; +var \u{2AE95}; +var \u{2AE96}; +var \u{2AE97}; +var \u{2AE98}; +var \u{2AE99}; +var \u{2AE9A}; +var \u{2AE9B}; +var \u{2AE9C}; +var \u{2AE9D}; +var \u{2AE9E}; +var \u{2AE9F}; +var \u{2AEA0}; +var \u{2AEA1}; +var \u{2AEA2}; +var \u{2AEA3}; +var \u{2AEA4}; +var \u{2AEA5}; +var \u{2AEA6}; +var \u{2AEA7}; +var \u{2AEA8}; +var \u{2AEA9}; +var \u{2AEAA}; +var \u{2AEAB}; +var \u{2AEAC}; +var \u{2AEAD}; +var \u{2AEAE}; +var \u{2AEAF}; +var \u{2AEB0}; +var \u{2AEB1}; +var \u{2AEB2}; +var \u{2AEB3}; +var \u{2AEB4}; +var \u{2AEB5}; +var \u{2AEB6}; +var \u{2AEB7}; +var \u{2AEB8}; +var \u{2AEB9}; +var \u{2AEBA}; +var \u{2AEBB}; +var \u{2AEBC}; +var \u{2AEBD}; +var \u{2AEBE}; +var \u{2AEBF}; +var \u{2AEC0}; +var \u{2AEC1}; +var \u{2AEC2}; +var \u{2AEC3}; +var \u{2AEC4}; +var \u{2AEC5}; +var \u{2AEC6}; +var \u{2AEC7}; +var \u{2AEC8}; +var \u{2AEC9}; +var \u{2AECA}; +var \u{2AECB}; +var \u{2AECC}; +var \u{2AECD}; +var \u{2AECE}; +var \u{2AECF}; +var \u{2AED0}; +var \u{2AED1}; +var \u{2AED2}; +var \u{2AED3}; +var \u{2AED4}; +var \u{2AED5}; +var \u{2AED6}; +var \u{2AED7}; +var \u{2AED8}; +var \u{2AED9}; +var \u{2AEDA}; +var \u{2AEDB}; +var \u{2AEDC}; +var \u{2AEDD}; +var \u{2AEDE}; +var \u{2AEDF}; +var \u{2AEE0}; +var \u{2AEE1}; +var \u{2AEE2}; +var \u{2AEE3}; +var \u{2AEE4}; +var \u{2AEE5}; +var \u{2AEE6}; +var \u{2AEE7}; +var \u{2AEE8}; +var \u{2AEE9}; +var \u{2AEEA}; +var \u{2AEEB}; +var \u{2AEEC}; +var \u{2AEED}; +var \u{2AEEE}; +var \u{2AEEF}; +var \u{2AEF0}; +var \u{2AEF1}; +var \u{2AEF2}; +var \u{2AEF3}; +var \u{2AEF4}; +var \u{2AEF5}; +var \u{2AEF6}; +var \u{2AEF7}; +var \u{2AEF8}; +var \u{2AEF9}; +var \u{2AEFA}; +var \u{2AEFB}; +var \u{2AEFC}; +var \u{2AEFD}; +var \u{2AEFE}; +var \u{2AEFF}; +var \u{2AF00}; +var \u{2AF01}; +var \u{2AF02}; +var \u{2AF03}; +var \u{2AF04}; +var \u{2AF05}; +var \u{2AF06}; +var \u{2AF07}; +var \u{2AF08}; +var \u{2AF09}; +var \u{2AF0A}; +var \u{2AF0B}; +var \u{2AF0C}; +var \u{2AF0D}; +var \u{2AF0E}; +var \u{2AF0F}; +var \u{2AF10}; +var \u{2AF11}; +var \u{2AF12}; +var \u{2AF13}; +var \u{2AF14}; +var \u{2AF15}; +var \u{2AF16}; +var \u{2AF17}; +var \u{2AF18}; +var \u{2AF19}; +var \u{2AF1A}; +var \u{2AF1B}; +var \u{2AF1C}; +var \u{2AF1D}; +var \u{2AF1E}; +var \u{2AF1F}; +var \u{2AF20}; +var \u{2AF21}; +var \u{2AF22}; +var \u{2AF23}; +var \u{2AF24}; +var \u{2AF25}; +var \u{2AF26}; +var \u{2AF27}; +var \u{2AF28}; +var \u{2AF29}; +var \u{2AF2A}; +var \u{2AF2B}; +var \u{2AF2C}; +var \u{2AF2D}; +var \u{2AF2E}; +var \u{2AF2F}; +var \u{2AF30}; +var \u{2AF31}; +var \u{2AF32}; +var \u{2AF33}; +var \u{2AF34}; +var \u{2AF35}; +var \u{2AF36}; +var \u{2AF37}; +var \u{2AF38}; +var \u{2AF39}; +var \u{2AF3A}; +var \u{2AF3B}; +var \u{2AF3C}; +var \u{2AF3D}; +var \u{2AF3E}; +var \u{2AF3F}; +var \u{2AF40}; +var \u{2AF41}; +var \u{2AF42}; +var \u{2AF43}; +var \u{2AF44}; +var \u{2AF45}; +var \u{2AF46}; +var \u{2AF47}; +var \u{2AF48}; +var \u{2AF49}; +var \u{2AF4A}; +var \u{2AF4B}; +var \u{2AF4C}; +var \u{2AF4D}; +var \u{2AF4E}; +var \u{2AF4F}; +var \u{2AF50}; +var \u{2AF51}; +var \u{2AF52}; +var \u{2AF53}; +var \u{2AF54}; +var \u{2AF55}; +var \u{2AF56}; +var \u{2AF57}; +var \u{2AF58}; +var \u{2AF59}; +var \u{2AF5A}; +var \u{2AF5B}; +var \u{2AF5C}; +var \u{2AF5D}; +var \u{2AF5E}; +var \u{2AF5F}; +var \u{2AF60}; +var \u{2AF61}; +var \u{2AF62}; +var \u{2AF63}; +var \u{2AF64}; +var \u{2AF65}; +var \u{2AF66}; +var \u{2AF67}; +var \u{2AF68}; +var \u{2AF69}; +var \u{2AF6A}; +var \u{2AF6B}; +var \u{2AF6C}; +var \u{2AF6D}; +var \u{2AF6E}; +var \u{2AF6F}; +var \u{2AF70}; +var \u{2AF71}; +var \u{2AF72}; +var \u{2AF73}; +var \u{2AF74}; +var \u{2AF75}; +var \u{2AF76}; +var \u{2AF77}; +var \u{2AF78}; +var \u{2AF79}; +var \u{2AF7A}; +var \u{2AF7B}; +var \u{2AF7C}; +var \u{2AF7D}; +var \u{2AF7E}; +var \u{2AF7F}; +var \u{2AF80}; +var \u{2AF81}; +var \u{2AF82}; +var \u{2AF83}; +var \u{2AF84}; +var \u{2AF85}; +var \u{2AF86}; +var \u{2AF87}; +var \u{2AF88}; +var \u{2AF89}; +var \u{2AF8A}; +var \u{2AF8B}; +var \u{2AF8C}; +var \u{2AF8D}; +var \u{2AF8E}; +var \u{2AF8F}; +var \u{2AF90}; +var \u{2AF91}; +var \u{2AF92}; +var \u{2AF93}; +var \u{2AF94}; +var \u{2AF95}; +var \u{2AF96}; +var \u{2AF97}; +var \u{2AF98}; +var \u{2AF99}; +var \u{2AF9A}; +var \u{2AF9B}; +var \u{2AF9C}; +var \u{2AF9D}; +var \u{2AF9E}; +var \u{2AF9F}; +var \u{2AFA0}; +var \u{2AFA1}; +var \u{2AFA2}; +var \u{2AFA3}; +var \u{2AFA4}; +var \u{2AFA5}; +var \u{2AFA6}; +var \u{2AFA7}; +var \u{2AFA8}; +var \u{2AFA9}; +var \u{2AFAA}; +var \u{2AFAB}; +var \u{2AFAC}; +var \u{2AFAD}; +var \u{2AFAE}; +var \u{2AFAF}; +var \u{2AFB0}; +var \u{2AFB1}; +var \u{2AFB2}; +var \u{2AFB3}; +var \u{2AFB4}; +var \u{2AFB5}; +var \u{2AFB6}; +var \u{2AFB7}; +var \u{2AFB8}; +var \u{2AFB9}; +var \u{2AFBA}; +var \u{2AFBB}; +var \u{2AFBC}; +var \u{2AFBD}; +var \u{2AFBE}; +var \u{2AFBF}; +var \u{2AFC0}; +var \u{2AFC1}; +var \u{2AFC2}; +var \u{2AFC3}; +var \u{2AFC4}; +var \u{2AFC5}; +var \u{2AFC6}; +var \u{2AFC7}; +var \u{2AFC8}; +var \u{2AFC9}; +var \u{2AFCA}; +var \u{2AFCB}; +var \u{2AFCC}; +var \u{2AFCD}; +var \u{2AFCE}; +var \u{2AFCF}; +var \u{2AFD0}; +var \u{2AFD1}; +var \u{2AFD2}; +var \u{2AFD3}; +var \u{2AFD4}; +var \u{2AFD5}; +var \u{2AFD6}; +var \u{2AFD7}; +var \u{2AFD8}; +var \u{2AFD9}; +var \u{2AFDA}; +var \u{2AFDB}; +var \u{2AFDC}; +var \u{2AFDD}; +var \u{2AFDE}; +var \u{2AFDF}; +var \u{2AFE0}; +var \u{2AFE1}; +var \u{2AFE2}; +var \u{2AFE3}; +var \u{2AFE4}; +var \u{2AFE5}; +var \u{2AFE6}; +var \u{2AFE7}; +var \u{2AFE8}; +var \u{2AFE9}; +var \u{2AFEA}; +var \u{2AFEB}; +var \u{2AFEC}; +var \u{2AFED}; +var \u{2AFEE}; +var \u{2AFEF}; +var \u{2AFF0}; +var \u{2AFF1}; +var \u{2AFF2}; +var \u{2AFF3}; +var \u{2AFF4}; +var \u{2AFF5}; +var \u{2AFF6}; +var \u{2AFF7}; +var \u{2AFF8}; +var \u{2AFF9}; +var \u{2AFFA}; +var \u{2AFFB}; +var \u{2AFFC}; +var \u{2AFFD}; +var \u{2AFFE}; +var \u{2AFFF}; +var \u{2B000}; +var \u{2B001}; +var \u{2B002}; +var \u{2B003}; +var \u{2B004}; +var \u{2B005}; +var \u{2B006}; +var \u{2B007}; +var \u{2B008}; +var \u{2B009}; +var \u{2B00A}; +var \u{2B00B}; +var \u{2B00C}; +var \u{2B00D}; +var \u{2B00E}; +var \u{2B00F}; +var \u{2B010}; +var \u{2B011}; +var \u{2B012}; +var \u{2B013}; +var \u{2B014}; +var \u{2B015}; +var \u{2B016}; +var \u{2B017}; +var \u{2B018}; +var \u{2B019}; +var \u{2B01A}; +var \u{2B01B}; +var \u{2B01C}; +var \u{2B01D}; +var \u{2B01E}; +var \u{2B01F}; +var \u{2B020}; +var \u{2B021}; +var \u{2B022}; +var \u{2B023}; +var \u{2B024}; +var \u{2B025}; +var \u{2B026}; +var \u{2B027}; +var \u{2B028}; +var \u{2B029}; +var \u{2B02A}; +var \u{2B02B}; +var \u{2B02C}; +var \u{2B02D}; +var \u{2B02E}; +var \u{2B02F}; +var \u{2B030}; +var \u{2B031}; +var \u{2B032}; +var \u{2B033}; +var \u{2B034}; +var \u{2B035}; +var \u{2B036}; +var \u{2B037}; +var \u{2B038}; +var \u{2B039}; +var \u{2B03A}; +var \u{2B03B}; +var \u{2B03C}; +var \u{2B03D}; +var \u{2B03E}; +var \u{2B03F}; +var \u{2B040}; +var \u{2B041}; +var \u{2B042}; +var \u{2B043}; +var \u{2B044}; +var \u{2B045}; +var \u{2B046}; +var \u{2B047}; +var \u{2B048}; +var \u{2B049}; +var \u{2B04A}; +var \u{2B04B}; +var \u{2B04C}; +var \u{2B04D}; +var \u{2B04E}; +var \u{2B04F}; +var \u{2B050}; +var \u{2B051}; +var \u{2B052}; +var \u{2B053}; +var \u{2B054}; +var \u{2B055}; +var \u{2B056}; +var \u{2B057}; +var \u{2B058}; +var \u{2B059}; +var \u{2B05A}; +var \u{2B05B}; +var \u{2B05C}; +var \u{2B05D}; +var \u{2B05E}; +var \u{2B05F}; +var \u{2B060}; +var \u{2B061}; +var \u{2B062}; +var \u{2B063}; +var \u{2B064}; +var \u{2B065}; +var \u{2B066}; +var \u{2B067}; +var \u{2B068}; +var \u{2B069}; +var \u{2B06A}; +var \u{2B06B}; +var \u{2B06C}; +var \u{2B06D}; +var \u{2B06E}; +var \u{2B06F}; +var \u{2B070}; +var \u{2B071}; +var \u{2B072}; +var \u{2B073}; +var \u{2B074}; +var \u{2B075}; +var \u{2B076}; +var \u{2B077}; +var \u{2B078}; +var \u{2B079}; +var \u{2B07A}; +var \u{2B07B}; +var \u{2B07C}; +var \u{2B07D}; +var \u{2B07E}; +var \u{2B07F}; +var \u{2B080}; +var \u{2B081}; +var \u{2B082}; +var \u{2B083}; +var \u{2B084}; +var \u{2B085}; +var \u{2B086}; +var \u{2B087}; +var \u{2B088}; +var \u{2B089}; +var \u{2B08A}; +var \u{2B08B}; +var \u{2B08C}; +var \u{2B08D}; +var \u{2B08E}; +var \u{2B08F}; +var \u{2B090}; +var \u{2B091}; +var \u{2B092}; +var \u{2B093}; +var \u{2B094}; +var \u{2B095}; +var \u{2B096}; +var \u{2B097}; +var \u{2B098}; +var \u{2B099}; +var \u{2B09A}; +var \u{2B09B}; +var \u{2B09C}; +var \u{2B09D}; +var \u{2B09E}; +var \u{2B09F}; +var \u{2B0A0}; +var \u{2B0A1}; +var \u{2B0A2}; +var \u{2B0A3}; +var \u{2B0A4}; +var \u{2B0A5}; +var \u{2B0A6}; +var \u{2B0A7}; +var \u{2B0A8}; +var \u{2B0A9}; +var \u{2B0AA}; +var \u{2B0AB}; +var \u{2B0AC}; +var \u{2B0AD}; +var \u{2B0AE}; +var \u{2B0AF}; +var \u{2B0B0}; +var \u{2B0B1}; +var \u{2B0B2}; +var \u{2B0B3}; +var \u{2B0B4}; +var \u{2B0B5}; +var \u{2B0B6}; +var \u{2B0B7}; +var \u{2B0B8}; +var \u{2B0B9}; +var \u{2B0BA}; +var \u{2B0BB}; +var \u{2B0BC}; +var \u{2B0BD}; +var \u{2B0BE}; +var \u{2B0BF}; +var \u{2B0C0}; +var \u{2B0C1}; +var \u{2B0C2}; +var \u{2B0C3}; +var \u{2B0C4}; +var \u{2B0C5}; +var \u{2B0C6}; +var \u{2B0C7}; +var \u{2B0C8}; +var \u{2B0C9}; +var \u{2B0CA}; +var \u{2B0CB}; +var \u{2B0CC}; +var \u{2B0CD}; +var \u{2B0CE}; +var \u{2B0CF}; +var \u{2B0D0}; +var \u{2B0D1}; +var \u{2B0D2}; +var \u{2B0D3}; +var \u{2B0D4}; +var \u{2B0D5}; +var \u{2B0D6}; +var \u{2B0D7}; +var \u{2B0D8}; +var \u{2B0D9}; +var \u{2B0DA}; +var \u{2B0DB}; +var \u{2B0DC}; +var \u{2B0DD}; +var \u{2B0DE}; +var \u{2B0DF}; +var \u{2B0E0}; +var \u{2B0E1}; +var \u{2B0E2}; +var \u{2B0E3}; +var \u{2B0E4}; +var \u{2B0E5}; +var \u{2B0E6}; +var \u{2B0E7}; +var \u{2B0E8}; +var \u{2B0E9}; +var \u{2B0EA}; +var \u{2B0EB}; +var \u{2B0EC}; +var \u{2B0ED}; +var \u{2B0EE}; +var \u{2B0EF}; +var \u{2B0F0}; +var \u{2B0F1}; +var \u{2B0F2}; +var \u{2B0F3}; +var \u{2B0F4}; +var \u{2B0F5}; +var \u{2B0F6}; +var \u{2B0F7}; +var \u{2B0F8}; +var \u{2B0F9}; +var \u{2B0FA}; +var \u{2B0FB}; +var \u{2B0FC}; +var \u{2B0FD}; +var \u{2B0FE}; +var \u{2B0FF}; +var \u{2B100}; +var \u{2B101}; +var \u{2B102}; +var \u{2B103}; +var \u{2B104}; +var \u{2B105}; +var \u{2B106}; +var \u{2B107}; +var \u{2B108}; +var \u{2B109}; +var \u{2B10A}; +var \u{2B10B}; +var \u{2B10C}; +var \u{2B10D}; +var \u{2B10E}; +var \u{2B10F}; +var \u{2B110}; +var \u{2B111}; +var \u{2B112}; +var \u{2B113}; +var \u{2B114}; +var \u{2B115}; +var \u{2B116}; +var \u{2B117}; +var \u{2B118}; +var \u{2B119}; +var \u{2B11A}; +var \u{2B11B}; +var \u{2B11C}; +var \u{2B11D}; +var \u{2B11E}; +var \u{2B11F}; +var \u{2B120}; +var \u{2B121}; +var \u{2B122}; +var \u{2B123}; +var \u{2B124}; +var \u{2B125}; +var \u{2B126}; +var \u{2B127}; +var \u{2B128}; +var \u{2B129}; +var \u{2B12A}; +var \u{2B12B}; +var \u{2B12C}; +var \u{2B12D}; +var \u{2B12E}; +var \u{2B12F}; +var \u{2B130}; +var \u{2B131}; +var \u{2B132}; +var \u{2B133}; +var \u{2B134}; +var \u{2B135}; +var \u{2B136}; +var \u{2B137}; +var \u{2B138}; +var \u{2B139}; +var \u{2B13A}; +var \u{2B13B}; +var \u{2B13C}; +var \u{2B13D}; +var \u{2B13E}; +var \u{2B13F}; +var \u{2B140}; +var \u{2B141}; +var \u{2B142}; +var \u{2B143}; +var \u{2B144}; +var \u{2B145}; +var \u{2B146}; +var \u{2B147}; +var \u{2B148}; +var \u{2B149}; +var \u{2B14A}; +var \u{2B14B}; +var \u{2B14C}; +var \u{2B14D}; +var \u{2B14E}; +var \u{2B14F}; +var \u{2B150}; +var \u{2B151}; +var \u{2B152}; +var \u{2B153}; +var \u{2B154}; +var \u{2B155}; +var \u{2B156}; +var \u{2B157}; +var \u{2B158}; +var \u{2B159}; +var \u{2B15A}; +var \u{2B15B}; +var \u{2B15C}; +var \u{2B15D}; +var \u{2B15E}; +var \u{2B15F}; +var \u{2B160}; +var \u{2B161}; +var \u{2B162}; +var \u{2B163}; +var \u{2B164}; +var \u{2B165}; +var \u{2B166}; +var \u{2B167}; +var \u{2B168}; +var \u{2B169}; +var \u{2B16A}; +var \u{2B16B}; +var \u{2B16C}; +var \u{2B16D}; +var \u{2B16E}; +var \u{2B16F}; +var \u{2B170}; +var \u{2B171}; +var \u{2B172}; +var \u{2B173}; +var \u{2B174}; +var \u{2B175}; +var \u{2B176}; +var \u{2B177}; +var \u{2B178}; +var \u{2B179}; +var \u{2B17A}; +var \u{2B17B}; +var \u{2B17C}; +var \u{2B17D}; +var \u{2B17E}; +var \u{2B17F}; +var \u{2B180}; +var \u{2B181}; +var \u{2B182}; +var \u{2B183}; +var \u{2B184}; +var \u{2B185}; +var \u{2B186}; +var \u{2B187}; +var \u{2B188}; +var \u{2B189}; +var \u{2B18A}; +var \u{2B18B}; +var \u{2B18C}; +var \u{2B18D}; +var \u{2B18E}; +var \u{2B18F}; +var \u{2B190}; +var \u{2B191}; +var \u{2B192}; +var \u{2B193}; +var \u{2B194}; +var \u{2B195}; +var \u{2B196}; +var \u{2B197}; +var \u{2B198}; +var \u{2B199}; +var \u{2B19A}; +var \u{2B19B}; +var \u{2B19C}; +var \u{2B19D}; +var \u{2B19E}; +var \u{2B19F}; +var \u{2B1A0}; +var \u{2B1A1}; +var \u{2B1A2}; +var \u{2B1A3}; +var \u{2B1A4}; +var \u{2B1A5}; +var \u{2B1A6}; +var \u{2B1A7}; +var \u{2B1A8}; +var \u{2B1A9}; +var \u{2B1AA}; +var \u{2B1AB}; +var \u{2B1AC}; +var \u{2B1AD}; +var \u{2B1AE}; +var \u{2B1AF}; +var \u{2B1B0}; +var \u{2B1B1}; +var \u{2B1B2}; +var \u{2B1B3}; +var \u{2B1B4}; +var \u{2B1B5}; +var \u{2B1B6}; +var \u{2B1B7}; +var \u{2B1B8}; +var \u{2B1B9}; +var \u{2B1BA}; +var \u{2B1BB}; +var \u{2B1BC}; +var \u{2B1BD}; +var \u{2B1BE}; +var \u{2B1BF}; +var \u{2B1C0}; +var \u{2B1C1}; +var \u{2B1C2}; +var \u{2B1C3}; +var \u{2B1C4}; +var \u{2B1C5}; +var \u{2B1C6}; +var \u{2B1C7}; +var \u{2B1C8}; +var \u{2B1C9}; +var \u{2B1CA}; +var \u{2B1CB}; +var \u{2B1CC}; +var \u{2B1CD}; +var \u{2B1CE}; +var \u{2B1CF}; +var \u{2B1D0}; +var \u{2B1D1}; +var \u{2B1D2}; +var \u{2B1D3}; +var \u{2B1D4}; +var \u{2B1D5}; +var \u{2B1D6}; +var \u{2B1D7}; +var \u{2B1D8}; +var \u{2B1D9}; +var \u{2B1DA}; +var \u{2B1DB}; +var \u{2B1DC}; +var \u{2B1DD}; +var \u{2B1DE}; +var \u{2B1DF}; +var \u{2B1E0}; +var \u{2B1E1}; +var \u{2B1E2}; +var \u{2B1E3}; +var \u{2B1E4}; +var \u{2B1E5}; +var \u{2B1E6}; +var \u{2B1E7}; +var \u{2B1E8}; +var \u{2B1E9}; +var \u{2B1EA}; +var \u{2B1EB}; +var \u{2B1EC}; +var \u{2B1ED}; +var \u{2B1EE}; +var \u{2B1EF}; +var \u{2B1F0}; +var \u{2B1F1}; +var \u{2B1F2}; +var \u{2B1F3}; +var \u{2B1F4}; +var \u{2B1F5}; +var \u{2B1F6}; +var \u{2B1F7}; +var \u{2B1F8}; +var \u{2B1F9}; +var \u{2B1FA}; +var \u{2B1FB}; +var \u{2B1FC}; +var \u{2B1FD}; +var \u{2B1FE}; +var \u{2B1FF}; +var \u{2B200}; +var \u{2B201}; +var \u{2B202}; +var \u{2B203}; +var \u{2B204}; +var \u{2B205}; +var \u{2B206}; +var \u{2B207}; +var \u{2B208}; +var \u{2B209}; +var \u{2B20A}; +var \u{2B20B}; +var \u{2B20C}; +var \u{2B20D}; +var \u{2B20E}; +var \u{2B20F}; +var \u{2B210}; +var \u{2B211}; +var \u{2B212}; +var \u{2B213}; +var \u{2B214}; +var \u{2B215}; +var \u{2B216}; +var \u{2B217}; +var \u{2B218}; +var \u{2B219}; +var \u{2B21A}; +var \u{2B21B}; +var \u{2B21C}; +var \u{2B21D}; +var \u{2B21E}; +var \u{2B21F}; +var \u{2B220}; +var \u{2B221}; +var \u{2B222}; +var \u{2B223}; +var \u{2B224}; +var \u{2B225}; +var \u{2B226}; +var \u{2B227}; +var \u{2B228}; +var \u{2B229}; +var \u{2B22A}; +var \u{2B22B}; +var \u{2B22C}; +var \u{2B22D}; +var \u{2B22E}; +var \u{2B22F}; +var \u{2B230}; +var \u{2B231}; +var \u{2B232}; +var \u{2B233}; +var \u{2B234}; +var \u{2B235}; +var \u{2B236}; +var \u{2B237}; +var \u{2B238}; +var \u{2B239}; +var \u{2B23A}; +var \u{2B23B}; +var \u{2B23C}; +var \u{2B23D}; +var \u{2B23E}; +var \u{2B23F}; +var \u{2B240}; +var \u{2B241}; +var \u{2B242}; +var \u{2B243}; +var \u{2B244}; +var \u{2B245}; +var \u{2B246}; +var \u{2B247}; +var \u{2B248}; +var \u{2B249}; +var \u{2B24A}; +var \u{2B24B}; +var \u{2B24C}; +var \u{2B24D}; +var \u{2B24E}; +var \u{2B24F}; +var \u{2B250}; +var \u{2B251}; +var \u{2B252}; +var \u{2B253}; +var \u{2B254}; +var \u{2B255}; +var \u{2B256}; +var \u{2B257}; +var \u{2B258}; +var \u{2B259}; +var \u{2B25A}; +var \u{2B25B}; +var \u{2B25C}; +var \u{2B25D}; +var \u{2B25E}; +var \u{2B25F}; +var \u{2B260}; +var \u{2B261}; +var \u{2B262}; +var \u{2B263}; +var \u{2B264}; +var \u{2B265}; +var \u{2B266}; +var \u{2B267}; +var \u{2B268}; +var \u{2B269}; +var \u{2B26A}; +var \u{2B26B}; +var \u{2B26C}; +var \u{2B26D}; +var \u{2B26E}; +var \u{2B26F}; +var \u{2B270}; +var \u{2B271}; +var \u{2B272}; +var \u{2B273}; +var \u{2B274}; +var \u{2B275}; +var \u{2B276}; +var \u{2B277}; +var \u{2B278}; +var \u{2B279}; +var \u{2B27A}; +var \u{2B27B}; +var \u{2B27C}; +var \u{2B27D}; +var \u{2B27E}; +var \u{2B27F}; +var \u{2B280}; +var \u{2B281}; +var \u{2B282}; +var \u{2B283}; +var \u{2B284}; +var \u{2B285}; +var \u{2B286}; +var \u{2B287}; +var \u{2B288}; +var \u{2B289}; +var \u{2B28A}; +var \u{2B28B}; +var \u{2B28C}; +var \u{2B28D}; +var \u{2B28E}; +var \u{2B28F}; +var \u{2B290}; +var \u{2B291}; +var \u{2B292}; +var \u{2B293}; +var \u{2B294}; +var \u{2B295}; +var \u{2B296}; +var \u{2B297}; +var \u{2B298}; +var \u{2B299}; +var \u{2B29A}; +var \u{2B29B}; +var \u{2B29C}; +var \u{2B29D}; +var \u{2B29E}; +var \u{2B29F}; +var \u{2B2A0}; +var \u{2B2A1}; +var \u{2B2A2}; +var \u{2B2A3}; +var \u{2B2A4}; +var \u{2B2A5}; +var \u{2B2A6}; +var \u{2B2A7}; +var \u{2B2A8}; +var \u{2B2A9}; +var \u{2B2AA}; +var \u{2B2AB}; +var \u{2B2AC}; +var \u{2B2AD}; +var \u{2B2AE}; +var \u{2B2AF}; +var \u{2B2B0}; +var \u{2B2B1}; +var \u{2B2B2}; +var \u{2B2B3}; +var \u{2B2B4}; +var \u{2B2B5}; +var \u{2B2B6}; +var \u{2B2B7}; +var \u{2B2B8}; +var \u{2B2B9}; +var \u{2B2BA}; +var \u{2B2BB}; +var \u{2B2BC}; +var \u{2B2BD}; +var \u{2B2BE}; +var \u{2B2BF}; +var \u{2B2C0}; +var \u{2B2C1}; +var \u{2B2C2}; +var \u{2B2C3}; +var \u{2B2C4}; +var \u{2B2C5}; +var \u{2B2C6}; +var \u{2B2C7}; +var \u{2B2C8}; +var \u{2B2C9}; +var \u{2B2CA}; +var \u{2B2CB}; +var \u{2B2CC}; +var \u{2B2CD}; +var \u{2B2CE}; +var \u{2B2CF}; +var \u{2B2D0}; +var \u{2B2D1}; +var \u{2B2D2}; +var \u{2B2D3}; +var \u{2B2D4}; +var \u{2B2D5}; +var \u{2B2D6}; +var \u{2B2D7}; +var \u{2B2D8}; +var \u{2B2D9}; +var \u{2B2DA}; +var \u{2B2DB}; +var \u{2B2DC}; +var \u{2B2DD}; +var \u{2B2DE}; +var \u{2B2DF}; +var \u{2B2E0}; +var \u{2B2E1}; +var \u{2B2E2}; +var \u{2B2E3}; +var \u{2B2E4}; +var \u{2B2E5}; +var \u{2B2E6}; +var \u{2B2E7}; +var \u{2B2E8}; +var \u{2B2E9}; +var \u{2B2EA}; +var \u{2B2EB}; +var \u{2B2EC}; +var \u{2B2ED}; +var \u{2B2EE}; +var \u{2B2EF}; +var \u{2B2F0}; +var \u{2B2F1}; +var \u{2B2F2}; +var \u{2B2F3}; +var \u{2B2F4}; +var \u{2B2F5}; +var \u{2B2F6}; +var \u{2B2F7}; +var \u{2B2F8}; +var \u{2B2F9}; +var \u{2B2FA}; +var \u{2B2FB}; +var \u{2B2FC}; +var \u{2B2FD}; +var \u{2B2FE}; +var \u{2B2FF}; +var \u{2B300}; +var \u{2B301}; +var \u{2B302}; +var \u{2B303}; +var \u{2B304}; +var \u{2B305}; +var \u{2B306}; +var \u{2B307}; +var \u{2B308}; +var \u{2B309}; +var \u{2B30A}; +var \u{2B30B}; +var \u{2B30C}; +var \u{2B30D}; +var \u{2B30E}; +var \u{2B30F}; +var \u{2B310}; +var \u{2B311}; +var \u{2B312}; +var \u{2B313}; +var \u{2B314}; +var \u{2B315}; +var \u{2B316}; +var \u{2B317}; +var \u{2B318}; +var \u{2B319}; +var \u{2B31A}; +var \u{2B31B}; +var \u{2B31C}; +var \u{2B31D}; +var \u{2B31E}; +var \u{2B31F}; +var \u{2B320}; +var \u{2B321}; +var \u{2B322}; +var \u{2B323}; +var \u{2B324}; +var \u{2B325}; +var \u{2B326}; +var \u{2B327}; +var \u{2B328}; +var \u{2B329}; +var \u{2B32A}; +var \u{2B32B}; +var \u{2B32C}; +var \u{2B32D}; +var \u{2B32E}; +var \u{2B32F}; +var \u{2B330}; +var \u{2B331}; +var \u{2B332}; +var \u{2B333}; +var \u{2B334}; +var \u{2B335}; +var \u{2B336}; +var \u{2B337}; +var \u{2B338}; +var \u{2B339}; +var \u{2B33A}; +var \u{2B33B}; +var \u{2B33C}; +var \u{2B33D}; +var \u{2B33E}; +var \u{2B33F}; +var \u{2B340}; +var \u{2B341}; +var \u{2B342}; +var \u{2B343}; +var \u{2B344}; +var \u{2B345}; +var \u{2B346}; +var \u{2B347}; +var \u{2B348}; +var \u{2B349}; +var \u{2B34A}; +var \u{2B34B}; +var \u{2B34C}; +var \u{2B34D}; +var \u{2B34E}; +var \u{2B34F}; +var \u{2B350}; +var \u{2B351}; +var \u{2B352}; +var \u{2B353}; +var \u{2B354}; +var \u{2B355}; +var \u{2B356}; +var \u{2B357}; +var \u{2B358}; +var \u{2B359}; +var \u{2B35A}; +var \u{2B35B}; +var \u{2B35C}; +var \u{2B35D}; +var \u{2B35E}; +var \u{2B35F}; +var \u{2B360}; +var \u{2B361}; +var \u{2B362}; +var \u{2B363}; +var \u{2B364}; +var \u{2B365}; +var \u{2B366}; +var \u{2B367}; +var \u{2B368}; +var \u{2B369}; +var \u{2B36A}; +var \u{2B36B}; +var \u{2B36C}; +var \u{2B36D}; +var \u{2B36E}; +var \u{2B36F}; +var \u{2B370}; +var \u{2B371}; +var \u{2B372}; +var \u{2B373}; +var \u{2B374}; +var \u{2B375}; +var \u{2B376}; +var \u{2B377}; +var \u{2B378}; +var \u{2B379}; +var \u{2B37A}; +var \u{2B37B}; +var \u{2B37C}; +var \u{2B37D}; +var \u{2B37E}; +var \u{2B37F}; +var \u{2B380}; +var \u{2B381}; +var \u{2B382}; +var \u{2B383}; +var \u{2B384}; +var \u{2B385}; +var \u{2B386}; +var \u{2B387}; +var \u{2B388}; +var \u{2B389}; +var \u{2B38A}; +var \u{2B38B}; +var \u{2B38C}; +var \u{2B38D}; +var \u{2B38E}; +var \u{2B38F}; +var \u{2B390}; +var \u{2B391}; +var \u{2B392}; +var \u{2B393}; +var \u{2B394}; +var \u{2B395}; +var \u{2B396}; +var \u{2B397}; +var \u{2B398}; +var \u{2B399}; +var \u{2B39A}; +var \u{2B39B}; +var \u{2B39C}; +var \u{2B39D}; +var \u{2B39E}; +var \u{2B39F}; +var \u{2B3A0}; +var \u{2B3A1}; +var \u{2B3A2}; +var \u{2B3A3}; +var \u{2B3A4}; +var \u{2B3A5}; +var \u{2B3A6}; +var \u{2B3A7}; +var \u{2B3A8}; +var \u{2B3A9}; +var \u{2B3AA}; +var \u{2B3AB}; +var \u{2B3AC}; +var \u{2B3AD}; +var \u{2B3AE}; +var \u{2B3AF}; +var \u{2B3B0}; +var \u{2B3B1}; +var \u{2B3B2}; +var \u{2B3B3}; +var \u{2B3B4}; +var \u{2B3B5}; +var \u{2B3B6}; +var \u{2B3B7}; +var \u{2B3B8}; +var \u{2B3B9}; +var \u{2B3BA}; +var \u{2B3BB}; +var \u{2B3BC}; +var \u{2B3BD}; +var \u{2B3BE}; +var \u{2B3BF}; +var \u{2B3C0}; +var \u{2B3C1}; +var \u{2B3C2}; +var \u{2B3C3}; +var \u{2B3C4}; +var \u{2B3C5}; +var \u{2B3C6}; +var \u{2B3C7}; +var \u{2B3C8}; +var \u{2B3C9}; +var \u{2B3CA}; +var \u{2B3CB}; +var \u{2B3CC}; +var \u{2B3CD}; +var \u{2B3CE}; +var \u{2B3CF}; +var \u{2B3D0}; +var \u{2B3D1}; +var \u{2B3D2}; +var \u{2B3D3}; +var \u{2B3D4}; +var \u{2B3D5}; +var \u{2B3D6}; +var \u{2B3D7}; +var \u{2B3D8}; +var \u{2B3D9}; +var \u{2B3DA}; +var \u{2B3DB}; +var \u{2B3DC}; +var \u{2B3DD}; +var \u{2B3DE}; +var \u{2B3DF}; +var \u{2B3E0}; +var \u{2B3E1}; +var \u{2B3E2}; +var \u{2B3E3}; +var \u{2B3E4}; +var \u{2B3E5}; +var \u{2B3E6}; +var \u{2B3E7}; +var \u{2B3E8}; +var \u{2B3E9}; +var \u{2B3EA}; +var \u{2B3EB}; +var \u{2B3EC}; +var \u{2B3ED}; +var \u{2B3EE}; +var \u{2B3EF}; +var \u{2B3F0}; +var \u{2B3F1}; +var \u{2B3F2}; +var \u{2B3F3}; +var \u{2B3F4}; +var \u{2B3F5}; +var \u{2B3F6}; +var \u{2B3F7}; +var \u{2B3F8}; +var \u{2B3F9}; +var \u{2B3FA}; +var \u{2B3FB}; +var \u{2B3FC}; +var \u{2B3FD}; +var \u{2B3FE}; +var \u{2B3FF}; +var \u{2B400}; +var \u{2B401}; +var \u{2B402}; +var \u{2B403}; +var \u{2B404}; +var \u{2B405}; +var \u{2B406}; +var \u{2B407}; +var \u{2B408}; +var \u{2B409}; +var \u{2B40A}; +var \u{2B40B}; +var \u{2B40C}; +var \u{2B40D}; +var \u{2B40E}; +var \u{2B40F}; +var \u{2B410}; +var \u{2B411}; +var \u{2B412}; +var \u{2B413}; +var \u{2B414}; +var \u{2B415}; +var \u{2B416}; +var \u{2B417}; +var \u{2B418}; +var \u{2B419}; +var \u{2B41A}; +var \u{2B41B}; +var \u{2B41C}; +var \u{2B41D}; +var \u{2B41E}; +var \u{2B41F}; +var \u{2B420}; +var \u{2B421}; +var \u{2B422}; +var \u{2B423}; +var \u{2B424}; +var \u{2B425}; +var \u{2B426}; +var \u{2B427}; +var \u{2B428}; +var \u{2B429}; +var \u{2B42A}; +var \u{2B42B}; +var \u{2B42C}; +var \u{2B42D}; +var \u{2B42E}; +var \u{2B42F}; +var \u{2B430}; +var \u{2B431}; +var \u{2B432}; +var \u{2B433}; +var \u{2B434}; +var \u{2B435}; +var \u{2B436}; +var \u{2B437}; +var \u{2B438}; +var \u{2B439}; +var \u{2B43A}; +var \u{2B43B}; +var \u{2B43C}; +var \u{2B43D}; +var \u{2B43E}; +var \u{2B43F}; +var \u{2B440}; +var \u{2B441}; +var \u{2B442}; +var \u{2B443}; +var \u{2B444}; +var \u{2B445}; +var \u{2B446}; +var \u{2B447}; +var \u{2B448}; +var \u{2B449}; +var \u{2B44A}; +var \u{2B44B}; +var \u{2B44C}; +var \u{2B44D}; +var \u{2B44E}; +var \u{2B44F}; +var \u{2B450}; +var \u{2B451}; +var \u{2B452}; +var \u{2B453}; +var \u{2B454}; +var \u{2B455}; +var \u{2B456}; +var \u{2B457}; +var \u{2B458}; +var \u{2B459}; +var \u{2B45A}; +var \u{2B45B}; +var \u{2B45C}; +var \u{2B45D}; +var \u{2B45E}; +var \u{2B45F}; +var \u{2B460}; +var \u{2B461}; +var \u{2B462}; +var \u{2B463}; +var \u{2B464}; +var \u{2B465}; +var \u{2B466}; +var \u{2B467}; +var \u{2B468}; +var \u{2B469}; +var \u{2B46A}; +var \u{2B46B}; +var \u{2B46C}; +var \u{2B46D}; +var \u{2B46E}; +var \u{2B46F}; +var \u{2B470}; +var \u{2B471}; +var \u{2B472}; +var \u{2B473}; +var \u{2B474}; +var \u{2B475}; +var \u{2B476}; +var \u{2B477}; +var \u{2B478}; +var \u{2B479}; +var \u{2B47A}; +var \u{2B47B}; +var \u{2B47C}; +var \u{2B47D}; +var \u{2B47E}; +var \u{2B47F}; +var \u{2B480}; +var \u{2B481}; +var \u{2B482}; +var \u{2B483}; +var \u{2B484}; +var \u{2B485}; +var \u{2B486}; +var \u{2B487}; +var \u{2B488}; +var \u{2B489}; +var \u{2B48A}; +var \u{2B48B}; +var \u{2B48C}; +var \u{2B48D}; +var \u{2B48E}; +var \u{2B48F}; +var \u{2B490}; +var \u{2B491}; +var \u{2B492}; +var \u{2B493}; +var \u{2B494}; +var \u{2B495}; +var \u{2B496}; +var \u{2B497}; +var \u{2B498}; +var \u{2B499}; +var \u{2B49A}; +var \u{2B49B}; +var \u{2B49C}; +var \u{2B49D}; +var \u{2B49E}; +var \u{2B49F}; +var \u{2B4A0}; +var \u{2B4A1}; +var \u{2B4A2}; +var \u{2B4A3}; +var \u{2B4A4}; +var \u{2B4A5}; +var \u{2B4A6}; +var \u{2B4A7}; +var \u{2B4A8}; +var \u{2B4A9}; +var \u{2B4AA}; +var \u{2B4AB}; +var \u{2B4AC}; +var \u{2B4AD}; +var \u{2B4AE}; +var \u{2B4AF}; +var \u{2B4B0}; +var \u{2B4B1}; +var \u{2B4B2}; +var \u{2B4B3}; +var \u{2B4B4}; +var \u{2B4B5}; +var \u{2B4B6}; +var \u{2B4B7}; +var \u{2B4B8}; +var \u{2B4B9}; +var \u{2B4BA}; +var \u{2B4BB}; +var \u{2B4BC}; +var \u{2B4BD}; +var \u{2B4BE}; +var \u{2B4BF}; +var \u{2B4C0}; +var \u{2B4C1}; +var \u{2B4C2}; +var \u{2B4C3}; +var \u{2B4C4}; +var \u{2B4C5}; +var \u{2B4C6}; +var \u{2B4C7}; +var \u{2B4C8}; +var \u{2B4C9}; +var \u{2B4CA}; +var \u{2B4CB}; +var \u{2B4CC}; +var \u{2B4CD}; +var \u{2B4CE}; +var \u{2B4CF}; +var \u{2B4D0}; +var \u{2B4D1}; +var \u{2B4D2}; +var \u{2B4D3}; +var \u{2B4D4}; +var \u{2B4D5}; +var \u{2B4D6}; +var \u{2B4D7}; +var \u{2B4D8}; +var \u{2B4D9}; +var \u{2B4DA}; +var \u{2B4DB}; +var \u{2B4DC}; +var \u{2B4DD}; +var \u{2B4DE}; +var \u{2B4DF}; +var \u{2B4E0}; +var \u{2B4E1}; +var \u{2B4E2}; +var \u{2B4E3}; +var \u{2B4E4}; +var \u{2B4E5}; +var \u{2B4E6}; +var \u{2B4E7}; +var \u{2B4E8}; +var \u{2B4E9}; +var \u{2B4EA}; +var \u{2B4EB}; +var \u{2B4EC}; +var \u{2B4ED}; +var \u{2B4EE}; +var \u{2B4EF}; +var \u{2B4F0}; +var \u{2B4F1}; +var \u{2B4F2}; +var \u{2B4F3}; +var \u{2B4F4}; +var \u{2B4F5}; +var \u{2B4F6}; +var \u{2B4F7}; +var \u{2B4F8}; +var \u{2B4F9}; +var \u{2B4FA}; +var \u{2B4FB}; +var \u{2B4FC}; +var \u{2B4FD}; +var \u{2B4FE}; +var \u{2B4FF}; +var \u{2B500}; +var \u{2B501}; +var \u{2B502}; +var \u{2B503}; +var \u{2B504}; +var \u{2B505}; +var \u{2B506}; +var \u{2B507}; +var \u{2B508}; +var \u{2B509}; +var \u{2B50A}; +var \u{2B50B}; +var \u{2B50C}; +var \u{2B50D}; +var \u{2B50E}; +var \u{2B50F}; +var \u{2B510}; +var \u{2B511}; +var \u{2B512}; +var \u{2B513}; +var \u{2B514}; +var \u{2B515}; +var \u{2B516}; +var \u{2B517}; +var \u{2B518}; +var \u{2B519}; +var \u{2B51A}; +var \u{2B51B}; +var \u{2B51C}; +var \u{2B51D}; +var \u{2B51E}; +var \u{2B51F}; +var \u{2B520}; +var \u{2B521}; +var \u{2B522}; +var \u{2B523}; +var \u{2B524}; +var \u{2B525}; +var \u{2B526}; +var \u{2B527}; +var \u{2B528}; +var \u{2B529}; +var \u{2B52A}; +var \u{2B52B}; +var \u{2B52C}; +var \u{2B52D}; +var \u{2B52E}; +var \u{2B52F}; +var \u{2B530}; +var \u{2B531}; +var \u{2B532}; +var \u{2B533}; +var \u{2B534}; +var \u{2B535}; +var \u{2B536}; +var \u{2B537}; +var \u{2B538}; +var \u{2B539}; +var \u{2B53A}; +var \u{2B53B}; +var \u{2B53C}; +var \u{2B53D}; +var \u{2B53E}; +var \u{2B53F}; +var \u{2B540}; +var \u{2B541}; +var \u{2B542}; +var \u{2B543}; +var \u{2B544}; +var \u{2B545}; +var \u{2B546}; +var \u{2B547}; +var \u{2B548}; +var \u{2B549}; +var \u{2B54A}; +var \u{2B54B}; +var \u{2B54C}; +var \u{2B54D}; +var \u{2B54E}; +var \u{2B54F}; +var \u{2B550}; +var \u{2B551}; +var \u{2B552}; +var \u{2B553}; +var \u{2B554}; +var \u{2B555}; +var \u{2B556}; +var \u{2B557}; +var \u{2B558}; +var \u{2B559}; +var \u{2B55A}; +var \u{2B55B}; +var \u{2B55C}; +var \u{2B55D}; +var \u{2B55E}; +var \u{2B55F}; +var \u{2B560}; +var \u{2B561}; +var \u{2B562}; +var \u{2B563}; +var \u{2B564}; +var \u{2B565}; +var \u{2B566}; +var \u{2B567}; +var \u{2B568}; +var \u{2B569}; +var \u{2B56A}; +var \u{2B56B}; +var \u{2B56C}; +var \u{2B56D}; +var \u{2B56E}; +var \u{2B56F}; +var \u{2B570}; +var \u{2B571}; +var \u{2B572}; +var \u{2B573}; +var \u{2B574}; +var \u{2B575}; +var \u{2B576}; +var \u{2B577}; +var \u{2B578}; +var \u{2B579}; +var \u{2B57A}; +var \u{2B57B}; +var \u{2B57C}; +var \u{2B57D}; +var \u{2B57E}; +var \u{2B57F}; +var \u{2B580}; +var \u{2B581}; +var \u{2B582}; +var \u{2B583}; +var \u{2B584}; +var \u{2B585}; +var \u{2B586}; +var \u{2B587}; +var \u{2B588}; +var \u{2B589}; +var \u{2B58A}; +var \u{2B58B}; +var \u{2B58C}; +var \u{2B58D}; +var \u{2B58E}; +var \u{2B58F}; +var \u{2B590}; +var \u{2B591}; +var \u{2B592}; +var \u{2B593}; +var \u{2B594}; +var \u{2B595}; +var \u{2B596}; +var \u{2B597}; +var \u{2B598}; +var \u{2B599}; +var \u{2B59A}; +var \u{2B59B}; +var \u{2B59C}; +var \u{2B59D}; +var \u{2B59E}; +var \u{2B59F}; +var \u{2B5A0}; +var \u{2B5A1}; +var \u{2B5A2}; +var \u{2B5A3}; +var \u{2B5A4}; +var \u{2B5A5}; +var \u{2B5A6}; +var \u{2B5A7}; +var \u{2B5A8}; +var \u{2B5A9}; +var \u{2B5AA}; +var \u{2B5AB}; +var \u{2B5AC}; +var \u{2B5AD}; +var \u{2B5AE}; +var \u{2B5AF}; +var \u{2B5B0}; +var \u{2B5B1}; +var \u{2B5B2}; +var \u{2B5B3}; +var \u{2B5B4}; +var \u{2B5B5}; +var \u{2B5B6}; +var \u{2B5B7}; +var \u{2B5B8}; +var \u{2B5B9}; +var \u{2B5BA}; +var \u{2B5BB}; +var \u{2B5BC}; +var \u{2B5BD}; +var \u{2B5BE}; +var \u{2B5BF}; +var \u{2B5C0}; +var \u{2B5C1}; +var \u{2B5C2}; +var \u{2B5C3}; +var \u{2B5C4}; +var \u{2B5C5}; +var \u{2B5C6}; +var \u{2B5C7}; +var \u{2B5C8}; +var \u{2B5C9}; +var \u{2B5CA}; +var \u{2B5CB}; +var \u{2B5CC}; +var \u{2B5CD}; +var \u{2B5CE}; +var \u{2B5CF}; +var \u{2B5D0}; +var \u{2B5D1}; +var \u{2B5D2}; +var \u{2B5D3}; +var \u{2B5D4}; +var \u{2B5D5}; +var \u{2B5D6}; +var \u{2B5D7}; +var \u{2B5D8}; +var \u{2B5D9}; +var \u{2B5DA}; +var \u{2B5DB}; +var \u{2B5DC}; +var \u{2B5DD}; +var \u{2B5DE}; +var \u{2B5DF}; +var \u{2B5E0}; +var \u{2B5E1}; +var \u{2B5E2}; +var \u{2B5E3}; +var \u{2B5E4}; +var \u{2B5E5}; +var \u{2B5E6}; +var \u{2B5E7}; +var \u{2B5E8}; +var \u{2B5E9}; +var \u{2B5EA}; +var \u{2B5EB}; +var \u{2B5EC}; +var \u{2B5ED}; +var \u{2B5EE}; +var \u{2B5EF}; +var \u{2B5F0}; +var \u{2B5F1}; +var \u{2B5F2}; +var \u{2B5F3}; +var \u{2B5F4}; +var \u{2B5F5}; +var \u{2B5F6}; +var \u{2B5F7}; +var \u{2B5F8}; +var \u{2B5F9}; +var \u{2B5FA}; +var \u{2B5FB}; +var \u{2B5FC}; +var \u{2B5FD}; +var \u{2B5FE}; +var \u{2B5FF}; +var \u{2B600}; +var \u{2B601}; +var \u{2B602}; +var \u{2B603}; +var \u{2B604}; +var \u{2B605}; +var \u{2B606}; +var \u{2B607}; +var \u{2B608}; +var \u{2B609}; +var \u{2B60A}; +var \u{2B60B}; +var \u{2B60C}; +var \u{2B60D}; +var \u{2B60E}; +var \u{2B60F}; +var \u{2B610}; +var \u{2B611}; +var \u{2B612}; +var \u{2B613}; +var \u{2B614}; +var \u{2B615}; +var \u{2B616}; +var \u{2B617}; +var \u{2B618}; +var \u{2B619}; +var \u{2B61A}; +var \u{2B61B}; +var \u{2B61C}; +var \u{2B61D}; +var \u{2B61E}; +var \u{2B61F}; +var \u{2B620}; +var \u{2B621}; +var \u{2B622}; +var \u{2B623}; +var \u{2B624}; +var \u{2B625}; +var \u{2B626}; +var \u{2B627}; +var \u{2B628}; +var \u{2B629}; +var \u{2B62A}; +var \u{2B62B}; +var \u{2B62C}; +var \u{2B62D}; +var \u{2B62E}; +var \u{2B62F}; +var \u{2B630}; +var \u{2B631}; +var \u{2B632}; +var \u{2B633}; +var \u{2B634}; +var \u{2B635}; +var \u{2B636}; +var \u{2B637}; +var \u{2B638}; +var \u{2B639}; +var \u{2B63A}; +var \u{2B63B}; +var \u{2B63C}; +var \u{2B63D}; +var \u{2B63E}; +var \u{2B63F}; +var \u{2B640}; +var \u{2B641}; +var \u{2B642}; +var \u{2B643}; +var \u{2B644}; +var \u{2B645}; +var \u{2B646}; +var \u{2B647}; +var \u{2B648}; +var \u{2B649}; +var \u{2B64A}; +var \u{2B64B}; +var \u{2B64C}; +var \u{2B64D}; +var \u{2B64E}; +var \u{2B64F}; +var \u{2B650}; +var \u{2B651}; +var \u{2B652}; +var \u{2B653}; +var \u{2B654}; +var \u{2B655}; +var \u{2B656}; +var \u{2B657}; +var \u{2B658}; +var \u{2B659}; +var \u{2B65A}; +var \u{2B65B}; +var \u{2B65C}; +var \u{2B65D}; +var \u{2B65E}; +var \u{2B65F}; +var \u{2B660}; +var \u{2B661}; +var \u{2B662}; +var \u{2B663}; +var \u{2B664}; +var \u{2B665}; +var \u{2B666}; +var \u{2B667}; +var \u{2B668}; +var \u{2B669}; +var \u{2B66A}; +var \u{2B66B}; +var \u{2B66C}; +var \u{2B66D}; +var \u{2B66E}; +var \u{2B66F}; +var \u{2B670}; +var \u{2B671}; +var \u{2B672}; +var \u{2B673}; +var \u{2B674}; +var \u{2B675}; +var \u{2B676}; +var \u{2B677}; +var \u{2B678}; +var \u{2B679}; +var \u{2B67A}; +var \u{2B67B}; +var \u{2B67C}; +var \u{2B67D}; +var \u{2B67E}; +var \u{2B67F}; +var \u{2B680}; +var \u{2B681}; +var \u{2B682}; +var \u{2B683}; +var \u{2B684}; +var \u{2B685}; +var \u{2B686}; +var \u{2B687}; +var \u{2B688}; +var \u{2B689}; +var \u{2B68A}; +var \u{2B68B}; +var \u{2B68C}; +var \u{2B68D}; +var \u{2B68E}; +var \u{2B68F}; +var \u{2B690}; +var \u{2B691}; +var \u{2B692}; +var \u{2B693}; +var \u{2B694}; +var \u{2B695}; +var \u{2B696}; +var \u{2B697}; +var \u{2B698}; +var \u{2B699}; +var \u{2B69A}; +var \u{2B69B}; +var \u{2B69C}; +var \u{2B69D}; +var \u{2B69E}; +var \u{2B69F}; +var \u{2B6A0}; +var \u{2B6A1}; +var \u{2B6A2}; +var \u{2B6A3}; +var \u{2B6A4}; +var \u{2B6A5}; +var \u{2B6A6}; +var \u{2B6A7}; +var \u{2B6A8}; +var \u{2B6A9}; +var \u{2B6AA}; +var \u{2B6AB}; +var \u{2B6AC}; +var \u{2B6AD}; +var \u{2B6AE}; +var \u{2B6AF}; +var \u{2B6B0}; +var \u{2B6B1}; +var \u{2B6B2}; +var \u{2B6B3}; +var \u{2B6B4}; +var \u{2B6B5}; +var \u{2B6B6}; +var \u{2B6B7}; +var \u{2B6B8}; +var \u{2B6B9}; +var \u{2B6BA}; +var \u{2B6BB}; +var \u{2B6BC}; +var \u{2B6BD}; +var \u{2B6BE}; +var \u{2B6BF}; +var \u{2B6C0}; +var \u{2B6C1}; +var \u{2B6C2}; +var \u{2B6C3}; +var \u{2B6C4}; +var \u{2B6C5}; +var \u{2B6C6}; +var \u{2B6C7}; +var \u{2B6C8}; +var \u{2B6C9}; +var \u{2B6CA}; +var \u{2B6CB}; +var \u{2B6CC}; +var \u{2B6CD}; +var \u{2B6CE}; +var \u{2B6CF}; +var \u{2B6D0}; +var \u{2B6D1}; +var \u{2B6D2}; +var \u{2B6D3}; +var \u{2B6D4}; +var \u{2B6D5}; +var \u{2B6D6}; +var \u{2B6D7}; +var \u{2B6D8}; +var \u{2B6D9}; +var \u{2B6DA}; +var \u{2B6DB}; +var \u{2B6DC}; +var \u{2B6DD}; +var \u{2B6DE}; +var \u{2B6DF}; +var \u{2B6E0}; +var \u{2B6E1}; +var \u{2B6E2}; +var \u{2B6E3}; +var \u{2B6E4}; +var \u{2B6E5}; +var \u{2B6E6}; +var \u{2B6E7}; +var \u{2B6E8}; +var \u{2B6E9}; +var \u{2B6EA}; +var \u{2B6EB}; +var \u{2B6EC}; +var \u{2B6ED}; +var \u{2B6EE}; +var \u{2B6EF}; +var \u{2B6F0}; +var \u{2B6F1}; +var \u{2B6F2}; +var \u{2B6F3}; +var \u{2B6F4}; +var \u{2B6F5}; +var \u{2B6F6}; +var \u{2B6F7}; +var \u{2B6F8}; +var \u{2B6F9}; +var \u{2B6FA}; +var \u{2B6FB}; +var \u{2B6FC}; +var \u{2B6FD}; +var \u{2B6FE}; +var \u{2B6FF}; +var \u{2B700}; +var \u{2B701}; +var \u{2B702}; +var \u{2B703}; +var \u{2B704}; +var \u{2B705}; +var \u{2B706}; +var \u{2B707}; +var \u{2B708}; +var \u{2B709}; +var \u{2B70A}; +var \u{2B70B}; +var \u{2B70C}; +var \u{2B70D}; +var \u{2B70E}; +var \u{2B70F}; +var \u{2B710}; +var \u{2B711}; +var \u{2B712}; +var \u{2B713}; +var \u{2B714}; +var \u{2B715}; +var \u{2B716}; +var \u{2B717}; +var \u{2B718}; +var \u{2B719}; +var \u{2B71A}; +var \u{2B71B}; +var \u{2B71C}; +var \u{2B71D}; +var \u{2B71E}; +var \u{2B71F}; +var \u{2B720}; +var \u{2B721}; +var \u{2B722}; +var \u{2B723}; +var \u{2B724}; +var \u{2B725}; +var \u{2B726}; +var \u{2B727}; +var \u{2B728}; +var \u{2B729}; +var \u{2B72A}; +var \u{2B72B}; +var \u{2B72C}; +var \u{2B72D}; +var \u{2B72E}; +var \u{2B72F}; +var \u{2B730}; +var \u{2B731}; +var \u{2B732}; +var \u{2B733}; +var \u{2B734}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0.js new file mode 100644 index 000000000..b30de5e17 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-5.2.0.js @@ -0,0 +1,6105 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v5.2.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var Ԥ; +var ԥ; +var ࠀ; +var ࠁ; +var ࠂ; +var ࠃ; +var ࠄ; +var ࠅ; +var ࠆ; +var ࠇ; +var ࠈ; +var ࠉ; +var ࠊ; +var ࠋ; +var ࠌ; +var ࠍ; +var ࠎ; +var ࠏ; +var ࠐ; +var ࠑ; +var ࠒ; +var ࠓ; +var ࠔ; +var ࠕ; +var ࠚ; +var ࠤ; +var ࠨ; +var ॹ; +var ॺ; +var ᅚ; +var ᅛ; +var ᅜ; +var ᅝ; +var ᅞ; +var ᆣ; +var ᆤ; +var ᆥ; +var ᆦ; +var ᆧ; +var ᇺ; +var ᇻ; +var ᇼ; +var ᇽ; +var ᇾ; +var ᇿ; +var ᙷ; +var ᙸ; +var ᙹ; +var ᙺ; +var ᙻ; +var ᙼ; +var ᙽ; +var ᙾ; +var ᙿ; +var ᢰ; +var ᢱ; +var ᢲ; +var ᢳ; +var ᢴ; +var ᢵ; +var ᢶ; +var ᢷ; +var ᢸ; +var ᢹ; +var ᢺ; +var ᢻ; +var ᢼ; +var ᢽ; +var ᢾ; +var ᢿ; +var ᣀ; +var ᣁ; +var ᣂ; +var ᣃ; +var ᣄ; +var ᣅ; +var ᣆ; +var ᣇ; +var ᣈ; +var ᣉ; +var ᣊ; +var ᣋ; +var ᣌ; +var ᣍ; +var ᣎ; +var ᣏ; +var ᣐ; +var ᣑ; +var ᣒ; +var ᣓ; +var ᣔ; +var ᣕ; +var ᣖ; +var ᣗ; +var ᣘ; +var ᣙ; +var ᣚ; +var ᣛ; +var ᣜ; +var ᣝ; +var ᣞ; +var ᣟ; +var ᣠ; +var ᣡ; +var ᣢ; +var ᣣ; +var ᣤ; +var ᣥ; +var ᣦ; +var ᣧ; +var ᣨ; +var ᣩ; +var ᣪ; +var ᣫ; +var ᣬ; +var ᣭ; +var ᣮ; +var ᣯ; +var ᣰ; +var ᣱ; +var ᣲ; +var ᣳ; +var ᣴ; +var ᣵ; +var ᦪ; +var ᦫ; +var ᨠ; +var ᨡ; +var ᨢ; +var ᨣ; +var ᨤ; +var ᨥ; +var ᨦ; +var ᨧ; +var ᨨ; +var ᨩ; +var ᨪ; +var ᨫ; +var ᨬ; +var ᨭ; +var ᨮ; +var ᨯ; +var ᨰ; +var ᨱ; +var ᨲ; +var ᨳ; +var ᨴ; +var ᨵ; +var ᨶ; +var ᨷ; +var ᨸ; +var ᨹ; +var ᨺ; +var ᨻ; +var ᨼ; +var ᨽ; +var ᨾ; +var ᨿ; +var ᩀ; +var ᩁ; +var ᩂ; +var ᩃ; +var ᩄ; +var ᩅ; +var ᩆ; +var ᩇ; +var ᩈ; +var ᩉ; +var ᩊ; +var ᩋ; +var ᩌ; +var ᩍ; +var ᩎ; +var ᩏ; +var ᩐ; +var ᩑ; +var ᩒ; +var ᩓ; +var ᩔ; +var ᪧ; +var ᳩ; +var ᳪ; +var ᳫ; +var ᳬ; +var ᳮ; +var ᳯ; +var ᳰ; +var ᳱ; +var Ɒ; +var Ȿ; +var Ɀ; +var Ⳬ; +var ⳬ; +var Ⳮ; +var ⳮ; +var 鿄; +var 鿅; +var 鿆; +var 鿇; +var 鿈; +var 鿉; +var 鿊; +var 鿋; +var ꓐ; +var ꓑ; +var ꓒ; +var ꓓ; +var ꓔ; +var ꓕ; +var ꓖ; +var ꓗ; +var ꓘ; +var ꓙ; +var ꓚ; +var ꓛ; +var ꓜ; +var ꓝ; +var ꓞ; +var ꓟ; +var ꓠ; +var ꓡ; +var ꓢ; +var ꓣ; +var ꓤ; +var ꓥ; +var ꓦ; +var ꓧ; +var ꓨ; +var ꓩ; +var ꓪ; +var ꓫ; +var ꓬ; +var ꓭ; +var ꓮ; +var ꓯ; +var ꓰ; +var ꓱ; +var ꓲ; +var ꓳ; +var ꓴ; +var ꓵ; +var ꓶ; +var ꓷ; +var ꓸ; +var ꓹ; +var ꓺ; +var ꓻ; +var ꓼ; +var ꓽ; +var ꚠ; +var ꚡ; +var ꚢ; +var ꚣ; +var ꚤ; +var ꚥ; +var ꚦ; +var ꚧ; +var ꚨ; +var ꚩ; +var ꚪ; +var ꚫ; +var ꚬ; +var ꚭ; +var ꚮ; +var ꚯ; +var ꚰ; +var ꚱ; +var ꚲ; +var ꚳ; +var ꚴ; +var ꚵ; +var ꚶ; +var ꚷ; +var ꚸ; +var ꚹ; +var ꚺ; +var ꚻ; +var ꚼ; +var ꚽ; +var ꚾ; +var ꚿ; +var ꛀ; +var ꛁ; +var ꛂ; +var ꛃ; +var ꛄ; +var ꛅ; +var ꛆ; +var ꛇ; +var ꛈ; +var ꛉ; +var ꛊ; +var ꛋ; +var ꛌ; +var ꛍ; +var ꛎ; +var ꛏ; +var ꛐ; +var ꛑ; +var ꛒ; +var ꛓ; +var ꛔ; +var ꛕ; +var ꛖ; +var ꛗ; +var ꛘ; +var ꛙ; +var ꛚ; +var ꛛ; +var ꛜ; +var ꛝ; +var ꛞ; +var ꛟ; +var ꛠ; +var ꛡ; +var ꛢ; +var ꛣ; +var ꛤ; +var ꛥ; +var ꛦ; +var ꛧ; +var ꛨ; +var ꛩ; +var ꛪ; +var ꛫ; +var ꛬ; +var ꛭ; +var ꛮ; +var ꛯ; +var ꣲ; +var ꣳ; +var ꣴ; +var ꣵ; +var ꣶ; +var ꣷ; +var ꣻ; +var ꥠ; +var ꥡ; +var ꥢ; +var ꥣ; +var ꥤ; +var ꥥ; +var ꥦ; +var ꥧ; +var ꥨ; +var ꥩ; +var ꥪ; +var ꥫ; +var ꥬ; +var ꥭ; +var ꥮ; +var ꥯ; +var ꥰ; +var ꥱ; +var ꥲ; +var ꥳ; +var ꥴ; +var ꥵ; +var ꥶ; +var ꥷ; +var ꥸ; +var ꥹ; +var ꥺ; +var ꥻ; +var ꥼ; +var ꦄ; +var ꦅ; +var ꦆ; +var ꦇ; +var ꦈ; +var ꦉ; +var ꦊ; +var ꦋ; +var ꦌ; +var ꦍ; +var ꦎ; +var ꦏ; +var ꦐ; +var ꦑ; +var ꦒ; +var ꦓ; +var ꦔ; +var ꦕ; +var ꦖ; +var ꦗ; +var ꦘ; +var ꦙ; +var ꦚ; +var ꦛ; +var ꦜ; +var ꦝ; +var ꦞ; +var ꦟ; +var ꦠ; +var ꦡ; +var ꦢ; +var ꦣ; +var ꦤ; +var ꦥ; +var ꦦ; +var ꦧ; +var ꦨ; +var ꦩ; +var ꦪ; +var ꦫ; +var ꦬ; +var ꦭ; +var ꦮ; +var ꦯ; +var ꦰ; +var ꦱ; +var ꦲ; +var ꧏ; +var ꩠ; +var ꩡ; +var ꩢ; +var ꩣ; +var ꩤ; +var ꩥ; +var ꩦ; +var ꩧ; +var ꩨ; +var ꩩ; +var ꩪ; +var ꩫ; +var ꩬ; +var ꩭ; +var ꩮ; +var ꩯ; +var ꩰ; +var ꩱ; +var ꩲ; +var ꩳ; +var ꩴ; +var ꩵ; +var ꩶ; +var ꩺ; +var ꪀ; +var ꪁ; +var ꪂ; +var ꪃ; +var ꪄ; +var ꪅ; +var ꪆ; +var ꪇ; +var ꪈ; +var ꪉ; +var ꪊ; +var ꪋ; +var ꪌ; +var ꪍ; +var ꪎ; +var ꪏ; +var ꪐ; +var ꪑ; +var ꪒ; +var ꪓ; +var ꪔ; +var ꪕ; +var ꪖ; +var ꪗ; +var ꪘ; +var ꪙ; +var ꪚ; +var ꪛ; +var ꪜ; +var ꪝ; +var ꪞ; +var ꪟ; +var ꪠ; +var ꪡ; +var ꪢ; +var ꪣ; +var ꪤ; +var ꪥ; +var ꪦ; +var ꪧ; +var ꪨ; +var ꪩ; +var ꪪ; +var ꪫ; +var ꪬ; +var ꪭ; +var ꪮ; +var ꪯ; +var ꪱ; +var ꪵ; +var ꪶ; +var ꪹ; +var ꪺ; +var ꪻ; +var ꪼ; +var ꪽ; +var ꫀ; +var ꫂ; +var ꫛ; +var ꫜ; +var ꫝ; +var ꯀ; +var ꯁ; +var ꯂ; +var ꯃ; +var ꯄ; +var ꯅ; +var ꯆ; +var ꯇ; +var ꯈ; +var ꯉ; +var ꯊ; +var ꯋ; +var ꯌ; +var ꯍ; +var ꯎ; +var ꯏ; +var ꯐ; +var ꯑ; +var ꯒ; +var ꯓ; +var ꯔ; +var ꯕ; +var ꯖ; +var ꯗ; +var ꯘ; +var ꯙ; +var ꯚ; +var ꯛ; +var ꯜ; +var ꯝ; +var ꯞ; +var ꯟ; +var ꯠ; +var ꯡ; +var ꯢ; +var ힰ; +var ힱ; +var ힲ; +var ힳ; +var ힴ; +var ힵ; +var ힶ; +var ힷ; +var ힸ; +var ힹ; +var ힺ; +var ힻ; +var ힼ; +var ힽ; +var ힾ; +var ힿ; +var ퟀ; +var ퟁ; +var ퟂ; +var ퟃ; +var ퟄ; +var ퟅ; +var ퟆ; +var ퟋ; +var ퟌ; +var ퟍ; +var ퟎ; +var ퟏ; +var ퟐ; +var ퟑ; +var ퟒ; +var ퟓ; +var ퟔ; +var ퟕ; +var ퟖ; +var ퟗ; +var ퟘ; +var ퟙ; +var ퟚ; +var ퟛ; +var ퟜ; +var ퟝ; +var ퟞ; +var ퟟ; +var ퟠ; +var ퟡ; +var ퟢ; +var ퟣ; +var ퟤ; +var ퟥ; +var ퟦ; +var ퟧ; +var ퟨ; +var ퟩ; +var ퟪ; +var ퟫ; +var ퟬ; +var ퟭ; +var ퟮ; +var ퟯ; +var ퟰ; +var ퟱ; +var ퟲ; +var ퟳ; +var ퟴ; +var ퟵ; +var ퟶ; +var ퟷ; +var ퟸ; +var ퟹ; +var ퟺ; +var ퟻ; +var 恵; +var 𤋮; +var 舘; +var 𐡀; +var 𐡁; +var 𐡂; +var 𐡃; +var 𐡄; +var 𐡅; +var 𐡆; +var 𐡇; +var 𐡈; +var 𐡉; +var 𐡊; +var 𐡋; +var 𐡌; +var 𐡍; +var 𐡎; +var 𐡏; +var 𐡐; +var 𐡑; +var 𐡒; +var 𐡓; +var 𐡔; +var 𐡕; +var 𐩠; +var 𐩡; +var 𐩢; +var 𐩣; +var 𐩤; +var 𐩥; +var 𐩦; +var 𐩧; +var 𐩨; +var 𐩩; +var 𐩪; +var 𐩫; +var 𐩬; +var 𐩭; +var 𐩮; +var 𐩯; +var 𐩰; +var 𐩱; +var 𐩲; +var 𐩳; +var 𐩴; +var 𐩵; +var 𐩶; +var 𐩷; +var 𐩸; +var 𐩹; +var 𐩺; +var 𐩻; +var 𐩼; +var 𐬀; +var 𐬁; +var 𐬂; +var 𐬃; +var 𐬄; +var 𐬅; +var 𐬆; +var 𐬇; +var 𐬈; +var 𐬉; +var 𐬊; +var 𐬋; +var 𐬌; +var 𐬍; +var 𐬎; +var 𐬏; +var 𐬐; +var 𐬑; +var 𐬒; +var 𐬓; +var 𐬔; +var 𐬕; +var 𐬖; +var 𐬗; +var 𐬘; +var 𐬙; +var 𐬚; +var 𐬛; +var 𐬜; +var 𐬝; +var 𐬞; +var 𐬟; +var 𐬠; +var 𐬡; +var 𐬢; +var 𐬣; +var 𐬤; +var 𐬥; +var 𐬦; +var 𐬧; +var 𐬨; +var 𐬩; +var 𐬪; +var 𐬫; +var 𐬬; +var 𐬭; +var 𐬮; +var 𐬯; +var 𐬰; +var 𐬱; +var 𐬲; +var 𐬳; +var 𐬴; +var 𐬵; +var 𐭀; +var 𐭁; +var 𐭂; +var 𐭃; +var 𐭄; +var 𐭅; +var 𐭆; +var 𐭇; +var 𐭈; +var 𐭉; +var 𐭊; +var 𐭋; +var 𐭌; +var 𐭍; +var 𐭎; +var 𐭏; +var 𐭐; +var 𐭑; +var 𐭒; +var 𐭓; +var 𐭔; +var 𐭕; +var 𐭠; +var 𐭡; +var 𐭢; +var 𐭣; +var 𐭤; +var 𐭥; +var 𐭦; +var 𐭧; +var 𐭨; +var 𐭩; +var 𐭪; +var 𐭫; +var 𐭬; +var 𐭭; +var 𐭮; +var 𐭯; +var 𐭰; +var 𐭱; +var 𐭲; +var 𐰀; +var 𐰁; +var 𐰂; +var 𐰃; +var 𐰄; +var 𐰅; +var 𐰆; +var 𐰇; +var 𐰈; +var 𐰉; +var 𐰊; +var 𐰋; +var 𐰌; +var 𐰍; +var 𐰎; +var 𐰏; +var 𐰐; +var 𐰑; +var 𐰒; +var 𐰓; +var 𐰔; +var 𐰕; +var 𐰖; +var 𐰗; +var 𐰘; +var 𐰙; +var 𐰚; +var 𐰛; +var 𐰜; +var 𐰝; +var 𐰞; +var 𐰟; +var 𐰠; +var 𐰡; +var 𐰢; +var 𐰣; +var 𐰤; +var 𐰥; +var 𐰦; +var 𐰧; +var 𐰨; +var 𐰩; +var 𐰪; +var 𐰫; +var 𐰬; +var 𐰭; +var 𐰮; +var 𐰯; +var 𐰰; +var 𐰱; +var 𐰲; +var 𐰳; +var 𐰴; +var 𐰵; +var 𐰶; +var 𐰷; +var 𐰸; +var 𐰹; +var 𐰺; +var 𐰻; +var 𐰼; +var 𐰽; +var 𐰾; +var 𐰿; +var 𐱀; +var 𐱁; +var 𐱂; +var 𐱃; +var 𐱄; +var 𐱅; +var 𐱆; +var 𐱇; +var 𐱈; +var 𑂃; +var 𑂄; +var 𑂅; +var 𑂆; +var 𑂇; +var 𑂈; +var 𑂉; +var 𑂊; +var 𑂋; +var 𑂌; +var 𑂍; +var 𑂎; +var 𑂏; +var 𑂐; +var 𑂑; +var 𑂒; +var 𑂓; +var 𑂔; +var 𑂕; +var 𑂖; +var 𑂗; +var 𑂘; +var 𑂙; +var 𑂚; +var 𑂛; +var 𑂜; +var 𑂝; +var 𑂞; +var 𑂟; +var 𑂠; +var 𑂡; +var 𑂢; +var 𑂣; +var 𑂤; +var 𑂥; +var 𑂦; +var 𑂧; +var 𑂨; +var 𑂩; +var 𑂪; +var 𑂫; +var 𑂬; +var 𑂭; +var 𑂮; +var 𑂯; +var 𓀀; +var 𓀁; +var 𓀂; +var 𓀃; +var 𓀄; +var 𓀅; +var 𓀆; +var 𓀇; +var 𓀈; +var 𓀉; +var 𓀊; +var 𓀋; +var 𓀌; +var 𓀍; +var 𓀎; +var 𓀏; +var 𓀐; +var 𓀑; +var 𓀒; +var 𓀓; +var 𓀔; +var 𓀕; +var 𓀖; +var 𓀗; +var 𓀘; +var 𓀙; +var 𓀚; +var 𓀛; +var 𓀜; +var 𓀝; +var 𓀞; +var 𓀟; +var 𓀠; +var 𓀡; +var 𓀢; +var 𓀣; +var 𓀤; +var 𓀥; +var 𓀦; +var 𓀧; +var 𓀨; +var 𓀩; +var 𓀪; +var 𓀫; +var 𓀬; +var 𓀭; +var 𓀮; +var 𓀯; +var 𓀰; +var 𓀱; +var 𓀲; +var 𓀳; +var 𓀴; +var 𓀵; +var 𓀶; +var 𓀷; +var 𓀸; +var 𓀹; +var 𓀺; +var 𓀻; +var 𓀼; +var 𓀽; +var 𓀾; +var 𓀿; +var 𓁀; +var 𓁁; +var 𓁂; +var 𓁃; +var 𓁄; +var 𓁅; +var 𓁆; +var 𓁇; +var 𓁈; +var 𓁉; +var 𓁊; +var 𓁋; +var 𓁌; +var 𓁍; +var 𓁎; +var 𓁏; +var 𓁐; +var 𓁑; +var 𓁒; +var 𓁓; +var 𓁔; +var 𓁕; +var 𓁖; +var 𓁗; +var 𓁘; +var 𓁙; +var 𓁚; +var 𓁛; +var 𓁜; +var 𓁝; +var 𓁞; +var 𓁟; +var 𓁠; +var 𓁡; +var 𓁢; +var 𓁣; +var 𓁤; +var 𓁥; +var 𓁦; +var 𓁧; +var 𓁨; +var 𓁩; +var 𓁪; +var 𓁫; +var 𓁬; +var 𓁭; +var 𓁮; +var 𓁯; +var 𓁰; +var 𓁱; +var 𓁲; +var 𓁳; +var 𓁴; +var 𓁵; +var 𓁶; +var 𓁷; +var 𓁸; +var 𓁹; +var 𓁺; +var 𓁻; +var 𓁼; +var 𓁽; +var 𓁾; +var 𓁿; +var 𓂀; +var 𓂁; +var 𓂂; +var 𓂃; +var 𓂄; +var 𓂅; +var 𓂆; +var 𓂇; +var 𓂈; +var 𓂉; +var 𓂊; +var 𓂋; +var 𓂌; +var 𓂍; +var 𓂎; +var 𓂏; +var 𓂐; +var 𓂑; +var 𓂒; +var 𓂓; +var 𓂔; +var 𓂕; +var 𓂖; +var 𓂗; +var 𓂘; +var 𓂙; +var 𓂚; +var 𓂛; +var 𓂜; +var 𓂝; +var 𓂞; +var 𓂟; +var 𓂠; +var 𓂡; +var 𓂢; +var 𓂣; +var 𓂤; +var 𓂥; +var 𓂦; +var 𓂧; +var 𓂨; +var 𓂩; +var 𓂪; +var 𓂫; +var 𓂬; +var 𓂭; +var 𓂮; +var 𓂯; +var 𓂰; +var 𓂱; +var 𓂲; +var 𓂳; +var 𓂴; +var 𓂵; +var 𓂶; +var 𓂷; +var 𓂸; +var 𓂹; +var 𓂺; +var 𓂻; +var 𓂼; +var 𓂽; +var 𓂾; +var 𓂿; +var 𓃀; +var 𓃁; +var 𓃂; +var 𓃃; +var 𓃄; +var 𓃅; +var 𓃆; +var 𓃇; +var 𓃈; +var 𓃉; +var 𓃊; +var 𓃋; +var 𓃌; +var 𓃍; +var 𓃎; +var 𓃏; +var 𓃐; +var 𓃑; +var 𓃒; +var 𓃓; +var 𓃔; +var 𓃕; +var 𓃖; +var 𓃗; +var 𓃘; +var 𓃙; +var 𓃚; +var 𓃛; +var 𓃜; +var 𓃝; +var 𓃞; +var 𓃟; +var 𓃠; +var 𓃡; +var 𓃢; +var 𓃣; +var 𓃤; +var 𓃥; +var 𓃦; +var 𓃧; +var 𓃨; +var 𓃩; +var 𓃪; +var 𓃫; +var 𓃬; +var 𓃭; +var 𓃮; +var 𓃯; +var 𓃰; +var 𓃱; +var 𓃲; +var 𓃳; +var 𓃴; +var 𓃵; +var 𓃶; +var 𓃷; +var 𓃸; +var 𓃹; +var 𓃺; +var 𓃻; +var 𓃼; +var 𓃽; +var 𓃾; +var 𓃿; +var 𓄀; +var 𓄁; +var 𓄂; +var 𓄃; +var 𓄄; +var 𓄅; +var 𓄆; +var 𓄇; +var 𓄈; +var 𓄉; +var 𓄊; +var 𓄋; +var 𓄌; +var 𓄍; +var 𓄎; +var 𓄏; +var 𓄐; +var 𓄑; +var 𓄒; +var 𓄓; +var 𓄔; +var 𓄕; +var 𓄖; +var 𓄗; +var 𓄘; +var 𓄙; +var 𓄚; +var 𓄛; +var 𓄜; +var 𓄝; +var 𓄞; +var 𓄟; +var 𓄠; +var 𓄡; +var 𓄢; +var 𓄣; +var 𓄤; +var 𓄥; +var 𓄦; +var 𓄧; +var 𓄨; +var 𓄩; +var 𓄪; +var 𓄫; +var 𓄬; +var 𓄭; +var 𓄮; +var 𓄯; +var 𓄰; +var 𓄱; +var 𓄲; +var 𓄳; +var 𓄴; +var 𓄵; +var 𓄶; +var 𓄷; +var 𓄸; +var 𓄹; +var 𓄺; +var 𓄻; +var 𓄼; +var 𓄽; +var 𓄾; +var 𓄿; +var 𓅀; +var 𓅁; +var 𓅂; +var 𓅃; +var 𓅄; +var 𓅅; +var 𓅆; +var 𓅇; +var 𓅈; +var 𓅉; +var 𓅊; +var 𓅋; +var 𓅌; +var 𓅍; +var 𓅎; +var 𓅏; +var 𓅐; +var 𓅑; +var 𓅒; +var 𓅓; +var 𓅔; +var 𓅕; +var 𓅖; +var 𓅗; +var 𓅘; +var 𓅙; +var 𓅚; +var 𓅛; +var 𓅜; +var 𓅝; +var 𓅞; +var 𓅟; +var 𓅠; +var 𓅡; +var 𓅢; +var 𓅣; +var 𓅤; +var 𓅥; +var 𓅦; +var 𓅧; +var 𓅨; +var 𓅩; +var 𓅪; +var 𓅫; +var 𓅬; +var 𓅭; +var 𓅮; +var 𓅯; +var 𓅰; +var 𓅱; +var 𓅲; +var 𓅳; +var 𓅴; +var 𓅵; +var 𓅶; +var 𓅷; +var 𓅸; +var 𓅹; +var 𓅺; +var 𓅻; +var 𓅼; +var 𓅽; +var 𓅾; +var 𓅿; +var 𓆀; +var 𓆁; +var 𓆂; +var 𓆃; +var 𓆄; +var 𓆅; +var 𓆆; +var 𓆇; +var 𓆈; +var 𓆉; +var 𓆊; +var 𓆋; +var 𓆌; +var 𓆍; +var 𓆎; +var 𓆏; +var 𓆐; +var 𓆑; +var 𓆒; +var 𓆓; +var 𓆔; +var 𓆕; +var 𓆖; +var 𓆗; +var 𓆘; +var 𓆙; +var 𓆚; +var 𓆛; +var 𓆜; +var 𓆝; +var 𓆞; +var 𓆟; +var 𓆠; +var 𓆡; +var 𓆢; +var 𓆣; +var 𓆤; +var 𓆥; +var 𓆦; +var 𓆧; +var 𓆨; +var 𓆩; +var 𓆪; +var 𓆫; +var 𓆬; +var 𓆭; +var 𓆮; +var 𓆯; +var 𓆰; +var 𓆱; +var 𓆲; +var 𓆳; +var 𓆴; +var 𓆵; +var 𓆶; +var 𓆷; +var 𓆸; +var 𓆹; +var 𓆺; +var 𓆻; +var 𓆼; +var 𓆽; +var 𓆾; +var 𓆿; +var 𓇀; +var 𓇁; +var 𓇂; +var 𓇃; +var 𓇄; +var 𓇅; +var 𓇆; +var 𓇇; +var 𓇈; +var 𓇉; +var 𓇊; +var 𓇋; +var 𓇌; +var 𓇍; +var 𓇎; +var 𓇏; +var 𓇐; +var 𓇑; +var 𓇒; +var 𓇓; +var 𓇔; +var 𓇕; +var 𓇖; +var 𓇗; +var 𓇘; +var 𓇙; +var 𓇚; +var 𓇛; +var 𓇜; +var 𓇝; +var 𓇞; +var 𓇟; +var 𓇠; +var 𓇡; +var 𓇢; +var 𓇣; +var 𓇤; +var 𓇥; +var 𓇦; +var 𓇧; +var 𓇨; +var 𓇩; +var 𓇪; +var 𓇫; +var 𓇬; +var 𓇭; +var 𓇮; +var 𓇯; +var 𓇰; +var 𓇱; +var 𓇲; +var 𓇳; +var 𓇴; +var 𓇵; +var 𓇶; +var 𓇷; +var 𓇸; +var 𓇹; +var 𓇺; +var 𓇻; +var 𓇼; +var 𓇽; +var 𓇾; +var 𓇿; +var 𓈀; +var 𓈁; +var 𓈂; +var 𓈃; +var 𓈄; +var 𓈅; +var 𓈆; +var 𓈇; +var 𓈈; +var 𓈉; +var 𓈊; +var 𓈋; +var 𓈌; +var 𓈍; +var 𓈎; +var 𓈏; +var 𓈐; +var 𓈑; +var 𓈒; +var 𓈓; +var 𓈔; +var 𓈕; +var 𓈖; +var 𓈗; +var 𓈘; +var 𓈙; +var 𓈚; +var 𓈛; +var 𓈜; +var 𓈝; +var 𓈞; +var 𓈟; +var 𓈠; +var 𓈡; +var 𓈢; +var 𓈣; +var 𓈤; +var 𓈥; +var 𓈦; +var 𓈧; +var 𓈨; +var 𓈩; +var 𓈪; +var 𓈫; +var 𓈬; +var 𓈭; +var 𓈮; +var 𓈯; +var 𓈰; +var 𓈱; +var 𓈲; +var 𓈳; +var 𓈴; +var 𓈵; +var 𓈶; +var 𓈷; +var 𓈸; +var 𓈹; +var 𓈺; +var 𓈻; +var 𓈼; +var 𓈽; +var 𓈾; +var 𓈿; +var 𓉀; +var 𓉁; +var 𓉂; +var 𓉃; +var 𓉄; +var 𓉅; +var 𓉆; +var 𓉇; +var 𓉈; +var 𓉉; +var 𓉊; +var 𓉋; +var 𓉌; +var 𓉍; +var 𓉎; +var 𓉏; +var 𓉐; +var 𓉑; +var 𓉒; +var 𓉓; +var 𓉔; +var 𓉕; +var 𓉖; +var 𓉗; +var 𓉘; +var 𓉙; +var 𓉚; +var 𓉛; +var 𓉜; +var 𓉝; +var 𓉞; +var 𓉟; +var 𓉠; +var 𓉡; +var 𓉢; +var 𓉣; +var 𓉤; +var 𓉥; +var 𓉦; +var 𓉧; +var 𓉨; +var 𓉩; +var 𓉪; +var 𓉫; +var 𓉬; +var 𓉭; +var 𓉮; +var 𓉯; +var 𓉰; +var 𓉱; +var 𓉲; +var 𓉳; +var 𓉴; +var 𓉵; +var 𓉶; +var 𓉷; +var 𓉸; +var 𓉹; +var 𓉺; +var 𓉻; +var 𓉼; +var 𓉽; +var 𓉾; +var 𓉿; +var 𓊀; +var 𓊁; +var 𓊂; +var 𓊃; +var 𓊄; +var 𓊅; +var 𓊆; +var 𓊇; +var 𓊈; +var 𓊉; +var 𓊊; +var 𓊋; +var 𓊌; +var 𓊍; +var 𓊎; +var 𓊏; +var 𓊐; +var 𓊑; +var 𓊒; +var 𓊓; +var 𓊔; +var 𓊕; +var 𓊖; +var 𓊗; +var 𓊘; +var 𓊙; +var 𓊚; +var 𓊛; +var 𓊜; +var 𓊝; +var 𓊞; +var 𓊟; +var 𓊠; +var 𓊡; +var 𓊢; +var 𓊣; +var 𓊤; +var 𓊥; +var 𓊦; +var 𓊧; +var 𓊨; +var 𓊩; +var 𓊪; +var 𓊫; +var 𓊬; +var 𓊭; +var 𓊮; +var 𓊯; +var 𓊰; +var 𓊱; +var 𓊲; +var 𓊳; +var 𓊴; +var 𓊵; +var 𓊶; +var 𓊷; +var 𓊸; +var 𓊹; +var 𓊺; +var 𓊻; +var 𓊼; +var 𓊽; +var 𓊾; +var 𓊿; +var 𓋀; +var 𓋁; +var 𓋂; +var 𓋃; +var 𓋄; +var 𓋅; +var 𓋆; +var 𓋇; +var 𓋈; +var 𓋉; +var 𓋊; +var 𓋋; +var 𓋌; +var 𓋍; +var 𓋎; +var 𓋏; +var 𓋐; +var 𓋑; +var 𓋒; +var 𓋓; +var 𓋔; +var 𓋕; +var 𓋖; +var 𓋗; +var 𓋘; +var 𓋙; +var 𓋚; +var 𓋛; +var 𓋜; +var 𓋝; +var 𓋞; +var 𓋟; +var 𓋠; +var 𓋡; +var 𓋢; +var 𓋣; +var 𓋤; +var 𓋥; +var 𓋦; +var 𓋧; +var 𓋨; +var 𓋩; +var 𓋪; +var 𓋫; +var 𓋬; +var 𓋭; +var 𓋮; +var 𓋯; +var 𓋰; +var 𓋱; +var 𓋲; +var 𓋳; +var 𓋴; +var 𓋵; +var 𓋶; +var 𓋷; +var 𓋸; +var 𓋹; +var 𓋺; +var 𓋻; +var 𓋼; +var 𓋽; +var 𓋾; +var 𓋿; +var 𓌀; +var 𓌁; +var 𓌂; +var 𓌃; +var 𓌄; +var 𓌅; +var 𓌆; +var 𓌇; +var 𓌈; +var 𓌉; +var 𓌊; +var 𓌋; +var 𓌌; +var 𓌍; +var 𓌎; +var 𓌏; +var 𓌐; +var 𓌑; +var 𓌒; +var 𓌓; +var 𓌔; +var 𓌕; +var 𓌖; +var 𓌗; +var 𓌘; +var 𓌙; +var 𓌚; +var 𓌛; +var 𓌜; +var 𓌝; +var 𓌞; +var 𓌟; +var 𓌠; +var 𓌡; +var 𓌢; +var 𓌣; +var 𓌤; +var 𓌥; +var 𓌦; +var 𓌧; +var 𓌨; +var 𓌩; +var 𓌪; +var 𓌫; +var 𓌬; +var 𓌭; +var 𓌮; +var 𓌯; +var 𓌰; +var 𓌱; +var 𓌲; +var 𓌳; +var 𓌴; +var 𓌵; +var 𓌶; +var 𓌷; +var 𓌸; +var 𓌹; +var 𓌺; +var 𓌻; +var 𓌼; +var 𓌽; +var 𓌾; +var 𓌿; +var 𓍀; +var 𓍁; +var 𓍂; +var 𓍃; +var 𓍄; +var 𓍅; +var 𓍆; +var 𓍇; +var 𓍈; +var 𓍉; +var 𓍊; +var 𓍋; +var 𓍌; +var 𓍍; +var 𓍎; +var 𓍏; +var 𓍐; +var 𓍑; +var 𓍒; +var 𓍓; +var 𓍔; +var 𓍕; +var 𓍖; +var 𓍗; +var 𓍘; +var 𓍙; +var 𓍚; +var 𓍛; +var 𓍜; +var 𓍝; +var 𓍞; +var 𓍟; +var 𓍠; +var 𓍡; +var 𓍢; +var 𓍣; +var 𓍤; +var 𓍥; +var 𓍦; +var 𓍧; +var 𓍨; +var 𓍩; +var 𓍪; +var 𓍫; +var 𓍬; +var 𓍭; +var 𓍮; +var 𓍯; +var 𓍰; +var 𓍱; +var 𓍲; +var 𓍳; +var 𓍴; +var 𓍵; +var 𓍶; +var 𓍷; +var 𓍸; +var 𓍹; +var 𓍺; +var 𓍻; +var 𓍼; +var 𓍽; +var 𓍾; +var 𓍿; +var 𓎀; +var 𓎁; +var 𓎂; +var 𓎃; +var 𓎄; +var 𓎅; +var 𓎆; +var 𓎇; +var 𓎈; +var 𓎉; +var 𓎊; +var 𓎋; +var 𓎌; +var 𓎍; +var 𓎎; +var 𓎏; +var 𓎐; +var 𓎑; +var 𓎒; +var 𓎓; +var 𓎔; +var 𓎕; +var 𓎖; +var 𓎗; +var 𓎘; +var 𓎙; +var 𓎚; +var 𓎛; +var 𓎜; +var 𓎝; +var 𓎞; +var 𓎟; +var 𓎠; +var 𓎡; +var 𓎢; +var 𓎣; +var 𓎤; +var 𓎥; +var 𓎦; +var 𓎧; +var 𓎨; +var 𓎩; +var 𓎪; +var 𓎫; +var 𓎬; +var 𓎭; +var 𓎮; +var 𓎯; +var 𓎰; +var 𓎱; +var 𓎲; +var 𓎳; +var 𓎴; +var 𓎵; +var 𓎶; +var 𓎷; +var 𓎸; +var 𓎹; +var 𓎺; +var 𓎻; +var 𓎼; +var 𓎽; +var 𓎾; +var 𓎿; +var 𓏀; +var 𓏁; +var 𓏂; +var 𓏃; +var 𓏄; +var 𓏅; +var 𓏆; +var 𓏇; +var 𓏈; +var 𓏉; +var 𓏊; +var 𓏋; +var 𓏌; +var 𓏍; +var 𓏎; +var 𓏏; +var 𓏐; +var 𓏑; +var 𓏒; +var 𓏓; +var 𓏔; +var 𓏕; +var 𓏖; +var 𓏗; +var 𓏘; +var 𓏙; +var 𓏚; +var 𓏛; +var 𓏜; +var 𓏝; +var 𓏞; +var 𓏟; +var 𓏠; +var 𓏡; +var 𓏢; +var 𓏣; +var 𓏤; +var 𓏥; +var 𓏦; +var 𓏧; +var 𓏨; +var 𓏩; +var 𓏪; +var 𓏫; +var 𓏬; +var 𓏭; +var 𓏮; +var 𓏯; +var 𓏰; +var 𓏱; +var 𓏲; +var 𓏳; +var 𓏴; +var 𓏵; +var 𓏶; +var 𓏷; +var 𓏸; +var 𓏹; +var 𓏺; +var 𓏻; +var 𓏼; +var 𓏽; +var 𓏾; +var 𓏿; +var 𓐀; +var 𓐁; +var 𓐂; +var 𓐃; +var 𓐄; +var 𓐅; +var 𓐆; +var 𓐇; +var 𓐈; +var 𓐉; +var 𓐊; +var 𓐋; +var 𓐌; +var 𓐍; +var 𓐎; +var 𓐏; +var 𓐐; +var 𓐑; +var 𓐒; +var 𓐓; +var 𓐔; +var 𓐕; +var 𓐖; +var 𓐗; +var 𓐘; +var 𓐙; +var 𓐚; +var 𓐛; +var 𓐜; +var 𓐝; +var 𓐞; +var 𓐟; +var 𓐠; +var 𓐡; +var 𓐢; +var 𓐣; +var 𓐤; +var 𓐥; +var 𓐦; +var 𓐧; +var 𓐨; +var 𓐩; +var 𓐪; +var 𓐫; +var 𓐬; +var 𓐭; +var 𓐮; +var 𪜀; +var 𪜁; +var 𪜂; +var 𪜃; +var 𪜄; +var 𪜅; +var 𪜆; +var 𪜇; +var 𪜈; +var 𪜉; +var 𪜊; +var 𪜋; +var 𪜌; +var 𪜍; +var 𪜎; +var 𪜏; +var 𪜐; +var 𪜑; +var 𪜒; +var 𪜓; +var 𪜔; +var 𪜕; +var 𪜖; +var 𪜗; +var 𪜘; +var 𪜙; +var 𪜚; +var 𪜛; +var 𪜜; +var 𪜝; +var 𪜞; +var 𪜟; +var 𪜠; +var 𪜡; +var 𪜢; +var 𪜣; +var 𪜤; +var 𪜥; +var 𪜦; +var 𪜧; +var 𪜨; +var 𪜩; +var 𪜪; +var 𪜫; +var 𪜬; +var 𪜭; +var 𪜮; +var 𪜯; +var 𪜰; +var 𪜱; +var 𪜲; +var 𪜳; +var 𪜴; +var 𪜵; +var 𪜶; +var 𪜷; +var 𪜸; +var 𪜹; +var 𪜺; +var 𪜻; +var 𪜼; +var 𪜽; +var 𪜾; +var 𪜿; +var 𪝀; +var 𪝁; +var 𪝂; +var 𪝃; +var 𪝄; +var 𪝅; +var 𪝆; +var 𪝇; +var 𪝈; +var 𪝉; +var 𪝊; +var 𪝋; +var 𪝌; +var 𪝍; +var 𪝎; +var 𪝏; +var 𪝐; +var 𪝑; +var 𪝒; +var 𪝓; +var 𪝔; +var 𪝕; +var 𪝖; +var 𪝗; +var 𪝘; +var 𪝙; +var 𪝚; +var 𪝛; +var 𪝜; +var 𪝝; +var 𪝞; +var 𪝟; +var 𪝠; +var 𪝡; +var 𪝢; +var 𪝣; +var 𪝤; +var 𪝥; +var 𪝦; +var 𪝧; +var 𪝨; +var 𪝩; +var 𪝪; +var 𪝫; +var 𪝬; +var 𪝭; +var 𪝮; +var 𪝯; +var 𪝰; +var 𪝱; +var 𪝲; +var 𪝳; +var 𪝴; +var 𪝵; +var 𪝶; +var 𪝷; +var 𪝸; +var 𪝹; +var 𪝺; +var 𪝻; +var 𪝼; +var 𪝽; +var 𪝾; +var 𪝿; +var 𪞀; +var 𪞁; +var 𪞂; +var 𪞃; +var 𪞄; +var 𪞅; +var 𪞆; +var 𪞇; +var 𪞈; +var 𪞉; +var 𪞊; +var 𪞋; +var 𪞌; +var 𪞍; +var 𪞎; +var 𪞏; +var 𪞐; +var 𪞑; +var 𪞒; +var 𪞓; +var 𪞔; +var 𪞕; +var 𪞖; +var 𪞗; +var 𪞘; +var 𪞙; +var 𪞚; +var 𪞛; +var 𪞜; +var 𪞝; +var 𪞞; +var 𪞟; +var 𪞠; +var 𪞡; +var 𪞢; +var 𪞣; +var 𪞤; +var 𪞥; +var 𪞦; +var 𪞧; +var 𪞨; +var 𪞩; +var 𪞪; +var 𪞫; +var 𪞬; +var 𪞭; +var 𪞮; +var 𪞯; +var 𪞰; +var 𪞱; +var 𪞲; +var 𪞳; +var 𪞴; +var 𪞵; +var 𪞶; +var 𪞷; +var 𪞸; +var 𪞹; +var 𪞺; +var 𪞻; +var 𪞼; +var 𪞽; +var 𪞾; +var 𪞿; +var 𪟀; +var 𪟁; +var 𪟂; +var 𪟃; +var 𪟄; +var 𪟅; +var 𪟆; +var 𪟇; +var 𪟈; +var 𪟉; +var 𪟊; +var 𪟋; +var 𪟌; +var 𪟍; +var 𪟎; +var 𪟏; +var 𪟐; +var 𪟑; +var 𪟒; +var 𪟓; +var 𪟔; +var 𪟕; +var 𪟖; +var 𪟗; +var 𪟘; +var 𪟙; +var 𪟚; +var 𪟛; +var 𪟜; +var 𪟝; +var 𪟞; +var 𪟟; +var 𪟠; +var 𪟡; +var 𪟢; +var 𪟣; +var 𪟤; +var 𪟥; +var 𪟦; +var 𪟧; +var 𪟨; +var 𪟩; +var 𪟪; +var 𪟫; +var 𪟬; +var 𪟭; +var 𪟮; +var 𪟯; +var 𪟰; +var 𪟱; +var 𪟲; +var 𪟳; +var 𪟴; +var 𪟵; +var 𪟶; +var 𪟷; +var 𪟸; +var 𪟹; +var 𪟺; +var 𪟻; +var 𪟼; +var 𪟽; +var 𪟾; +var 𪟿; +var 𪠀; +var 𪠁; +var 𪠂; +var 𪠃; +var 𪠄; +var 𪠅; +var 𪠆; +var 𪠇; +var 𪠈; +var 𪠉; +var 𪠊; +var 𪠋; +var 𪠌; +var 𪠍; +var 𪠎; +var 𪠏; +var 𪠐; +var 𪠑; +var 𪠒; +var 𪠓; +var 𪠔; +var 𪠕; +var 𪠖; +var 𪠗; +var 𪠘; +var 𪠙; +var 𪠚; +var 𪠛; +var 𪠜; +var 𪠝; +var 𪠞; +var 𪠟; +var 𪠠; +var 𪠡; +var 𪠢; +var 𪠣; +var 𪠤; +var 𪠥; +var 𪠦; +var 𪠧; +var 𪠨; +var 𪠩; +var 𪠪; +var 𪠫; +var 𪠬; +var 𪠭; +var 𪠮; +var 𪠯; +var 𪠰; +var 𪠱; +var 𪠲; +var 𪠳; +var 𪠴; +var 𪠵; +var 𪠶; +var 𪠷; +var 𪠸; +var 𪠹; +var 𪠺; +var 𪠻; +var 𪠼; +var 𪠽; +var 𪠾; +var 𪠿; +var 𪡀; +var 𪡁; +var 𪡂; +var 𪡃; +var 𪡄; +var 𪡅; +var 𪡆; +var 𪡇; +var 𪡈; +var 𪡉; +var 𪡊; +var 𪡋; +var 𪡌; +var 𪡍; +var 𪡎; +var 𪡏; +var 𪡐; +var 𪡑; +var 𪡒; +var 𪡓; +var 𪡔; +var 𪡕; +var 𪡖; +var 𪡗; +var 𪡘; +var 𪡙; +var 𪡚; +var 𪡛; +var 𪡜; +var 𪡝; +var 𪡞; +var 𪡟; +var 𪡠; +var 𪡡; +var 𪡢; +var 𪡣; +var 𪡤; +var 𪡥; +var 𪡦; +var 𪡧; +var 𪡨; +var 𪡩; +var 𪡪; +var 𪡫; +var 𪡬; +var 𪡭; +var 𪡮; +var 𪡯; +var 𪡰; +var 𪡱; +var 𪡲; +var 𪡳; +var 𪡴; +var 𪡵; +var 𪡶; +var 𪡷; +var 𪡸; +var 𪡹; +var 𪡺; +var 𪡻; +var 𪡼; +var 𪡽; +var 𪡾; +var 𪡿; +var 𪢀; +var 𪢁; +var 𪢂; +var 𪢃; +var 𪢄; +var 𪢅; +var 𪢆; +var 𪢇; +var 𪢈; +var 𪢉; +var 𪢊; +var 𪢋; +var 𪢌; +var 𪢍; +var 𪢎; +var 𪢏; +var 𪢐; +var 𪢑; +var 𪢒; +var 𪢓; +var 𪢔; +var 𪢕; +var 𪢖; +var 𪢗; +var 𪢘; +var 𪢙; +var 𪢚; +var 𪢛; +var 𪢜; +var 𪢝; +var 𪢞; +var 𪢟; +var 𪢠; +var 𪢡; +var 𪢢; +var 𪢣; +var 𪢤; +var 𪢥; +var 𪢦; +var 𪢧; +var 𪢨; +var 𪢩; +var 𪢪; +var 𪢫; +var 𪢬; +var 𪢭; +var 𪢮; +var 𪢯; +var 𪢰; +var 𪢱; +var 𪢲; +var 𪢳; +var 𪢴; +var 𪢵; +var 𪢶; +var 𪢷; +var 𪢸; +var 𪢹; +var 𪢺; +var 𪢻; +var 𪢼; +var 𪢽; +var 𪢾; +var 𪢿; +var 𪣀; +var 𪣁; +var 𪣂; +var 𪣃; +var 𪣄; +var 𪣅; +var 𪣆; +var 𪣇; +var 𪣈; +var 𪣉; +var 𪣊; +var 𪣋; +var 𪣌; +var 𪣍; +var 𪣎; +var 𪣏; +var 𪣐; +var 𪣑; +var 𪣒; +var 𪣓; +var 𪣔; +var 𪣕; +var 𪣖; +var 𪣗; +var 𪣘; +var 𪣙; +var 𪣚; +var 𪣛; +var 𪣜; +var 𪣝; +var 𪣞; +var 𪣟; +var 𪣠; +var 𪣡; +var 𪣢; +var 𪣣; +var 𪣤; +var 𪣥; +var 𪣦; +var 𪣧; +var 𪣨; +var 𪣩; +var 𪣪; +var 𪣫; +var 𪣬; +var 𪣭; +var 𪣮; +var 𪣯; +var 𪣰; +var 𪣱; +var 𪣲; +var 𪣳; +var 𪣴; +var 𪣵; +var 𪣶; +var 𪣷; +var 𪣸; +var 𪣹; +var 𪣺; +var 𪣻; +var 𪣼; +var 𪣽; +var 𪣾; +var 𪣿; +var 𪤀; +var 𪤁; +var 𪤂; +var 𪤃; +var 𪤄; +var 𪤅; +var 𪤆; +var 𪤇; +var 𪤈; +var 𪤉; +var 𪤊; +var 𪤋; +var 𪤌; +var 𪤍; +var 𪤎; +var 𪤏; +var 𪤐; +var 𪤑; +var 𪤒; +var 𪤓; +var 𪤔; +var 𪤕; +var 𪤖; +var 𪤗; +var 𪤘; +var 𪤙; +var 𪤚; +var 𪤛; +var 𪤜; +var 𪤝; +var 𪤞; +var 𪤟; +var 𪤠; +var 𪤡; +var 𪤢; +var 𪤣; +var 𪤤; +var 𪤥; +var 𪤦; +var 𪤧; +var 𪤨; +var 𪤩; +var 𪤪; +var 𪤫; +var 𪤬; +var 𪤭; +var 𪤮; +var 𪤯; +var 𪤰; +var 𪤱; +var 𪤲; +var 𪤳; +var 𪤴; +var 𪤵; +var 𪤶; +var 𪤷; +var 𪤸; +var 𪤹; +var 𪤺; +var 𪤻; +var 𪤼; +var 𪤽; +var 𪤾; +var 𪤿; +var 𪥀; +var 𪥁; +var 𪥂; +var 𪥃; +var 𪥄; +var 𪥅; +var 𪥆; +var 𪥇; +var 𪥈; +var 𪥉; +var 𪥊; +var 𪥋; +var 𪥌; +var 𪥍; +var 𪥎; +var 𪥏; +var 𪥐; +var 𪥑; +var 𪥒; +var 𪥓; +var 𪥔; +var 𪥕; +var 𪥖; +var 𪥗; +var 𪥘; +var 𪥙; +var 𪥚; +var 𪥛; +var 𪥜; +var 𪥝; +var 𪥞; +var 𪥟; +var 𪥠; +var 𪥡; +var 𪥢; +var 𪥣; +var 𪥤; +var 𪥥; +var 𪥦; +var 𪥧; +var 𪥨; +var 𪥩; +var 𪥪; +var 𪥫; +var 𪥬; +var 𪥭; +var 𪥮; +var 𪥯; +var 𪥰; +var 𪥱; +var 𪥲; +var 𪥳; +var 𪥴; +var 𪥵; +var 𪥶; +var 𪥷; +var 𪥸; +var 𪥹; +var 𪥺; +var 𪥻; +var 𪥼; +var 𪥽; +var 𪥾; +var 𪥿; +var 𪦀; +var 𪦁; +var 𪦂; +var 𪦃; +var 𪦄; +var 𪦅; +var 𪦆; +var 𪦇; +var 𪦈; +var 𪦉; +var 𪦊; +var 𪦋; +var 𪦌; +var 𪦍; +var 𪦎; +var 𪦏; +var 𪦐; +var 𪦑; +var 𪦒; +var 𪦓; +var 𪦔; +var 𪦕; +var 𪦖; +var 𪦗; +var 𪦘; +var 𪦙; +var 𪦚; +var 𪦛; +var 𪦜; +var 𪦝; +var 𪦞; +var 𪦟; +var 𪦠; +var 𪦡; +var 𪦢; +var 𪦣; +var 𪦤; +var 𪦥; +var 𪦦; +var 𪦧; +var 𪦨; +var 𪦩; +var 𪦪; +var 𪦫; +var 𪦬; +var 𪦭; +var 𪦮; +var 𪦯; +var 𪦰; +var 𪦱; +var 𪦲; +var 𪦳; +var 𪦴; +var 𪦵; +var 𪦶; +var 𪦷; +var 𪦸; +var 𪦹; +var 𪦺; +var 𪦻; +var 𪦼; +var 𪦽; +var 𪦾; +var 𪦿; +var 𪧀; +var 𪧁; +var 𪧂; +var 𪧃; +var 𪧄; +var 𪧅; +var 𪧆; +var 𪧇; +var 𪧈; +var 𪧉; +var 𪧊; +var 𪧋; +var 𪧌; +var 𪧍; +var 𪧎; +var 𪧏; +var 𪧐; +var 𪧑; +var 𪧒; +var 𪧓; +var 𪧔; +var 𪧕; +var 𪧖; +var 𪧗; +var 𪧘; +var 𪧙; +var 𪧚; +var 𪧛; +var 𪧜; +var 𪧝; +var 𪧞; +var 𪧟; +var 𪧠; +var 𪧡; +var 𪧢; +var 𪧣; +var 𪧤; +var 𪧥; +var 𪧦; +var 𪧧; +var 𪧨; +var 𪧩; +var 𪧪; +var 𪧫; +var 𪧬; +var 𪧭; +var 𪧮; +var 𪧯; +var 𪧰; +var 𪧱; +var 𪧲; +var 𪧳; +var 𪧴; +var 𪧵; +var 𪧶; +var 𪧷; +var 𪧸; +var 𪧹; +var 𪧺; +var 𪧻; +var 𪧼; +var 𪧽; +var 𪧾; +var 𪧿; +var 𪨀; +var 𪨁; +var 𪨂; +var 𪨃; +var 𪨄; +var 𪨅; +var 𪨆; +var 𪨇; +var 𪨈; +var 𪨉; +var 𪨊; +var 𪨋; +var 𪨌; +var 𪨍; +var 𪨎; +var 𪨏; +var 𪨐; +var 𪨑; +var 𪨒; +var 𪨓; +var 𪨔; +var 𪨕; +var 𪨖; +var 𪨗; +var 𪨘; +var 𪨙; +var 𪨚; +var 𪨛; +var 𪨜; +var 𪨝; +var 𪨞; +var 𪨟; +var 𪨠; +var 𪨡; +var 𪨢; +var 𪨣; +var 𪨤; +var 𪨥; +var 𪨦; +var 𪨧; +var 𪨨; +var 𪨩; +var 𪨪; +var 𪨫; +var 𪨬; +var 𪨭; +var 𪨮; +var 𪨯; +var 𪨰; +var 𪨱; +var 𪨲; +var 𪨳; +var 𪨴; +var 𪨵; +var 𪨶; +var 𪨷; +var 𪨸; +var 𪨹; +var 𪨺; +var 𪨻; +var 𪨼; +var 𪨽; +var 𪨾; +var 𪨿; +var 𪩀; +var 𪩁; +var 𪩂; +var 𪩃; +var 𪩄; +var 𪩅; +var 𪩆; +var 𪩇; +var 𪩈; +var 𪩉; +var 𪩊; +var 𪩋; +var 𪩌; +var 𪩍; +var 𪩎; +var 𪩏; +var 𪩐; +var 𪩑; +var 𪩒; +var 𪩓; +var 𪩔; +var 𪩕; +var 𪩖; +var 𪩗; +var 𪩘; +var 𪩙; +var 𪩚; +var 𪩛; +var 𪩜; +var 𪩝; +var 𪩞; +var 𪩟; +var 𪩠; +var 𪩡; +var 𪩢; +var 𪩣; +var 𪩤; +var 𪩥; +var 𪩦; +var 𪩧; +var 𪩨; +var 𪩩; +var 𪩪; +var 𪩫; +var 𪩬; +var 𪩭; +var 𪩮; +var 𪩯; +var 𪩰; +var 𪩱; +var 𪩲; +var 𪩳; +var 𪩴; +var 𪩵; +var 𪩶; +var 𪩷; +var 𪩸; +var 𪩹; +var 𪩺; +var 𪩻; +var 𪩼; +var 𪩽; +var 𪩾; +var 𪩿; +var 𪪀; +var 𪪁; +var 𪪂; +var 𪪃; +var 𪪄; +var 𪪅; +var 𪪆; +var 𪪇; +var 𪪈; +var 𪪉; +var 𪪊; +var 𪪋; +var 𪪌; +var 𪪍; +var 𪪎; +var 𪪏; +var 𪪐; +var 𪪑; +var 𪪒; +var 𪪓; +var 𪪔; +var 𪪕; +var 𪪖; +var 𪪗; +var 𪪘; +var 𪪙; +var 𪪚; +var 𪪛; +var 𪪜; +var 𪪝; +var 𪪞; +var 𪪟; +var 𪪠; +var 𪪡; +var 𪪢; +var 𪪣; +var 𪪤; +var 𪪥; +var 𪪦; +var 𪪧; +var 𪪨; +var 𪪩; +var 𪪪; +var 𪪫; +var 𪪬; +var 𪪭; +var 𪪮; +var 𪪯; +var 𪪰; +var 𪪱; +var 𪪲; +var 𪪳; +var 𪪴; +var 𪪵; +var 𪪶; +var 𪪷; +var 𪪸; +var 𪪹; +var 𪪺; +var 𪪻; +var 𪪼; +var 𪪽; +var 𪪾; +var 𪪿; +var 𪫀; +var 𪫁; +var 𪫂; +var 𪫃; +var 𪫄; +var 𪫅; +var 𪫆; +var 𪫇; +var 𪫈; +var 𪫉; +var 𪫊; +var 𪫋; +var 𪫌; +var 𪫍; +var 𪫎; +var 𪫏; +var 𪫐; +var 𪫑; +var 𪫒; +var 𪫓; +var 𪫔; +var 𪫕; +var 𪫖; +var 𪫗; +var 𪫘; +var 𪫙; +var 𪫚; +var 𪫛; +var 𪫜; +var 𪫝; +var 𪫞; +var 𪫟; +var 𪫠; +var 𪫡; +var 𪫢; +var 𪫣; +var 𪫤; +var 𪫥; +var 𪫦; +var 𪫧; +var 𪫨; +var 𪫩; +var 𪫪; +var 𪫫; +var 𪫬; +var 𪫭; +var 𪫮; +var 𪫯; +var 𪫰; +var 𪫱; +var 𪫲; +var 𪫳; +var 𪫴; +var 𪫵; +var 𪫶; +var 𪫷; +var 𪫸; +var 𪫹; +var 𪫺; +var 𪫻; +var 𪫼; +var 𪫽; +var 𪫾; +var 𪫿; +var 𪬀; +var 𪬁; +var 𪬂; +var 𪬃; +var 𪬄; +var 𪬅; +var 𪬆; +var 𪬇; +var 𪬈; +var 𪬉; +var 𪬊; +var 𪬋; +var 𪬌; +var 𪬍; +var 𪬎; +var 𪬏; +var 𪬐; +var 𪬑; +var 𪬒; +var 𪬓; +var 𪬔; +var 𪬕; +var 𪬖; +var 𪬗; +var 𪬘; +var 𪬙; +var 𪬚; +var 𪬛; +var 𪬜; +var 𪬝; +var 𪬞; +var 𪬟; +var 𪬠; +var 𪬡; +var 𪬢; +var 𪬣; +var 𪬤; +var 𪬥; +var 𪬦; +var 𪬧; +var 𪬨; +var 𪬩; +var 𪬪; +var 𪬫; +var 𪬬; +var 𪬭; +var 𪬮; +var 𪬯; +var 𪬰; +var 𪬱; +var 𪬲; +var 𪬳; +var 𪬴; +var 𪬵; +var 𪬶; +var 𪬷; +var 𪬸; +var 𪬹; +var 𪬺; +var 𪬻; +var 𪬼; +var 𪬽; +var 𪬾; +var 𪬿; +var 𪭀; +var 𪭁; +var 𪭂; +var 𪭃; +var 𪭄; +var 𪭅; +var 𪭆; +var 𪭇; +var 𪭈; +var 𪭉; +var 𪭊; +var 𪭋; +var 𪭌; +var 𪭍; +var 𪭎; +var 𪭏; +var 𪭐; +var 𪭑; +var 𪭒; +var 𪭓; +var 𪭔; +var 𪭕; +var 𪭖; +var 𪭗; +var 𪭘; +var 𪭙; +var 𪭚; +var 𪭛; +var 𪭜; +var 𪭝; +var 𪭞; +var 𪭟; +var 𪭠; +var 𪭡; +var 𪭢; +var 𪭣; +var 𪭤; +var 𪭥; +var 𪭦; +var 𪭧; +var 𪭨; +var 𪭩; +var 𪭪; +var 𪭫; +var 𪭬; +var 𪭭; +var 𪭮; +var 𪭯; +var 𪭰; +var 𪭱; +var 𪭲; +var 𪭳; +var 𪭴; +var 𪭵; +var 𪭶; +var 𪭷; +var 𪭸; +var 𪭹; +var 𪭺; +var 𪭻; +var 𪭼; +var 𪭽; +var 𪭾; +var 𪭿; +var 𪮀; +var 𪮁; +var 𪮂; +var 𪮃; +var 𪮄; +var 𪮅; +var 𪮆; +var 𪮇; +var 𪮈; +var 𪮉; +var 𪮊; +var 𪮋; +var 𪮌; +var 𪮍; +var 𪮎; +var 𪮏; +var 𪮐; +var 𪮑; +var 𪮒; +var 𪮓; +var 𪮔; +var 𪮕; +var 𪮖; +var 𪮗; +var 𪮘; +var 𪮙; +var 𪮚; +var 𪮛; +var 𪮜; +var 𪮝; +var 𪮞; +var 𪮟; +var 𪮠; +var 𪮡; +var 𪮢; +var 𪮣; +var 𪮤; +var 𪮥; +var 𪮦; +var 𪮧; +var 𪮨; +var 𪮩; +var 𪮪; +var 𪮫; +var 𪮬; +var 𪮭; +var 𪮮; +var 𪮯; +var 𪮰; +var 𪮱; +var 𪮲; +var 𪮳; +var 𪮴; +var 𪮵; +var 𪮶; +var 𪮷; +var 𪮸; +var 𪮹; +var 𪮺; +var 𪮻; +var 𪮼; +var 𪮽; +var 𪮾; +var 𪮿; +var 𪯀; +var 𪯁; +var 𪯂; +var 𪯃; +var 𪯄; +var 𪯅; +var 𪯆; +var 𪯇; +var 𪯈; +var 𪯉; +var 𪯊; +var 𪯋; +var 𪯌; +var 𪯍; +var 𪯎; +var 𪯏; +var 𪯐; +var 𪯑; +var 𪯒; +var 𪯓; +var 𪯔; +var 𪯕; +var 𪯖; +var 𪯗; +var 𪯘; +var 𪯙; +var 𪯚; +var 𪯛; +var 𪯜; +var 𪯝; +var 𪯞; +var 𪯟; +var 𪯠; +var 𪯡; +var 𪯢; +var 𪯣; +var 𪯤; +var 𪯥; +var 𪯦; +var 𪯧; +var 𪯨; +var 𪯩; +var 𪯪; +var 𪯫; +var 𪯬; +var 𪯭; +var 𪯮; +var 𪯯; +var 𪯰; +var 𪯱; +var 𪯲; +var 𪯳; +var 𪯴; +var 𪯵; +var 𪯶; +var 𪯷; +var 𪯸; +var 𪯹; +var 𪯺; +var 𪯻; +var 𪯼; +var 𪯽; +var 𪯾; +var 𪯿; +var 𪰀; +var 𪰁; +var 𪰂; +var 𪰃; +var 𪰄; +var 𪰅; +var 𪰆; +var 𪰇; +var 𪰈; +var 𪰉; +var 𪰊; +var 𪰋; +var 𪰌; +var 𪰍; +var 𪰎; +var 𪰏; +var 𪰐; +var 𪰑; +var 𪰒; +var 𪰓; +var 𪰔; +var 𪰕; +var 𪰖; +var 𪰗; +var 𪰘; +var 𪰙; +var 𪰚; +var 𪰛; +var 𪰜; +var 𪰝; +var 𪰞; +var 𪰟; +var 𪰠; +var 𪰡; +var 𪰢; +var 𪰣; +var 𪰤; +var 𪰥; +var 𪰦; +var 𪰧; +var 𪰨; +var 𪰩; +var 𪰪; +var 𪰫; +var 𪰬; +var 𪰭; +var 𪰮; +var 𪰯; +var 𪰰; +var 𪰱; +var 𪰲; +var 𪰳; +var 𪰴; +var 𪰵; +var 𪰶; +var 𪰷; +var 𪰸; +var 𪰹; +var 𪰺; +var 𪰻; +var 𪰼; +var 𪰽; +var 𪰾; +var 𪰿; +var 𪱀; +var 𪱁; +var 𪱂; +var 𪱃; +var 𪱄; +var 𪱅; +var 𪱆; +var 𪱇; +var 𪱈; +var 𪱉; +var 𪱊; +var 𪱋; +var 𪱌; +var 𪱍; +var 𪱎; +var 𪱏; +var 𪱐; +var 𪱑; +var 𪱒; +var 𪱓; +var 𪱔; +var 𪱕; +var 𪱖; +var 𪱗; +var 𪱘; +var 𪱙; +var 𪱚; +var 𪱛; +var 𪱜; +var 𪱝; +var 𪱞; +var 𪱟; +var 𪱠; +var 𪱡; +var 𪱢; +var 𪱣; +var 𪱤; +var 𪱥; +var 𪱦; +var 𪱧; +var 𪱨; +var 𪱩; +var 𪱪; +var 𪱫; +var 𪱬; +var 𪱭; +var 𪱮; +var 𪱯; +var 𪱰; +var 𪱱; +var 𪱲; +var 𪱳; +var 𪱴; +var 𪱵; +var 𪱶; +var 𪱷; +var 𪱸; +var 𪱹; +var 𪱺; +var 𪱻; +var 𪱼; +var 𪱽; +var 𪱾; +var 𪱿; +var 𪲀; +var 𪲁; +var 𪲂; +var 𪲃; +var 𪲄; +var 𪲅; +var 𪲆; +var 𪲇; +var 𪲈; +var 𪲉; +var 𪲊; +var 𪲋; +var 𪲌; +var 𪲍; +var 𪲎; +var 𪲏; +var 𪲐; +var 𪲑; +var 𪲒; +var 𪲓; +var 𪲔; +var 𪲕; +var 𪲖; +var 𪲗; +var 𪲘; +var 𪲙; +var 𪲚; +var 𪲛; +var 𪲜; +var 𪲝; +var 𪲞; +var 𪲟; +var 𪲠; +var 𪲡; +var 𪲢; +var 𪲣; +var 𪲤; +var 𪲥; +var 𪲦; +var 𪲧; +var 𪲨; +var 𪲩; +var 𪲪; +var 𪲫; +var 𪲬; +var 𪲭; +var 𪲮; +var 𪲯; +var 𪲰; +var 𪲱; +var 𪲲; +var 𪲳; +var 𪲴; +var 𪲵; +var 𪲶; +var 𪲷; +var 𪲸; +var 𪲹; +var 𪲺; +var 𪲻; +var 𪲼; +var 𪲽; +var 𪲾; +var 𪲿; +var 𪳀; +var 𪳁; +var 𪳂; +var 𪳃; +var 𪳄; +var 𪳅; +var 𪳆; +var 𪳇; +var 𪳈; +var 𪳉; +var 𪳊; +var 𪳋; +var 𪳌; +var 𪳍; +var 𪳎; +var 𪳏; +var 𪳐; +var 𪳑; +var 𪳒; +var 𪳓; +var 𪳔; +var 𪳕; +var 𪳖; +var 𪳗; +var 𪳘; +var 𪳙; +var 𪳚; +var 𪳛; +var 𪳜; +var 𪳝; +var 𪳞; +var 𪳟; +var 𪳠; +var 𪳡; +var 𪳢; +var 𪳣; +var 𪳤; +var 𪳥; +var 𪳦; +var 𪳧; +var 𪳨; +var 𪳩; +var 𪳪; +var 𪳫; +var 𪳬; +var 𪳭; +var 𪳮; +var 𪳯; +var 𪳰; +var 𪳱; +var 𪳲; +var 𪳳; +var 𪳴; +var 𪳵; +var 𪳶; +var 𪳷; +var 𪳸; +var 𪳹; +var 𪳺; +var 𪳻; +var 𪳼; +var 𪳽; +var 𪳾; +var 𪳿; +var 𪴀; +var 𪴁; +var 𪴂; +var 𪴃; +var 𪴄; +var 𪴅; +var 𪴆; +var 𪴇; +var 𪴈; +var 𪴉; +var 𪴊; +var 𪴋; +var 𪴌; +var 𪴍; +var 𪴎; +var 𪴏; +var 𪴐; +var 𪴑; +var 𪴒; +var 𪴓; +var 𪴔; +var 𪴕; +var 𪴖; +var 𪴗; +var 𪴘; +var 𪴙; +var 𪴚; +var 𪴛; +var 𪴜; +var 𪴝; +var 𪴞; +var 𪴟; +var 𪴠; +var 𪴡; +var 𪴢; +var 𪴣; +var 𪴤; +var 𪴥; +var 𪴦; +var 𪴧; +var 𪴨; +var 𪴩; +var 𪴪; +var 𪴫; +var 𪴬; +var 𪴭; +var 𪴮; +var 𪴯; +var 𪴰; +var 𪴱; +var 𪴲; +var 𪴳; +var 𪴴; +var 𪴵; +var 𪴶; +var 𪴷; +var 𪴸; +var 𪴹; +var 𪴺; +var 𪴻; +var 𪴼; +var 𪴽; +var 𪴾; +var 𪴿; +var 𪵀; +var 𪵁; +var 𪵂; +var 𪵃; +var 𪵄; +var 𪵅; +var 𪵆; +var 𪵇; +var 𪵈; +var 𪵉; +var 𪵊; +var 𪵋; +var 𪵌; +var 𪵍; +var 𪵎; +var 𪵏; +var 𪵐; +var 𪵑; +var 𪵒; +var 𪵓; +var 𪵔; +var 𪵕; +var 𪵖; +var 𪵗; +var 𪵘; +var 𪵙; +var 𪵚; +var 𪵛; +var 𪵜; +var 𪵝; +var 𪵞; +var 𪵟; +var 𪵠; +var 𪵡; +var 𪵢; +var 𪵣; +var 𪵤; +var 𪵥; +var 𪵦; +var 𪵧; +var 𪵨; +var 𪵩; +var 𪵪; +var 𪵫; +var 𪵬; +var 𪵭; +var 𪵮; +var 𪵯; +var 𪵰; +var 𪵱; +var 𪵲; +var 𪵳; +var 𪵴; +var 𪵵; +var 𪵶; +var 𪵷; +var 𪵸; +var 𪵹; +var 𪵺; +var 𪵻; +var 𪵼; +var 𪵽; +var 𪵾; +var 𪵿; +var 𪶀; +var 𪶁; +var 𪶂; +var 𪶃; +var 𪶄; +var 𪶅; +var 𪶆; +var 𪶇; +var 𪶈; +var 𪶉; +var 𪶊; +var 𪶋; +var 𪶌; +var 𪶍; +var 𪶎; +var 𪶏; +var 𪶐; +var 𪶑; +var 𪶒; +var 𪶓; +var 𪶔; +var 𪶕; +var 𪶖; +var 𪶗; +var 𪶘; +var 𪶙; +var 𪶚; +var 𪶛; +var 𪶜; +var 𪶝; +var 𪶞; +var 𪶟; +var 𪶠; +var 𪶡; +var 𪶢; +var 𪶣; +var 𪶤; +var 𪶥; +var 𪶦; +var 𪶧; +var 𪶨; +var 𪶩; +var 𪶪; +var 𪶫; +var 𪶬; +var 𪶭; +var 𪶮; +var 𪶯; +var 𪶰; +var 𪶱; +var 𪶲; +var 𪶳; +var 𪶴; +var 𪶵; +var 𪶶; +var 𪶷; +var 𪶸; +var 𪶹; +var 𪶺; +var 𪶻; +var 𪶼; +var 𪶽; +var 𪶾; +var 𪶿; +var 𪷀; +var 𪷁; +var 𪷂; +var 𪷃; +var 𪷄; +var 𪷅; +var 𪷆; +var 𪷇; +var 𪷈; +var 𪷉; +var 𪷊; +var 𪷋; +var 𪷌; +var 𪷍; +var 𪷎; +var 𪷏; +var 𪷐; +var 𪷑; +var 𪷒; +var 𪷓; +var 𪷔; +var 𪷕; +var 𪷖; +var 𪷗; +var 𪷘; +var 𪷙; +var 𪷚; +var 𪷛; +var 𪷜; +var 𪷝; +var 𪷞; +var 𪷟; +var 𪷠; +var 𪷡; +var 𪷢; +var 𪷣; +var 𪷤; +var 𪷥; +var 𪷦; +var 𪷧; +var 𪷨; +var 𪷩; +var 𪷪; +var 𪷫; +var 𪷬; +var 𪷭; +var 𪷮; +var 𪷯; +var 𪷰; +var 𪷱; +var 𪷲; +var 𪷳; +var 𪷴; +var 𪷵; +var 𪷶; +var 𪷷; +var 𪷸; +var 𪷹; +var 𪷺; +var 𪷻; +var 𪷼; +var 𪷽; +var 𪷾; +var 𪷿; +var 𪸀; +var 𪸁; +var 𪸂; +var 𪸃; +var 𪸄; +var 𪸅; +var 𪸆; +var 𪸇; +var 𪸈; +var 𪸉; +var 𪸊; +var 𪸋; +var 𪸌; +var 𪸍; +var 𪸎; +var 𪸏; +var 𪸐; +var 𪸑; +var 𪸒; +var 𪸓; +var 𪸔; +var 𪸕; +var 𪸖; +var 𪸗; +var 𪸘; +var 𪸙; +var 𪸚; +var 𪸛; +var 𪸜; +var 𪸝; +var 𪸞; +var 𪸟; +var 𪸠; +var 𪸡; +var 𪸢; +var 𪸣; +var 𪸤; +var 𪸥; +var 𪸦; +var 𪸧; +var 𪸨; +var 𪸩; +var 𪸪; +var 𪸫; +var 𪸬; +var 𪸭; +var 𪸮; +var 𪸯; +var 𪸰; +var 𪸱; +var 𪸲; +var 𪸳; +var 𪸴; +var 𪸵; +var 𪸶; +var 𪸷; +var 𪸸; +var 𪸹; +var 𪸺; +var 𪸻; +var 𪸼; +var 𪸽; +var 𪸾; +var 𪸿; +var 𪹀; +var 𪹁; +var 𪹂; +var 𪹃; +var 𪹄; +var 𪹅; +var 𪹆; +var 𪹇; +var 𪹈; +var 𪹉; +var 𪹊; +var 𪹋; +var 𪹌; +var 𪹍; +var 𪹎; +var 𪹏; +var 𪹐; +var 𪹑; +var 𪹒; +var 𪹓; +var 𪹔; +var 𪹕; +var 𪹖; +var 𪹗; +var 𪹘; +var 𪹙; +var 𪹚; +var 𪹛; +var 𪹜; +var 𪹝; +var 𪹞; +var 𪹟; +var 𪹠; +var 𪹡; +var 𪹢; +var 𪹣; +var 𪹤; +var 𪹥; +var 𪹦; +var 𪹧; +var 𪹨; +var 𪹩; +var 𪹪; +var 𪹫; +var 𪹬; +var 𪹭; +var 𪹮; +var 𪹯; +var 𪹰; +var 𪹱; +var 𪹲; +var 𪹳; +var 𪹴; +var 𪹵; +var 𪹶; +var 𪹷; +var 𪹸; +var 𪹹; +var 𪹺; +var 𪹻; +var 𪹼; +var 𪹽; +var 𪹾; +var 𪹿; +var 𪺀; +var 𪺁; +var 𪺂; +var 𪺃; +var 𪺄; +var 𪺅; +var 𪺆; +var 𪺇; +var 𪺈; +var 𪺉; +var 𪺊; +var 𪺋; +var 𪺌; +var 𪺍; +var 𪺎; +var 𪺏; +var 𪺐; +var 𪺑; +var 𪺒; +var 𪺓; +var 𪺔; +var 𪺕; +var 𪺖; +var 𪺗; +var 𪺘; +var 𪺙; +var 𪺚; +var 𪺛; +var 𪺜; +var 𪺝; +var 𪺞; +var 𪺟; +var 𪺠; +var 𪺡; +var 𪺢; +var 𪺣; +var 𪺤; +var 𪺥; +var 𪺦; +var 𪺧; +var 𪺨; +var 𪺩; +var 𪺪; +var 𪺫; +var 𪺬; +var 𪺭; +var 𪺮; +var 𪺯; +var 𪺰; +var 𪺱; +var 𪺲; +var 𪺳; +var 𪺴; +var 𪺵; +var 𪺶; +var 𪺷; +var 𪺸; +var 𪺹; +var 𪺺; +var 𪺻; +var 𪺼; +var 𪺽; +var 𪺾; +var 𪺿; +var 𪻀; +var 𪻁; +var 𪻂; +var 𪻃; +var 𪻄; +var 𪻅; +var 𪻆; +var 𪻇; +var 𪻈; +var 𪻉; +var 𪻊; +var 𪻋; +var 𪻌; +var 𪻍; +var 𪻎; +var 𪻏; +var 𪻐; +var 𪻑; +var 𪻒; +var 𪻓; +var 𪻔; +var 𪻕; +var 𪻖; +var 𪻗; +var 𪻘; +var 𪻙; +var 𪻚; +var 𪻛; +var 𪻜; +var 𪻝; +var 𪻞; +var 𪻟; +var 𪻠; +var 𪻡; +var 𪻢; +var 𪻣; +var 𪻤; +var 𪻥; +var 𪻦; +var 𪻧; +var 𪻨; +var 𪻩; +var 𪻪; +var 𪻫; +var 𪻬; +var 𪻭; +var 𪻮; +var 𪻯; +var 𪻰; +var 𪻱; +var 𪻲; +var 𪻳; +var 𪻴; +var 𪻵; +var 𪻶; +var 𪻷; +var 𪻸; +var 𪻹; +var 𪻺; +var 𪻻; +var 𪻼; +var 𪻽; +var 𪻾; +var 𪻿; +var 𪼀; +var 𪼁; +var 𪼂; +var 𪼃; +var 𪼄; +var 𪼅; +var 𪼆; +var 𪼇; +var 𪼈; +var 𪼉; +var 𪼊; +var 𪼋; +var 𪼌; +var 𪼍; +var 𪼎; +var 𪼏; +var 𪼐; +var 𪼑; +var 𪼒; +var 𪼓; +var 𪼔; +var 𪼕; +var 𪼖; +var 𪼗; +var 𪼘; +var 𪼙; +var 𪼚; +var 𪼛; +var 𪼜; +var 𪼝; +var 𪼞; +var 𪼟; +var 𪼠; +var 𪼡; +var 𪼢; +var 𪼣; +var 𪼤; +var 𪼥; +var 𪼦; +var 𪼧; +var 𪼨; +var 𪼩; +var 𪼪; +var 𪼫; +var 𪼬; +var 𪼭; +var 𪼮; +var 𪼯; +var 𪼰; +var 𪼱; +var 𪼲; +var 𪼳; +var 𪼴; +var 𪼵; +var 𪼶; +var 𪼷; +var 𪼸; +var 𪼹; +var 𪼺; +var 𪼻; +var 𪼼; +var 𪼽; +var 𪼾; +var 𪼿; +var 𪽀; +var 𪽁; +var 𪽂; +var 𪽃; +var 𪽄; +var 𪽅; +var 𪽆; +var 𪽇; +var 𪽈; +var 𪽉; +var 𪽊; +var 𪽋; +var 𪽌; +var 𪽍; +var 𪽎; +var 𪽏; +var 𪽐; +var 𪽑; +var 𪽒; +var 𪽓; +var 𪽔; +var 𪽕; +var 𪽖; +var 𪽗; +var 𪽘; +var 𪽙; +var 𪽚; +var 𪽛; +var 𪽜; +var 𪽝; +var 𪽞; +var 𪽟; +var 𪽠; +var 𪽡; +var 𪽢; +var 𪽣; +var 𪽤; +var 𪽥; +var 𪽦; +var 𪽧; +var 𪽨; +var 𪽩; +var 𪽪; +var 𪽫; +var 𪽬; +var 𪽭; +var 𪽮; +var 𪽯; +var 𪽰; +var 𪽱; +var 𪽲; +var 𪽳; +var 𪽴; +var 𪽵; +var 𪽶; +var 𪽷; +var 𪽸; +var 𪽹; +var 𪽺; +var 𪽻; +var 𪽼; +var 𪽽; +var 𪽾; +var 𪽿; +var 𪾀; +var 𪾁; +var 𪾂; +var 𪾃; +var 𪾄; +var 𪾅; +var 𪾆; +var 𪾇; +var 𪾈; +var 𪾉; +var 𪾊; +var 𪾋; +var 𪾌; +var 𪾍; +var 𪾎; +var 𪾏; +var 𪾐; +var 𪾑; +var 𪾒; +var 𪾓; +var 𪾔; +var 𪾕; +var 𪾖; +var 𪾗; +var 𪾘; +var 𪾙; +var 𪾚; +var 𪾛; +var 𪾜; +var 𪾝; +var 𪾞; +var 𪾟; +var 𪾠; +var 𪾡; +var 𪾢; +var 𪾣; +var 𪾤; +var 𪾥; +var 𪾦; +var 𪾧; +var 𪾨; +var 𪾩; +var 𪾪; +var 𪾫; +var 𪾬; +var 𪾭; +var 𪾮; +var 𪾯; +var 𪾰; +var 𪾱; +var 𪾲; +var 𪾳; +var 𪾴; +var 𪾵; +var 𪾶; +var 𪾷; +var 𪾸; +var 𪾹; +var 𪾺; +var 𪾻; +var 𪾼; +var 𪾽; +var 𪾾; +var 𪾿; +var 𪿀; +var 𪿁; +var 𪿂; +var 𪿃; +var 𪿄; +var 𪿅; +var 𪿆; +var 𪿇; +var 𪿈; +var 𪿉; +var 𪿊; +var 𪿋; +var 𪿌; +var 𪿍; +var 𪿎; +var 𪿏; +var 𪿐; +var 𪿑; +var 𪿒; +var 𪿓; +var 𪿔; +var 𪿕; +var 𪿖; +var 𪿗; +var 𪿘; +var 𪿙; +var 𪿚; +var 𪿛; +var 𪿜; +var 𪿝; +var 𪿞; +var 𪿟; +var 𪿠; +var 𪿡; +var 𪿢; +var 𪿣; +var 𪿤; +var 𪿥; +var 𪿦; +var 𪿧; +var 𪿨; +var 𪿩; +var 𪿪; +var 𪿫; +var 𪿬; +var 𪿭; +var 𪿮; +var 𪿯; +var 𪿰; +var 𪿱; +var 𪿲; +var 𪿳; +var 𪿴; +var 𪿵; +var 𪿶; +var 𪿷; +var 𪿸; +var 𪿹; +var 𪿺; +var 𪿻; +var 𪿼; +var 𪿽; +var 𪿾; +var 𪿿; +var 𫀀; +var 𫀁; +var 𫀂; +var 𫀃; +var 𫀄; +var 𫀅; +var 𫀆; +var 𫀇; +var 𫀈; +var 𫀉; +var 𫀊; +var 𫀋; +var 𫀌; +var 𫀍; +var 𫀎; +var 𫀏; +var 𫀐; +var 𫀑; +var 𫀒; +var 𫀓; +var 𫀔; +var 𫀕; +var 𫀖; +var 𫀗; +var 𫀘; +var 𫀙; +var 𫀚; +var 𫀛; +var 𫀜; +var 𫀝; +var 𫀞; +var 𫀟; +var 𫀠; +var 𫀡; +var 𫀢; +var 𫀣; +var 𫀤; +var 𫀥; +var 𫀦; +var 𫀧; +var 𫀨; +var 𫀩; +var 𫀪; +var 𫀫; +var 𫀬; +var 𫀭; +var 𫀮; +var 𫀯; +var 𫀰; +var 𫀱; +var 𫀲; +var 𫀳; +var 𫀴; +var 𫀵; +var 𫀶; +var 𫀷; +var 𫀸; +var 𫀹; +var 𫀺; +var 𫀻; +var 𫀼; +var 𫀽; +var 𫀾; +var 𫀿; +var 𫁀; +var 𫁁; +var 𫁂; +var 𫁃; +var 𫁄; +var 𫁅; +var 𫁆; +var 𫁇; +var 𫁈; +var 𫁉; +var 𫁊; +var 𫁋; +var 𫁌; +var 𫁍; +var 𫁎; +var 𫁏; +var 𫁐; +var 𫁑; +var 𫁒; +var 𫁓; +var 𫁔; +var 𫁕; +var 𫁖; +var 𫁗; +var 𫁘; +var 𫁙; +var 𫁚; +var 𫁛; +var 𫁜; +var 𫁝; +var 𫁞; +var 𫁟; +var 𫁠; +var 𫁡; +var 𫁢; +var 𫁣; +var 𫁤; +var 𫁥; +var 𫁦; +var 𫁧; +var 𫁨; +var 𫁩; +var 𫁪; +var 𫁫; +var 𫁬; +var 𫁭; +var 𫁮; +var 𫁯; +var 𫁰; +var 𫁱; +var 𫁲; +var 𫁳; +var 𫁴; +var 𫁵; +var 𫁶; +var 𫁷; +var 𫁸; +var 𫁹; +var 𫁺; +var 𫁻; +var 𫁼; +var 𫁽; +var 𫁾; +var 𫁿; +var 𫂀; +var 𫂁; +var 𫂂; +var 𫂃; +var 𫂄; +var 𫂅; +var 𫂆; +var 𫂇; +var 𫂈; +var 𫂉; +var 𫂊; +var 𫂋; +var 𫂌; +var 𫂍; +var 𫂎; +var 𫂏; +var 𫂐; +var 𫂑; +var 𫂒; +var 𫂓; +var 𫂔; +var 𫂕; +var 𫂖; +var 𫂗; +var 𫂘; +var 𫂙; +var 𫂚; +var 𫂛; +var 𫂜; +var 𫂝; +var 𫂞; +var 𫂟; +var 𫂠; +var 𫂡; +var 𫂢; +var 𫂣; +var 𫂤; +var 𫂥; +var 𫂦; +var 𫂧; +var 𫂨; +var 𫂩; +var 𫂪; +var 𫂫; +var 𫂬; +var 𫂭; +var 𫂮; +var 𫂯; +var 𫂰; +var 𫂱; +var 𫂲; +var 𫂳; +var 𫂴; +var 𫂵; +var 𫂶; +var 𫂷; +var 𫂸; +var 𫂹; +var 𫂺; +var 𫂻; +var 𫂼; +var 𫂽; +var 𫂾; +var 𫂿; +var 𫃀; +var 𫃁; +var 𫃂; +var 𫃃; +var 𫃄; +var 𫃅; +var 𫃆; +var 𫃇; +var 𫃈; +var 𫃉; +var 𫃊; +var 𫃋; +var 𫃌; +var 𫃍; +var 𫃎; +var 𫃏; +var 𫃐; +var 𫃑; +var 𫃒; +var 𫃓; +var 𫃔; +var 𫃕; +var 𫃖; +var 𫃗; +var 𫃘; +var 𫃙; +var 𫃚; +var 𫃛; +var 𫃜; +var 𫃝; +var 𫃞; +var 𫃟; +var 𫃠; +var 𫃡; +var 𫃢; +var 𫃣; +var 𫃤; +var 𫃥; +var 𫃦; +var 𫃧; +var 𫃨; +var 𫃩; +var 𫃪; +var 𫃫; +var 𫃬; +var 𫃭; +var 𫃮; +var 𫃯; +var 𫃰; +var 𫃱; +var 𫃲; +var 𫃳; +var 𫃴; +var 𫃵; +var 𫃶; +var 𫃷; +var 𫃸; +var 𫃹; +var 𫃺; +var 𫃻; +var 𫃼; +var 𫃽; +var 𫃾; +var 𫃿; +var 𫄀; +var 𫄁; +var 𫄂; +var 𫄃; +var 𫄄; +var 𫄅; +var 𫄆; +var 𫄇; +var 𫄈; +var 𫄉; +var 𫄊; +var 𫄋; +var 𫄌; +var 𫄍; +var 𫄎; +var 𫄏; +var 𫄐; +var 𫄑; +var 𫄒; +var 𫄓; +var 𫄔; +var 𫄕; +var 𫄖; +var 𫄗; +var 𫄘; +var 𫄙; +var 𫄚; +var 𫄛; +var 𫄜; +var 𫄝; +var 𫄞; +var 𫄟; +var 𫄠; +var 𫄡; +var 𫄢; +var 𫄣; +var 𫄤; +var 𫄥; +var 𫄦; +var 𫄧; +var 𫄨; +var 𫄩; +var 𫄪; +var 𫄫; +var 𫄬; +var 𫄭; +var 𫄮; +var 𫄯; +var 𫄰; +var 𫄱; +var 𫄲; +var 𫄳; +var 𫄴; +var 𫄵; +var 𫄶; +var 𫄷; +var 𫄸; +var 𫄹; +var 𫄺; +var 𫄻; +var 𫄼; +var 𫄽; +var 𫄾; +var 𫄿; +var 𫅀; +var 𫅁; +var 𫅂; +var 𫅃; +var 𫅄; +var 𫅅; +var 𫅆; +var 𫅇; +var 𫅈; +var 𫅉; +var 𫅊; +var 𫅋; +var 𫅌; +var 𫅍; +var 𫅎; +var 𫅏; +var 𫅐; +var 𫅑; +var 𫅒; +var 𫅓; +var 𫅔; +var 𫅕; +var 𫅖; +var 𫅗; +var 𫅘; +var 𫅙; +var 𫅚; +var 𫅛; +var 𫅜; +var 𫅝; +var 𫅞; +var 𫅟; +var 𫅠; +var 𫅡; +var 𫅢; +var 𫅣; +var 𫅤; +var 𫅥; +var 𫅦; +var 𫅧; +var 𫅨; +var 𫅩; +var 𫅪; +var 𫅫; +var 𫅬; +var 𫅭; +var 𫅮; +var 𫅯; +var 𫅰; +var 𫅱; +var 𫅲; +var 𫅳; +var 𫅴; +var 𫅵; +var 𫅶; +var 𫅷; +var 𫅸; +var 𫅹; +var 𫅺; +var 𫅻; +var 𫅼; +var 𫅽; +var 𫅾; +var 𫅿; +var 𫆀; +var 𫆁; +var 𫆂; +var 𫆃; +var 𫆄; +var 𫆅; +var 𫆆; +var 𫆇; +var 𫆈; +var 𫆉; +var 𫆊; +var 𫆋; +var 𫆌; +var 𫆍; +var 𫆎; +var 𫆏; +var 𫆐; +var 𫆑; +var 𫆒; +var 𫆓; +var 𫆔; +var 𫆕; +var 𫆖; +var 𫆗; +var 𫆘; +var 𫆙; +var 𫆚; +var 𫆛; +var 𫆜; +var 𫆝; +var 𫆞; +var 𫆟; +var 𫆠; +var 𫆡; +var 𫆢; +var 𫆣; +var 𫆤; +var 𫆥; +var 𫆦; +var 𫆧; +var 𫆨; +var 𫆩; +var 𫆪; +var 𫆫; +var 𫆬; +var 𫆭; +var 𫆮; +var 𫆯; +var 𫆰; +var 𫆱; +var 𫆲; +var 𫆳; +var 𫆴; +var 𫆵; +var 𫆶; +var 𫆷; +var 𫆸; +var 𫆹; +var 𫆺; +var 𫆻; +var 𫆼; +var 𫆽; +var 𫆾; +var 𫆿; +var 𫇀; +var 𫇁; +var 𫇂; +var 𫇃; +var 𫇄; +var 𫇅; +var 𫇆; +var 𫇇; +var 𫇈; +var 𫇉; +var 𫇊; +var 𫇋; +var 𫇌; +var 𫇍; +var 𫇎; +var 𫇏; +var 𫇐; +var 𫇑; +var 𫇒; +var 𫇓; +var 𫇔; +var 𫇕; +var 𫇖; +var 𫇗; +var 𫇘; +var 𫇙; +var 𫇚; +var 𫇛; +var 𫇜; +var 𫇝; +var 𫇞; +var 𫇟; +var 𫇠; +var 𫇡; +var 𫇢; +var 𫇣; +var 𫇤; +var 𫇥; +var 𫇦; +var 𫇧; +var 𫇨; +var 𫇩; +var 𫇪; +var 𫇫; +var 𫇬; +var 𫇭; +var 𫇮; +var 𫇯; +var 𫇰; +var 𫇱; +var 𫇲; +var 𫇳; +var 𫇴; +var 𫇵; +var 𫇶; +var 𫇷; +var 𫇸; +var 𫇹; +var 𫇺; +var 𫇻; +var 𫇼; +var 𫇽; +var 𫇾; +var 𫇿; +var 𫈀; +var 𫈁; +var 𫈂; +var 𫈃; +var 𫈄; +var 𫈅; +var 𫈆; +var 𫈇; +var 𫈈; +var 𫈉; +var 𫈊; +var 𫈋; +var 𫈌; +var 𫈍; +var 𫈎; +var 𫈏; +var 𫈐; +var 𫈑; +var 𫈒; +var 𫈓; +var 𫈔; +var 𫈕; +var 𫈖; +var 𫈗; +var 𫈘; +var 𫈙; +var 𫈚; +var 𫈛; +var 𫈜; +var 𫈝; +var 𫈞; +var 𫈟; +var 𫈠; +var 𫈡; +var 𫈢; +var 𫈣; +var 𫈤; +var 𫈥; +var 𫈦; +var 𫈧; +var 𫈨; +var 𫈩; +var 𫈪; +var 𫈫; +var 𫈬; +var 𫈭; +var 𫈮; +var 𫈯; +var 𫈰; +var 𫈱; +var 𫈲; +var 𫈳; +var 𫈴; +var 𫈵; +var 𫈶; +var 𫈷; +var 𫈸; +var 𫈹; +var 𫈺; +var 𫈻; +var 𫈼; +var 𫈽; +var 𫈾; +var 𫈿; +var 𫉀; +var 𫉁; +var 𫉂; +var 𫉃; +var 𫉄; +var 𫉅; +var 𫉆; +var 𫉇; +var 𫉈; +var 𫉉; +var 𫉊; +var 𫉋; +var 𫉌; +var 𫉍; +var 𫉎; +var 𫉏; +var 𫉐; +var 𫉑; +var 𫉒; +var 𫉓; +var 𫉔; +var 𫉕; +var 𫉖; +var 𫉗; +var 𫉘; +var 𫉙; +var 𫉚; +var 𫉛; +var 𫉜; +var 𫉝; +var 𫉞; +var 𫉟; +var 𫉠; +var 𫉡; +var 𫉢; +var 𫉣; +var 𫉤; +var 𫉥; +var 𫉦; +var 𫉧; +var 𫉨; +var 𫉩; +var 𫉪; +var 𫉫; +var 𫉬; +var 𫉭; +var 𫉮; +var 𫉯; +var 𫉰; +var 𫉱; +var 𫉲; +var 𫉳; +var 𫉴; +var 𫉵; +var 𫉶; +var 𫉷; +var 𫉸; +var 𫉹; +var 𫉺; +var 𫉻; +var 𫉼; +var 𫉽; +var 𫉾; +var 𫉿; +var 𫊀; +var 𫊁; +var 𫊂; +var 𫊃; +var 𫊄; +var 𫊅; +var 𫊆; +var 𫊇; +var 𫊈; +var 𫊉; +var 𫊊; +var 𫊋; +var 𫊌; +var 𫊍; +var 𫊎; +var 𫊏; +var 𫊐; +var 𫊑; +var 𫊒; +var 𫊓; +var 𫊔; +var 𫊕; +var 𫊖; +var 𫊗; +var 𫊘; +var 𫊙; +var 𫊚; +var 𫊛; +var 𫊜; +var 𫊝; +var 𫊞; +var 𫊟; +var 𫊠; +var 𫊡; +var 𫊢; +var 𫊣; +var 𫊤; +var 𫊥; +var 𫊦; +var 𫊧; +var 𫊨; +var 𫊩; +var 𫊪; +var 𫊫; +var 𫊬; +var 𫊭; +var 𫊮; +var 𫊯; +var 𫊰; +var 𫊱; +var 𫊲; +var 𫊳; +var 𫊴; +var 𫊵; +var 𫊶; +var 𫊷; +var 𫊸; +var 𫊹; +var 𫊺; +var 𫊻; +var 𫊼; +var 𫊽; +var 𫊾; +var 𫊿; +var 𫋀; +var 𫋁; +var 𫋂; +var 𫋃; +var 𫋄; +var 𫋅; +var 𫋆; +var 𫋇; +var 𫋈; +var 𫋉; +var 𫋊; +var 𫋋; +var 𫋌; +var 𫋍; +var 𫋎; +var 𫋏; +var 𫋐; +var 𫋑; +var 𫋒; +var 𫋓; +var 𫋔; +var 𫋕; +var 𫋖; +var 𫋗; +var 𫋘; +var 𫋙; +var 𫋚; +var 𫋛; +var 𫋜; +var 𫋝; +var 𫋞; +var 𫋟; +var 𫋠; +var 𫋡; +var 𫋢; +var 𫋣; +var 𫋤; +var 𫋥; +var 𫋦; +var 𫋧; +var 𫋨; +var 𫋩; +var 𫋪; +var 𫋫; +var 𫋬; +var 𫋭; +var 𫋮; +var 𫋯; +var 𫋰; +var 𫋱; +var 𫋲; +var 𫋳; +var 𫋴; +var 𫋵; +var 𫋶; +var 𫋷; +var 𫋸; +var 𫋹; +var 𫋺; +var 𫋻; +var 𫋼; +var 𫋽; +var 𫋾; +var 𫋿; +var 𫌀; +var 𫌁; +var 𫌂; +var 𫌃; +var 𫌄; +var 𫌅; +var 𫌆; +var 𫌇; +var 𫌈; +var 𫌉; +var 𫌊; +var 𫌋; +var 𫌌; +var 𫌍; +var 𫌎; +var 𫌏; +var 𫌐; +var 𫌑; +var 𫌒; +var 𫌓; +var 𫌔; +var 𫌕; +var 𫌖; +var 𫌗; +var 𫌘; +var 𫌙; +var 𫌚; +var 𫌛; +var 𫌜; +var 𫌝; +var 𫌞; +var 𫌟; +var 𫌠; +var 𫌡; +var 𫌢; +var 𫌣; +var 𫌤; +var 𫌥; +var 𫌦; +var 𫌧; +var 𫌨; +var 𫌩; +var 𫌪; +var 𫌫; +var 𫌬; +var 𫌭; +var 𫌮; +var 𫌯; +var 𫌰; +var 𫌱; +var 𫌲; +var 𫌳; +var 𫌴; +var 𫌵; +var 𫌶; +var 𫌷; +var 𫌸; +var 𫌹; +var 𫌺; +var 𫌻; +var 𫌼; +var 𫌽; +var 𫌾; +var 𫌿; +var 𫍀; +var 𫍁; +var 𫍂; +var 𫍃; +var 𫍄; +var 𫍅; +var 𫍆; +var 𫍇; +var 𫍈; +var 𫍉; +var 𫍊; +var 𫍋; +var 𫍌; +var 𫍍; +var 𫍎; +var 𫍏; +var 𫍐; +var 𫍑; +var 𫍒; +var 𫍓; +var 𫍔; +var 𫍕; +var 𫍖; +var 𫍗; +var 𫍘; +var 𫍙; +var 𫍚; +var 𫍛; +var 𫍜; +var 𫍝; +var 𫍞; +var 𫍟; +var 𫍠; +var 𫍡; +var 𫍢; +var 𫍣; +var 𫍤; +var 𫍥; +var 𫍦; +var 𫍧; +var 𫍨; +var 𫍩; +var 𫍪; +var 𫍫; +var 𫍬; +var 𫍭; +var 𫍮; +var 𫍯; +var 𫍰; +var 𫍱; +var 𫍲; +var 𫍳; +var 𫍴; +var 𫍵; +var 𫍶; +var 𫍷; +var 𫍸; +var 𫍹; +var 𫍺; +var 𫍻; +var 𫍼; +var 𫍽; +var 𫍾; +var 𫍿; +var 𫎀; +var 𫎁; +var 𫎂; +var 𫎃; +var 𫎄; +var 𫎅; +var 𫎆; +var 𫎇; +var 𫎈; +var 𫎉; +var 𫎊; +var 𫎋; +var 𫎌; +var 𫎍; +var 𫎎; +var 𫎏; +var 𫎐; +var 𫎑; +var 𫎒; +var 𫎓; +var 𫎔; +var 𫎕; +var 𫎖; +var 𫎗; +var 𫎘; +var 𫎙; +var 𫎚; +var 𫎛; +var 𫎜; +var 𫎝; +var 𫎞; +var 𫎟; +var 𫎠; +var 𫎡; +var 𫎢; +var 𫎣; +var 𫎤; +var 𫎥; +var 𫎦; +var 𫎧; +var 𫎨; +var 𫎩; +var 𫎪; +var 𫎫; +var 𫎬; +var 𫎭; +var 𫎮; +var 𫎯; +var 𫎰; +var 𫎱; +var 𫎲; +var 𫎳; +var 𫎴; +var 𫎵; +var 𫎶; +var 𫎷; +var 𫎸; +var 𫎹; +var 𫎺; +var 𫎻; +var 𫎼; +var 𫎽; +var 𫎾; +var 𫎿; +var 𫏀; +var 𫏁; +var 𫏂; +var 𫏃; +var 𫏄; +var 𫏅; +var 𫏆; +var 𫏇; +var 𫏈; +var 𫏉; +var 𫏊; +var 𫏋; +var 𫏌; +var 𫏍; +var 𫏎; +var 𫏏; +var 𫏐; +var 𫏑; +var 𫏒; +var 𫏓; +var 𫏔; +var 𫏕; +var 𫏖; +var 𫏗; +var 𫏘; +var 𫏙; +var 𫏚; +var 𫏛; +var 𫏜; +var 𫏝; +var 𫏞; +var 𫏟; +var 𫏠; +var 𫏡; +var 𫏢; +var 𫏣; +var 𫏤; +var 𫏥; +var 𫏦; +var 𫏧; +var 𫏨; +var 𫏩; +var 𫏪; +var 𫏫; +var 𫏬; +var 𫏭; +var 𫏮; +var 𫏯; +var 𫏰; +var 𫏱; +var 𫏲; +var 𫏳; +var 𫏴; +var 𫏵; +var 𫏶; +var 𫏷; +var 𫏸; +var 𫏹; +var 𫏺; +var 𫏻; +var 𫏼; +var 𫏽; +var 𫏾; +var 𫏿; +var 𫐀; +var 𫐁; +var 𫐂; +var 𫐃; +var 𫐄; +var 𫐅; +var 𫐆; +var 𫐇; +var 𫐈; +var 𫐉; +var 𫐊; +var 𫐋; +var 𫐌; +var 𫐍; +var 𫐎; +var 𫐏; +var 𫐐; +var 𫐑; +var 𫐒; +var 𫐓; +var 𫐔; +var 𫐕; +var 𫐖; +var 𫐗; +var 𫐘; +var 𫐙; +var 𫐚; +var 𫐛; +var 𫐜; +var 𫐝; +var 𫐞; +var 𫐟; +var 𫐠; +var 𫐡; +var 𫐢; +var 𫐣; +var 𫐤; +var 𫐥; +var 𫐦; +var 𫐧; +var 𫐨; +var 𫐩; +var 𫐪; +var 𫐫; +var 𫐬; +var 𫐭; +var 𫐮; +var 𫐯; +var 𫐰; +var 𫐱; +var 𫐲; +var 𫐳; +var 𫐴; +var 𫐵; +var 𫐶; +var 𫐷; +var 𫐸; +var 𫐹; +var 𫐺; +var 𫐻; +var 𫐼; +var 𫐽; +var 𫐾; +var 𫐿; +var 𫑀; +var 𫑁; +var 𫑂; +var 𫑃; +var 𫑄; +var 𫑅; +var 𫑆; +var 𫑇; +var 𫑈; +var 𫑉; +var 𫑊; +var 𫑋; +var 𫑌; +var 𫑍; +var 𫑎; +var 𫑏; +var 𫑐; +var 𫑑; +var 𫑒; +var 𫑓; +var 𫑔; +var 𫑕; +var 𫑖; +var 𫑗; +var 𫑘; +var 𫑙; +var 𫑚; +var 𫑛; +var 𫑜; +var 𫑝; +var 𫑞; +var 𫑟; +var 𫑠; +var 𫑡; +var 𫑢; +var 𫑣; +var 𫑤; +var 𫑥; +var 𫑦; +var 𫑧; +var 𫑨; +var 𫑩; +var 𫑪; +var 𫑫; +var 𫑬; +var 𫑭; +var 𫑮; +var 𫑯; +var 𫑰; +var 𫑱; +var 𫑲; +var 𫑳; +var 𫑴; +var 𫑵; +var 𫑶; +var 𫑷; +var 𫑸; +var 𫑹; +var 𫑺; +var 𫑻; +var 𫑼; +var 𫑽; +var 𫑾; +var 𫑿; +var 𫒀; +var 𫒁; +var 𫒂; +var 𫒃; +var 𫒄; +var 𫒅; +var 𫒆; +var 𫒇; +var 𫒈; +var 𫒉; +var 𫒊; +var 𫒋; +var 𫒌; +var 𫒍; +var 𫒎; +var 𫒏; +var 𫒐; +var 𫒑; +var 𫒒; +var 𫒓; +var 𫒔; +var 𫒕; +var 𫒖; +var 𫒗; +var 𫒘; +var 𫒙; +var 𫒚; +var 𫒛; +var 𫒜; +var 𫒝; +var 𫒞; +var 𫒟; +var 𫒠; +var 𫒡; +var 𫒢; +var 𫒣; +var 𫒤; +var 𫒥; +var 𫒦; +var 𫒧; +var 𫒨; +var 𫒩; +var 𫒪; +var 𫒫; +var 𫒬; +var 𫒭; +var 𫒮; +var 𫒯; +var 𫒰; +var 𫒱; +var 𫒲; +var 𫒳; +var 𫒴; +var 𫒵; +var 𫒶; +var 𫒷; +var 𫒸; +var 𫒹; +var 𫒺; +var 𫒻; +var 𫒼; +var 𫒽; +var 𫒾; +var 𫒿; +var 𫓀; +var 𫓁; +var 𫓂; +var 𫓃; +var 𫓄; +var 𫓅; +var 𫓆; +var 𫓇; +var 𫓈; +var 𫓉; +var 𫓊; +var 𫓋; +var 𫓌; +var 𫓍; +var 𫓎; +var 𫓏; +var 𫓐; +var 𫓑; +var 𫓒; +var 𫓓; +var 𫓔; +var 𫓕; +var 𫓖; +var 𫓗; +var 𫓘; +var 𫓙; +var 𫓚; +var 𫓛; +var 𫓜; +var 𫓝; +var 𫓞; +var 𫓟; +var 𫓠; +var 𫓡; +var 𫓢; +var 𫓣; +var 𫓤; +var 𫓥; +var 𫓦; +var 𫓧; +var 𫓨; +var 𫓩; +var 𫓪; +var 𫓫; +var 𫓬; +var 𫓭; +var 𫓮; +var 𫓯; +var 𫓰; +var 𫓱; +var 𫓲; +var 𫓳; +var 𫓴; +var 𫓵; +var 𫓶; +var 𫓷; +var 𫓸; +var 𫓹; +var 𫓺; +var 𫓻; +var 𫓼; +var 𫓽; +var 𫓾; +var 𫓿; +var 𫔀; +var 𫔁; +var 𫔂; +var 𫔃; +var 𫔄; +var 𫔅; +var 𫔆; +var 𫔇; +var 𫔈; +var 𫔉; +var 𫔊; +var 𫔋; +var 𫔌; +var 𫔍; +var 𫔎; +var 𫔏; +var 𫔐; +var 𫔑; +var 𫔒; +var 𫔓; +var 𫔔; +var 𫔕; +var 𫔖; +var 𫔗; +var 𫔘; +var 𫔙; +var 𫔚; +var 𫔛; +var 𫔜; +var 𫔝; +var 𫔞; +var 𫔟; +var 𫔠; +var 𫔡; +var 𫔢; +var 𫔣; +var 𫔤; +var 𫔥; +var 𫔦; +var 𫔧; +var 𫔨; +var 𫔩; +var 𫔪; +var 𫔫; +var 𫔬; +var 𫔭; +var 𫔮; +var 𫔯; +var 𫔰; +var 𫔱; +var 𫔲; +var 𫔳; +var 𫔴; +var 𫔵; +var 𫔶; +var 𫔷; +var 𫔸; +var 𫔹; +var 𫔺; +var 𫔻; +var 𫔼; +var 𫔽; +var 𫔾; +var 𫔿; +var 𫕀; +var 𫕁; +var 𫕂; +var 𫕃; +var 𫕄; +var 𫕅; +var 𫕆; +var 𫕇; +var 𫕈; +var 𫕉; +var 𫕊; +var 𫕋; +var 𫕌; +var 𫕍; +var 𫕎; +var 𫕏; +var 𫕐; +var 𫕑; +var 𫕒; +var 𫕓; +var 𫕔; +var 𫕕; +var 𫕖; +var 𫕗; +var 𫕘; +var 𫕙; +var 𫕚; +var 𫕛; +var 𫕜; +var 𫕝; +var 𫕞; +var 𫕟; +var 𫕠; +var 𫕡; +var 𫕢; +var 𫕣; +var 𫕤; +var 𫕥; +var 𫕦; +var 𫕧; +var 𫕨; +var 𫕩; +var 𫕪; +var 𫕫; +var 𫕬; +var 𫕭; +var 𫕮; +var 𫕯; +var 𫕰; +var 𫕱; +var 𫕲; +var 𫕳; +var 𫕴; +var 𫕵; +var 𫕶; +var 𫕷; +var 𫕸; +var 𫕹; +var 𫕺; +var 𫕻; +var 𫕼; +var 𫕽; +var 𫕾; +var 𫕿; +var 𫖀; +var 𫖁; +var 𫖂; +var 𫖃; +var 𫖄; +var 𫖅; +var 𫖆; +var 𫖇; +var 𫖈; +var 𫖉; +var 𫖊; +var 𫖋; +var 𫖌; +var 𫖍; +var 𫖎; +var 𫖏; +var 𫖐; +var 𫖑; +var 𫖒; +var 𫖓; +var 𫖔; +var 𫖕; +var 𫖖; +var 𫖗; +var 𫖘; +var 𫖙; +var 𫖚; +var 𫖛; +var 𫖜; +var 𫖝; +var 𫖞; +var 𫖟; +var 𫖠; +var 𫖡; +var 𫖢; +var 𫖣; +var 𫖤; +var 𫖥; +var 𫖦; +var 𫖧; +var 𫖨; +var 𫖩; +var 𫖪; +var 𫖫; +var 𫖬; +var 𫖭; +var 𫖮; +var 𫖯; +var 𫖰; +var 𫖱; +var 𫖲; +var 𫖳; +var 𫖴; +var 𫖵; +var 𫖶; +var 𫖷; +var 𫖸; +var 𫖹; +var 𫖺; +var 𫖻; +var 𫖼; +var 𫖽; +var 𫖾; +var 𫖿; +var 𫗀; +var 𫗁; +var 𫗂; +var 𫗃; +var 𫗄; +var 𫗅; +var 𫗆; +var 𫗇; +var 𫗈; +var 𫗉; +var 𫗊; +var 𫗋; +var 𫗌; +var 𫗍; +var 𫗎; +var 𫗏; +var 𫗐; +var 𫗑; +var 𫗒; +var 𫗓; +var 𫗔; +var 𫗕; +var 𫗖; +var 𫗗; +var 𫗘; +var 𫗙; +var 𫗚; +var 𫗛; +var 𫗜; +var 𫗝; +var 𫗞; +var 𫗟; +var 𫗠; +var 𫗡; +var 𫗢; +var 𫗣; +var 𫗤; +var 𫗥; +var 𫗦; +var 𫗧; +var 𫗨; +var 𫗩; +var 𫗪; +var 𫗫; +var 𫗬; +var 𫗭; +var 𫗮; +var 𫗯; +var 𫗰; +var 𫗱; +var 𫗲; +var 𫗳; +var 𫗴; +var 𫗵; +var 𫗶; +var 𫗷; +var 𫗸; +var 𫗹; +var 𫗺; +var 𫗻; +var 𫗼; +var 𫗽; +var 𫗾; +var 𫗿; +var 𫘀; +var 𫘁; +var 𫘂; +var 𫘃; +var 𫘄; +var 𫘅; +var 𫘆; +var 𫘇; +var 𫘈; +var 𫘉; +var 𫘊; +var 𫘋; +var 𫘌; +var 𫘍; +var 𫘎; +var 𫘏; +var 𫘐; +var 𫘑; +var 𫘒; +var 𫘓; +var 𫘔; +var 𫘕; +var 𫘖; +var 𫘗; +var 𫘘; +var 𫘙; +var 𫘚; +var 𫘛; +var 𫘜; +var 𫘝; +var 𫘞; +var 𫘟; +var 𫘠; +var 𫘡; +var 𫘢; +var 𫘣; +var 𫘤; +var 𫘥; +var 𫘦; +var 𫘧; +var 𫘨; +var 𫘩; +var 𫘪; +var 𫘫; +var 𫘬; +var 𫘭; +var 𫘮; +var 𫘯; +var 𫘰; +var 𫘱; +var 𫘲; +var 𫘳; +var 𫘴; +var 𫘵; +var 𫘶; +var 𫘷; +var 𫘸; +var 𫘹; +var 𫘺; +var 𫘻; +var 𫘼; +var 𫘽; +var 𫘾; +var 𫘿; +var 𫙀; +var 𫙁; +var 𫙂; +var 𫙃; +var 𫙄; +var 𫙅; +var 𫙆; +var 𫙇; +var 𫙈; +var 𫙉; +var 𫙊; +var 𫙋; +var 𫙌; +var 𫙍; +var 𫙎; +var 𫙏; +var 𫙐; +var 𫙑; +var 𫙒; +var 𫙓; +var 𫙔; +var 𫙕; +var 𫙖; +var 𫙗; +var 𫙘; +var 𫙙; +var 𫙚; +var 𫙛; +var 𫙜; +var 𫙝; +var 𫙞; +var 𫙟; +var 𫙠; +var 𫙡; +var 𫙢; +var 𫙣; +var 𫙤; +var 𫙥; +var 𫙦; +var 𫙧; +var 𫙨; +var 𫙩; +var 𫙪; +var 𫙫; +var 𫙬; +var 𫙭; +var 𫙮; +var 𫙯; +var 𫙰; +var 𫙱; +var 𫙲; +var 𫙳; +var 𫙴; +var 𫙵; +var 𫙶; +var 𫙷; +var 𫙸; +var 𫙹; +var 𫙺; +var 𫙻; +var 𫙼; +var 𫙽; +var 𫙾; +var 𫙿; +var 𫚀; +var 𫚁; +var 𫚂; +var 𫚃; +var 𫚄; +var 𫚅; +var 𫚆; +var 𫚇; +var 𫚈; +var 𫚉; +var 𫚊; +var 𫚋; +var 𫚌; +var 𫚍; +var 𫚎; +var 𫚏; +var 𫚐; +var 𫚑; +var 𫚒; +var 𫚓; +var 𫚔; +var 𫚕; +var 𫚖; +var 𫚗; +var 𫚘; +var 𫚙; +var 𫚚; +var 𫚛; +var 𫚜; +var 𫚝; +var 𫚞; +var 𫚟; +var 𫚠; +var 𫚡; +var 𫚢; +var 𫚣; +var 𫚤; +var 𫚥; +var 𫚦; +var 𫚧; +var 𫚨; +var 𫚩; +var 𫚪; +var 𫚫; +var 𫚬; +var 𫚭; +var 𫚮; +var 𫚯; +var 𫚰; +var 𫚱; +var 𫚲; +var 𫚳; +var 𫚴; +var 𫚵; +var 𫚶; +var 𫚷; +var 𫚸; +var 𫚹; +var 𫚺; +var 𫚻; +var 𫚼; +var 𫚽; +var 𫚾; +var 𫚿; +var 𫛀; +var 𫛁; +var 𫛂; +var 𫛃; +var 𫛄; +var 𫛅; +var 𫛆; +var 𫛇; +var 𫛈; +var 𫛉; +var 𫛊; +var 𫛋; +var 𫛌; +var 𫛍; +var 𫛎; +var 𫛏; +var 𫛐; +var 𫛑; +var 𫛒; +var 𫛓; +var 𫛔; +var 𫛕; +var 𫛖; +var 𫛗; +var 𫛘; +var 𫛙; +var 𫛚; +var 𫛛; +var 𫛜; +var 𫛝; +var 𫛞; +var 𫛟; +var 𫛠; +var 𫛡; +var 𫛢; +var 𫛣; +var 𫛤; +var 𫛥; +var 𫛦; +var 𫛧; +var 𫛨; +var 𫛩; +var 𫛪; +var 𫛫; +var 𫛬; +var 𫛭; +var 𫛮; +var 𫛯; +var 𫛰; +var 𫛱; +var 𫛲; +var 𫛳; +var 𫛴; +var 𫛵; +var 𫛶; +var 𫛷; +var 𫛸; +var 𫛹; +var 𫛺; +var 𫛻; +var 𫛼; +var 𫛽; +var 𫛾; +var 𫛿; +var 𫜀; +var 𫜁; +var 𫜂; +var 𫜃; +var 𫜄; +var 𫜅; +var 𫜆; +var 𫜇; +var 𫜈; +var 𫜉; +var 𫜊; +var 𫜋; +var 𫜌; +var 𫜍; +var 𫜎; +var 𫜏; +var 𫜐; +var 𫜑; +var 𫜒; +var 𫜓; +var 𫜔; +var 𫜕; +var 𫜖; +var 𫜗; +var 𫜘; +var 𫜙; +var 𫜚; +var 𫜛; +var 𫜜; +var 𫜝; +var 𫜞; +var 𫜟; +var 𫜠; +var 𫜡; +var 𫜢; +var 𫜣; +var 𫜤; +var 𫜥; +var 𫜦; +var 𫜧; +var 𫜨; +var 𫜩; +var 𫜪; +var 𫜫; +var 𫜬; +var 𫜭; +var 𫜮; +var 𫜯; +var 𫜰; +var 𫜱; +var 𫜲; +var 𫜳; +var 𫜴; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0-class-escaped.js new file mode 100644 index 000000000..2c39baf31 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0-class-escaped.js @@ -0,0 +1,1002 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v6.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u0526; + #\u0527; + #\u0620; + #\u0840; + #\u0841; + #\u0842; + #\u0843; + #\u0844; + #\u0845; + #\u0846; + #\u0847; + #\u0848; + #\u0849; + #\u084A; + #\u084B; + #\u084C; + #\u084D; + #\u084E; + #\u084F; + #\u0850; + #\u0851; + #\u0852; + #\u0853; + #\u0854; + #\u0855; + #\u0856; + #\u0857; + #\u0858; + #\u0973; + #\u0974; + #\u0975; + #\u0976; + #\u0977; + #\u0CF1; + #\u0CF2; + #\u0D29; + #\u0D3A; + #\u0D4E; + #\u0F8C; + #\u1BC0; + #\u1BC1; + #\u1BC2; + #\u1BC3; + #\u1BC4; + #\u1BC5; + #\u1BC6; + #\u1BC7; + #\u1BC8; + #\u1BC9; + #\u1BCA; + #\u1BCB; + #\u1BCC; + #\u1BCD; + #\u1BCE; + #\u1BCF; + #\u1BD0; + #\u1BD1; + #\u1BD2; + #\u1BD3; + #\u1BD4; + #\u1BD5; + #\u1BD6; + #\u1BD7; + #\u1BD8; + #\u1BD9; + #\u1BDA; + #\u1BDB; + #\u1BDC; + #\u1BDD; + #\u1BDE; + #\u1BDF; + #\u1BE0; + #\u1BE1; + #\u1BE2; + #\u1BE3; + #\u1BE4; + #\u1BE5; + #\u2095; + #\u2096; + #\u2097; + #\u2098; + #\u2099; + #\u209A; + #\u209B; + #\u209C; + #\u31B8; + #\u31B9; + #\u31BA; + #\uA660; + #\uA661; + #\uA78D; + #\uA78E; + #\uA790; + #\uA791; + #\uA7A0; + #\uA7A1; + #\uA7A2; + #\uA7A3; + #\uA7A4; + #\uA7A5; + #\uA7A6; + #\uA7A7; + #\uA7A8; + #\uA7A9; + #\uA7FA; + #\uAB01; + #\uAB02; + #\uAB03; + #\uAB04; + #\uAB05; + #\uAB06; + #\uAB09; + #\uAB0A; + #\uAB0B; + #\uAB0C; + #\uAB0D; + #\uAB0E; + #\uAB11; + #\uAB12; + #\uAB13; + #\uAB14; + #\uAB15; + #\uAB16; + #\uAB20; + #\uAB21; + #\uAB22; + #\uAB23; + #\uAB24; + #\uAB25; + #\uAB26; + #\uAB28; + #\uAB29; + #\uAB2A; + #\uAB2B; + #\uAB2C; + #\uAB2D; + #\uAB2E; + #\u{11003}; + #\u{11004}; + #\u{11005}; + #\u{11006}; + #\u{11007}; + #\u{11008}; + #\u{11009}; + #\u{1100A}; + #\u{1100B}; + #\u{1100C}; + #\u{1100D}; + #\u{1100E}; + #\u{1100F}; + #\u{11010}; + #\u{11011}; + #\u{11012}; + #\u{11013}; + #\u{11014}; + #\u{11015}; + #\u{11016}; + #\u{11017}; + #\u{11018}; + #\u{11019}; + #\u{1101A}; + #\u{1101B}; + #\u{1101C}; + #\u{1101D}; + #\u{1101E}; + #\u{1101F}; + #\u{11020}; + #\u{11021}; + #\u{11022}; + #\u{11023}; + #\u{11024}; + #\u{11025}; + #\u{11026}; + #\u{11027}; + #\u{11028}; + #\u{11029}; + #\u{1102A}; + #\u{1102B}; + #\u{1102C}; + #\u{1102D}; + #\u{1102E}; + #\u{1102F}; + #\u{11030}; + #\u{11031}; + #\u{11032}; + #\u{11033}; + #\u{11034}; + #\u{11035}; + #\u{11036}; + #\u{11037}; + #\u{16800}; + #\u{16801}; + #\u{16802}; + #\u{16803}; + #\u{16804}; + #\u{16805}; + #\u{16806}; + #\u{16807}; + #\u{16808}; + #\u{16809}; + #\u{1680A}; + #\u{1680B}; + #\u{1680C}; + #\u{1680D}; + #\u{1680E}; + #\u{1680F}; + #\u{16810}; + #\u{16811}; + #\u{16812}; + #\u{16813}; + #\u{16814}; + #\u{16815}; + #\u{16816}; + #\u{16817}; + #\u{16818}; + #\u{16819}; + #\u{1681A}; + #\u{1681B}; + #\u{1681C}; + #\u{1681D}; + #\u{1681E}; + #\u{1681F}; + #\u{16820}; + #\u{16821}; + #\u{16822}; + #\u{16823}; + #\u{16824}; + #\u{16825}; + #\u{16826}; + #\u{16827}; + #\u{16828}; + #\u{16829}; + #\u{1682A}; + #\u{1682B}; + #\u{1682C}; + #\u{1682D}; + #\u{1682E}; + #\u{1682F}; + #\u{16830}; + #\u{16831}; + #\u{16832}; + #\u{16833}; + #\u{16834}; + #\u{16835}; + #\u{16836}; + #\u{16837}; + #\u{16838}; + #\u{16839}; + #\u{1683A}; + #\u{1683B}; + #\u{1683C}; + #\u{1683D}; + #\u{1683E}; + #\u{1683F}; + #\u{16840}; + #\u{16841}; + #\u{16842}; + #\u{16843}; + #\u{16844}; + #\u{16845}; + #\u{16846}; + #\u{16847}; + #\u{16848}; + #\u{16849}; + #\u{1684A}; + #\u{1684B}; + #\u{1684C}; + #\u{1684D}; + #\u{1684E}; + #\u{1684F}; + #\u{16850}; + #\u{16851}; + #\u{16852}; + #\u{16853}; + #\u{16854}; + #\u{16855}; + #\u{16856}; + #\u{16857}; + #\u{16858}; + #\u{16859}; + #\u{1685A}; + #\u{1685B}; + #\u{1685C}; + #\u{1685D}; + #\u{1685E}; + #\u{1685F}; + #\u{16860}; + #\u{16861}; + #\u{16862}; + #\u{16863}; + #\u{16864}; + #\u{16865}; + #\u{16866}; + #\u{16867}; + #\u{16868}; + #\u{16869}; + #\u{1686A}; + #\u{1686B}; + #\u{1686C}; + #\u{1686D}; + #\u{1686E}; + #\u{1686F}; + #\u{16870}; + #\u{16871}; + #\u{16872}; + #\u{16873}; + #\u{16874}; + #\u{16875}; + #\u{16876}; + #\u{16877}; + #\u{16878}; + #\u{16879}; + #\u{1687A}; + #\u{1687B}; + #\u{1687C}; + #\u{1687D}; + #\u{1687E}; + #\u{1687F}; + #\u{16880}; + #\u{16881}; + #\u{16882}; + #\u{16883}; + #\u{16884}; + #\u{16885}; + #\u{16886}; + #\u{16887}; + #\u{16888}; + #\u{16889}; + #\u{1688A}; + #\u{1688B}; + #\u{1688C}; + #\u{1688D}; + #\u{1688E}; + #\u{1688F}; + #\u{16890}; + #\u{16891}; + #\u{16892}; + #\u{16893}; + #\u{16894}; + #\u{16895}; + #\u{16896}; + #\u{16897}; + #\u{16898}; + #\u{16899}; + #\u{1689A}; + #\u{1689B}; + #\u{1689C}; + #\u{1689D}; + #\u{1689E}; + #\u{1689F}; + #\u{168A0}; + #\u{168A1}; + #\u{168A2}; + #\u{168A3}; + #\u{168A4}; + #\u{168A5}; + #\u{168A6}; + #\u{168A7}; + #\u{168A8}; + #\u{168A9}; + #\u{168AA}; + #\u{168AB}; + #\u{168AC}; + #\u{168AD}; + #\u{168AE}; + #\u{168AF}; + #\u{168B0}; + #\u{168B1}; + #\u{168B2}; + #\u{168B3}; + #\u{168B4}; + #\u{168B5}; + #\u{168B6}; + #\u{168B7}; + #\u{168B8}; + #\u{168B9}; + #\u{168BA}; + #\u{168BB}; + #\u{168BC}; + #\u{168BD}; + #\u{168BE}; + #\u{168BF}; + #\u{168C0}; + #\u{168C1}; + #\u{168C2}; + #\u{168C3}; + #\u{168C4}; + #\u{168C5}; + #\u{168C6}; + #\u{168C7}; + #\u{168C8}; + #\u{168C9}; + #\u{168CA}; + #\u{168CB}; + #\u{168CC}; + #\u{168CD}; + #\u{168CE}; + #\u{168CF}; + #\u{168D0}; + #\u{168D1}; + #\u{168D2}; + #\u{168D3}; + #\u{168D4}; + #\u{168D5}; + #\u{168D6}; + #\u{168D7}; + #\u{168D8}; + #\u{168D9}; + #\u{168DA}; + #\u{168DB}; + #\u{168DC}; + #\u{168DD}; + #\u{168DE}; + #\u{168DF}; + #\u{168E0}; + #\u{168E1}; + #\u{168E2}; + #\u{168E3}; + #\u{168E4}; + #\u{168E5}; + #\u{168E6}; + #\u{168E7}; + #\u{168E8}; + #\u{168E9}; + #\u{168EA}; + #\u{168EB}; + #\u{168EC}; + #\u{168ED}; + #\u{168EE}; + #\u{168EF}; + #\u{168F0}; + #\u{168F1}; + #\u{168F2}; + #\u{168F3}; + #\u{168F4}; + #\u{168F5}; + #\u{168F6}; + #\u{168F7}; + #\u{168F8}; + #\u{168F9}; + #\u{168FA}; + #\u{168FB}; + #\u{168FC}; + #\u{168FD}; + #\u{168FE}; + #\u{168FF}; + #\u{16900}; + #\u{16901}; + #\u{16902}; + #\u{16903}; + #\u{16904}; + #\u{16905}; + #\u{16906}; + #\u{16907}; + #\u{16908}; + #\u{16909}; + #\u{1690A}; + #\u{1690B}; + #\u{1690C}; + #\u{1690D}; + #\u{1690E}; + #\u{1690F}; + #\u{16910}; + #\u{16911}; + #\u{16912}; + #\u{16913}; + #\u{16914}; + #\u{16915}; + #\u{16916}; + #\u{16917}; + #\u{16918}; + #\u{16919}; + #\u{1691A}; + #\u{1691B}; + #\u{1691C}; + #\u{1691D}; + #\u{1691E}; + #\u{1691F}; + #\u{16920}; + #\u{16921}; + #\u{16922}; + #\u{16923}; + #\u{16924}; + #\u{16925}; + #\u{16926}; + #\u{16927}; + #\u{16928}; + #\u{16929}; + #\u{1692A}; + #\u{1692B}; + #\u{1692C}; + #\u{1692D}; + #\u{1692E}; + #\u{1692F}; + #\u{16930}; + #\u{16931}; + #\u{16932}; + #\u{16933}; + #\u{16934}; + #\u{16935}; + #\u{16936}; + #\u{16937}; + #\u{16938}; + #\u{16939}; + #\u{1693A}; + #\u{1693B}; + #\u{1693C}; + #\u{1693D}; + #\u{1693E}; + #\u{1693F}; + #\u{16940}; + #\u{16941}; + #\u{16942}; + #\u{16943}; + #\u{16944}; + #\u{16945}; + #\u{16946}; + #\u{16947}; + #\u{16948}; + #\u{16949}; + #\u{1694A}; + #\u{1694B}; + #\u{1694C}; + #\u{1694D}; + #\u{1694E}; + #\u{1694F}; + #\u{16950}; + #\u{16951}; + #\u{16952}; + #\u{16953}; + #\u{16954}; + #\u{16955}; + #\u{16956}; + #\u{16957}; + #\u{16958}; + #\u{16959}; + #\u{1695A}; + #\u{1695B}; + #\u{1695C}; + #\u{1695D}; + #\u{1695E}; + #\u{1695F}; + #\u{16960}; + #\u{16961}; + #\u{16962}; + #\u{16963}; + #\u{16964}; + #\u{16965}; + #\u{16966}; + #\u{16967}; + #\u{16968}; + #\u{16969}; + #\u{1696A}; + #\u{1696B}; + #\u{1696C}; + #\u{1696D}; + #\u{1696E}; + #\u{1696F}; + #\u{16970}; + #\u{16971}; + #\u{16972}; + #\u{16973}; + #\u{16974}; + #\u{16975}; + #\u{16976}; + #\u{16977}; + #\u{16978}; + #\u{16979}; + #\u{1697A}; + #\u{1697B}; + #\u{1697C}; + #\u{1697D}; + #\u{1697E}; + #\u{1697F}; + #\u{16980}; + #\u{16981}; + #\u{16982}; + #\u{16983}; + #\u{16984}; + #\u{16985}; + #\u{16986}; + #\u{16987}; + #\u{16988}; + #\u{16989}; + #\u{1698A}; + #\u{1698B}; + #\u{1698C}; + #\u{1698D}; + #\u{1698E}; + #\u{1698F}; + #\u{16990}; + #\u{16991}; + #\u{16992}; + #\u{16993}; + #\u{16994}; + #\u{16995}; + #\u{16996}; + #\u{16997}; + #\u{16998}; + #\u{16999}; + #\u{1699A}; + #\u{1699B}; + #\u{1699C}; + #\u{1699D}; + #\u{1699E}; + #\u{1699F}; + #\u{169A0}; + #\u{169A1}; + #\u{169A2}; + #\u{169A3}; + #\u{169A4}; + #\u{169A5}; + #\u{169A6}; + #\u{169A7}; + #\u{169A8}; + #\u{169A9}; + #\u{169AA}; + #\u{169AB}; + #\u{169AC}; + #\u{169AD}; + #\u{169AE}; + #\u{169AF}; + #\u{169B0}; + #\u{169B1}; + #\u{169B2}; + #\u{169B3}; + #\u{169B4}; + #\u{169B5}; + #\u{169B6}; + #\u{169B7}; + #\u{169B8}; + #\u{169B9}; + #\u{169BA}; + #\u{169BB}; + #\u{169BC}; + #\u{169BD}; + #\u{169BE}; + #\u{169BF}; + #\u{169C0}; + #\u{169C1}; + #\u{169C2}; + #\u{169C3}; + #\u{169C4}; + #\u{169C5}; + #\u{169C6}; + #\u{169C7}; + #\u{169C8}; + #\u{169C9}; + #\u{169CA}; + #\u{169CB}; + #\u{169CC}; + #\u{169CD}; + #\u{169CE}; + #\u{169CF}; + #\u{169D0}; + #\u{169D1}; + #\u{169D2}; + #\u{169D3}; + #\u{169D4}; + #\u{169D5}; + #\u{169D6}; + #\u{169D7}; + #\u{169D8}; + #\u{169D9}; + #\u{169DA}; + #\u{169DB}; + #\u{169DC}; + #\u{169DD}; + #\u{169DE}; + #\u{169DF}; + #\u{169E0}; + #\u{169E1}; + #\u{169E2}; + #\u{169E3}; + #\u{169E4}; + #\u{169E5}; + #\u{169E6}; + #\u{169E7}; + #\u{169E8}; + #\u{169E9}; + #\u{169EA}; + #\u{169EB}; + #\u{169EC}; + #\u{169ED}; + #\u{169EE}; + #\u{169EF}; + #\u{169F0}; + #\u{169F1}; + #\u{169F2}; + #\u{169F3}; + #\u{169F4}; + #\u{169F5}; + #\u{169F6}; + #\u{169F7}; + #\u{169F8}; + #\u{169F9}; + #\u{169FA}; + #\u{169FB}; + #\u{169FC}; + #\u{169FD}; + #\u{169FE}; + #\u{169FF}; + #\u{16A00}; + #\u{16A01}; + #\u{16A02}; + #\u{16A03}; + #\u{16A04}; + #\u{16A05}; + #\u{16A06}; + #\u{16A07}; + #\u{16A08}; + #\u{16A09}; + #\u{16A0A}; + #\u{16A0B}; + #\u{16A0C}; + #\u{16A0D}; + #\u{16A0E}; + #\u{16A0F}; + #\u{16A10}; + #\u{16A11}; + #\u{16A12}; + #\u{16A13}; + #\u{16A14}; + #\u{16A15}; + #\u{16A16}; + #\u{16A17}; + #\u{16A18}; + #\u{16A19}; + #\u{16A1A}; + #\u{16A1B}; + #\u{16A1C}; + #\u{16A1D}; + #\u{16A1E}; + #\u{16A1F}; + #\u{16A20}; + #\u{16A21}; + #\u{16A22}; + #\u{16A23}; + #\u{16A24}; + #\u{16A25}; + #\u{16A26}; + #\u{16A27}; + #\u{16A28}; + #\u{16A29}; + #\u{16A2A}; + #\u{16A2B}; + #\u{16A2C}; + #\u{16A2D}; + #\u{16A2E}; + #\u{16A2F}; + #\u{16A30}; + #\u{16A31}; + #\u{16A32}; + #\u{16A33}; + #\u{16A34}; + #\u{16A35}; + #\u{16A36}; + #\u{16A37}; + #\u{16A38}; + #\u{1B000}; + #\u{1B001}; + #\u{2B740}; + #\u{2B741}; + #\u{2B742}; + #\u{2B743}; + #\u{2B744}; + #\u{2B745}; + #\u{2B746}; + #\u{2B747}; + #\u{2B748}; + #\u{2B749}; + #\u{2B74A}; + #\u{2B74B}; + #\u{2B74C}; + #\u{2B74D}; + #\u{2B74E}; + #\u{2B74F}; + #\u{2B750}; + #\u{2B751}; + #\u{2B752}; + #\u{2B753}; + #\u{2B754}; + #\u{2B755}; + #\u{2B756}; + #\u{2B757}; + #\u{2B758}; + #\u{2B759}; + #\u{2B75A}; + #\u{2B75B}; + #\u{2B75C}; + #\u{2B75D}; + #\u{2B75E}; + #\u{2B75F}; + #\u{2B760}; + #\u{2B761}; + #\u{2B762}; + #\u{2B763}; + #\u{2B764}; + #\u{2B765}; + #\u{2B766}; + #\u{2B767}; + #\u{2B768}; + #\u{2B769}; + #\u{2B76A}; + #\u{2B76B}; + #\u{2B76C}; + #\u{2B76D}; + #\u{2B76E}; + #\u{2B76F}; + #\u{2B770}; + #\u{2B771}; + #\u{2B772}; + #\u{2B773}; + #\u{2B774}; + #\u{2B775}; + #\u{2B776}; + #\u{2B777}; + #\u{2B778}; + #\u{2B779}; + #\u{2B77A}; + #\u{2B77B}; + #\u{2B77C}; + #\u{2B77D}; + #\u{2B77E}; + #\u{2B77F}; + #\u{2B780}; + #\u{2B781}; + #\u{2B782}; + #\u{2B783}; + #\u{2B784}; + #\u{2B785}; + #\u{2B786}; + #\u{2B787}; + #\u{2B788}; + #\u{2B789}; + #\u{2B78A}; + #\u{2B78B}; + #\u{2B78C}; + #\u{2B78D}; + #\u{2B78E}; + #\u{2B78F}; + #\u{2B790}; + #\u{2B791}; + #\u{2B792}; + #\u{2B793}; + #\u{2B794}; + #\u{2B795}; + #\u{2B796}; + #\u{2B797}; + #\u{2B798}; + #\u{2B799}; + #\u{2B79A}; + #\u{2B79B}; + #\u{2B79C}; + #\u{2B79D}; + #\u{2B79E}; + #\u{2B79F}; + #\u{2B7A0}; + #\u{2B7A1}; + #\u{2B7A2}; + #\u{2B7A3}; + #\u{2B7A4}; + #\u{2B7A5}; + #\u{2B7A6}; + #\u{2B7A7}; + #\u{2B7A8}; + #\u{2B7A9}; + #\u{2B7AA}; + #\u{2B7AB}; + #\u{2B7AC}; + #\u{2B7AD}; + #\u{2B7AE}; + #\u{2B7AF}; + #\u{2B7B0}; + #\u{2B7B1}; + #\u{2B7B2}; + #\u{2B7B3}; + #\u{2B7B4}; + #\u{2B7B5}; + #\u{2B7B6}; + #\u{2B7B7}; + #\u{2B7B8}; + #\u{2B7B9}; + #\u{2B7BA}; + #\u{2B7BB}; + #\u{2B7BC}; + #\u{2B7BD}; + #\u{2B7BE}; + #\u{2B7BF}; + #\u{2B7C0}; + #\u{2B7C1}; + #\u{2B7C2}; + #\u{2B7C3}; + #\u{2B7C4}; + #\u{2B7C5}; + #\u{2B7C6}; + #\u{2B7C7}; + #\u{2B7C8}; + #\u{2B7C9}; + #\u{2B7CA}; + #\u{2B7CB}; + #\u{2B7CC}; + #\u{2B7CD}; + #\u{2B7CE}; + #\u{2B7CF}; + #\u{2B7D0}; + #\u{2B7D1}; + #\u{2B7D2}; + #\u{2B7D3}; + #\u{2B7D4}; + #\u{2B7D5}; + #\u{2B7D6}; + #\u{2B7D7}; + #\u{2B7D8}; + #\u{2B7D9}; + #\u{2B7DA}; + #\u{2B7DB}; + #\u{2B7DC}; + #\u{2B7DD}; + #\u{2B7DE}; + #\u{2B7DF}; + #\u{2B7E0}; + #\u{2B7E1}; + #\u{2B7E2}; + #\u{2B7E3}; + #\u{2B7E4}; + #\u{2B7E5}; + #\u{2B7E6}; + #\u{2B7E7}; + #\u{2B7E8}; + #\u{2B7E9}; + #\u{2B7EA}; + #\u{2B7EB}; + #\u{2B7EC}; + #\u{2B7ED}; + #\u{2B7EE}; + #\u{2B7EF}; + #\u{2B7F0}; + #\u{2B7F1}; + #\u{2B7F2}; + #\u{2B7F3}; + #\u{2B7F4}; + #\u{2B7F5}; + #\u{2B7F6}; + #\u{2B7F7}; + #\u{2B7F8}; + #\u{2B7F9}; + #\u{2B7FA}; + #\u{2B7FB}; + #\u{2B7FC}; + #\u{2B7FD}; + #\u{2B7FE}; + #\u{2B7FF}; + #\u{2B800}; + #\u{2B801}; + #\u{2B802}; + #\u{2B803}; + #\u{2B804}; + #\u{2B805}; + #\u{2B806}; + #\u{2B807}; + #\u{2B808}; + #\u{2B809}; + #\u{2B80A}; + #\u{2B80B}; + #\u{2B80C}; + #\u{2B80D}; + #\u{2B80E}; + #\u{2B80F}; + #\u{2B810}; + #\u{2B811}; + #\u{2B812}; + #\u{2B813}; + #\u{2B814}; + #\u{2B815}; + #\u{2B816}; + #\u{2B817}; + #\u{2B818}; + #\u{2B819}; + #\u{2B81A}; + #\u{2B81B}; + #\u{2B81C}; + #\u{2B81D}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0-class.js new file mode 100644 index 000000000..b99dfd42f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0-class.js @@ -0,0 +1,999 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v6.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #Ԧ; + #ԧ; + #ؠ; + #ࡀ; + #ࡁ; + #ࡂ; + #ࡃ; + #ࡄ; + #ࡅ; + #ࡆ; + #ࡇ; + #ࡈ; + #ࡉ; + #ࡊ; + #ࡋ; + #ࡌ; + #ࡍ; + #ࡎ; + #ࡏ; + #ࡐ; + #ࡑ; + #ࡒ; + #ࡓ; + #ࡔ; + #ࡕ; + #ࡖ; + #ࡗ; + #ࡘ; + #ॳ; + #ॴ; + #ॵ; + #ॶ; + #ॷ; + #ೱ; + #ೲ; + #ഩ; + #ഺ; + #ൎ; + #ྌ; + #ᯀ; + #ᯁ; + #ᯂ; + #ᯃ; + #ᯄ; + #ᯅ; + #ᯆ; + #ᯇ; + #ᯈ; + #ᯉ; + #ᯊ; + #ᯋ; + #ᯌ; + #ᯍ; + #ᯎ; + #ᯏ; + #ᯐ; + #ᯑ; + #ᯒ; + #ᯓ; + #ᯔ; + #ᯕ; + #ᯖ; + #ᯗ; + #ᯘ; + #ᯙ; + #ᯚ; + #ᯛ; + #ᯜ; + #ᯝ; + #ᯞ; + #ᯟ; + #ᯠ; + #ᯡ; + #ᯢ; + #ᯣ; + #ᯤ; + #ᯥ; + #ₕ; + #ₖ; + #ₗ; + #ₘ; + #ₙ; + #ₚ; + #ₛ; + #ₜ; + #ㆸ; + #ㆹ; + #ㆺ; + #Ꙡ; + #ꙡ; + #Ɥ; + #ꞎ; + #Ꞑ; + #ꞑ; + #Ꞡ; + #ꞡ; + #Ꞣ; + #ꞣ; + #Ꞥ; + #ꞥ; + #Ꞧ; + #ꞧ; + #Ꞩ; + #ꞩ; + #ꟺ; + #ꬁ; + #ꬂ; + #ꬃ; + #ꬄ; + #ꬅ; + #ꬆ; + #ꬉ; + #ꬊ; + #ꬋ; + #ꬌ; + #ꬍ; + #ꬎ; + #ꬑ; + #ꬒ; + #ꬓ; + #ꬔ; + #ꬕ; + #ꬖ; + #ꬠ; + #ꬡ; + #ꬢ; + #ꬣ; + #ꬤ; + #ꬥ; + #ꬦ; + #ꬨ; + #ꬩ; + #ꬪ; + #ꬫ; + #ꬬ; + #ꬭ; + #ꬮ; + #𑀃; + #𑀄; + #𑀅; + #𑀆; + #𑀇; + #𑀈; + #𑀉; + #𑀊; + #𑀋; + #𑀌; + #𑀍; + #𑀎; + #𑀏; + #𑀐; + #𑀑; + #𑀒; + #𑀓; + #𑀔; + #𑀕; + #𑀖; + #𑀗; + #𑀘; + #𑀙; + #𑀚; + #𑀛; + #𑀜; + #𑀝; + #𑀞; + #𑀟; + #𑀠; + #𑀡; + #𑀢; + #𑀣; + #𑀤; + #𑀥; + #𑀦; + #𑀧; + #𑀨; + #𑀩; + #𑀪; + #𑀫; + #𑀬; + #𑀭; + #𑀮; + #𑀯; + #𑀰; + #𑀱; + #𑀲; + #𑀳; + #𑀴; + #𑀵; + #𑀶; + #𑀷; + #𖠀; + #𖠁; + #𖠂; + #𖠃; + #𖠄; + #𖠅; + #𖠆; + #𖠇; + #𖠈; + #𖠉; + #𖠊; + #𖠋; + #𖠌; + #𖠍; + #𖠎; + #𖠏; + #𖠐; + #𖠑; + #𖠒; + #𖠓; + #𖠔; + #𖠕; + #𖠖; + #𖠗; + #𖠘; + #𖠙; + #𖠚; + #𖠛; + #𖠜; + #𖠝; + #𖠞; + #𖠟; + #𖠠; + #𖠡; + #𖠢; + #𖠣; + #𖠤; + #𖠥; + #𖠦; + #𖠧; + #𖠨; + #𖠩; + #𖠪; + #𖠫; + #𖠬; + #𖠭; + #𖠮; + #𖠯; + #𖠰; + #𖠱; + #𖠲; + #𖠳; + #𖠴; + #𖠵; + #𖠶; + #𖠷; + #𖠸; + #𖠹; + #𖠺; + #𖠻; + #𖠼; + #𖠽; + #𖠾; + #𖠿; + #𖡀; + #𖡁; + #𖡂; + #𖡃; + #𖡄; + #𖡅; + #𖡆; + #𖡇; + #𖡈; + #𖡉; + #𖡊; + #𖡋; + #𖡌; + #𖡍; + #𖡎; + #𖡏; + #𖡐; + #𖡑; + #𖡒; + #𖡓; + #𖡔; + #𖡕; + #𖡖; + #𖡗; + #𖡘; + #𖡙; + #𖡚; + #𖡛; + #𖡜; + #𖡝; + #𖡞; + #𖡟; + #𖡠; + #𖡡; + #𖡢; + #𖡣; + #𖡤; + #𖡥; + #𖡦; + #𖡧; + #𖡨; + #𖡩; + #𖡪; + #𖡫; + #𖡬; + #𖡭; + #𖡮; + #𖡯; + #𖡰; + #𖡱; + #𖡲; + #𖡳; + #𖡴; + #𖡵; + #𖡶; + #𖡷; + #𖡸; + #𖡹; + #𖡺; + #𖡻; + #𖡼; + #𖡽; + #𖡾; + #𖡿; + #𖢀; + #𖢁; + #𖢂; + #𖢃; + #𖢄; + #𖢅; + #𖢆; + #𖢇; + #𖢈; + #𖢉; + #𖢊; + #𖢋; + #𖢌; + #𖢍; + #𖢎; + #𖢏; + #𖢐; + #𖢑; + #𖢒; + #𖢓; + #𖢔; + #𖢕; + #𖢖; + #𖢗; + #𖢘; + #𖢙; + #𖢚; + #𖢛; + #𖢜; + #𖢝; + #𖢞; + #𖢟; + #𖢠; + #𖢡; + #𖢢; + #𖢣; + #𖢤; + #𖢥; + #𖢦; + #𖢧; + #𖢨; + #𖢩; + #𖢪; + #𖢫; + #𖢬; + #𖢭; + #𖢮; + #𖢯; + #𖢰; + #𖢱; + #𖢲; + #𖢳; + #𖢴; + #𖢵; + #𖢶; + #𖢷; + #𖢸; + #𖢹; + #𖢺; + #𖢻; + #𖢼; + #𖢽; + #𖢾; + #𖢿; + #𖣀; + #𖣁; + #𖣂; + #𖣃; + #𖣄; + #𖣅; + #𖣆; + #𖣇; + #𖣈; + #𖣉; + #𖣊; + #𖣋; + #𖣌; + #𖣍; + #𖣎; + #𖣏; + #𖣐; + #𖣑; + #𖣒; + #𖣓; + #𖣔; + #𖣕; + #𖣖; + #𖣗; + #𖣘; + #𖣙; + #𖣚; + #𖣛; + #𖣜; + #𖣝; + #𖣞; + #𖣟; + #𖣠; + #𖣡; + #𖣢; + #𖣣; + #𖣤; + #𖣥; + #𖣦; + #𖣧; + #𖣨; + #𖣩; + #𖣪; + #𖣫; + #𖣬; + #𖣭; + #𖣮; + #𖣯; + #𖣰; + #𖣱; + #𖣲; + #𖣳; + #𖣴; + #𖣵; + #𖣶; + #𖣷; + #𖣸; + #𖣹; + #𖣺; + #𖣻; + #𖣼; + #𖣽; + #𖣾; + #𖣿; + #𖤀; + #𖤁; + #𖤂; + #𖤃; + #𖤄; + #𖤅; + #𖤆; + #𖤇; + #𖤈; + #𖤉; + #𖤊; + #𖤋; + #𖤌; + #𖤍; + #𖤎; + #𖤏; + #𖤐; + #𖤑; + #𖤒; + #𖤓; + #𖤔; + #𖤕; + #𖤖; + #𖤗; + #𖤘; + #𖤙; + #𖤚; + #𖤛; + #𖤜; + #𖤝; + #𖤞; + #𖤟; + #𖤠; + #𖤡; + #𖤢; + #𖤣; + #𖤤; + #𖤥; + #𖤦; + #𖤧; + #𖤨; + #𖤩; + #𖤪; + #𖤫; + #𖤬; + #𖤭; + #𖤮; + #𖤯; + #𖤰; + #𖤱; + #𖤲; + #𖤳; + #𖤴; + #𖤵; + #𖤶; + #𖤷; + #𖤸; + #𖤹; + #𖤺; + #𖤻; + #𖤼; + #𖤽; + #𖤾; + #𖤿; + #𖥀; + #𖥁; + #𖥂; + #𖥃; + #𖥄; + #𖥅; + #𖥆; + #𖥇; + #𖥈; + #𖥉; + #𖥊; + #𖥋; + #𖥌; + #𖥍; + #𖥎; + #𖥏; + #𖥐; + #𖥑; + #𖥒; + #𖥓; + #𖥔; + #𖥕; + #𖥖; + #𖥗; + #𖥘; + #𖥙; + #𖥚; + #𖥛; + #𖥜; + #𖥝; + #𖥞; + #𖥟; + #𖥠; + #𖥡; + #𖥢; + #𖥣; + #𖥤; + #𖥥; + #𖥦; + #𖥧; + #𖥨; + #𖥩; + #𖥪; + #𖥫; + #𖥬; + #𖥭; + #𖥮; + #𖥯; + #𖥰; + #𖥱; + #𖥲; + #𖥳; + #𖥴; + #𖥵; + #𖥶; + #𖥷; + #𖥸; + #𖥹; + #𖥺; + #𖥻; + #𖥼; + #𖥽; + #𖥾; + #𖥿; + #𖦀; + #𖦁; + #𖦂; + #𖦃; + #𖦄; + #𖦅; + #𖦆; + #𖦇; + #𖦈; + #𖦉; + #𖦊; + #𖦋; + #𖦌; + #𖦍; + #𖦎; + #𖦏; + #𖦐; + #𖦑; + #𖦒; + #𖦓; + #𖦔; + #𖦕; + #𖦖; + #𖦗; + #𖦘; + #𖦙; + #𖦚; + #𖦛; + #𖦜; + #𖦝; + #𖦞; + #𖦟; + #𖦠; + #𖦡; + #𖦢; + #𖦣; + #𖦤; + #𖦥; + #𖦦; + #𖦧; + #𖦨; + #𖦩; + #𖦪; + #𖦫; + #𖦬; + #𖦭; + #𖦮; + #𖦯; + #𖦰; + #𖦱; + #𖦲; + #𖦳; + #𖦴; + #𖦵; + #𖦶; + #𖦷; + #𖦸; + #𖦹; + #𖦺; + #𖦻; + #𖦼; + #𖦽; + #𖦾; + #𖦿; + #𖧀; + #𖧁; + #𖧂; + #𖧃; + #𖧄; + #𖧅; + #𖧆; + #𖧇; + #𖧈; + #𖧉; + #𖧊; + #𖧋; + #𖧌; + #𖧍; + #𖧎; + #𖧏; + #𖧐; + #𖧑; + #𖧒; + #𖧓; + #𖧔; + #𖧕; + #𖧖; + #𖧗; + #𖧘; + #𖧙; + #𖧚; + #𖧛; + #𖧜; + #𖧝; + #𖧞; + #𖧟; + #𖧠; + #𖧡; + #𖧢; + #𖧣; + #𖧤; + #𖧥; + #𖧦; + #𖧧; + #𖧨; + #𖧩; + #𖧪; + #𖧫; + #𖧬; + #𖧭; + #𖧮; + #𖧯; + #𖧰; + #𖧱; + #𖧲; + #𖧳; + #𖧴; + #𖧵; + #𖧶; + #𖧷; + #𖧸; + #𖧹; + #𖧺; + #𖧻; + #𖧼; + #𖧽; + #𖧾; + #𖧿; + #𖨀; + #𖨁; + #𖨂; + #𖨃; + #𖨄; + #𖨅; + #𖨆; + #𖨇; + #𖨈; + #𖨉; + #𖨊; + #𖨋; + #𖨌; + #𖨍; + #𖨎; + #𖨏; + #𖨐; + #𖨑; + #𖨒; + #𖨓; + #𖨔; + #𖨕; + #𖨖; + #𖨗; + #𖨘; + #𖨙; + #𖨚; + #𖨛; + #𖨜; + #𖨝; + #𖨞; + #𖨟; + #𖨠; + #𖨡; + #𖨢; + #𖨣; + #𖨤; + #𖨥; + #𖨦; + #𖨧; + #𖨨; + #𖨩; + #𖨪; + #𖨫; + #𖨬; + #𖨭; + #𖨮; + #𖨯; + #𖨰; + #𖨱; + #𖨲; + #𖨳; + #𖨴; + #𖨵; + #𖨶; + #𖨷; + #𖨸; + #𛀀; + #𛀁; + #𫝀; + #𫝁; + #𫝂; + #𫝃; + #𫝄; + #𫝅; + #𫝆; + #𫝇; + #𫝈; + #𫝉; + #𫝊; + #𫝋; + #𫝌; + #𫝍; + #𫝎; + #𫝏; + #𫝐; + #𫝑; + #𫝒; + #𫝓; + #𫝔; + #𫝕; + #𫝖; + #𫝗; + #𫝘; + #𫝙; + #𫝚; + #𫝛; + #𫝜; + #𫝝; + #𫝞; + #𫝟; + #𫝠; + #𫝡; + #𫝢; + #𫝣; + #𫝤; + #𫝥; + #𫝦; + #𫝧; + #𫝨; + #𫝩; + #𫝪; + #𫝫; + #𫝬; + #𫝭; + #𫝮; + #𫝯; + #𫝰; + #𫝱; + #𫝲; + #𫝳; + #𫝴; + #𫝵; + #𫝶; + #𫝷; + #𫝸; + #𫝹; + #𫝺; + #𫝻; + #𫝼; + #𫝽; + #𫝾; + #𫝿; + #𫞀; + #𫞁; + #𫞂; + #𫞃; + #𫞄; + #𫞅; + #𫞆; + #𫞇; + #𫞈; + #𫞉; + #𫞊; + #𫞋; + #𫞌; + #𫞍; + #𫞎; + #𫞏; + #𫞐; + #𫞑; + #𫞒; + #𫞓; + #𫞔; + #𫞕; + #𫞖; + #𫞗; + #𫞘; + #𫞙; + #𫞚; + #𫞛; + #𫞜; + #𫞝; + #𫞞; + #𫞟; + #𫞠; + #𫞡; + #𫞢; + #𫞣; + #𫞤; + #𫞥; + #𫞦; + #𫞧; + #𫞨; + #𫞩; + #𫞪; + #𫞫; + #𫞬; + #𫞭; + #𫞮; + #𫞯; + #𫞰; + #𫞱; + #𫞲; + #𫞳; + #𫞴; + #𫞵; + #𫞶; + #𫞷; + #𫞸; + #𫞹; + #𫞺; + #𫞻; + #𫞼; + #𫞽; + #𫞾; + #𫞿; + #𫟀; + #𫟁; + #𫟂; + #𫟃; + #𫟄; + #𫟅; + #𫟆; + #𫟇; + #𫟈; + #𫟉; + #𫟊; + #𫟋; + #𫟌; + #𫟍; + #𫟎; + #𫟏; + #𫟐; + #𫟑; + #𫟒; + #𫟓; + #𫟔; + #𫟕; + #𫟖; + #𫟗; + #𫟘; + #𫟙; + #𫟚; + #𫟛; + #𫟜; + #𫟝; + #𫟞; + #𫟟; + #𫟠; + #𫟡; + #𫟢; + #𫟣; + #𫟤; + #𫟥; + #𫟦; + #𫟧; + #𫟨; + #𫟩; + #𫟪; + #𫟫; + #𫟬; + #𫟭; + #𫟮; + #𫟯; + #𫟰; + #𫟱; + #𫟲; + #𫟳; + #𫟴; + #𫟵; + #𫟶; + #𫟷; + #𫟸; + #𫟹; + #𫟺; + #𫟻; + #𫟼; + #𫟽; + #𫟾; + #𫟿; + #𫠀; + #𫠁; + #𫠂; + #𫠃; + #𫠄; + #𫠅; + #𫠆; + #𫠇; + #𫠈; + #𫠉; + #𫠊; + #𫠋; + #𫠌; + #𫠍; + #𫠎; + #𫠏; + #𫠐; + #𫠑; + #𫠒; + #𫠓; + #𫠔; + #𫠕; + #𫠖; + #𫠗; + #𫠘; + #𫠙; + #𫠚; + #𫠛; + #𫠜; + #𫠝; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0-escaped.js new file mode 100644 index 000000000..42e7d185b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0-escaped.js @@ -0,0 +1,998 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v6.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u0526; +var \u0527; +var \u0620; +var \u0840; +var \u0841; +var \u0842; +var \u0843; +var \u0844; +var \u0845; +var \u0846; +var \u0847; +var \u0848; +var \u0849; +var \u084A; +var \u084B; +var \u084C; +var \u084D; +var \u084E; +var \u084F; +var \u0850; +var \u0851; +var \u0852; +var \u0853; +var \u0854; +var \u0855; +var \u0856; +var \u0857; +var \u0858; +var \u0973; +var \u0974; +var \u0975; +var \u0976; +var \u0977; +var \u0CF1; +var \u0CF2; +var \u0D29; +var \u0D3A; +var \u0D4E; +var \u0F8C; +var \u1BC0; +var \u1BC1; +var \u1BC2; +var \u1BC3; +var \u1BC4; +var \u1BC5; +var \u1BC6; +var \u1BC7; +var \u1BC8; +var \u1BC9; +var \u1BCA; +var \u1BCB; +var \u1BCC; +var \u1BCD; +var \u1BCE; +var \u1BCF; +var \u1BD0; +var \u1BD1; +var \u1BD2; +var \u1BD3; +var \u1BD4; +var \u1BD5; +var \u1BD6; +var \u1BD7; +var \u1BD8; +var \u1BD9; +var \u1BDA; +var \u1BDB; +var \u1BDC; +var \u1BDD; +var \u1BDE; +var \u1BDF; +var \u1BE0; +var \u1BE1; +var \u1BE2; +var \u1BE3; +var \u1BE4; +var \u1BE5; +var \u2095; +var \u2096; +var \u2097; +var \u2098; +var \u2099; +var \u209A; +var \u209B; +var \u209C; +var \u31B8; +var \u31B9; +var \u31BA; +var \uA660; +var \uA661; +var \uA78D; +var \uA78E; +var \uA790; +var \uA791; +var \uA7A0; +var \uA7A1; +var \uA7A2; +var \uA7A3; +var \uA7A4; +var \uA7A5; +var \uA7A6; +var \uA7A7; +var \uA7A8; +var \uA7A9; +var \uA7FA; +var \uAB01; +var \uAB02; +var \uAB03; +var \uAB04; +var \uAB05; +var \uAB06; +var \uAB09; +var \uAB0A; +var \uAB0B; +var \uAB0C; +var \uAB0D; +var \uAB0E; +var \uAB11; +var \uAB12; +var \uAB13; +var \uAB14; +var \uAB15; +var \uAB16; +var \uAB20; +var \uAB21; +var \uAB22; +var \uAB23; +var \uAB24; +var \uAB25; +var \uAB26; +var \uAB28; +var \uAB29; +var \uAB2A; +var \uAB2B; +var \uAB2C; +var \uAB2D; +var \uAB2E; +var \u{11003}; +var \u{11004}; +var \u{11005}; +var \u{11006}; +var \u{11007}; +var \u{11008}; +var \u{11009}; +var \u{1100A}; +var \u{1100B}; +var \u{1100C}; +var \u{1100D}; +var \u{1100E}; +var \u{1100F}; +var \u{11010}; +var \u{11011}; +var \u{11012}; +var \u{11013}; +var \u{11014}; +var \u{11015}; +var \u{11016}; +var \u{11017}; +var \u{11018}; +var \u{11019}; +var \u{1101A}; +var \u{1101B}; +var \u{1101C}; +var \u{1101D}; +var \u{1101E}; +var \u{1101F}; +var \u{11020}; +var \u{11021}; +var \u{11022}; +var \u{11023}; +var \u{11024}; +var \u{11025}; +var \u{11026}; +var \u{11027}; +var \u{11028}; +var \u{11029}; +var \u{1102A}; +var \u{1102B}; +var \u{1102C}; +var \u{1102D}; +var \u{1102E}; +var \u{1102F}; +var \u{11030}; +var \u{11031}; +var \u{11032}; +var \u{11033}; +var \u{11034}; +var \u{11035}; +var \u{11036}; +var \u{11037}; +var \u{16800}; +var \u{16801}; +var \u{16802}; +var \u{16803}; +var \u{16804}; +var \u{16805}; +var \u{16806}; +var \u{16807}; +var \u{16808}; +var \u{16809}; +var \u{1680A}; +var \u{1680B}; +var \u{1680C}; +var \u{1680D}; +var \u{1680E}; +var \u{1680F}; +var \u{16810}; +var \u{16811}; +var \u{16812}; +var \u{16813}; +var \u{16814}; +var \u{16815}; +var \u{16816}; +var \u{16817}; +var \u{16818}; +var \u{16819}; +var \u{1681A}; +var \u{1681B}; +var \u{1681C}; +var \u{1681D}; +var \u{1681E}; +var \u{1681F}; +var \u{16820}; +var \u{16821}; +var \u{16822}; +var \u{16823}; +var \u{16824}; +var \u{16825}; +var \u{16826}; +var \u{16827}; +var \u{16828}; +var \u{16829}; +var \u{1682A}; +var \u{1682B}; +var \u{1682C}; +var \u{1682D}; +var \u{1682E}; +var \u{1682F}; +var \u{16830}; +var \u{16831}; +var \u{16832}; +var \u{16833}; +var \u{16834}; +var \u{16835}; +var \u{16836}; +var \u{16837}; +var \u{16838}; +var \u{16839}; +var \u{1683A}; +var \u{1683B}; +var \u{1683C}; +var \u{1683D}; +var \u{1683E}; +var \u{1683F}; +var \u{16840}; +var \u{16841}; +var \u{16842}; +var \u{16843}; +var \u{16844}; +var \u{16845}; +var \u{16846}; +var \u{16847}; +var \u{16848}; +var \u{16849}; +var \u{1684A}; +var \u{1684B}; +var \u{1684C}; +var \u{1684D}; +var \u{1684E}; +var \u{1684F}; +var \u{16850}; +var \u{16851}; +var \u{16852}; +var \u{16853}; +var \u{16854}; +var \u{16855}; +var \u{16856}; +var \u{16857}; +var \u{16858}; +var \u{16859}; +var \u{1685A}; +var \u{1685B}; +var \u{1685C}; +var \u{1685D}; +var \u{1685E}; +var \u{1685F}; +var \u{16860}; +var \u{16861}; +var \u{16862}; +var \u{16863}; +var \u{16864}; +var \u{16865}; +var \u{16866}; +var \u{16867}; +var \u{16868}; +var \u{16869}; +var \u{1686A}; +var \u{1686B}; +var \u{1686C}; +var \u{1686D}; +var \u{1686E}; +var \u{1686F}; +var \u{16870}; +var \u{16871}; +var \u{16872}; +var \u{16873}; +var \u{16874}; +var \u{16875}; +var \u{16876}; +var \u{16877}; +var \u{16878}; +var \u{16879}; +var \u{1687A}; +var \u{1687B}; +var \u{1687C}; +var \u{1687D}; +var \u{1687E}; +var \u{1687F}; +var \u{16880}; +var \u{16881}; +var \u{16882}; +var \u{16883}; +var \u{16884}; +var \u{16885}; +var \u{16886}; +var \u{16887}; +var \u{16888}; +var \u{16889}; +var \u{1688A}; +var \u{1688B}; +var \u{1688C}; +var \u{1688D}; +var \u{1688E}; +var \u{1688F}; +var \u{16890}; +var \u{16891}; +var \u{16892}; +var \u{16893}; +var \u{16894}; +var \u{16895}; +var \u{16896}; +var \u{16897}; +var \u{16898}; +var \u{16899}; +var \u{1689A}; +var \u{1689B}; +var \u{1689C}; +var \u{1689D}; +var \u{1689E}; +var \u{1689F}; +var \u{168A0}; +var \u{168A1}; +var \u{168A2}; +var \u{168A3}; +var \u{168A4}; +var \u{168A5}; +var \u{168A6}; +var \u{168A7}; +var \u{168A8}; +var \u{168A9}; +var \u{168AA}; +var \u{168AB}; +var \u{168AC}; +var \u{168AD}; +var \u{168AE}; +var \u{168AF}; +var \u{168B0}; +var \u{168B1}; +var \u{168B2}; +var \u{168B3}; +var \u{168B4}; +var \u{168B5}; +var \u{168B6}; +var \u{168B7}; +var \u{168B8}; +var \u{168B9}; +var \u{168BA}; +var \u{168BB}; +var \u{168BC}; +var \u{168BD}; +var \u{168BE}; +var \u{168BF}; +var \u{168C0}; +var \u{168C1}; +var \u{168C2}; +var \u{168C3}; +var \u{168C4}; +var \u{168C5}; +var \u{168C6}; +var \u{168C7}; +var \u{168C8}; +var \u{168C9}; +var \u{168CA}; +var \u{168CB}; +var \u{168CC}; +var \u{168CD}; +var \u{168CE}; +var \u{168CF}; +var \u{168D0}; +var \u{168D1}; +var \u{168D2}; +var \u{168D3}; +var \u{168D4}; +var \u{168D5}; +var \u{168D6}; +var \u{168D7}; +var \u{168D8}; +var \u{168D9}; +var \u{168DA}; +var \u{168DB}; +var \u{168DC}; +var \u{168DD}; +var \u{168DE}; +var \u{168DF}; +var \u{168E0}; +var \u{168E1}; +var \u{168E2}; +var \u{168E3}; +var \u{168E4}; +var \u{168E5}; +var \u{168E6}; +var \u{168E7}; +var \u{168E8}; +var \u{168E9}; +var \u{168EA}; +var \u{168EB}; +var \u{168EC}; +var \u{168ED}; +var \u{168EE}; +var \u{168EF}; +var \u{168F0}; +var \u{168F1}; +var \u{168F2}; +var \u{168F3}; +var \u{168F4}; +var \u{168F5}; +var \u{168F6}; +var \u{168F7}; +var \u{168F8}; +var \u{168F9}; +var \u{168FA}; +var \u{168FB}; +var \u{168FC}; +var \u{168FD}; +var \u{168FE}; +var \u{168FF}; +var \u{16900}; +var \u{16901}; +var \u{16902}; +var \u{16903}; +var \u{16904}; +var \u{16905}; +var \u{16906}; +var \u{16907}; +var \u{16908}; +var \u{16909}; +var \u{1690A}; +var \u{1690B}; +var \u{1690C}; +var \u{1690D}; +var \u{1690E}; +var \u{1690F}; +var \u{16910}; +var \u{16911}; +var \u{16912}; +var \u{16913}; +var \u{16914}; +var \u{16915}; +var \u{16916}; +var \u{16917}; +var \u{16918}; +var \u{16919}; +var \u{1691A}; +var \u{1691B}; +var \u{1691C}; +var \u{1691D}; +var \u{1691E}; +var \u{1691F}; +var \u{16920}; +var \u{16921}; +var \u{16922}; +var \u{16923}; +var \u{16924}; +var \u{16925}; +var \u{16926}; +var \u{16927}; +var \u{16928}; +var \u{16929}; +var \u{1692A}; +var \u{1692B}; +var \u{1692C}; +var \u{1692D}; +var \u{1692E}; +var \u{1692F}; +var \u{16930}; +var \u{16931}; +var \u{16932}; +var \u{16933}; +var \u{16934}; +var \u{16935}; +var \u{16936}; +var \u{16937}; +var \u{16938}; +var \u{16939}; +var \u{1693A}; +var \u{1693B}; +var \u{1693C}; +var \u{1693D}; +var \u{1693E}; +var \u{1693F}; +var \u{16940}; +var \u{16941}; +var \u{16942}; +var \u{16943}; +var \u{16944}; +var \u{16945}; +var \u{16946}; +var \u{16947}; +var \u{16948}; +var \u{16949}; +var \u{1694A}; +var \u{1694B}; +var \u{1694C}; +var \u{1694D}; +var \u{1694E}; +var \u{1694F}; +var \u{16950}; +var \u{16951}; +var \u{16952}; +var \u{16953}; +var \u{16954}; +var \u{16955}; +var \u{16956}; +var \u{16957}; +var \u{16958}; +var \u{16959}; +var \u{1695A}; +var \u{1695B}; +var \u{1695C}; +var \u{1695D}; +var \u{1695E}; +var \u{1695F}; +var \u{16960}; +var \u{16961}; +var \u{16962}; +var \u{16963}; +var \u{16964}; +var \u{16965}; +var \u{16966}; +var \u{16967}; +var \u{16968}; +var \u{16969}; +var \u{1696A}; +var \u{1696B}; +var \u{1696C}; +var \u{1696D}; +var \u{1696E}; +var \u{1696F}; +var \u{16970}; +var \u{16971}; +var \u{16972}; +var \u{16973}; +var \u{16974}; +var \u{16975}; +var \u{16976}; +var \u{16977}; +var \u{16978}; +var \u{16979}; +var \u{1697A}; +var \u{1697B}; +var \u{1697C}; +var \u{1697D}; +var \u{1697E}; +var \u{1697F}; +var \u{16980}; +var \u{16981}; +var \u{16982}; +var \u{16983}; +var \u{16984}; +var \u{16985}; +var \u{16986}; +var \u{16987}; +var \u{16988}; +var \u{16989}; +var \u{1698A}; +var \u{1698B}; +var \u{1698C}; +var \u{1698D}; +var \u{1698E}; +var \u{1698F}; +var \u{16990}; +var \u{16991}; +var \u{16992}; +var \u{16993}; +var \u{16994}; +var \u{16995}; +var \u{16996}; +var \u{16997}; +var \u{16998}; +var \u{16999}; +var \u{1699A}; +var \u{1699B}; +var \u{1699C}; +var \u{1699D}; +var \u{1699E}; +var \u{1699F}; +var \u{169A0}; +var \u{169A1}; +var \u{169A2}; +var \u{169A3}; +var \u{169A4}; +var \u{169A5}; +var \u{169A6}; +var \u{169A7}; +var \u{169A8}; +var \u{169A9}; +var \u{169AA}; +var \u{169AB}; +var \u{169AC}; +var \u{169AD}; +var \u{169AE}; +var \u{169AF}; +var \u{169B0}; +var \u{169B1}; +var \u{169B2}; +var \u{169B3}; +var \u{169B4}; +var \u{169B5}; +var \u{169B6}; +var \u{169B7}; +var \u{169B8}; +var \u{169B9}; +var \u{169BA}; +var \u{169BB}; +var \u{169BC}; +var \u{169BD}; +var \u{169BE}; +var \u{169BF}; +var \u{169C0}; +var \u{169C1}; +var \u{169C2}; +var \u{169C3}; +var \u{169C4}; +var \u{169C5}; +var \u{169C6}; +var \u{169C7}; +var \u{169C8}; +var \u{169C9}; +var \u{169CA}; +var \u{169CB}; +var \u{169CC}; +var \u{169CD}; +var \u{169CE}; +var \u{169CF}; +var \u{169D0}; +var \u{169D1}; +var \u{169D2}; +var \u{169D3}; +var \u{169D4}; +var \u{169D5}; +var \u{169D6}; +var \u{169D7}; +var \u{169D8}; +var \u{169D9}; +var \u{169DA}; +var \u{169DB}; +var \u{169DC}; +var \u{169DD}; +var \u{169DE}; +var \u{169DF}; +var \u{169E0}; +var \u{169E1}; +var \u{169E2}; +var \u{169E3}; +var \u{169E4}; +var \u{169E5}; +var \u{169E6}; +var \u{169E7}; +var \u{169E8}; +var \u{169E9}; +var \u{169EA}; +var \u{169EB}; +var \u{169EC}; +var \u{169ED}; +var \u{169EE}; +var \u{169EF}; +var \u{169F0}; +var \u{169F1}; +var \u{169F2}; +var \u{169F3}; +var \u{169F4}; +var \u{169F5}; +var \u{169F6}; +var \u{169F7}; +var \u{169F8}; +var \u{169F9}; +var \u{169FA}; +var \u{169FB}; +var \u{169FC}; +var \u{169FD}; +var \u{169FE}; +var \u{169FF}; +var \u{16A00}; +var \u{16A01}; +var \u{16A02}; +var \u{16A03}; +var \u{16A04}; +var \u{16A05}; +var \u{16A06}; +var \u{16A07}; +var \u{16A08}; +var \u{16A09}; +var \u{16A0A}; +var \u{16A0B}; +var \u{16A0C}; +var \u{16A0D}; +var \u{16A0E}; +var \u{16A0F}; +var \u{16A10}; +var \u{16A11}; +var \u{16A12}; +var \u{16A13}; +var \u{16A14}; +var \u{16A15}; +var \u{16A16}; +var \u{16A17}; +var \u{16A18}; +var \u{16A19}; +var \u{16A1A}; +var \u{16A1B}; +var \u{16A1C}; +var \u{16A1D}; +var \u{16A1E}; +var \u{16A1F}; +var \u{16A20}; +var \u{16A21}; +var \u{16A22}; +var \u{16A23}; +var \u{16A24}; +var \u{16A25}; +var \u{16A26}; +var \u{16A27}; +var \u{16A28}; +var \u{16A29}; +var \u{16A2A}; +var \u{16A2B}; +var \u{16A2C}; +var \u{16A2D}; +var \u{16A2E}; +var \u{16A2F}; +var \u{16A30}; +var \u{16A31}; +var \u{16A32}; +var \u{16A33}; +var \u{16A34}; +var \u{16A35}; +var \u{16A36}; +var \u{16A37}; +var \u{16A38}; +var \u{1B000}; +var \u{1B001}; +var \u{2B740}; +var \u{2B741}; +var \u{2B742}; +var \u{2B743}; +var \u{2B744}; +var \u{2B745}; +var \u{2B746}; +var \u{2B747}; +var \u{2B748}; +var \u{2B749}; +var \u{2B74A}; +var \u{2B74B}; +var \u{2B74C}; +var \u{2B74D}; +var \u{2B74E}; +var \u{2B74F}; +var \u{2B750}; +var \u{2B751}; +var \u{2B752}; +var \u{2B753}; +var \u{2B754}; +var \u{2B755}; +var \u{2B756}; +var \u{2B757}; +var \u{2B758}; +var \u{2B759}; +var \u{2B75A}; +var \u{2B75B}; +var \u{2B75C}; +var \u{2B75D}; +var \u{2B75E}; +var \u{2B75F}; +var \u{2B760}; +var \u{2B761}; +var \u{2B762}; +var \u{2B763}; +var \u{2B764}; +var \u{2B765}; +var \u{2B766}; +var \u{2B767}; +var \u{2B768}; +var \u{2B769}; +var \u{2B76A}; +var \u{2B76B}; +var \u{2B76C}; +var \u{2B76D}; +var \u{2B76E}; +var \u{2B76F}; +var \u{2B770}; +var \u{2B771}; +var \u{2B772}; +var \u{2B773}; +var \u{2B774}; +var \u{2B775}; +var \u{2B776}; +var \u{2B777}; +var \u{2B778}; +var \u{2B779}; +var \u{2B77A}; +var \u{2B77B}; +var \u{2B77C}; +var \u{2B77D}; +var \u{2B77E}; +var \u{2B77F}; +var \u{2B780}; +var \u{2B781}; +var \u{2B782}; +var \u{2B783}; +var \u{2B784}; +var \u{2B785}; +var \u{2B786}; +var \u{2B787}; +var \u{2B788}; +var \u{2B789}; +var \u{2B78A}; +var \u{2B78B}; +var \u{2B78C}; +var \u{2B78D}; +var \u{2B78E}; +var \u{2B78F}; +var \u{2B790}; +var \u{2B791}; +var \u{2B792}; +var \u{2B793}; +var \u{2B794}; +var \u{2B795}; +var \u{2B796}; +var \u{2B797}; +var \u{2B798}; +var \u{2B799}; +var \u{2B79A}; +var \u{2B79B}; +var \u{2B79C}; +var \u{2B79D}; +var \u{2B79E}; +var \u{2B79F}; +var \u{2B7A0}; +var \u{2B7A1}; +var \u{2B7A2}; +var \u{2B7A3}; +var \u{2B7A4}; +var \u{2B7A5}; +var \u{2B7A6}; +var \u{2B7A7}; +var \u{2B7A8}; +var \u{2B7A9}; +var \u{2B7AA}; +var \u{2B7AB}; +var \u{2B7AC}; +var \u{2B7AD}; +var \u{2B7AE}; +var \u{2B7AF}; +var \u{2B7B0}; +var \u{2B7B1}; +var \u{2B7B2}; +var \u{2B7B3}; +var \u{2B7B4}; +var \u{2B7B5}; +var \u{2B7B6}; +var \u{2B7B7}; +var \u{2B7B8}; +var \u{2B7B9}; +var \u{2B7BA}; +var \u{2B7BB}; +var \u{2B7BC}; +var \u{2B7BD}; +var \u{2B7BE}; +var \u{2B7BF}; +var \u{2B7C0}; +var \u{2B7C1}; +var \u{2B7C2}; +var \u{2B7C3}; +var \u{2B7C4}; +var \u{2B7C5}; +var \u{2B7C6}; +var \u{2B7C7}; +var \u{2B7C8}; +var \u{2B7C9}; +var \u{2B7CA}; +var \u{2B7CB}; +var \u{2B7CC}; +var \u{2B7CD}; +var \u{2B7CE}; +var \u{2B7CF}; +var \u{2B7D0}; +var \u{2B7D1}; +var \u{2B7D2}; +var \u{2B7D3}; +var \u{2B7D4}; +var \u{2B7D5}; +var \u{2B7D6}; +var \u{2B7D7}; +var \u{2B7D8}; +var \u{2B7D9}; +var \u{2B7DA}; +var \u{2B7DB}; +var \u{2B7DC}; +var \u{2B7DD}; +var \u{2B7DE}; +var \u{2B7DF}; +var \u{2B7E0}; +var \u{2B7E1}; +var \u{2B7E2}; +var \u{2B7E3}; +var \u{2B7E4}; +var \u{2B7E5}; +var \u{2B7E6}; +var \u{2B7E7}; +var \u{2B7E8}; +var \u{2B7E9}; +var \u{2B7EA}; +var \u{2B7EB}; +var \u{2B7EC}; +var \u{2B7ED}; +var \u{2B7EE}; +var \u{2B7EF}; +var \u{2B7F0}; +var \u{2B7F1}; +var \u{2B7F2}; +var \u{2B7F3}; +var \u{2B7F4}; +var \u{2B7F5}; +var \u{2B7F6}; +var \u{2B7F7}; +var \u{2B7F8}; +var \u{2B7F9}; +var \u{2B7FA}; +var \u{2B7FB}; +var \u{2B7FC}; +var \u{2B7FD}; +var \u{2B7FE}; +var \u{2B7FF}; +var \u{2B800}; +var \u{2B801}; +var \u{2B802}; +var \u{2B803}; +var \u{2B804}; +var \u{2B805}; +var \u{2B806}; +var \u{2B807}; +var \u{2B808}; +var \u{2B809}; +var \u{2B80A}; +var \u{2B80B}; +var \u{2B80C}; +var \u{2B80D}; +var \u{2B80E}; +var \u{2B80F}; +var \u{2B810}; +var \u{2B811}; +var \u{2B812}; +var \u{2B813}; +var \u{2B814}; +var \u{2B815}; +var \u{2B816}; +var \u{2B817}; +var \u{2B818}; +var \u{2B819}; +var \u{2B81A}; +var \u{2B81B}; +var \u{2B81C}; +var \u{2B81D}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0.js new file mode 100644 index 000000000..325b29c75 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.0.0.js @@ -0,0 +1,996 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v6.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var Ԧ; +var ԧ; +var ؠ; +var ࡀ; +var ࡁ; +var ࡂ; +var ࡃ; +var ࡄ; +var ࡅ; +var ࡆ; +var ࡇ; +var ࡈ; +var ࡉ; +var ࡊ; +var ࡋ; +var ࡌ; +var ࡍ; +var ࡎ; +var ࡏ; +var ࡐ; +var ࡑ; +var ࡒ; +var ࡓ; +var ࡔ; +var ࡕ; +var ࡖ; +var ࡗ; +var ࡘ; +var ॳ; +var ॴ; +var ॵ; +var ॶ; +var ॷ; +var ೱ; +var ೲ; +var ഩ; +var ഺ; +var ൎ; +var ྌ; +var ᯀ; +var ᯁ; +var ᯂ; +var ᯃ; +var ᯄ; +var ᯅ; +var ᯆ; +var ᯇ; +var ᯈ; +var ᯉ; +var ᯊ; +var ᯋ; +var ᯌ; +var ᯍ; +var ᯎ; +var ᯏ; +var ᯐ; +var ᯑ; +var ᯒ; +var ᯓ; +var ᯔ; +var ᯕ; +var ᯖ; +var ᯗ; +var ᯘ; +var ᯙ; +var ᯚ; +var ᯛ; +var ᯜ; +var ᯝ; +var ᯞ; +var ᯟ; +var ᯠ; +var ᯡ; +var ᯢ; +var ᯣ; +var ᯤ; +var ᯥ; +var ₕ; +var ₖ; +var ₗ; +var ₘ; +var ₙ; +var ₚ; +var ₛ; +var ₜ; +var ㆸ; +var ㆹ; +var ㆺ; +var Ꙡ; +var ꙡ; +var Ɥ; +var ꞎ; +var Ꞑ; +var ꞑ; +var Ꞡ; +var ꞡ; +var Ꞣ; +var ꞣ; +var Ꞥ; +var ꞥ; +var Ꞧ; +var ꞧ; +var Ꞩ; +var ꞩ; +var ꟺ; +var ꬁ; +var ꬂ; +var ꬃ; +var ꬄ; +var ꬅ; +var ꬆ; +var ꬉ; +var ꬊ; +var ꬋ; +var ꬌ; +var ꬍ; +var ꬎ; +var ꬑ; +var ꬒ; +var ꬓ; +var ꬔ; +var ꬕ; +var ꬖ; +var ꬠ; +var ꬡ; +var ꬢ; +var ꬣ; +var ꬤ; +var ꬥ; +var ꬦ; +var ꬨ; +var ꬩ; +var ꬪ; +var ꬫ; +var ꬬ; +var ꬭ; +var ꬮ; +var 𑀃; +var 𑀄; +var 𑀅; +var 𑀆; +var 𑀇; +var 𑀈; +var 𑀉; +var 𑀊; +var 𑀋; +var 𑀌; +var 𑀍; +var 𑀎; +var 𑀏; +var 𑀐; +var 𑀑; +var 𑀒; +var 𑀓; +var 𑀔; +var 𑀕; +var 𑀖; +var 𑀗; +var 𑀘; +var 𑀙; +var 𑀚; +var 𑀛; +var 𑀜; +var 𑀝; +var 𑀞; +var 𑀟; +var 𑀠; +var 𑀡; +var 𑀢; +var 𑀣; +var 𑀤; +var 𑀥; +var 𑀦; +var 𑀧; +var 𑀨; +var 𑀩; +var 𑀪; +var 𑀫; +var 𑀬; +var 𑀭; +var 𑀮; +var 𑀯; +var 𑀰; +var 𑀱; +var 𑀲; +var 𑀳; +var 𑀴; +var 𑀵; +var 𑀶; +var 𑀷; +var 𖠀; +var 𖠁; +var 𖠂; +var 𖠃; +var 𖠄; +var 𖠅; +var 𖠆; +var 𖠇; +var 𖠈; +var 𖠉; +var 𖠊; +var 𖠋; +var 𖠌; +var 𖠍; +var 𖠎; +var 𖠏; +var 𖠐; +var 𖠑; +var 𖠒; +var 𖠓; +var 𖠔; +var 𖠕; +var 𖠖; +var 𖠗; +var 𖠘; +var 𖠙; +var 𖠚; +var 𖠛; +var 𖠜; +var 𖠝; +var 𖠞; +var 𖠟; +var 𖠠; +var 𖠡; +var 𖠢; +var 𖠣; +var 𖠤; +var 𖠥; +var 𖠦; +var 𖠧; +var 𖠨; +var 𖠩; +var 𖠪; +var 𖠫; +var 𖠬; +var 𖠭; +var 𖠮; +var 𖠯; +var 𖠰; +var 𖠱; +var 𖠲; +var 𖠳; +var 𖠴; +var 𖠵; +var 𖠶; +var 𖠷; +var 𖠸; +var 𖠹; +var 𖠺; +var 𖠻; +var 𖠼; +var 𖠽; +var 𖠾; +var 𖠿; +var 𖡀; +var 𖡁; +var 𖡂; +var 𖡃; +var 𖡄; +var 𖡅; +var 𖡆; +var 𖡇; +var 𖡈; +var 𖡉; +var 𖡊; +var 𖡋; +var 𖡌; +var 𖡍; +var 𖡎; +var 𖡏; +var 𖡐; +var 𖡑; +var 𖡒; +var 𖡓; +var 𖡔; +var 𖡕; +var 𖡖; +var 𖡗; +var 𖡘; +var 𖡙; +var 𖡚; +var 𖡛; +var 𖡜; +var 𖡝; +var 𖡞; +var 𖡟; +var 𖡠; +var 𖡡; +var 𖡢; +var 𖡣; +var 𖡤; +var 𖡥; +var 𖡦; +var 𖡧; +var 𖡨; +var 𖡩; +var 𖡪; +var 𖡫; +var 𖡬; +var 𖡭; +var 𖡮; +var 𖡯; +var 𖡰; +var 𖡱; +var 𖡲; +var 𖡳; +var 𖡴; +var 𖡵; +var 𖡶; +var 𖡷; +var 𖡸; +var 𖡹; +var 𖡺; +var 𖡻; +var 𖡼; +var 𖡽; +var 𖡾; +var 𖡿; +var 𖢀; +var 𖢁; +var 𖢂; +var 𖢃; +var 𖢄; +var 𖢅; +var 𖢆; +var 𖢇; +var 𖢈; +var 𖢉; +var 𖢊; +var 𖢋; +var 𖢌; +var 𖢍; +var 𖢎; +var 𖢏; +var 𖢐; +var 𖢑; +var 𖢒; +var 𖢓; +var 𖢔; +var 𖢕; +var 𖢖; +var 𖢗; +var 𖢘; +var 𖢙; +var 𖢚; +var 𖢛; +var 𖢜; +var 𖢝; +var 𖢞; +var 𖢟; +var 𖢠; +var 𖢡; +var 𖢢; +var 𖢣; +var 𖢤; +var 𖢥; +var 𖢦; +var 𖢧; +var 𖢨; +var 𖢩; +var 𖢪; +var 𖢫; +var 𖢬; +var 𖢭; +var 𖢮; +var 𖢯; +var 𖢰; +var 𖢱; +var 𖢲; +var 𖢳; +var 𖢴; +var 𖢵; +var 𖢶; +var 𖢷; +var 𖢸; +var 𖢹; +var 𖢺; +var 𖢻; +var 𖢼; +var 𖢽; +var 𖢾; +var 𖢿; +var 𖣀; +var 𖣁; +var 𖣂; +var 𖣃; +var 𖣄; +var 𖣅; +var 𖣆; +var 𖣇; +var 𖣈; +var 𖣉; +var 𖣊; +var 𖣋; +var 𖣌; +var 𖣍; +var 𖣎; +var 𖣏; +var 𖣐; +var 𖣑; +var 𖣒; +var 𖣓; +var 𖣔; +var 𖣕; +var 𖣖; +var 𖣗; +var 𖣘; +var 𖣙; +var 𖣚; +var 𖣛; +var 𖣜; +var 𖣝; +var 𖣞; +var 𖣟; +var 𖣠; +var 𖣡; +var 𖣢; +var 𖣣; +var 𖣤; +var 𖣥; +var 𖣦; +var 𖣧; +var 𖣨; +var 𖣩; +var 𖣪; +var 𖣫; +var 𖣬; +var 𖣭; +var 𖣮; +var 𖣯; +var 𖣰; +var 𖣱; +var 𖣲; +var 𖣳; +var 𖣴; +var 𖣵; +var 𖣶; +var 𖣷; +var 𖣸; +var 𖣹; +var 𖣺; +var 𖣻; +var 𖣼; +var 𖣽; +var 𖣾; +var 𖣿; +var 𖤀; +var 𖤁; +var 𖤂; +var 𖤃; +var 𖤄; +var 𖤅; +var 𖤆; +var 𖤇; +var 𖤈; +var 𖤉; +var 𖤊; +var 𖤋; +var 𖤌; +var 𖤍; +var 𖤎; +var 𖤏; +var 𖤐; +var 𖤑; +var 𖤒; +var 𖤓; +var 𖤔; +var 𖤕; +var 𖤖; +var 𖤗; +var 𖤘; +var 𖤙; +var 𖤚; +var 𖤛; +var 𖤜; +var 𖤝; +var 𖤞; +var 𖤟; +var 𖤠; +var 𖤡; +var 𖤢; +var 𖤣; +var 𖤤; +var 𖤥; +var 𖤦; +var 𖤧; +var 𖤨; +var 𖤩; +var 𖤪; +var 𖤫; +var 𖤬; +var 𖤭; +var 𖤮; +var 𖤯; +var 𖤰; +var 𖤱; +var 𖤲; +var 𖤳; +var 𖤴; +var 𖤵; +var 𖤶; +var 𖤷; +var 𖤸; +var 𖤹; +var 𖤺; +var 𖤻; +var 𖤼; +var 𖤽; +var 𖤾; +var 𖤿; +var 𖥀; +var 𖥁; +var 𖥂; +var 𖥃; +var 𖥄; +var 𖥅; +var 𖥆; +var 𖥇; +var 𖥈; +var 𖥉; +var 𖥊; +var 𖥋; +var 𖥌; +var 𖥍; +var 𖥎; +var 𖥏; +var 𖥐; +var 𖥑; +var 𖥒; +var 𖥓; +var 𖥔; +var 𖥕; +var 𖥖; +var 𖥗; +var 𖥘; +var 𖥙; +var 𖥚; +var 𖥛; +var 𖥜; +var 𖥝; +var 𖥞; +var 𖥟; +var 𖥠; +var 𖥡; +var 𖥢; +var 𖥣; +var 𖥤; +var 𖥥; +var 𖥦; +var 𖥧; +var 𖥨; +var 𖥩; +var 𖥪; +var 𖥫; +var 𖥬; +var 𖥭; +var 𖥮; +var 𖥯; +var 𖥰; +var 𖥱; +var 𖥲; +var 𖥳; +var 𖥴; +var 𖥵; +var 𖥶; +var 𖥷; +var 𖥸; +var 𖥹; +var 𖥺; +var 𖥻; +var 𖥼; +var 𖥽; +var 𖥾; +var 𖥿; +var 𖦀; +var 𖦁; +var 𖦂; +var 𖦃; +var 𖦄; +var 𖦅; +var 𖦆; +var 𖦇; +var 𖦈; +var 𖦉; +var 𖦊; +var 𖦋; +var 𖦌; +var 𖦍; +var 𖦎; +var 𖦏; +var 𖦐; +var 𖦑; +var 𖦒; +var 𖦓; +var 𖦔; +var 𖦕; +var 𖦖; +var 𖦗; +var 𖦘; +var 𖦙; +var 𖦚; +var 𖦛; +var 𖦜; +var 𖦝; +var 𖦞; +var 𖦟; +var 𖦠; +var 𖦡; +var 𖦢; +var 𖦣; +var 𖦤; +var 𖦥; +var 𖦦; +var 𖦧; +var 𖦨; +var 𖦩; +var 𖦪; +var 𖦫; +var 𖦬; +var 𖦭; +var 𖦮; +var 𖦯; +var 𖦰; +var 𖦱; +var 𖦲; +var 𖦳; +var 𖦴; +var 𖦵; +var 𖦶; +var 𖦷; +var 𖦸; +var 𖦹; +var 𖦺; +var 𖦻; +var 𖦼; +var 𖦽; +var 𖦾; +var 𖦿; +var 𖧀; +var 𖧁; +var 𖧂; +var 𖧃; +var 𖧄; +var 𖧅; +var 𖧆; +var 𖧇; +var 𖧈; +var 𖧉; +var 𖧊; +var 𖧋; +var 𖧌; +var 𖧍; +var 𖧎; +var 𖧏; +var 𖧐; +var 𖧑; +var 𖧒; +var 𖧓; +var 𖧔; +var 𖧕; +var 𖧖; +var 𖧗; +var 𖧘; +var 𖧙; +var 𖧚; +var 𖧛; +var 𖧜; +var 𖧝; +var 𖧞; +var 𖧟; +var 𖧠; +var 𖧡; +var 𖧢; +var 𖧣; +var 𖧤; +var 𖧥; +var 𖧦; +var 𖧧; +var 𖧨; +var 𖧩; +var 𖧪; +var 𖧫; +var 𖧬; +var 𖧭; +var 𖧮; +var 𖧯; +var 𖧰; +var 𖧱; +var 𖧲; +var 𖧳; +var 𖧴; +var 𖧵; +var 𖧶; +var 𖧷; +var 𖧸; +var 𖧹; +var 𖧺; +var 𖧻; +var 𖧼; +var 𖧽; +var 𖧾; +var 𖧿; +var 𖨀; +var 𖨁; +var 𖨂; +var 𖨃; +var 𖨄; +var 𖨅; +var 𖨆; +var 𖨇; +var 𖨈; +var 𖨉; +var 𖨊; +var 𖨋; +var 𖨌; +var 𖨍; +var 𖨎; +var 𖨏; +var 𖨐; +var 𖨑; +var 𖨒; +var 𖨓; +var 𖨔; +var 𖨕; +var 𖨖; +var 𖨗; +var 𖨘; +var 𖨙; +var 𖨚; +var 𖨛; +var 𖨜; +var 𖨝; +var 𖨞; +var 𖨟; +var 𖨠; +var 𖨡; +var 𖨢; +var 𖨣; +var 𖨤; +var 𖨥; +var 𖨦; +var 𖨧; +var 𖨨; +var 𖨩; +var 𖨪; +var 𖨫; +var 𖨬; +var 𖨭; +var 𖨮; +var 𖨯; +var 𖨰; +var 𖨱; +var 𖨲; +var 𖨳; +var 𖨴; +var 𖨵; +var 𖨶; +var 𖨷; +var 𖨸; +var 𛀀; +var 𛀁; +var 𫝀; +var 𫝁; +var 𫝂; +var 𫝃; +var 𫝄; +var 𫝅; +var 𫝆; +var 𫝇; +var 𫝈; +var 𫝉; +var 𫝊; +var 𫝋; +var 𫝌; +var 𫝍; +var 𫝎; +var 𫝏; +var 𫝐; +var 𫝑; +var 𫝒; +var 𫝓; +var 𫝔; +var 𫝕; +var 𫝖; +var 𫝗; +var 𫝘; +var 𫝙; +var 𫝚; +var 𫝛; +var 𫝜; +var 𫝝; +var 𫝞; +var 𫝟; +var 𫝠; +var 𫝡; +var 𫝢; +var 𫝣; +var 𫝤; +var 𫝥; +var 𫝦; +var 𫝧; +var 𫝨; +var 𫝩; +var 𫝪; +var 𫝫; +var 𫝬; +var 𫝭; +var 𫝮; +var 𫝯; +var 𫝰; +var 𫝱; +var 𫝲; +var 𫝳; +var 𫝴; +var 𫝵; +var 𫝶; +var 𫝷; +var 𫝸; +var 𫝹; +var 𫝺; +var 𫝻; +var 𫝼; +var 𫝽; +var 𫝾; +var 𫝿; +var 𫞀; +var 𫞁; +var 𫞂; +var 𫞃; +var 𫞄; +var 𫞅; +var 𫞆; +var 𫞇; +var 𫞈; +var 𫞉; +var 𫞊; +var 𫞋; +var 𫞌; +var 𫞍; +var 𫞎; +var 𫞏; +var 𫞐; +var 𫞑; +var 𫞒; +var 𫞓; +var 𫞔; +var 𫞕; +var 𫞖; +var 𫞗; +var 𫞘; +var 𫞙; +var 𫞚; +var 𫞛; +var 𫞜; +var 𫞝; +var 𫞞; +var 𫞟; +var 𫞠; +var 𫞡; +var 𫞢; +var 𫞣; +var 𫞤; +var 𫞥; +var 𫞦; +var 𫞧; +var 𫞨; +var 𫞩; +var 𫞪; +var 𫞫; +var 𫞬; +var 𫞭; +var 𫞮; +var 𫞯; +var 𫞰; +var 𫞱; +var 𫞲; +var 𫞳; +var 𫞴; +var 𫞵; +var 𫞶; +var 𫞷; +var 𫞸; +var 𫞹; +var 𫞺; +var 𫞻; +var 𫞼; +var 𫞽; +var 𫞾; +var 𫞿; +var 𫟀; +var 𫟁; +var 𫟂; +var 𫟃; +var 𫟄; +var 𫟅; +var 𫟆; +var 𫟇; +var 𫟈; +var 𫟉; +var 𫟊; +var 𫟋; +var 𫟌; +var 𫟍; +var 𫟎; +var 𫟏; +var 𫟐; +var 𫟑; +var 𫟒; +var 𫟓; +var 𫟔; +var 𫟕; +var 𫟖; +var 𫟗; +var 𫟘; +var 𫟙; +var 𫟚; +var 𫟛; +var 𫟜; +var 𫟝; +var 𫟞; +var 𫟟; +var 𫟠; +var 𫟡; +var 𫟢; +var 𫟣; +var 𫟤; +var 𫟥; +var 𫟦; +var 𫟧; +var 𫟨; +var 𫟩; +var 𫟪; +var 𫟫; +var 𫟬; +var 𫟭; +var 𫟮; +var 𫟯; +var 𫟰; +var 𫟱; +var 𫟲; +var 𫟳; +var 𫟴; +var 𫟵; +var 𫟶; +var 𫟷; +var 𫟸; +var 𫟹; +var 𫟺; +var 𫟻; +var 𫟼; +var 𫟽; +var 𫟾; +var 𫟿; +var 𫠀; +var 𫠁; +var 𫠂; +var 𫠃; +var 𫠄; +var 𫠅; +var 𫠆; +var 𫠇; +var 𫠈; +var 𫠉; +var 𫠊; +var 𫠋; +var 𫠌; +var 𫠍; +var 𫠎; +var 𫠏; +var 𫠐; +var 𫠑; +var 𫠒; +var 𫠓; +var 𫠔; +var 𫠕; +var 𫠖; +var 𫠗; +var 𫠘; +var 𫠙; +var 𫠚; +var 𫠛; +var 𫠜; +var 𫠝; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0-class-escaped.js new file mode 100644 index 000000000..121de0607 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0-class-escaped.js @@ -0,0 +1,512 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v6.1.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u08A0; + #\u08A2; + #\u08A3; + #\u08A4; + #\u08A5; + #\u08A6; + #\u08A7; + #\u08A8; + #\u08A9; + #\u08AA; + #\u08AB; + #\u08AC; + #\u0EDE; + #\u0EDF; + #\u10C7; + #\u10CD; + #\u10FD; + #\u10FE; + #\u10FF; + #\u1BBA; + #\u1BBB; + #\u1BBC; + #\u1BBD; + #\u1BBE; + #\u1BBF; + #\u1CF5; + #\u1CF6; + #\u2CF2; + #\u2CF3; + #\u2D27; + #\u2D2D; + #\u2D66; + #\u2D67; + #\u9FCC; + #\uA792; + #\uA793; + #\uA7AA; + #\uA7F8; + #\uA7F9; + #\uAAE0; + #\uAAE1; + #\uAAE2; + #\uAAE3; + #\uAAE4; + #\uAAE5; + #\uAAE6; + #\uAAE7; + #\uAAE8; + #\uAAE9; + #\uAAEA; + #\uAAF2; + #\uAAF3; + #\uAAF4; + #\uFA2E; + #\uFA2F; + #\u{10980}; + #\u{10981}; + #\u{10982}; + #\u{10983}; + #\u{10984}; + #\u{10985}; + #\u{10986}; + #\u{10987}; + #\u{10988}; + #\u{10989}; + #\u{1098A}; + #\u{1098B}; + #\u{1098C}; + #\u{1098D}; + #\u{1098E}; + #\u{1098F}; + #\u{10990}; + #\u{10991}; + #\u{10992}; + #\u{10993}; + #\u{10994}; + #\u{10995}; + #\u{10996}; + #\u{10997}; + #\u{10998}; + #\u{10999}; + #\u{1099A}; + #\u{1099B}; + #\u{1099C}; + #\u{1099D}; + #\u{1099E}; + #\u{1099F}; + #\u{109A0}; + #\u{109A1}; + #\u{109A2}; + #\u{109A3}; + #\u{109A4}; + #\u{109A5}; + #\u{109A6}; + #\u{109A7}; + #\u{109A8}; + #\u{109A9}; + #\u{109AA}; + #\u{109AB}; + #\u{109AC}; + #\u{109AD}; + #\u{109AE}; + #\u{109AF}; + #\u{109B0}; + #\u{109B1}; + #\u{109B2}; + #\u{109B3}; + #\u{109B4}; + #\u{109B5}; + #\u{109B6}; + #\u{109B7}; + #\u{109BE}; + #\u{109BF}; + #\u{110D0}; + #\u{110D1}; + #\u{110D2}; + #\u{110D3}; + #\u{110D4}; + #\u{110D5}; + #\u{110D6}; + #\u{110D7}; + #\u{110D8}; + #\u{110D9}; + #\u{110DA}; + #\u{110DB}; + #\u{110DC}; + #\u{110DD}; + #\u{110DE}; + #\u{110DF}; + #\u{110E0}; + #\u{110E1}; + #\u{110E2}; + #\u{110E3}; + #\u{110E4}; + #\u{110E5}; + #\u{110E6}; + #\u{110E7}; + #\u{110E8}; + #\u{11103}; + #\u{11104}; + #\u{11105}; + #\u{11106}; + #\u{11107}; + #\u{11108}; + #\u{11109}; + #\u{1110A}; + #\u{1110B}; + #\u{1110C}; + #\u{1110D}; + #\u{1110E}; + #\u{1110F}; + #\u{11110}; + #\u{11111}; + #\u{11112}; + #\u{11113}; + #\u{11114}; + #\u{11115}; + #\u{11116}; + #\u{11117}; + #\u{11118}; + #\u{11119}; + #\u{1111A}; + #\u{1111B}; + #\u{1111C}; + #\u{1111D}; + #\u{1111E}; + #\u{1111F}; + #\u{11120}; + #\u{11121}; + #\u{11122}; + #\u{11123}; + #\u{11124}; + #\u{11125}; + #\u{11126}; + #\u{11183}; + #\u{11184}; + #\u{11185}; + #\u{11186}; + #\u{11187}; + #\u{11188}; + #\u{11189}; + #\u{1118A}; + #\u{1118B}; + #\u{1118C}; + #\u{1118D}; + #\u{1118E}; + #\u{1118F}; + #\u{11190}; + #\u{11191}; + #\u{11192}; + #\u{11193}; + #\u{11194}; + #\u{11195}; + #\u{11196}; + #\u{11197}; + #\u{11198}; + #\u{11199}; + #\u{1119A}; + #\u{1119B}; + #\u{1119C}; + #\u{1119D}; + #\u{1119E}; + #\u{1119F}; + #\u{111A0}; + #\u{111A1}; + #\u{111A2}; + #\u{111A3}; + #\u{111A4}; + #\u{111A5}; + #\u{111A6}; + #\u{111A7}; + #\u{111A8}; + #\u{111A9}; + #\u{111AA}; + #\u{111AB}; + #\u{111AC}; + #\u{111AD}; + #\u{111AE}; + #\u{111AF}; + #\u{111B0}; + #\u{111B1}; + #\u{111B2}; + #\u{111C1}; + #\u{111C2}; + #\u{111C3}; + #\u{111C4}; + #\u{11680}; + #\u{11681}; + #\u{11682}; + #\u{11683}; + #\u{11684}; + #\u{11685}; + #\u{11686}; + #\u{11687}; + #\u{11688}; + #\u{11689}; + #\u{1168A}; + #\u{1168B}; + #\u{1168C}; + #\u{1168D}; + #\u{1168E}; + #\u{1168F}; + #\u{11690}; + #\u{11691}; + #\u{11692}; + #\u{11693}; + #\u{11694}; + #\u{11695}; + #\u{11696}; + #\u{11697}; + #\u{11698}; + #\u{11699}; + #\u{1169A}; + #\u{1169B}; + #\u{1169C}; + #\u{1169D}; + #\u{1169E}; + #\u{1169F}; + #\u{116A0}; + #\u{116A1}; + #\u{116A2}; + #\u{116A3}; + #\u{116A4}; + #\u{116A5}; + #\u{116A6}; + #\u{116A7}; + #\u{116A8}; + #\u{116A9}; + #\u{116AA}; + #\u{16F00}; + #\u{16F01}; + #\u{16F02}; + #\u{16F03}; + #\u{16F04}; + #\u{16F05}; + #\u{16F06}; + #\u{16F07}; + #\u{16F08}; + #\u{16F09}; + #\u{16F0A}; + #\u{16F0B}; + #\u{16F0C}; + #\u{16F0D}; + #\u{16F0E}; + #\u{16F0F}; + #\u{16F10}; + #\u{16F11}; + #\u{16F12}; + #\u{16F13}; + #\u{16F14}; + #\u{16F15}; + #\u{16F16}; + #\u{16F17}; + #\u{16F18}; + #\u{16F19}; + #\u{16F1A}; + #\u{16F1B}; + #\u{16F1C}; + #\u{16F1D}; + #\u{16F1E}; + #\u{16F1F}; + #\u{16F20}; + #\u{16F21}; + #\u{16F22}; + #\u{16F23}; + #\u{16F24}; + #\u{16F25}; + #\u{16F26}; + #\u{16F27}; + #\u{16F28}; + #\u{16F29}; + #\u{16F2A}; + #\u{16F2B}; + #\u{16F2C}; + #\u{16F2D}; + #\u{16F2E}; + #\u{16F2F}; + #\u{16F30}; + #\u{16F31}; + #\u{16F32}; + #\u{16F33}; + #\u{16F34}; + #\u{16F35}; + #\u{16F36}; + #\u{16F37}; + #\u{16F38}; + #\u{16F39}; + #\u{16F3A}; + #\u{16F3B}; + #\u{16F3C}; + #\u{16F3D}; + #\u{16F3E}; + #\u{16F3F}; + #\u{16F40}; + #\u{16F41}; + #\u{16F42}; + #\u{16F43}; + #\u{16F44}; + #\u{16F50}; + #\u{16F93}; + #\u{16F94}; + #\u{16F95}; + #\u{16F96}; + #\u{16F97}; + #\u{16F98}; + #\u{16F99}; + #\u{16F9A}; + #\u{16F9B}; + #\u{16F9C}; + #\u{16F9D}; + #\u{16F9E}; + #\u{16F9F}; + #\u{1EE00}; + #\u{1EE01}; + #\u{1EE02}; + #\u{1EE03}; + #\u{1EE05}; + #\u{1EE06}; + #\u{1EE07}; + #\u{1EE08}; + #\u{1EE09}; + #\u{1EE0A}; + #\u{1EE0B}; + #\u{1EE0C}; + #\u{1EE0D}; + #\u{1EE0E}; + #\u{1EE0F}; + #\u{1EE10}; + #\u{1EE11}; + #\u{1EE12}; + #\u{1EE13}; + #\u{1EE14}; + #\u{1EE15}; + #\u{1EE16}; + #\u{1EE17}; + #\u{1EE18}; + #\u{1EE19}; + #\u{1EE1A}; + #\u{1EE1B}; + #\u{1EE1C}; + #\u{1EE1D}; + #\u{1EE1E}; + #\u{1EE1F}; + #\u{1EE21}; + #\u{1EE22}; + #\u{1EE24}; + #\u{1EE27}; + #\u{1EE29}; + #\u{1EE2A}; + #\u{1EE2B}; + #\u{1EE2C}; + #\u{1EE2D}; + #\u{1EE2E}; + #\u{1EE2F}; + #\u{1EE30}; + #\u{1EE31}; + #\u{1EE32}; + #\u{1EE34}; + #\u{1EE35}; + #\u{1EE36}; + #\u{1EE37}; + #\u{1EE39}; + #\u{1EE3B}; + #\u{1EE42}; + #\u{1EE47}; + #\u{1EE49}; + #\u{1EE4B}; + #\u{1EE4D}; + #\u{1EE4E}; + #\u{1EE4F}; + #\u{1EE51}; + #\u{1EE52}; + #\u{1EE54}; + #\u{1EE57}; + #\u{1EE59}; + #\u{1EE5B}; + #\u{1EE5D}; + #\u{1EE5F}; + #\u{1EE61}; + #\u{1EE62}; + #\u{1EE64}; + #\u{1EE67}; + #\u{1EE68}; + #\u{1EE69}; + #\u{1EE6A}; + #\u{1EE6C}; + #\u{1EE6D}; + #\u{1EE6E}; + #\u{1EE6F}; + #\u{1EE70}; + #\u{1EE71}; + #\u{1EE72}; + #\u{1EE74}; + #\u{1EE75}; + #\u{1EE76}; + #\u{1EE77}; + #\u{1EE79}; + #\u{1EE7A}; + #\u{1EE7B}; + #\u{1EE7C}; + #\u{1EE7E}; + #\u{1EE80}; + #\u{1EE81}; + #\u{1EE82}; + #\u{1EE83}; + #\u{1EE84}; + #\u{1EE85}; + #\u{1EE86}; + #\u{1EE87}; + #\u{1EE88}; + #\u{1EE89}; + #\u{1EE8B}; + #\u{1EE8C}; + #\u{1EE8D}; + #\u{1EE8E}; + #\u{1EE8F}; + #\u{1EE90}; + #\u{1EE91}; + #\u{1EE92}; + #\u{1EE93}; + #\u{1EE94}; + #\u{1EE95}; + #\u{1EE96}; + #\u{1EE97}; + #\u{1EE98}; + #\u{1EE99}; + #\u{1EE9A}; + #\u{1EE9B}; + #\u{1EEA1}; + #\u{1EEA2}; + #\u{1EEA3}; + #\u{1EEA5}; + #\u{1EEA6}; + #\u{1EEA7}; + #\u{1EEA8}; + #\u{1EEA9}; + #\u{1EEAB}; + #\u{1EEAC}; + #\u{1EEAD}; + #\u{1EEAE}; + #\u{1EEAF}; + #\u{1EEB0}; + #\u{1EEB1}; + #\u{1EEB2}; + #\u{1EEB3}; + #\u{1EEB4}; + #\u{1EEB5}; + #\u{1EEB6}; + #\u{1EEB7}; + #\u{1EEB8}; + #\u{1EEB9}; + #\u{1EEBA}; + #\u{1EEBB}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0-class.js new file mode 100644 index 000000000..e57805613 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0-class.js @@ -0,0 +1,509 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v6.1.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #ࢠ; + #ࢢ; + #ࢣ; + #ࢤ; + #ࢥ; + #ࢦ; + #ࢧ; + #ࢨ; + #ࢩ; + #ࢪ; + #ࢫ; + #ࢬ; + #ໞ; + #ໟ; + #Ⴧ; + #Ⴭ; + #ჽ; + #ჾ; + #ჿ; + #ᮺ; + #ᮻ; + #ᮼ; + #ᮽ; + #ᮾ; + #ᮿ; + #ᳵ; + #ᳶ; + #Ⳳ; + #ⳳ; + #ⴧ; + #ⴭ; + #ⵦ; + #ⵧ; + #鿌; + #Ꞓ; + #ꞓ; + #Ɦ; + #ꟸ; + #ꟹ; + #ꫠ; + #ꫡ; + #ꫢ; + #ꫣ; + #ꫤ; + #ꫥ; + #ꫦ; + #ꫧ; + #ꫨ; + #ꫩ; + #ꫪ; + #ꫲ; + #ꫳ; + #ꫴ; + #郞; + #隷; + #𐦀; + #𐦁; + #𐦂; + #𐦃; + #𐦄; + #𐦅; + #𐦆; + #𐦇; + #𐦈; + #𐦉; + #𐦊; + #𐦋; + #𐦌; + #𐦍; + #𐦎; + #𐦏; + #𐦐; + #𐦑; + #𐦒; + #𐦓; + #𐦔; + #𐦕; + #𐦖; + #𐦗; + #𐦘; + #𐦙; + #𐦚; + #𐦛; + #𐦜; + #𐦝; + #𐦞; + #𐦟; + #𐦠; + #𐦡; + #𐦢; + #𐦣; + #𐦤; + #𐦥; + #𐦦; + #𐦧; + #𐦨; + #𐦩; + #𐦪; + #𐦫; + #𐦬; + #𐦭; + #𐦮; + #𐦯; + #𐦰; + #𐦱; + #𐦲; + #𐦳; + #𐦴; + #𐦵; + #𐦶; + #𐦷; + #𐦾; + #𐦿; + #𑃐; + #𑃑; + #𑃒; + #𑃓; + #𑃔; + #𑃕; + #𑃖; + #𑃗; + #𑃘; + #𑃙; + #𑃚; + #𑃛; + #𑃜; + #𑃝; + #𑃞; + #𑃟; + #𑃠; + #𑃡; + #𑃢; + #𑃣; + #𑃤; + #𑃥; + #𑃦; + #𑃧; + #𑃨; + #𑄃; + #𑄄; + #𑄅; + #𑄆; + #𑄇; + #𑄈; + #𑄉; + #𑄊; + #𑄋; + #𑄌; + #𑄍; + #𑄎; + #𑄏; + #𑄐; + #𑄑; + #𑄒; + #𑄓; + #𑄔; + #𑄕; + #𑄖; + #𑄗; + #𑄘; + #𑄙; + #𑄚; + #𑄛; + #𑄜; + #𑄝; + #𑄞; + #𑄟; + #𑄠; + #𑄡; + #𑄢; + #𑄣; + #𑄤; + #𑄥; + #𑄦; + #𑆃; + #𑆄; + #𑆅; + #𑆆; + #𑆇; + #𑆈; + #𑆉; + #𑆊; + #𑆋; + #𑆌; + #𑆍; + #𑆎; + #𑆏; + #𑆐; + #𑆑; + #𑆒; + #𑆓; + #𑆔; + #𑆕; + #𑆖; + #𑆗; + #𑆘; + #𑆙; + #𑆚; + #𑆛; + #𑆜; + #𑆝; + #𑆞; + #𑆟; + #𑆠; + #𑆡; + #𑆢; + #𑆣; + #𑆤; + #𑆥; + #𑆦; + #𑆧; + #𑆨; + #𑆩; + #𑆪; + #𑆫; + #𑆬; + #𑆭; + #𑆮; + #𑆯; + #𑆰; + #𑆱; + #𑆲; + #𑇁; + #𑇂; + #𑇃; + #𑇄; + #𑚀; + #𑚁; + #𑚂; + #𑚃; + #𑚄; + #𑚅; + #𑚆; + #𑚇; + #𑚈; + #𑚉; + #𑚊; + #𑚋; + #𑚌; + #𑚍; + #𑚎; + #𑚏; + #𑚐; + #𑚑; + #𑚒; + #𑚓; + #𑚔; + #𑚕; + #𑚖; + #𑚗; + #𑚘; + #𑚙; + #𑚚; + #𑚛; + #𑚜; + #𑚝; + #𑚞; + #𑚟; + #𑚠; + #𑚡; + #𑚢; + #𑚣; + #𑚤; + #𑚥; + #𑚦; + #𑚧; + #𑚨; + #𑚩; + #𑚪; + #𖼀; + #𖼁; + #𖼂; + #𖼃; + #𖼄; + #𖼅; + #𖼆; + #𖼇; + #𖼈; + #𖼉; + #𖼊; + #𖼋; + #𖼌; + #𖼍; + #𖼎; + #𖼏; + #𖼐; + #𖼑; + #𖼒; + #𖼓; + #𖼔; + #𖼕; + #𖼖; + #𖼗; + #𖼘; + #𖼙; + #𖼚; + #𖼛; + #𖼜; + #𖼝; + #𖼞; + #𖼟; + #𖼠; + #𖼡; + #𖼢; + #𖼣; + #𖼤; + #𖼥; + #𖼦; + #𖼧; + #𖼨; + #𖼩; + #𖼪; + #𖼫; + #𖼬; + #𖼭; + #𖼮; + #𖼯; + #𖼰; + #𖼱; + #𖼲; + #𖼳; + #𖼴; + #𖼵; + #𖼶; + #𖼷; + #𖼸; + #𖼹; + #𖼺; + #𖼻; + #𖼼; + #𖼽; + #𖼾; + #𖼿; + #𖽀; + #𖽁; + #𖽂; + #𖽃; + #𖽄; + #𖽐; + #𖾓; + #𖾔; + #𖾕; + #𖾖; + #𖾗; + #𖾘; + #𖾙; + #𖾚; + #𖾛; + #𖾜; + #𖾝; + #𖾞; + #𖾟; + #𞸀; + #𞸁; + #𞸂; + #𞸃; + #𞸅; + #𞸆; + #𞸇; + #𞸈; + #𞸉; + #𞸊; + #𞸋; + #𞸌; + #𞸍; + #𞸎; + #𞸏; + #𞸐; + #𞸑; + #𞸒; + #𞸓; + #𞸔; + #𞸕; + #𞸖; + #𞸗; + #𞸘; + #𞸙; + #𞸚; + #𞸛; + #𞸜; + #𞸝; + #𞸞; + #𞸟; + #𞸡; + #𞸢; + #𞸤; + #𞸧; + #𞸩; + #𞸪; + #𞸫; + #𞸬; + #𞸭; + #𞸮; + #𞸯; + #𞸰; + #𞸱; + #𞸲; + #𞸴; + #𞸵; + #𞸶; + #𞸷; + #𞸹; + #𞸻; + #𞹂; + #𞹇; + #𞹉; + #𞹋; + #𞹍; + #𞹎; + #𞹏; + #𞹑; + #𞹒; + #𞹔; + #𞹗; + #𞹙; + #𞹛; + #𞹝; + #𞹟; + #𞹡; + #𞹢; + #𞹤; + #𞹧; + #𞹨; + #𞹩; + #𞹪; + #𞹬; + #𞹭; + #𞹮; + #𞹯; + #𞹰; + #𞹱; + #𞹲; + #𞹴; + #𞹵; + #𞹶; + #𞹷; + #𞹹; + #𞹺; + #𞹻; + #𞹼; + #𞹾; + #𞺀; + #𞺁; + #𞺂; + #𞺃; + #𞺄; + #𞺅; + #𞺆; + #𞺇; + #𞺈; + #𞺉; + #𞺋; + #𞺌; + #𞺍; + #𞺎; + #𞺏; + #𞺐; + #𞺑; + #𞺒; + #𞺓; + #𞺔; + #𞺕; + #𞺖; + #𞺗; + #𞺘; + #𞺙; + #𞺚; + #𞺛; + #𞺡; + #𞺢; + #𞺣; + #𞺥; + #𞺦; + #𞺧; + #𞺨; + #𞺩; + #𞺫; + #𞺬; + #𞺭; + #𞺮; + #𞺯; + #𞺰; + #𞺱; + #𞺲; + #𞺳; + #𞺴; + #𞺵; + #𞺶; + #𞺷; + #𞺸; + #𞺹; + #𞺺; + #𞺻; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0-escaped.js new file mode 100644 index 000000000..fda61b9d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0-escaped.js @@ -0,0 +1,508 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v6.1.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u08A0; +var \u08A2; +var \u08A3; +var \u08A4; +var \u08A5; +var \u08A6; +var \u08A7; +var \u08A8; +var \u08A9; +var \u08AA; +var \u08AB; +var \u08AC; +var \u0EDE; +var \u0EDF; +var \u10C7; +var \u10CD; +var \u10FD; +var \u10FE; +var \u10FF; +var \u1BBA; +var \u1BBB; +var \u1BBC; +var \u1BBD; +var \u1BBE; +var \u1BBF; +var \u1CF5; +var \u1CF6; +var \u2CF2; +var \u2CF3; +var \u2D27; +var \u2D2D; +var \u2D66; +var \u2D67; +var \u9FCC; +var \uA792; +var \uA793; +var \uA7AA; +var \uA7F8; +var \uA7F9; +var \uAAE0; +var \uAAE1; +var \uAAE2; +var \uAAE3; +var \uAAE4; +var \uAAE5; +var \uAAE6; +var \uAAE7; +var \uAAE8; +var \uAAE9; +var \uAAEA; +var \uAAF2; +var \uAAF3; +var \uAAF4; +var \uFA2E; +var \uFA2F; +var \u{10980}; +var \u{10981}; +var \u{10982}; +var \u{10983}; +var \u{10984}; +var \u{10985}; +var \u{10986}; +var \u{10987}; +var \u{10988}; +var \u{10989}; +var \u{1098A}; +var \u{1098B}; +var \u{1098C}; +var \u{1098D}; +var \u{1098E}; +var \u{1098F}; +var \u{10990}; +var \u{10991}; +var \u{10992}; +var \u{10993}; +var \u{10994}; +var \u{10995}; +var \u{10996}; +var \u{10997}; +var \u{10998}; +var \u{10999}; +var \u{1099A}; +var \u{1099B}; +var \u{1099C}; +var \u{1099D}; +var \u{1099E}; +var \u{1099F}; +var \u{109A0}; +var \u{109A1}; +var \u{109A2}; +var \u{109A3}; +var \u{109A4}; +var \u{109A5}; +var \u{109A6}; +var \u{109A7}; +var \u{109A8}; +var \u{109A9}; +var \u{109AA}; +var \u{109AB}; +var \u{109AC}; +var \u{109AD}; +var \u{109AE}; +var \u{109AF}; +var \u{109B0}; +var \u{109B1}; +var \u{109B2}; +var \u{109B3}; +var \u{109B4}; +var \u{109B5}; +var \u{109B6}; +var \u{109B7}; +var \u{109BE}; +var \u{109BF}; +var \u{110D0}; +var \u{110D1}; +var \u{110D2}; +var \u{110D3}; +var \u{110D4}; +var \u{110D5}; +var \u{110D6}; +var \u{110D7}; +var \u{110D8}; +var \u{110D9}; +var \u{110DA}; +var \u{110DB}; +var \u{110DC}; +var \u{110DD}; +var \u{110DE}; +var \u{110DF}; +var \u{110E0}; +var \u{110E1}; +var \u{110E2}; +var \u{110E3}; +var \u{110E4}; +var \u{110E5}; +var \u{110E6}; +var \u{110E7}; +var \u{110E8}; +var \u{11103}; +var \u{11104}; +var \u{11105}; +var \u{11106}; +var \u{11107}; +var \u{11108}; +var \u{11109}; +var \u{1110A}; +var \u{1110B}; +var \u{1110C}; +var \u{1110D}; +var \u{1110E}; +var \u{1110F}; +var \u{11110}; +var \u{11111}; +var \u{11112}; +var \u{11113}; +var \u{11114}; +var \u{11115}; +var \u{11116}; +var \u{11117}; +var \u{11118}; +var \u{11119}; +var \u{1111A}; +var \u{1111B}; +var \u{1111C}; +var \u{1111D}; +var \u{1111E}; +var \u{1111F}; +var \u{11120}; +var \u{11121}; +var \u{11122}; +var \u{11123}; +var \u{11124}; +var \u{11125}; +var \u{11126}; +var \u{11183}; +var \u{11184}; +var \u{11185}; +var \u{11186}; +var \u{11187}; +var \u{11188}; +var \u{11189}; +var \u{1118A}; +var \u{1118B}; +var \u{1118C}; +var \u{1118D}; +var \u{1118E}; +var \u{1118F}; +var \u{11190}; +var \u{11191}; +var \u{11192}; +var \u{11193}; +var \u{11194}; +var \u{11195}; +var \u{11196}; +var \u{11197}; +var \u{11198}; +var \u{11199}; +var \u{1119A}; +var \u{1119B}; +var \u{1119C}; +var \u{1119D}; +var \u{1119E}; +var \u{1119F}; +var \u{111A0}; +var \u{111A1}; +var \u{111A2}; +var \u{111A3}; +var \u{111A4}; +var \u{111A5}; +var \u{111A6}; +var \u{111A7}; +var \u{111A8}; +var \u{111A9}; +var \u{111AA}; +var \u{111AB}; +var \u{111AC}; +var \u{111AD}; +var \u{111AE}; +var \u{111AF}; +var \u{111B0}; +var \u{111B1}; +var \u{111B2}; +var \u{111C1}; +var \u{111C2}; +var \u{111C3}; +var \u{111C4}; +var \u{11680}; +var \u{11681}; +var \u{11682}; +var \u{11683}; +var \u{11684}; +var \u{11685}; +var \u{11686}; +var \u{11687}; +var \u{11688}; +var \u{11689}; +var \u{1168A}; +var \u{1168B}; +var \u{1168C}; +var \u{1168D}; +var \u{1168E}; +var \u{1168F}; +var \u{11690}; +var \u{11691}; +var \u{11692}; +var \u{11693}; +var \u{11694}; +var \u{11695}; +var \u{11696}; +var \u{11697}; +var \u{11698}; +var \u{11699}; +var \u{1169A}; +var \u{1169B}; +var \u{1169C}; +var \u{1169D}; +var \u{1169E}; +var \u{1169F}; +var \u{116A0}; +var \u{116A1}; +var \u{116A2}; +var \u{116A3}; +var \u{116A4}; +var \u{116A5}; +var \u{116A6}; +var \u{116A7}; +var \u{116A8}; +var \u{116A9}; +var \u{116AA}; +var \u{16F00}; +var \u{16F01}; +var \u{16F02}; +var \u{16F03}; +var \u{16F04}; +var \u{16F05}; +var \u{16F06}; +var \u{16F07}; +var \u{16F08}; +var \u{16F09}; +var \u{16F0A}; +var \u{16F0B}; +var \u{16F0C}; +var \u{16F0D}; +var \u{16F0E}; +var \u{16F0F}; +var \u{16F10}; +var \u{16F11}; +var \u{16F12}; +var \u{16F13}; +var \u{16F14}; +var \u{16F15}; +var \u{16F16}; +var \u{16F17}; +var \u{16F18}; +var \u{16F19}; +var \u{16F1A}; +var \u{16F1B}; +var \u{16F1C}; +var \u{16F1D}; +var \u{16F1E}; +var \u{16F1F}; +var \u{16F20}; +var \u{16F21}; +var \u{16F22}; +var \u{16F23}; +var \u{16F24}; +var \u{16F25}; +var \u{16F26}; +var \u{16F27}; +var \u{16F28}; +var \u{16F29}; +var \u{16F2A}; +var \u{16F2B}; +var \u{16F2C}; +var \u{16F2D}; +var \u{16F2E}; +var \u{16F2F}; +var \u{16F30}; +var \u{16F31}; +var \u{16F32}; +var \u{16F33}; +var \u{16F34}; +var \u{16F35}; +var \u{16F36}; +var \u{16F37}; +var \u{16F38}; +var \u{16F39}; +var \u{16F3A}; +var \u{16F3B}; +var \u{16F3C}; +var \u{16F3D}; +var \u{16F3E}; +var \u{16F3F}; +var \u{16F40}; +var \u{16F41}; +var \u{16F42}; +var \u{16F43}; +var \u{16F44}; +var \u{16F50}; +var \u{16F93}; +var \u{16F94}; +var \u{16F95}; +var \u{16F96}; +var \u{16F97}; +var \u{16F98}; +var \u{16F99}; +var \u{16F9A}; +var \u{16F9B}; +var \u{16F9C}; +var \u{16F9D}; +var \u{16F9E}; +var \u{16F9F}; +var \u{1EE00}; +var \u{1EE01}; +var \u{1EE02}; +var \u{1EE03}; +var \u{1EE05}; +var \u{1EE06}; +var \u{1EE07}; +var \u{1EE08}; +var \u{1EE09}; +var \u{1EE0A}; +var \u{1EE0B}; +var \u{1EE0C}; +var \u{1EE0D}; +var \u{1EE0E}; +var \u{1EE0F}; +var \u{1EE10}; +var \u{1EE11}; +var \u{1EE12}; +var \u{1EE13}; +var \u{1EE14}; +var \u{1EE15}; +var \u{1EE16}; +var \u{1EE17}; +var \u{1EE18}; +var \u{1EE19}; +var \u{1EE1A}; +var \u{1EE1B}; +var \u{1EE1C}; +var \u{1EE1D}; +var \u{1EE1E}; +var \u{1EE1F}; +var \u{1EE21}; +var \u{1EE22}; +var \u{1EE24}; +var \u{1EE27}; +var \u{1EE29}; +var \u{1EE2A}; +var \u{1EE2B}; +var \u{1EE2C}; +var \u{1EE2D}; +var \u{1EE2E}; +var \u{1EE2F}; +var \u{1EE30}; +var \u{1EE31}; +var \u{1EE32}; +var \u{1EE34}; +var \u{1EE35}; +var \u{1EE36}; +var \u{1EE37}; +var \u{1EE39}; +var \u{1EE3B}; +var \u{1EE42}; +var \u{1EE47}; +var \u{1EE49}; +var \u{1EE4B}; +var \u{1EE4D}; +var \u{1EE4E}; +var \u{1EE4F}; +var \u{1EE51}; +var \u{1EE52}; +var \u{1EE54}; +var \u{1EE57}; +var \u{1EE59}; +var \u{1EE5B}; +var \u{1EE5D}; +var \u{1EE5F}; +var \u{1EE61}; +var \u{1EE62}; +var \u{1EE64}; +var \u{1EE67}; +var \u{1EE68}; +var \u{1EE69}; +var \u{1EE6A}; +var \u{1EE6C}; +var \u{1EE6D}; +var \u{1EE6E}; +var \u{1EE6F}; +var \u{1EE70}; +var \u{1EE71}; +var \u{1EE72}; +var \u{1EE74}; +var \u{1EE75}; +var \u{1EE76}; +var \u{1EE77}; +var \u{1EE79}; +var \u{1EE7A}; +var \u{1EE7B}; +var \u{1EE7C}; +var \u{1EE7E}; +var \u{1EE80}; +var \u{1EE81}; +var \u{1EE82}; +var \u{1EE83}; +var \u{1EE84}; +var \u{1EE85}; +var \u{1EE86}; +var \u{1EE87}; +var \u{1EE88}; +var \u{1EE89}; +var \u{1EE8B}; +var \u{1EE8C}; +var \u{1EE8D}; +var \u{1EE8E}; +var \u{1EE8F}; +var \u{1EE90}; +var \u{1EE91}; +var \u{1EE92}; +var \u{1EE93}; +var \u{1EE94}; +var \u{1EE95}; +var \u{1EE96}; +var \u{1EE97}; +var \u{1EE98}; +var \u{1EE99}; +var \u{1EE9A}; +var \u{1EE9B}; +var \u{1EEA1}; +var \u{1EEA2}; +var \u{1EEA3}; +var \u{1EEA5}; +var \u{1EEA6}; +var \u{1EEA7}; +var \u{1EEA8}; +var \u{1EEA9}; +var \u{1EEAB}; +var \u{1EEAC}; +var \u{1EEAD}; +var \u{1EEAE}; +var \u{1EEAF}; +var \u{1EEB0}; +var \u{1EEB1}; +var \u{1EEB2}; +var \u{1EEB3}; +var \u{1EEB4}; +var \u{1EEB5}; +var \u{1EEB6}; +var \u{1EEB7}; +var \u{1EEB8}; +var \u{1EEB9}; +var \u{1EEBA}; +var \u{1EEBB}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0.js new file mode 100644 index 000000000..61fbcbd5b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-6.1.0.js @@ -0,0 +1,506 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v6.1.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var ࢠ; +var ࢢ; +var ࢣ; +var ࢤ; +var ࢥ; +var ࢦ; +var ࢧ; +var ࢨ; +var ࢩ; +var ࢪ; +var ࢫ; +var ࢬ; +var ໞ; +var ໟ; +var Ⴧ; +var Ⴭ; +var ჽ; +var ჾ; +var ჿ; +var ᮺ; +var ᮻ; +var ᮼ; +var ᮽ; +var ᮾ; +var ᮿ; +var ᳵ; +var ᳶ; +var Ⳳ; +var ⳳ; +var ⴧ; +var ⴭ; +var ⵦ; +var ⵧ; +var 鿌; +var Ꞓ; +var ꞓ; +var Ɦ; +var ꟸ; +var ꟹ; +var ꫠ; +var ꫡ; +var ꫢ; +var ꫣ; +var ꫤ; +var ꫥ; +var ꫦ; +var ꫧ; +var ꫨ; +var ꫩ; +var ꫪ; +var ꫲ; +var ꫳ; +var ꫴ; +var 郞; +var 隷; +var 𐦀; +var 𐦁; +var 𐦂; +var 𐦃; +var 𐦄; +var 𐦅; +var 𐦆; +var 𐦇; +var 𐦈; +var 𐦉; +var 𐦊; +var 𐦋; +var 𐦌; +var 𐦍; +var 𐦎; +var 𐦏; +var 𐦐; +var 𐦑; +var 𐦒; +var 𐦓; +var 𐦔; +var 𐦕; +var 𐦖; +var 𐦗; +var 𐦘; +var 𐦙; +var 𐦚; +var 𐦛; +var 𐦜; +var 𐦝; +var 𐦞; +var 𐦟; +var 𐦠; +var 𐦡; +var 𐦢; +var 𐦣; +var 𐦤; +var 𐦥; +var 𐦦; +var 𐦧; +var 𐦨; +var 𐦩; +var 𐦪; +var 𐦫; +var 𐦬; +var 𐦭; +var 𐦮; +var 𐦯; +var 𐦰; +var 𐦱; +var 𐦲; +var 𐦳; +var 𐦴; +var 𐦵; +var 𐦶; +var 𐦷; +var 𐦾; +var 𐦿; +var 𑃐; +var 𑃑; +var 𑃒; +var 𑃓; +var 𑃔; +var 𑃕; +var 𑃖; +var 𑃗; +var 𑃘; +var 𑃙; +var 𑃚; +var 𑃛; +var 𑃜; +var 𑃝; +var 𑃞; +var 𑃟; +var 𑃠; +var 𑃡; +var 𑃢; +var 𑃣; +var 𑃤; +var 𑃥; +var 𑃦; +var 𑃧; +var 𑃨; +var 𑄃; +var 𑄄; +var 𑄅; +var 𑄆; +var 𑄇; +var 𑄈; +var 𑄉; +var 𑄊; +var 𑄋; +var 𑄌; +var 𑄍; +var 𑄎; +var 𑄏; +var 𑄐; +var 𑄑; +var 𑄒; +var 𑄓; +var 𑄔; +var 𑄕; +var 𑄖; +var 𑄗; +var 𑄘; +var 𑄙; +var 𑄚; +var 𑄛; +var 𑄜; +var 𑄝; +var 𑄞; +var 𑄟; +var 𑄠; +var 𑄡; +var 𑄢; +var 𑄣; +var 𑄤; +var 𑄥; +var 𑄦; +var 𑆃; +var 𑆄; +var 𑆅; +var 𑆆; +var 𑆇; +var 𑆈; +var 𑆉; +var 𑆊; +var 𑆋; +var 𑆌; +var 𑆍; +var 𑆎; +var 𑆏; +var 𑆐; +var 𑆑; +var 𑆒; +var 𑆓; +var 𑆔; +var 𑆕; +var 𑆖; +var 𑆗; +var 𑆘; +var 𑆙; +var 𑆚; +var 𑆛; +var 𑆜; +var 𑆝; +var 𑆞; +var 𑆟; +var 𑆠; +var 𑆡; +var 𑆢; +var 𑆣; +var 𑆤; +var 𑆥; +var 𑆦; +var 𑆧; +var 𑆨; +var 𑆩; +var 𑆪; +var 𑆫; +var 𑆬; +var 𑆭; +var 𑆮; +var 𑆯; +var 𑆰; +var 𑆱; +var 𑆲; +var 𑇁; +var 𑇂; +var 𑇃; +var 𑇄; +var 𑚀; +var 𑚁; +var 𑚂; +var 𑚃; +var 𑚄; +var 𑚅; +var 𑚆; +var 𑚇; +var 𑚈; +var 𑚉; +var 𑚊; +var 𑚋; +var 𑚌; +var 𑚍; +var 𑚎; +var 𑚏; +var 𑚐; +var 𑚑; +var 𑚒; +var 𑚓; +var 𑚔; +var 𑚕; +var 𑚖; +var 𑚗; +var 𑚘; +var 𑚙; +var 𑚚; +var 𑚛; +var 𑚜; +var 𑚝; +var 𑚞; +var 𑚟; +var 𑚠; +var 𑚡; +var 𑚢; +var 𑚣; +var 𑚤; +var 𑚥; +var 𑚦; +var 𑚧; +var 𑚨; +var 𑚩; +var 𑚪; +var 𖼀; +var 𖼁; +var 𖼂; +var 𖼃; +var 𖼄; +var 𖼅; +var 𖼆; +var 𖼇; +var 𖼈; +var 𖼉; +var 𖼊; +var 𖼋; +var 𖼌; +var 𖼍; +var 𖼎; +var 𖼏; +var 𖼐; +var 𖼑; +var 𖼒; +var 𖼓; +var 𖼔; +var 𖼕; +var 𖼖; +var 𖼗; +var 𖼘; +var 𖼙; +var 𖼚; +var 𖼛; +var 𖼜; +var 𖼝; +var 𖼞; +var 𖼟; +var 𖼠; +var 𖼡; +var 𖼢; +var 𖼣; +var 𖼤; +var 𖼥; +var 𖼦; +var 𖼧; +var 𖼨; +var 𖼩; +var 𖼪; +var 𖼫; +var 𖼬; +var 𖼭; +var 𖼮; +var 𖼯; +var 𖼰; +var 𖼱; +var 𖼲; +var 𖼳; +var 𖼴; +var 𖼵; +var 𖼶; +var 𖼷; +var 𖼸; +var 𖼹; +var 𖼺; +var 𖼻; +var 𖼼; +var 𖼽; +var 𖼾; +var 𖼿; +var 𖽀; +var 𖽁; +var 𖽂; +var 𖽃; +var 𖽄; +var 𖽐; +var 𖾓; +var 𖾔; +var 𖾕; +var 𖾖; +var 𖾗; +var 𖾘; +var 𖾙; +var 𖾚; +var 𖾛; +var 𖾜; +var 𖾝; +var 𖾞; +var 𖾟; +var 𞸀; +var 𞸁; +var 𞸂; +var 𞸃; +var 𞸅; +var 𞸆; +var 𞸇; +var 𞸈; +var 𞸉; +var 𞸊; +var 𞸋; +var 𞸌; +var 𞸍; +var 𞸎; +var 𞸏; +var 𞸐; +var 𞸑; +var 𞸒; +var 𞸓; +var 𞸔; +var 𞸕; +var 𞸖; +var 𞸗; +var 𞸘; +var 𞸙; +var 𞸚; +var 𞸛; +var 𞸜; +var 𞸝; +var 𞸞; +var 𞸟; +var 𞸡; +var 𞸢; +var 𞸤; +var 𞸧; +var 𞸩; +var 𞸪; +var 𞸫; +var 𞸬; +var 𞸭; +var 𞸮; +var 𞸯; +var 𞸰; +var 𞸱; +var 𞸲; +var 𞸴; +var 𞸵; +var 𞸶; +var 𞸷; +var 𞸹; +var 𞸻; +var 𞹂; +var 𞹇; +var 𞹉; +var 𞹋; +var 𞹍; +var 𞹎; +var 𞹏; +var 𞹑; +var 𞹒; +var 𞹔; +var 𞹗; +var 𞹙; +var 𞹛; +var 𞹝; +var 𞹟; +var 𞹡; +var 𞹢; +var 𞹤; +var 𞹧; +var 𞹨; +var 𞹩; +var 𞹪; +var 𞹬; +var 𞹭; +var 𞹮; +var 𞹯; +var 𞹰; +var 𞹱; +var 𞹲; +var 𞹴; +var 𞹵; +var 𞹶; +var 𞹷; +var 𞹹; +var 𞹺; +var 𞹻; +var 𞹼; +var 𞹾; +var 𞺀; +var 𞺁; +var 𞺂; +var 𞺃; +var 𞺄; +var 𞺅; +var 𞺆; +var 𞺇; +var 𞺈; +var 𞺉; +var 𞺋; +var 𞺌; +var 𞺍; +var 𞺎; +var 𞺏; +var 𞺐; +var 𞺑; +var 𞺒; +var 𞺓; +var 𞺔; +var 𞺕; +var 𞺖; +var 𞺗; +var 𞺘; +var 𞺙; +var 𞺚; +var 𞺛; +var 𞺡; +var 𞺢; +var 𞺣; +var 𞺥; +var 𞺦; +var 𞺧; +var 𞺨; +var 𞺩; +var 𞺫; +var 𞺬; +var 𞺭; +var 𞺮; +var 𞺯; +var 𞺰; +var 𞺱; +var 𞺲; +var 𞺳; +var 𞺴; +var 𞺵; +var 𞺶; +var 𞺷; +var 𞺸; +var 𞺹; +var 𞺺; +var 𞺻; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0-class-escaped.js new file mode 100644 index 000000000..eefb39d08 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0-class-escaped.js @@ -0,0 +1,1743 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v7.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u037F; + #\u0528; + #\u0529; + #\u052A; + #\u052B; + #\u052C; + #\u052D; + #\u052E; + #\u052F; + #\u08A1; + #\u08AD; + #\u08AE; + #\u08AF; + #\u08B0; + #\u08B1; + #\u08B2; + #\u0978; + #\u0980; + #\u0C34; + #\u16F1; + #\u16F2; + #\u16F3; + #\u16F4; + #\u16F5; + #\u16F6; + #\u16F7; + #\u16F8; + #\u191D; + #\u191E; + #\uA698; + #\uA699; + #\uA69A; + #\uA69B; + #\uA69C; + #\uA69D; + #\uA794; + #\uA795; + #\uA796; + #\uA797; + #\uA798; + #\uA799; + #\uA79A; + #\uA79B; + #\uA79C; + #\uA79D; + #\uA79E; + #\uA79F; + #\uA7AB; + #\uA7AC; + #\uA7AD; + #\uA7B0; + #\uA7B1; + #\uA7F7; + #\uA9E0; + #\uA9E1; + #\uA9E2; + #\uA9E3; + #\uA9E4; + #\uA9E6; + #\uA9E7; + #\uA9E8; + #\uA9E9; + #\uA9EA; + #\uA9EB; + #\uA9EC; + #\uA9ED; + #\uA9EE; + #\uA9EF; + #\uA9FA; + #\uA9FB; + #\uA9FC; + #\uA9FD; + #\uA9FE; + #\uAA7E; + #\uAA7F; + #\uAB30; + #\uAB31; + #\uAB32; + #\uAB33; + #\uAB34; + #\uAB35; + #\uAB36; + #\uAB37; + #\uAB38; + #\uAB39; + #\uAB3A; + #\uAB3B; + #\uAB3C; + #\uAB3D; + #\uAB3E; + #\uAB3F; + #\uAB40; + #\uAB41; + #\uAB42; + #\uAB43; + #\uAB44; + #\uAB45; + #\uAB46; + #\uAB47; + #\uAB48; + #\uAB49; + #\uAB4A; + #\uAB4B; + #\uAB4C; + #\uAB4D; + #\uAB4E; + #\uAB4F; + #\uAB50; + #\uAB51; + #\uAB52; + #\uAB53; + #\uAB54; + #\uAB55; + #\uAB56; + #\uAB57; + #\uAB58; + #\uAB59; + #\uAB5A; + #\uAB5C; + #\uAB5D; + #\uAB5E; + #\uAB5F; + #\uAB64; + #\uAB65; + #\u{1031F}; + #\u{10350}; + #\u{10351}; + #\u{10352}; + #\u{10353}; + #\u{10354}; + #\u{10355}; + #\u{10356}; + #\u{10357}; + #\u{10358}; + #\u{10359}; + #\u{1035A}; + #\u{1035B}; + #\u{1035C}; + #\u{1035D}; + #\u{1035E}; + #\u{1035F}; + #\u{10360}; + #\u{10361}; + #\u{10362}; + #\u{10363}; + #\u{10364}; + #\u{10365}; + #\u{10366}; + #\u{10367}; + #\u{10368}; + #\u{10369}; + #\u{1036A}; + #\u{1036B}; + #\u{1036C}; + #\u{1036D}; + #\u{1036E}; + #\u{1036F}; + #\u{10370}; + #\u{10371}; + #\u{10372}; + #\u{10373}; + #\u{10374}; + #\u{10375}; + #\u{10500}; + #\u{10501}; + #\u{10502}; + #\u{10503}; + #\u{10504}; + #\u{10505}; + #\u{10506}; + #\u{10507}; + #\u{10508}; + #\u{10509}; + #\u{1050A}; + #\u{1050B}; + #\u{1050C}; + #\u{1050D}; + #\u{1050E}; + #\u{1050F}; + #\u{10510}; + #\u{10511}; + #\u{10512}; + #\u{10513}; + #\u{10514}; + #\u{10515}; + #\u{10516}; + #\u{10517}; + #\u{10518}; + #\u{10519}; + #\u{1051A}; + #\u{1051B}; + #\u{1051C}; + #\u{1051D}; + #\u{1051E}; + #\u{1051F}; + #\u{10520}; + #\u{10521}; + #\u{10522}; + #\u{10523}; + #\u{10524}; + #\u{10525}; + #\u{10526}; + #\u{10527}; + #\u{10530}; + #\u{10531}; + #\u{10532}; + #\u{10533}; + #\u{10534}; + #\u{10535}; + #\u{10536}; + #\u{10537}; + #\u{10538}; + #\u{10539}; + #\u{1053A}; + #\u{1053B}; + #\u{1053C}; + #\u{1053D}; + #\u{1053E}; + #\u{1053F}; + #\u{10540}; + #\u{10541}; + #\u{10542}; + #\u{10543}; + #\u{10544}; + #\u{10545}; + #\u{10546}; + #\u{10547}; + #\u{10548}; + #\u{10549}; + #\u{1054A}; + #\u{1054B}; + #\u{1054C}; + #\u{1054D}; + #\u{1054E}; + #\u{1054F}; + #\u{10550}; + #\u{10551}; + #\u{10552}; + #\u{10553}; + #\u{10554}; + #\u{10555}; + #\u{10556}; + #\u{10557}; + #\u{10558}; + #\u{10559}; + #\u{1055A}; + #\u{1055B}; + #\u{1055C}; + #\u{1055D}; + #\u{1055E}; + #\u{1055F}; + #\u{10560}; + #\u{10561}; + #\u{10562}; + #\u{10563}; + #\u{10600}; + #\u{10601}; + #\u{10602}; + #\u{10603}; + #\u{10604}; + #\u{10605}; + #\u{10606}; + #\u{10607}; + #\u{10608}; + #\u{10609}; + #\u{1060A}; + #\u{1060B}; + #\u{1060C}; + #\u{1060D}; + #\u{1060E}; + #\u{1060F}; + #\u{10610}; + #\u{10611}; + #\u{10612}; + #\u{10613}; + #\u{10614}; + #\u{10615}; + #\u{10616}; + #\u{10617}; + #\u{10618}; + #\u{10619}; + #\u{1061A}; + #\u{1061B}; + #\u{1061C}; + #\u{1061D}; + #\u{1061E}; + #\u{1061F}; + #\u{10620}; + #\u{10621}; + #\u{10622}; + #\u{10623}; + #\u{10624}; + #\u{10625}; + #\u{10626}; + #\u{10627}; + #\u{10628}; + #\u{10629}; + #\u{1062A}; + #\u{1062B}; + #\u{1062C}; + #\u{1062D}; + #\u{1062E}; + #\u{1062F}; + #\u{10630}; + #\u{10631}; + #\u{10632}; + #\u{10633}; + #\u{10634}; + #\u{10635}; + #\u{10636}; + #\u{10637}; + #\u{10638}; + #\u{10639}; + #\u{1063A}; + #\u{1063B}; + #\u{1063C}; + #\u{1063D}; + #\u{1063E}; + #\u{1063F}; + #\u{10640}; + #\u{10641}; + #\u{10642}; + #\u{10643}; + #\u{10644}; + #\u{10645}; + #\u{10646}; + #\u{10647}; + #\u{10648}; + #\u{10649}; + #\u{1064A}; + #\u{1064B}; + #\u{1064C}; + #\u{1064D}; + #\u{1064E}; + #\u{1064F}; + #\u{10650}; + #\u{10651}; + #\u{10652}; + #\u{10653}; + #\u{10654}; + #\u{10655}; + #\u{10656}; + #\u{10657}; + #\u{10658}; + #\u{10659}; + #\u{1065A}; + #\u{1065B}; + #\u{1065C}; + #\u{1065D}; + #\u{1065E}; + #\u{1065F}; + #\u{10660}; + #\u{10661}; + #\u{10662}; + #\u{10663}; + #\u{10664}; + #\u{10665}; + #\u{10666}; + #\u{10667}; + #\u{10668}; + #\u{10669}; + #\u{1066A}; + #\u{1066B}; + #\u{1066C}; + #\u{1066D}; + #\u{1066E}; + #\u{1066F}; + #\u{10670}; + #\u{10671}; + #\u{10672}; + #\u{10673}; + #\u{10674}; + #\u{10675}; + #\u{10676}; + #\u{10677}; + #\u{10678}; + #\u{10679}; + #\u{1067A}; + #\u{1067B}; + #\u{1067C}; + #\u{1067D}; + #\u{1067E}; + #\u{1067F}; + #\u{10680}; + #\u{10681}; + #\u{10682}; + #\u{10683}; + #\u{10684}; + #\u{10685}; + #\u{10686}; + #\u{10687}; + #\u{10688}; + #\u{10689}; + #\u{1068A}; + #\u{1068B}; + #\u{1068C}; + #\u{1068D}; + #\u{1068E}; + #\u{1068F}; + #\u{10690}; + #\u{10691}; + #\u{10692}; + #\u{10693}; + #\u{10694}; + #\u{10695}; + #\u{10696}; + #\u{10697}; + #\u{10698}; + #\u{10699}; + #\u{1069A}; + #\u{1069B}; + #\u{1069C}; + #\u{1069D}; + #\u{1069E}; + #\u{1069F}; + #\u{106A0}; + #\u{106A1}; + #\u{106A2}; + #\u{106A3}; + #\u{106A4}; + #\u{106A5}; + #\u{106A6}; + #\u{106A7}; + #\u{106A8}; + #\u{106A9}; + #\u{106AA}; + #\u{106AB}; + #\u{106AC}; + #\u{106AD}; + #\u{106AE}; + #\u{106AF}; + #\u{106B0}; + #\u{106B1}; + #\u{106B2}; + #\u{106B3}; + #\u{106B4}; + #\u{106B5}; + #\u{106B6}; + #\u{106B7}; + #\u{106B8}; + #\u{106B9}; + #\u{106BA}; + #\u{106BB}; + #\u{106BC}; + #\u{106BD}; + #\u{106BE}; + #\u{106BF}; + #\u{106C0}; + #\u{106C1}; + #\u{106C2}; + #\u{106C3}; + #\u{106C4}; + #\u{106C5}; + #\u{106C6}; + #\u{106C7}; + #\u{106C8}; + #\u{106C9}; + #\u{106CA}; + #\u{106CB}; + #\u{106CC}; + #\u{106CD}; + #\u{106CE}; + #\u{106CF}; + #\u{106D0}; + #\u{106D1}; + #\u{106D2}; + #\u{106D3}; + #\u{106D4}; + #\u{106D5}; + #\u{106D6}; + #\u{106D7}; + #\u{106D8}; + #\u{106D9}; + #\u{106DA}; + #\u{106DB}; + #\u{106DC}; + #\u{106DD}; + #\u{106DE}; + #\u{106DF}; + #\u{106E0}; + #\u{106E1}; + #\u{106E2}; + #\u{106E3}; + #\u{106E4}; + #\u{106E5}; + #\u{106E6}; + #\u{106E7}; + #\u{106E8}; + #\u{106E9}; + #\u{106EA}; + #\u{106EB}; + #\u{106EC}; + #\u{106ED}; + #\u{106EE}; + #\u{106EF}; + #\u{106F0}; + #\u{106F1}; + #\u{106F2}; + #\u{106F3}; + #\u{106F4}; + #\u{106F5}; + #\u{106F6}; + #\u{106F7}; + #\u{106F8}; + #\u{106F9}; + #\u{106FA}; + #\u{106FB}; + #\u{106FC}; + #\u{106FD}; + #\u{106FE}; + #\u{106FF}; + #\u{10700}; + #\u{10701}; + #\u{10702}; + #\u{10703}; + #\u{10704}; + #\u{10705}; + #\u{10706}; + #\u{10707}; + #\u{10708}; + #\u{10709}; + #\u{1070A}; + #\u{1070B}; + #\u{1070C}; + #\u{1070D}; + #\u{1070E}; + #\u{1070F}; + #\u{10710}; + #\u{10711}; + #\u{10712}; + #\u{10713}; + #\u{10714}; + #\u{10715}; + #\u{10716}; + #\u{10717}; + #\u{10718}; + #\u{10719}; + #\u{1071A}; + #\u{1071B}; + #\u{1071C}; + #\u{1071D}; + #\u{1071E}; + #\u{1071F}; + #\u{10720}; + #\u{10721}; + #\u{10722}; + #\u{10723}; + #\u{10724}; + #\u{10725}; + #\u{10726}; + #\u{10727}; + #\u{10728}; + #\u{10729}; + #\u{1072A}; + #\u{1072B}; + #\u{1072C}; + #\u{1072D}; + #\u{1072E}; + #\u{1072F}; + #\u{10730}; + #\u{10731}; + #\u{10732}; + #\u{10733}; + #\u{10734}; + #\u{10735}; + #\u{10736}; + #\u{10740}; + #\u{10741}; + #\u{10742}; + #\u{10743}; + #\u{10744}; + #\u{10745}; + #\u{10746}; + #\u{10747}; + #\u{10748}; + #\u{10749}; + #\u{1074A}; + #\u{1074B}; + #\u{1074C}; + #\u{1074D}; + #\u{1074E}; + #\u{1074F}; + #\u{10750}; + #\u{10751}; + #\u{10752}; + #\u{10753}; + #\u{10754}; + #\u{10755}; + #\u{10760}; + #\u{10761}; + #\u{10762}; + #\u{10763}; + #\u{10764}; + #\u{10765}; + #\u{10766}; + #\u{10767}; + #\u{10860}; + #\u{10861}; + #\u{10862}; + #\u{10863}; + #\u{10864}; + #\u{10865}; + #\u{10866}; + #\u{10867}; + #\u{10868}; + #\u{10869}; + #\u{1086A}; + #\u{1086B}; + #\u{1086C}; + #\u{1086D}; + #\u{1086E}; + #\u{1086F}; + #\u{10870}; + #\u{10871}; + #\u{10872}; + #\u{10873}; + #\u{10874}; + #\u{10875}; + #\u{10876}; + #\u{10880}; + #\u{10881}; + #\u{10882}; + #\u{10883}; + #\u{10884}; + #\u{10885}; + #\u{10886}; + #\u{10887}; + #\u{10888}; + #\u{10889}; + #\u{1088A}; + #\u{1088B}; + #\u{1088C}; + #\u{1088D}; + #\u{1088E}; + #\u{1088F}; + #\u{10890}; + #\u{10891}; + #\u{10892}; + #\u{10893}; + #\u{10894}; + #\u{10895}; + #\u{10896}; + #\u{10897}; + #\u{10898}; + #\u{10899}; + #\u{1089A}; + #\u{1089B}; + #\u{1089C}; + #\u{1089D}; + #\u{1089E}; + #\u{10A80}; + #\u{10A81}; + #\u{10A82}; + #\u{10A83}; + #\u{10A84}; + #\u{10A85}; + #\u{10A86}; + #\u{10A87}; + #\u{10A88}; + #\u{10A89}; + #\u{10A8A}; + #\u{10A8B}; + #\u{10A8C}; + #\u{10A8D}; + #\u{10A8E}; + #\u{10A8F}; + #\u{10A90}; + #\u{10A91}; + #\u{10A92}; + #\u{10A93}; + #\u{10A94}; + #\u{10A95}; + #\u{10A96}; + #\u{10A97}; + #\u{10A98}; + #\u{10A99}; + #\u{10A9A}; + #\u{10A9B}; + #\u{10A9C}; + #\u{10AC0}; + #\u{10AC1}; + #\u{10AC2}; + #\u{10AC3}; + #\u{10AC4}; + #\u{10AC5}; + #\u{10AC6}; + #\u{10AC7}; + #\u{10AC9}; + #\u{10ACA}; + #\u{10ACB}; + #\u{10ACC}; + #\u{10ACD}; + #\u{10ACE}; + #\u{10ACF}; + #\u{10AD0}; + #\u{10AD1}; + #\u{10AD2}; + #\u{10AD3}; + #\u{10AD4}; + #\u{10AD5}; + #\u{10AD6}; + #\u{10AD7}; + #\u{10AD8}; + #\u{10AD9}; + #\u{10ADA}; + #\u{10ADB}; + #\u{10ADC}; + #\u{10ADD}; + #\u{10ADE}; + #\u{10ADF}; + #\u{10AE0}; + #\u{10AE1}; + #\u{10AE2}; + #\u{10AE3}; + #\u{10AE4}; + #\u{10B80}; + #\u{10B81}; + #\u{10B82}; + #\u{10B83}; + #\u{10B84}; + #\u{10B85}; + #\u{10B86}; + #\u{10B87}; + #\u{10B88}; + #\u{10B89}; + #\u{10B8A}; + #\u{10B8B}; + #\u{10B8C}; + #\u{10B8D}; + #\u{10B8E}; + #\u{10B8F}; + #\u{10B90}; + #\u{10B91}; + #\u{11150}; + #\u{11151}; + #\u{11152}; + #\u{11153}; + #\u{11154}; + #\u{11155}; + #\u{11156}; + #\u{11157}; + #\u{11158}; + #\u{11159}; + #\u{1115A}; + #\u{1115B}; + #\u{1115C}; + #\u{1115D}; + #\u{1115E}; + #\u{1115F}; + #\u{11160}; + #\u{11161}; + #\u{11162}; + #\u{11163}; + #\u{11164}; + #\u{11165}; + #\u{11166}; + #\u{11167}; + #\u{11168}; + #\u{11169}; + #\u{1116A}; + #\u{1116B}; + #\u{1116C}; + #\u{1116D}; + #\u{1116E}; + #\u{1116F}; + #\u{11170}; + #\u{11171}; + #\u{11172}; + #\u{11176}; + #\u{111DA}; + #\u{11200}; + #\u{11201}; + #\u{11202}; + #\u{11203}; + #\u{11204}; + #\u{11205}; + #\u{11206}; + #\u{11207}; + #\u{11208}; + #\u{11209}; + #\u{1120A}; + #\u{1120B}; + #\u{1120C}; + #\u{1120D}; + #\u{1120E}; + #\u{1120F}; + #\u{11210}; + #\u{11211}; + #\u{11213}; + #\u{11214}; + #\u{11215}; + #\u{11216}; + #\u{11217}; + #\u{11218}; + #\u{11219}; + #\u{1121A}; + #\u{1121B}; + #\u{1121C}; + #\u{1121D}; + #\u{1121E}; + #\u{1121F}; + #\u{11220}; + #\u{11221}; + #\u{11222}; + #\u{11223}; + #\u{11224}; + #\u{11225}; + #\u{11226}; + #\u{11227}; + #\u{11228}; + #\u{11229}; + #\u{1122A}; + #\u{1122B}; + #\u{112B0}; + #\u{112B1}; + #\u{112B2}; + #\u{112B3}; + #\u{112B4}; + #\u{112B5}; + #\u{112B6}; + #\u{112B7}; + #\u{112B8}; + #\u{112B9}; + #\u{112BA}; + #\u{112BB}; + #\u{112BC}; + #\u{112BD}; + #\u{112BE}; + #\u{112BF}; + #\u{112C0}; + #\u{112C1}; + #\u{112C2}; + #\u{112C3}; + #\u{112C4}; + #\u{112C5}; + #\u{112C6}; + #\u{112C7}; + #\u{112C8}; + #\u{112C9}; + #\u{112CA}; + #\u{112CB}; + #\u{112CC}; + #\u{112CD}; + #\u{112CE}; + #\u{112CF}; + #\u{112D0}; + #\u{112D1}; + #\u{112D2}; + #\u{112D3}; + #\u{112D4}; + #\u{112D5}; + #\u{112D6}; + #\u{112D7}; + #\u{112D8}; + #\u{112D9}; + #\u{112DA}; + #\u{112DB}; + #\u{112DC}; + #\u{112DD}; + #\u{112DE}; + #\u{11305}; + #\u{11306}; + #\u{11307}; + #\u{11308}; + #\u{11309}; + #\u{1130A}; + #\u{1130B}; + #\u{1130C}; + #\u{1130F}; + #\u{11310}; + #\u{11313}; + #\u{11314}; + #\u{11315}; + #\u{11316}; + #\u{11317}; + #\u{11318}; + #\u{11319}; + #\u{1131A}; + #\u{1131B}; + #\u{1131C}; + #\u{1131D}; + #\u{1131E}; + #\u{1131F}; + #\u{11320}; + #\u{11321}; + #\u{11322}; + #\u{11323}; + #\u{11324}; + #\u{11325}; + #\u{11326}; + #\u{11327}; + #\u{11328}; + #\u{1132A}; + #\u{1132B}; + #\u{1132C}; + #\u{1132D}; + #\u{1132E}; + #\u{1132F}; + #\u{11330}; + #\u{11332}; + #\u{11333}; + #\u{11335}; + #\u{11336}; + #\u{11337}; + #\u{11338}; + #\u{11339}; + #\u{1133D}; + #\u{1135D}; + #\u{1135E}; + #\u{1135F}; + #\u{11360}; + #\u{11361}; + #\u{11480}; + #\u{11481}; + #\u{11482}; + #\u{11483}; + #\u{11484}; + #\u{11485}; + #\u{11486}; + #\u{11487}; + #\u{11488}; + #\u{11489}; + #\u{1148A}; + #\u{1148B}; + #\u{1148C}; + #\u{1148D}; + #\u{1148E}; + #\u{1148F}; + #\u{11490}; + #\u{11491}; + #\u{11492}; + #\u{11493}; + #\u{11494}; + #\u{11495}; + #\u{11496}; + #\u{11497}; + #\u{11498}; + #\u{11499}; + #\u{1149A}; + #\u{1149B}; + #\u{1149C}; + #\u{1149D}; + #\u{1149E}; + #\u{1149F}; + #\u{114A0}; + #\u{114A1}; + #\u{114A2}; + #\u{114A3}; + #\u{114A4}; + #\u{114A5}; + #\u{114A6}; + #\u{114A7}; + #\u{114A8}; + #\u{114A9}; + #\u{114AA}; + #\u{114AB}; + #\u{114AC}; + #\u{114AD}; + #\u{114AE}; + #\u{114AF}; + #\u{114C4}; + #\u{114C5}; + #\u{114C7}; + #\u{11580}; + #\u{11581}; + #\u{11582}; + #\u{11583}; + #\u{11584}; + #\u{11585}; + #\u{11586}; + #\u{11587}; + #\u{11588}; + #\u{11589}; + #\u{1158A}; + #\u{1158B}; + #\u{1158C}; + #\u{1158D}; + #\u{1158E}; + #\u{1158F}; + #\u{11590}; + #\u{11591}; + #\u{11592}; + #\u{11593}; + #\u{11594}; + #\u{11595}; + #\u{11596}; + #\u{11597}; + #\u{11598}; + #\u{11599}; + #\u{1159A}; + #\u{1159B}; + #\u{1159C}; + #\u{1159D}; + #\u{1159E}; + #\u{1159F}; + #\u{115A0}; + #\u{115A1}; + #\u{115A2}; + #\u{115A3}; + #\u{115A4}; + #\u{115A5}; + #\u{115A6}; + #\u{115A7}; + #\u{115A8}; + #\u{115A9}; + #\u{115AA}; + #\u{115AB}; + #\u{115AC}; + #\u{115AD}; + #\u{115AE}; + #\u{11600}; + #\u{11601}; + #\u{11602}; + #\u{11603}; + #\u{11604}; + #\u{11605}; + #\u{11606}; + #\u{11607}; + #\u{11608}; + #\u{11609}; + #\u{1160A}; + #\u{1160B}; + #\u{1160C}; + #\u{1160D}; + #\u{1160E}; + #\u{1160F}; + #\u{11610}; + #\u{11611}; + #\u{11612}; + #\u{11613}; + #\u{11614}; + #\u{11615}; + #\u{11616}; + #\u{11617}; + #\u{11618}; + #\u{11619}; + #\u{1161A}; + #\u{1161B}; + #\u{1161C}; + #\u{1161D}; + #\u{1161E}; + #\u{1161F}; + #\u{11620}; + #\u{11621}; + #\u{11622}; + #\u{11623}; + #\u{11624}; + #\u{11625}; + #\u{11626}; + #\u{11627}; + #\u{11628}; + #\u{11629}; + #\u{1162A}; + #\u{1162B}; + #\u{1162C}; + #\u{1162D}; + #\u{1162E}; + #\u{1162F}; + #\u{11644}; + #\u{118A0}; + #\u{118A1}; + #\u{118A2}; + #\u{118A3}; + #\u{118A4}; + #\u{118A5}; + #\u{118A6}; + #\u{118A7}; + #\u{118A8}; + #\u{118A9}; + #\u{118AA}; + #\u{118AB}; + #\u{118AC}; + #\u{118AD}; + #\u{118AE}; + #\u{118AF}; + #\u{118B0}; + #\u{118B1}; + #\u{118B2}; + #\u{118B3}; + #\u{118B4}; + #\u{118B5}; + #\u{118B6}; + #\u{118B7}; + #\u{118B8}; + #\u{118B9}; + #\u{118BA}; + #\u{118BB}; + #\u{118BC}; + #\u{118BD}; + #\u{118BE}; + #\u{118BF}; + #\u{118C0}; + #\u{118C1}; + #\u{118C2}; + #\u{118C3}; + #\u{118C4}; + #\u{118C5}; + #\u{118C6}; + #\u{118C7}; + #\u{118C8}; + #\u{118C9}; + #\u{118CA}; + #\u{118CB}; + #\u{118CC}; + #\u{118CD}; + #\u{118CE}; + #\u{118CF}; + #\u{118D0}; + #\u{118D1}; + #\u{118D2}; + #\u{118D3}; + #\u{118D4}; + #\u{118D5}; + #\u{118D6}; + #\u{118D7}; + #\u{118D8}; + #\u{118D9}; + #\u{118DA}; + #\u{118DB}; + #\u{118DC}; + #\u{118DD}; + #\u{118DE}; + #\u{118DF}; + #\u{118FF}; + #\u{11AC0}; + #\u{11AC1}; + #\u{11AC2}; + #\u{11AC3}; + #\u{11AC4}; + #\u{11AC5}; + #\u{11AC6}; + #\u{11AC7}; + #\u{11AC8}; + #\u{11AC9}; + #\u{11ACA}; + #\u{11ACB}; + #\u{11ACC}; + #\u{11ACD}; + #\u{11ACE}; + #\u{11ACF}; + #\u{11AD0}; + #\u{11AD1}; + #\u{11AD2}; + #\u{11AD3}; + #\u{11AD4}; + #\u{11AD5}; + #\u{11AD6}; + #\u{11AD7}; + #\u{11AD8}; + #\u{11AD9}; + #\u{11ADA}; + #\u{11ADB}; + #\u{11ADC}; + #\u{11ADD}; + #\u{11ADE}; + #\u{11ADF}; + #\u{11AE0}; + #\u{11AE1}; + #\u{11AE2}; + #\u{11AE3}; + #\u{11AE4}; + #\u{11AE5}; + #\u{11AE6}; + #\u{11AE7}; + #\u{11AE8}; + #\u{11AE9}; + #\u{11AEA}; + #\u{11AEB}; + #\u{11AEC}; + #\u{11AED}; + #\u{11AEE}; + #\u{11AEF}; + #\u{11AF0}; + #\u{11AF1}; + #\u{11AF2}; + #\u{11AF3}; + #\u{11AF4}; + #\u{11AF5}; + #\u{11AF6}; + #\u{11AF7}; + #\u{11AF8}; + #\u{1236F}; + #\u{12370}; + #\u{12371}; + #\u{12372}; + #\u{12373}; + #\u{12374}; + #\u{12375}; + #\u{12376}; + #\u{12377}; + #\u{12378}; + #\u{12379}; + #\u{1237A}; + #\u{1237B}; + #\u{1237C}; + #\u{1237D}; + #\u{1237E}; + #\u{1237F}; + #\u{12380}; + #\u{12381}; + #\u{12382}; + #\u{12383}; + #\u{12384}; + #\u{12385}; + #\u{12386}; + #\u{12387}; + #\u{12388}; + #\u{12389}; + #\u{1238A}; + #\u{1238B}; + #\u{1238C}; + #\u{1238D}; + #\u{1238E}; + #\u{1238F}; + #\u{12390}; + #\u{12391}; + #\u{12392}; + #\u{12393}; + #\u{12394}; + #\u{12395}; + #\u{12396}; + #\u{12397}; + #\u{12398}; + #\u{12463}; + #\u{12464}; + #\u{12465}; + #\u{12466}; + #\u{12467}; + #\u{12468}; + #\u{12469}; + #\u{1246A}; + #\u{1246B}; + #\u{1246C}; + #\u{1246D}; + #\u{1246E}; + #\u{16A40}; + #\u{16A41}; + #\u{16A42}; + #\u{16A43}; + #\u{16A44}; + #\u{16A45}; + #\u{16A46}; + #\u{16A47}; + #\u{16A48}; + #\u{16A49}; + #\u{16A4A}; + #\u{16A4B}; + #\u{16A4C}; + #\u{16A4D}; + #\u{16A4E}; + #\u{16A4F}; + #\u{16A50}; + #\u{16A51}; + #\u{16A52}; + #\u{16A53}; + #\u{16A54}; + #\u{16A55}; + #\u{16A56}; + #\u{16A57}; + #\u{16A58}; + #\u{16A59}; + #\u{16A5A}; + #\u{16A5B}; + #\u{16A5C}; + #\u{16A5D}; + #\u{16A5E}; + #\u{16AD0}; + #\u{16AD1}; + #\u{16AD2}; + #\u{16AD3}; + #\u{16AD4}; + #\u{16AD5}; + #\u{16AD6}; + #\u{16AD7}; + #\u{16AD8}; + #\u{16AD9}; + #\u{16ADA}; + #\u{16ADB}; + #\u{16ADC}; + #\u{16ADD}; + #\u{16ADE}; + #\u{16ADF}; + #\u{16AE0}; + #\u{16AE1}; + #\u{16AE2}; + #\u{16AE3}; + #\u{16AE4}; + #\u{16AE5}; + #\u{16AE6}; + #\u{16AE7}; + #\u{16AE8}; + #\u{16AE9}; + #\u{16AEA}; + #\u{16AEB}; + #\u{16AEC}; + #\u{16AED}; + #\u{16B00}; + #\u{16B01}; + #\u{16B02}; + #\u{16B03}; + #\u{16B04}; + #\u{16B05}; + #\u{16B06}; + #\u{16B07}; + #\u{16B08}; + #\u{16B09}; + #\u{16B0A}; + #\u{16B0B}; + #\u{16B0C}; + #\u{16B0D}; + #\u{16B0E}; + #\u{16B0F}; + #\u{16B10}; + #\u{16B11}; + #\u{16B12}; + #\u{16B13}; + #\u{16B14}; + #\u{16B15}; + #\u{16B16}; + #\u{16B17}; + #\u{16B18}; + #\u{16B19}; + #\u{16B1A}; + #\u{16B1B}; + #\u{16B1C}; + #\u{16B1D}; + #\u{16B1E}; + #\u{16B1F}; + #\u{16B20}; + #\u{16B21}; + #\u{16B22}; + #\u{16B23}; + #\u{16B24}; + #\u{16B25}; + #\u{16B26}; + #\u{16B27}; + #\u{16B28}; + #\u{16B29}; + #\u{16B2A}; + #\u{16B2B}; + #\u{16B2C}; + #\u{16B2D}; + #\u{16B2E}; + #\u{16B2F}; + #\u{16B40}; + #\u{16B41}; + #\u{16B42}; + #\u{16B43}; + #\u{16B63}; + #\u{16B64}; + #\u{16B65}; + #\u{16B66}; + #\u{16B67}; + #\u{16B68}; + #\u{16B69}; + #\u{16B6A}; + #\u{16B6B}; + #\u{16B6C}; + #\u{16B6D}; + #\u{16B6E}; + #\u{16B6F}; + #\u{16B70}; + #\u{16B71}; + #\u{16B72}; + #\u{16B73}; + #\u{16B74}; + #\u{16B75}; + #\u{16B76}; + #\u{16B77}; + #\u{16B7D}; + #\u{16B7E}; + #\u{16B7F}; + #\u{16B80}; + #\u{16B81}; + #\u{16B82}; + #\u{16B83}; + #\u{16B84}; + #\u{16B85}; + #\u{16B86}; + #\u{16B87}; + #\u{16B88}; + #\u{16B89}; + #\u{16B8A}; + #\u{16B8B}; + #\u{16B8C}; + #\u{16B8D}; + #\u{16B8E}; + #\u{16B8F}; + #\u{1BC00}; + #\u{1BC01}; + #\u{1BC02}; + #\u{1BC03}; + #\u{1BC04}; + #\u{1BC05}; + #\u{1BC06}; + #\u{1BC07}; + #\u{1BC08}; + #\u{1BC09}; + #\u{1BC0A}; + #\u{1BC0B}; + #\u{1BC0C}; + #\u{1BC0D}; + #\u{1BC0E}; + #\u{1BC0F}; + #\u{1BC10}; + #\u{1BC11}; + #\u{1BC12}; + #\u{1BC13}; + #\u{1BC14}; + #\u{1BC15}; + #\u{1BC16}; + #\u{1BC17}; + #\u{1BC18}; + #\u{1BC19}; + #\u{1BC1A}; + #\u{1BC1B}; + #\u{1BC1C}; + #\u{1BC1D}; + #\u{1BC1E}; + #\u{1BC1F}; + #\u{1BC20}; + #\u{1BC21}; + #\u{1BC22}; + #\u{1BC23}; + #\u{1BC24}; + #\u{1BC25}; + #\u{1BC26}; + #\u{1BC27}; + #\u{1BC28}; + #\u{1BC29}; + #\u{1BC2A}; + #\u{1BC2B}; + #\u{1BC2C}; + #\u{1BC2D}; + #\u{1BC2E}; + #\u{1BC2F}; + #\u{1BC30}; + #\u{1BC31}; + #\u{1BC32}; + #\u{1BC33}; + #\u{1BC34}; + #\u{1BC35}; + #\u{1BC36}; + #\u{1BC37}; + #\u{1BC38}; + #\u{1BC39}; + #\u{1BC3A}; + #\u{1BC3B}; + #\u{1BC3C}; + #\u{1BC3D}; + #\u{1BC3E}; + #\u{1BC3F}; + #\u{1BC40}; + #\u{1BC41}; + #\u{1BC42}; + #\u{1BC43}; + #\u{1BC44}; + #\u{1BC45}; + #\u{1BC46}; + #\u{1BC47}; + #\u{1BC48}; + #\u{1BC49}; + #\u{1BC4A}; + #\u{1BC4B}; + #\u{1BC4C}; + #\u{1BC4D}; + #\u{1BC4E}; + #\u{1BC4F}; + #\u{1BC50}; + #\u{1BC51}; + #\u{1BC52}; + #\u{1BC53}; + #\u{1BC54}; + #\u{1BC55}; + #\u{1BC56}; + #\u{1BC57}; + #\u{1BC58}; + #\u{1BC59}; + #\u{1BC5A}; + #\u{1BC5B}; + #\u{1BC5C}; + #\u{1BC5D}; + #\u{1BC5E}; + #\u{1BC5F}; + #\u{1BC60}; + #\u{1BC61}; + #\u{1BC62}; + #\u{1BC63}; + #\u{1BC64}; + #\u{1BC65}; + #\u{1BC66}; + #\u{1BC67}; + #\u{1BC68}; + #\u{1BC69}; + #\u{1BC6A}; + #\u{1BC70}; + #\u{1BC71}; + #\u{1BC72}; + #\u{1BC73}; + #\u{1BC74}; + #\u{1BC75}; + #\u{1BC76}; + #\u{1BC77}; + #\u{1BC78}; + #\u{1BC79}; + #\u{1BC7A}; + #\u{1BC7B}; + #\u{1BC7C}; + #\u{1BC80}; + #\u{1BC81}; + #\u{1BC82}; + #\u{1BC83}; + #\u{1BC84}; + #\u{1BC85}; + #\u{1BC86}; + #\u{1BC87}; + #\u{1BC88}; + #\u{1BC90}; + #\u{1BC91}; + #\u{1BC92}; + #\u{1BC93}; + #\u{1BC94}; + #\u{1BC95}; + #\u{1BC96}; + #\u{1BC97}; + #\u{1BC98}; + #\u{1BC99}; + #\u{1E800}; + #\u{1E801}; + #\u{1E802}; + #\u{1E803}; + #\u{1E804}; + #\u{1E805}; + #\u{1E806}; + #\u{1E807}; + #\u{1E808}; + #\u{1E809}; + #\u{1E80A}; + #\u{1E80B}; + #\u{1E80C}; + #\u{1E80D}; + #\u{1E80E}; + #\u{1E80F}; + #\u{1E810}; + #\u{1E811}; + #\u{1E812}; + #\u{1E813}; + #\u{1E814}; + #\u{1E815}; + #\u{1E816}; + #\u{1E817}; + #\u{1E818}; + #\u{1E819}; + #\u{1E81A}; + #\u{1E81B}; + #\u{1E81C}; + #\u{1E81D}; + #\u{1E81E}; + #\u{1E81F}; + #\u{1E820}; + #\u{1E821}; + #\u{1E822}; + #\u{1E823}; + #\u{1E824}; + #\u{1E825}; + #\u{1E826}; + #\u{1E827}; + #\u{1E828}; + #\u{1E829}; + #\u{1E82A}; + #\u{1E82B}; + #\u{1E82C}; + #\u{1E82D}; + #\u{1E82E}; + #\u{1E82F}; + #\u{1E830}; + #\u{1E831}; + #\u{1E832}; + #\u{1E833}; + #\u{1E834}; + #\u{1E835}; + #\u{1E836}; + #\u{1E837}; + #\u{1E838}; + #\u{1E839}; + #\u{1E83A}; + #\u{1E83B}; + #\u{1E83C}; + #\u{1E83D}; + #\u{1E83E}; + #\u{1E83F}; + #\u{1E840}; + #\u{1E841}; + #\u{1E842}; + #\u{1E843}; + #\u{1E844}; + #\u{1E845}; + #\u{1E846}; + #\u{1E847}; + #\u{1E848}; + #\u{1E849}; + #\u{1E84A}; + #\u{1E84B}; + #\u{1E84C}; + #\u{1E84D}; + #\u{1E84E}; + #\u{1E84F}; + #\u{1E850}; + #\u{1E851}; + #\u{1E852}; + #\u{1E853}; + #\u{1E854}; + #\u{1E855}; + #\u{1E856}; + #\u{1E857}; + #\u{1E858}; + #\u{1E859}; + #\u{1E85A}; + #\u{1E85B}; + #\u{1E85C}; + #\u{1E85D}; + #\u{1E85E}; + #\u{1E85F}; + #\u{1E860}; + #\u{1E861}; + #\u{1E862}; + #\u{1E863}; + #\u{1E864}; + #\u{1E865}; + #\u{1E866}; + #\u{1E867}; + #\u{1E868}; + #\u{1E869}; + #\u{1E86A}; + #\u{1E86B}; + #\u{1E86C}; + #\u{1E86D}; + #\u{1E86E}; + #\u{1E86F}; + #\u{1E870}; + #\u{1E871}; + #\u{1E872}; + #\u{1E873}; + #\u{1E874}; + #\u{1E875}; + #\u{1E876}; + #\u{1E877}; + #\u{1E878}; + #\u{1E879}; + #\u{1E87A}; + #\u{1E87B}; + #\u{1E87C}; + #\u{1E87D}; + #\u{1E87E}; + #\u{1E87F}; + #\u{1E880}; + #\u{1E881}; + #\u{1E882}; + #\u{1E883}; + #\u{1E884}; + #\u{1E885}; + #\u{1E886}; + #\u{1E887}; + #\u{1E888}; + #\u{1E889}; + #\u{1E88A}; + #\u{1E88B}; + #\u{1E88C}; + #\u{1E88D}; + #\u{1E88E}; + #\u{1E88F}; + #\u{1E890}; + #\u{1E891}; + #\u{1E892}; + #\u{1E893}; + #\u{1E894}; + #\u{1E895}; + #\u{1E896}; + #\u{1E897}; + #\u{1E898}; + #\u{1E899}; + #\u{1E89A}; + #\u{1E89B}; + #\u{1E89C}; + #\u{1E89D}; + #\u{1E89E}; + #\u{1E89F}; + #\u{1E8A0}; + #\u{1E8A1}; + #\u{1E8A2}; + #\u{1E8A3}; + #\u{1E8A4}; + #\u{1E8A5}; + #\u{1E8A6}; + #\u{1E8A7}; + #\u{1E8A8}; + #\u{1E8A9}; + #\u{1E8AA}; + #\u{1E8AB}; + #\u{1E8AC}; + #\u{1E8AD}; + #\u{1E8AE}; + #\u{1E8AF}; + #\u{1E8B0}; + #\u{1E8B1}; + #\u{1E8B2}; + #\u{1E8B3}; + #\u{1E8B4}; + #\u{1E8B5}; + #\u{1E8B6}; + #\u{1E8B7}; + #\u{1E8B8}; + #\u{1E8B9}; + #\u{1E8BA}; + #\u{1E8BB}; + #\u{1E8BC}; + #\u{1E8BD}; + #\u{1E8BE}; + #\u{1E8BF}; + #\u{1E8C0}; + #\u{1E8C1}; + #\u{1E8C2}; + #\u{1E8C3}; + #\u{1E8C4}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0-class.js new file mode 100644 index 000000000..54e0ddbc8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0-class.js @@ -0,0 +1,1740 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v7.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #Ϳ; + #Ԩ; + #ԩ; + #Ԫ; + #ԫ; + #Ԭ; + #ԭ; + #Ԯ; + #ԯ; + #ࢡ; + #ࢭ; + #ࢮ; + #ࢯ; + #ࢰ; + #ࢱ; + #ࢲ; + #ॸ; + #ঀ; + #ఴ; + #ᛱ; + #ᛲ; + #ᛳ; + #ᛴ; + #ᛵ; + #ᛶ; + #ᛷ; + #ᛸ; + #ᤝ; + #ᤞ; + #Ꚙ; + #ꚙ; + #Ꚛ; + #ꚛ; + #ꚜ; + #ꚝ; + #ꞔ; + #ꞕ; + #Ꞗ; + #ꞗ; + #Ꞙ; + #ꞙ; + #Ꞛ; + #ꞛ; + #Ꞝ; + #ꞝ; + #Ꞟ; + #ꞟ; + #Ɜ; + #Ɡ; + #Ɬ; + #Ʞ; + #Ʇ; + #ꟷ; + #ꧠ; + #ꧡ; + #ꧢ; + #ꧣ; + #ꧤ; + #ꧦ; + #ꧧ; + #ꧨ; + #ꧩ; + #ꧪ; + #ꧫ; + #ꧬ; + #ꧭ; + #ꧮ; + #ꧯ; + #ꧺ; + #ꧻ; + #ꧼ; + #ꧽ; + #ꧾ; + #ꩾ; + #ꩿ; + #ꬰ; + #ꬱ; + #ꬲ; + #ꬳ; + #ꬴ; + #ꬵ; + #ꬶ; + #ꬷ; + #ꬸ; + #ꬹ; + #ꬺ; + #ꬻ; + #ꬼ; + #ꬽ; + #ꬾ; + #ꬿ; + #ꭀ; + #ꭁ; + #ꭂ; + #ꭃ; + #ꭄ; + #ꭅ; + #ꭆ; + #ꭇ; + #ꭈ; + #ꭉ; + #ꭊ; + #ꭋ; + #ꭌ; + #ꭍ; + #ꭎ; + #ꭏ; + #ꭐ; + #ꭑ; + #ꭒ; + #ꭓ; + #ꭔ; + #ꭕ; + #ꭖ; + #ꭗ; + #ꭘ; + #ꭙ; + #ꭚ; + #ꭜ; + #ꭝ; + #ꭞ; + #ꭟ; + #ꭤ; + #ꭥ; + #𐌟; + #𐍐; + #𐍑; + #𐍒; + #𐍓; + #𐍔; + #𐍕; + #𐍖; + #𐍗; + #𐍘; + #𐍙; + #𐍚; + #𐍛; + #𐍜; + #𐍝; + #𐍞; + #𐍟; + #𐍠; + #𐍡; + #𐍢; + #𐍣; + #𐍤; + #𐍥; + #𐍦; + #𐍧; + #𐍨; + #𐍩; + #𐍪; + #𐍫; + #𐍬; + #𐍭; + #𐍮; + #𐍯; + #𐍰; + #𐍱; + #𐍲; + #𐍳; + #𐍴; + #𐍵; + #𐔀; + #𐔁; + #𐔂; + #𐔃; + #𐔄; + #𐔅; + #𐔆; + #𐔇; + #𐔈; + #𐔉; + #𐔊; + #𐔋; + #𐔌; + #𐔍; + #𐔎; + #𐔏; + #𐔐; + #𐔑; + #𐔒; + #𐔓; + #𐔔; + #𐔕; + #𐔖; + #𐔗; + #𐔘; + #𐔙; + #𐔚; + #𐔛; + #𐔜; + #𐔝; + #𐔞; + #𐔟; + #𐔠; + #𐔡; + #𐔢; + #𐔣; + #𐔤; + #𐔥; + #𐔦; + #𐔧; + #𐔰; + #𐔱; + #𐔲; + #𐔳; + #𐔴; + #𐔵; + #𐔶; + #𐔷; + #𐔸; + #𐔹; + #𐔺; + #𐔻; + #𐔼; + #𐔽; + #𐔾; + #𐔿; + #𐕀; + #𐕁; + #𐕂; + #𐕃; + #𐕄; + #𐕅; + #𐕆; + #𐕇; + #𐕈; + #𐕉; + #𐕊; + #𐕋; + #𐕌; + #𐕍; + #𐕎; + #𐕏; + #𐕐; + #𐕑; + #𐕒; + #𐕓; + #𐕔; + #𐕕; + #𐕖; + #𐕗; + #𐕘; + #𐕙; + #𐕚; + #𐕛; + #𐕜; + #𐕝; + #𐕞; + #𐕟; + #𐕠; + #𐕡; + #𐕢; + #𐕣; + #𐘀; + #𐘁; + #𐘂; + #𐘃; + #𐘄; + #𐘅; + #𐘆; + #𐘇; + #𐘈; + #𐘉; + #𐘊; + #𐘋; + #𐘌; + #𐘍; + #𐘎; + #𐘏; + #𐘐; + #𐘑; + #𐘒; + #𐘓; + #𐘔; + #𐘕; + #𐘖; + #𐘗; + #𐘘; + #𐘙; + #𐘚; + #𐘛; + #𐘜; + #𐘝; + #𐘞; + #𐘟; + #𐘠; + #𐘡; + #𐘢; + #𐘣; + #𐘤; + #𐘥; + #𐘦; + #𐘧; + #𐘨; + #𐘩; + #𐘪; + #𐘫; + #𐘬; + #𐘭; + #𐘮; + #𐘯; + #𐘰; + #𐘱; + #𐘲; + #𐘳; + #𐘴; + #𐘵; + #𐘶; + #𐘷; + #𐘸; + #𐘹; + #𐘺; + #𐘻; + #𐘼; + #𐘽; + #𐘾; + #𐘿; + #𐙀; + #𐙁; + #𐙂; + #𐙃; + #𐙄; + #𐙅; + #𐙆; + #𐙇; + #𐙈; + #𐙉; + #𐙊; + #𐙋; + #𐙌; + #𐙍; + #𐙎; + #𐙏; + #𐙐; + #𐙑; + #𐙒; + #𐙓; + #𐙔; + #𐙕; + #𐙖; + #𐙗; + #𐙘; + #𐙙; + #𐙚; + #𐙛; + #𐙜; + #𐙝; + #𐙞; + #𐙟; + #𐙠; + #𐙡; + #𐙢; + #𐙣; + #𐙤; + #𐙥; + #𐙦; + #𐙧; + #𐙨; + #𐙩; + #𐙪; + #𐙫; + #𐙬; + #𐙭; + #𐙮; + #𐙯; + #𐙰; + #𐙱; + #𐙲; + #𐙳; + #𐙴; + #𐙵; + #𐙶; + #𐙷; + #𐙸; + #𐙹; + #𐙺; + #𐙻; + #𐙼; + #𐙽; + #𐙾; + #𐙿; + #𐚀; + #𐚁; + #𐚂; + #𐚃; + #𐚄; + #𐚅; + #𐚆; + #𐚇; + #𐚈; + #𐚉; + #𐚊; + #𐚋; + #𐚌; + #𐚍; + #𐚎; + #𐚏; + #𐚐; + #𐚑; + #𐚒; + #𐚓; + #𐚔; + #𐚕; + #𐚖; + #𐚗; + #𐚘; + #𐚙; + #𐚚; + #𐚛; + #𐚜; + #𐚝; + #𐚞; + #𐚟; + #𐚠; + #𐚡; + #𐚢; + #𐚣; + #𐚤; + #𐚥; + #𐚦; + #𐚧; + #𐚨; + #𐚩; + #𐚪; + #𐚫; + #𐚬; + #𐚭; + #𐚮; + #𐚯; + #𐚰; + #𐚱; + #𐚲; + #𐚳; + #𐚴; + #𐚵; + #𐚶; + #𐚷; + #𐚸; + #𐚹; + #𐚺; + #𐚻; + #𐚼; + #𐚽; + #𐚾; + #𐚿; + #𐛀; + #𐛁; + #𐛂; + #𐛃; + #𐛄; + #𐛅; + #𐛆; + #𐛇; + #𐛈; + #𐛉; + #𐛊; + #𐛋; + #𐛌; + #𐛍; + #𐛎; + #𐛏; + #𐛐; + #𐛑; + #𐛒; + #𐛓; + #𐛔; + #𐛕; + #𐛖; + #𐛗; + #𐛘; + #𐛙; + #𐛚; + #𐛛; + #𐛜; + #𐛝; + #𐛞; + #𐛟; + #𐛠; + #𐛡; + #𐛢; + #𐛣; + #𐛤; + #𐛥; + #𐛦; + #𐛧; + #𐛨; + #𐛩; + #𐛪; + #𐛫; + #𐛬; + #𐛭; + #𐛮; + #𐛯; + #𐛰; + #𐛱; + #𐛲; + #𐛳; + #𐛴; + #𐛵; + #𐛶; + #𐛷; + #𐛸; + #𐛹; + #𐛺; + #𐛻; + #𐛼; + #𐛽; + #𐛾; + #𐛿; + #𐜀; + #𐜁; + #𐜂; + #𐜃; + #𐜄; + #𐜅; + #𐜆; + #𐜇; + #𐜈; + #𐜉; + #𐜊; + #𐜋; + #𐜌; + #𐜍; + #𐜎; + #𐜏; + #𐜐; + #𐜑; + #𐜒; + #𐜓; + #𐜔; + #𐜕; + #𐜖; + #𐜗; + #𐜘; + #𐜙; + #𐜚; + #𐜛; + #𐜜; + #𐜝; + #𐜞; + #𐜟; + #𐜠; + #𐜡; + #𐜢; + #𐜣; + #𐜤; + #𐜥; + #𐜦; + #𐜧; + #𐜨; + #𐜩; + #𐜪; + #𐜫; + #𐜬; + #𐜭; + #𐜮; + #𐜯; + #𐜰; + #𐜱; + #𐜲; + #𐜳; + #𐜴; + #𐜵; + #𐜶; + #𐝀; + #𐝁; + #𐝂; + #𐝃; + #𐝄; + #𐝅; + #𐝆; + #𐝇; + #𐝈; + #𐝉; + #𐝊; + #𐝋; + #𐝌; + #𐝍; + #𐝎; + #𐝏; + #𐝐; + #𐝑; + #𐝒; + #𐝓; + #𐝔; + #𐝕; + #𐝠; + #𐝡; + #𐝢; + #𐝣; + #𐝤; + #𐝥; + #𐝦; + #𐝧; + #𐡠; + #𐡡; + #𐡢; + #𐡣; + #𐡤; + #𐡥; + #𐡦; + #𐡧; + #𐡨; + #𐡩; + #𐡪; + #𐡫; + #𐡬; + #𐡭; + #𐡮; + #𐡯; + #𐡰; + #𐡱; + #𐡲; + #𐡳; + #𐡴; + #𐡵; + #𐡶; + #𐢀; + #𐢁; + #𐢂; + #𐢃; + #𐢄; + #𐢅; + #𐢆; + #𐢇; + #𐢈; + #𐢉; + #𐢊; + #𐢋; + #𐢌; + #𐢍; + #𐢎; + #𐢏; + #𐢐; + #𐢑; + #𐢒; + #𐢓; + #𐢔; + #𐢕; + #𐢖; + #𐢗; + #𐢘; + #𐢙; + #𐢚; + #𐢛; + #𐢜; + #𐢝; + #𐢞; + #𐪀; + #𐪁; + #𐪂; + #𐪃; + #𐪄; + #𐪅; + #𐪆; + #𐪇; + #𐪈; + #𐪉; + #𐪊; + #𐪋; + #𐪌; + #𐪍; + #𐪎; + #𐪏; + #𐪐; + #𐪑; + #𐪒; + #𐪓; + #𐪔; + #𐪕; + #𐪖; + #𐪗; + #𐪘; + #𐪙; + #𐪚; + #𐪛; + #𐪜; + #𐫀; + #𐫁; + #𐫂; + #𐫃; + #𐫄; + #𐫅; + #𐫆; + #𐫇; + #𐫉; + #𐫊; + #𐫋; + #𐫌; + #𐫍; + #𐫎; + #𐫏; + #𐫐; + #𐫑; + #𐫒; + #𐫓; + #𐫔; + #𐫕; + #𐫖; + #𐫗; + #𐫘; + #𐫙; + #𐫚; + #𐫛; + #𐫜; + #𐫝; + #𐫞; + #𐫟; + #𐫠; + #𐫡; + #𐫢; + #𐫣; + #𐫤; + #𐮀; + #𐮁; + #𐮂; + #𐮃; + #𐮄; + #𐮅; + #𐮆; + #𐮇; + #𐮈; + #𐮉; + #𐮊; + #𐮋; + #𐮌; + #𐮍; + #𐮎; + #𐮏; + #𐮐; + #𐮑; + #𑅐; + #𑅑; + #𑅒; + #𑅓; + #𑅔; + #𑅕; + #𑅖; + #𑅗; + #𑅘; + #𑅙; + #𑅚; + #𑅛; + #𑅜; + #𑅝; + #𑅞; + #𑅟; + #𑅠; + #𑅡; + #𑅢; + #𑅣; + #𑅤; + #𑅥; + #𑅦; + #𑅧; + #𑅨; + #𑅩; + #𑅪; + #𑅫; + #𑅬; + #𑅭; + #𑅮; + #𑅯; + #𑅰; + #𑅱; + #𑅲; + #𑅶; + #𑇚; + #𑈀; + #𑈁; + #𑈂; + #𑈃; + #𑈄; + #𑈅; + #𑈆; + #𑈇; + #𑈈; + #𑈉; + #𑈊; + #𑈋; + #𑈌; + #𑈍; + #𑈎; + #𑈏; + #𑈐; + #𑈑; + #𑈓; + #𑈔; + #𑈕; + #𑈖; + #𑈗; + #𑈘; + #𑈙; + #𑈚; + #𑈛; + #𑈜; + #𑈝; + #𑈞; + #𑈟; + #𑈠; + #𑈡; + #𑈢; + #𑈣; + #𑈤; + #𑈥; + #𑈦; + #𑈧; + #𑈨; + #𑈩; + #𑈪; + #𑈫; + #𑊰; + #𑊱; + #𑊲; + #𑊳; + #𑊴; + #𑊵; + #𑊶; + #𑊷; + #𑊸; + #𑊹; + #𑊺; + #𑊻; + #𑊼; + #𑊽; + #𑊾; + #𑊿; + #𑋀; + #𑋁; + #𑋂; + #𑋃; + #𑋄; + #𑋅; + #𑋆; + #𑋇; + #𑋈; + #𑋉; + #𑋊; + #𑋋; + #𑋌; + #𑋍; + #𑋎; + #𑋏; + #𑋐; + #𑋑; + #𑋒; + #𑋓; + #𑋔; + #𑋕; + #𑋖; + #𑋗; + #𑋘; + #𑋙; + #𑋚; + #𑋛; + #𑋜; + #𑋝; + #𑋞; + #𑌅; + #𑌆; + #𑌇; + #𑌈; + #𑌉; + #𑌊; + #𑌋; + #𑌌; + #𑌏; + #𑌐; + #𑌓; + #𑌔; + #𑌕; + #𑌖; + #𑌗; + #𑌘; + #𑌙; + #𑌚; + #𑌛; + #𑌜; + #𑌝; + #𑌞; + #𑌟; + #𑌠; + #𑌡; + #𑌢; + #𑌣; + #𑌤; + #𑌥; + #𑌦; + #𑌧; + #𑌨; + #𑌪; + #𑌫; + #𑌬; + #𑌭; + #𑌮; + #𑌯; + #𑌰; + #𑌲; + #𑌳; + #𑌵; + #𑌶; + #𑌷; + #𑌸; + #𑌹; + #𑌽; + #𑍝; + #𑍞; + #𑍟; + #𑍠; + #𑍡; + #𑒀; + #𑒁; + #𑒂; + #𑒃; + #𑒄; + #𑒅; + #𑒆; + #𑒇; + #𑒈; + #𑒉; + #𑒊; + #𑒋; + #𑒌; + #𑒍; + #𑒎; + #𑒏; + #𑒐; + #𑒑; + #𑒒; + #𑒓; + #𑒔; + #𑒕; + #𑒖; + #𑒗; + #𑒘; + #𑒙; + #𑒚; + #𑒛; + #𑒜; + #𑒝; + #𑒞; + #𑒟; + #𑒠; + #𑒡; + #𑒢; + #𑒣; + #𑒤; + #𑒥; + #𑒦; + #𑒧; + #𑒨; + #𑒩; + #𑒪; + #𑒫; + #𑒬; + #𑒭; + #𑒮; + #𑒯; + #𑓄; + #𑓅; + #𑓇; + #𑖀; + #𑖁; + #𑖂; + #𑖃; + #𑖄; + #𑖅; + #𑖆; + #𑖇; + #𑖈; + #𑖉; + #𑖊; + #𑖋; + #𑖌; + #𑖍; + #𑖎; + #𑖏; + #𑖐; + #𑖑; + #𑖒; + #𑖓; + #𑖔; + #𑖕; + #𑖖; + #𑖗; + #𑖘; + #𑖙; + #𑖚; + #𑖛; + #𑖜; + #𑖝; + #𑖞; + #𑖟; + #𑖠; + #𑖡; + #𑖢; + #𑖣; + #𑖤; + #𑖥; + #𑖦; + #𑖧; + #𑖨; + #𑖩; + #𑖪; + #𑖫; + #𑖬; + #𑖭; + #𑖮; + #𑘀; + #𑘁; + #𑘂; + #𑘃; + #𑘄; + #𑘅; + #𑘆; + #𑘇; + #𑘈; + #𑘉; + #𑘊; + #𑘋; + #𑘌; + #𑘍; + #𑘎; + #𑘏; + #𑘐; + #𑘑; + #𑘒; + #𑘓; + #𑘔; + #𑘕; + #𑘖; + #𑘗; + #𑘘; + #𑘙; + #𑘚; + #𑘛; + #𑘜; + #𑘝; + #𑘞; + #𑘟; + #𑘠; + #𑘡; + #𑘢; + #𑘣; + #𑘤; + #𑘥; + #𑘦; + #𑘧; + #𑘨; + #𑘩; + #𑘪; + #𑘫; + #𑘬; + #𑘭; + #𑘮; + #𑘯; + #𑙄; + #𑢠; + #𑢡; + #𑢢; + #𑢣; + #𑢤; + #𑢥; + #𑢦; + #𑢧; + #𑢨; + #𑢩; + #𑢪; + #𑢫; + #𑢬; + #𑢭; + #𑢮; + #𑢯; + #𑢰; + #𑢱; + #𑢲; + #𑢳; + #𑢴; + #𑢵; + #𑢶; + #𑢷; + #𑢸; + #𑢹; + #𑢺; + #𑢻; + #𑢼; + #𑢽; + #𑢾; + #𑢿; + #𑣀; + #𑣁; + #𑣂; + #𑣃; + #𑣄; + #𑣅; + #𑣆; + #𑣇; + #𑣈; + #𑣉; + #𑣊; + #𑣋; + #𑣌; + #𑣍; + #𑣎; + #𑣏; + #𑣐; + #𑣑; + #𑣒; + #𑣓; + #𑣔; + #𑣕; + #𑣖; + #𑣗; + #𑣘; + #𑣙; + #𑣚; + #𑣛; + #𑣜; + #𑣝; + #𑣞; + #𑣟; + #𑣿; + #𑫀; + #𑫁; + #𑫂; + #𑫃; + #𑫄; + #𑫅; + #𑫆; + #𑫇; + #𑫈; + #𑫉; + #𑫊; + #𑫋; + #𑫌; + #𑫍; + #𑫎; + #𑫏; + #𑫐; + #𑫑; + #𑫒; + #𑫓; + #𑫔; + #𑫕; + #𑫖; + #𑫗; + #𑫘; + #𑫙; + #𑫚; + #𑫛; + #𑫜; + #𑫝; + #𑫞; + #𑫟; + #𑫠; + #𑫡; + #𑫢; + #𑫣; + #𑫤; + #𑫥; + #𑫦; + #𑫧; + #𑫨; + #𑫩; + #𑫪; + #𑫫; + #𑫬; + #𑫭; + #𑫮; + #𑫯; + #𑫰; + #𑫱; + #𑫲; + #𑫳; + #𑫴; + #𑫵; + #𑫶; + #𑫷; + #𑫸; + #𒍯; + #𒍰; + #𒍱; + #𒍲; + #𒍳; + #𒍴; + #𒍵; + #𒍶; + #𒍷; + #𒍸; + #𒍹; + #𒍺; + #𒍻; + #𒍼; + #𒍽; + #𒍾; + #𒍿; + #𒎀; + #𒎁; + #𒎂; + #𒎃; + #𒎄; + #𒎅; + #𒎆; + #𒎇; + #𒎈; + #𒎉; + #𒎊; + #𒎋; + #𒎌; + #𒎍; + #𒎎; + #𒎏; + #𒎐; + #𒎑; + #𒎒; + #𒎓; + #𒎔; + #𒎕; + #𒎖; + #𒎗; + #𒎘; + #𒑣; + #𒑤; + #𒑥; + #𒑦; + #𒑧; + #𒑨; + #𒑩; + #𒑪; + #𒑫; + #𒑬; + #𒑭; + #𒑮; + #𖩀; + #𖩁; + #𖩂; + #𖩃; + #𖩄; + #𖩅; + #𖩆; + #𖩇; + #𖩈; + #𖩉; + #𖩊; + #𖩋; + #𖩌; + #𖩍; + #𖩎; + #𖩏; + #𖩐; + #𖩑; + #𖩒; + #𖩓; + #𖩔; + #𖩕; + #𖩖; + #𖩗; + #𖩘; + #𖩙; + #𖩚; + #𖩛; + #𖩜; + #𖩝; + #𖩞; + #𖫐; + #𖫑; + #𖫒; + #𖫓; + #𖫔; + #𖫕; + #𖫖; + #𖫗; + #𖫘; + #𖫙; + #𖫚; + #𖫛; + #𖫜; + #𖫝; + #𖫞; + #𖫟; + #𖫠; + #𖫡; + #𖫢; + #𖫣; + #𖫤; + #𖫥; + #𖫦; + #𖫧; + #𖫨; + #𖫩; + #𖫪; + #𖫫; + #𖫬; + #𖫭; + #𖬀; + #𖬁; + #𖬂; + #𖬃; + #𖬄; + #𖬅; + #𖬆; + #𖬇; + #𖬈; + #𖬉; + #𖬊; + #𖬋; + #𖬌; + #𖬍; + #𖬎; + #𖬏; + #𖬐; + #𖬑; + #𖬒; + #𖬓; + #𖬔; + #𖬕; + #𖬖; + #𖬗; + #𖬘; + #𖬙; + #𖬚; + #𖬛; + #𖬜; + #𖬝; + #𖬞; + #𖬟; + #𖬠; + #𖬡; + #𖬢; + #𖬣; + #𖬤; + #𖬥; + #𖬦; + #𖬧; + #𖬨; + #𖬩; + #𖬪; + #𖬫; + #𖬬; + #𖬭; + #𖬮; + #𖬯; + #𖭀; + #𖭁; + #𖭂; + #𖭃; + #𖭣; + #𖭤; + #𖭥; + #𖭦; + #𖭧; + #𖭨; + #𖭩; + #𖭪; + #𖭫; + #𖭬; + #𖭭; + #𖭮; + #𖭯; + #𖭰; + #𖭱; + #𖭲; + #𖭳; + #𖭴; + #𖭵; + #𖭶; + #𖭷; + #𖭽; + #𖭾; + #𖭿; + #𖮀; + #𖮁; + #𖮂; + #𖮃; + #𖮄; + #𖮅; + #𖮆; + #𖮇; + #𖮈; + #𖮉; + #𖮊; + #𖮋; + #𖮌; + #𖮍; + #𖮎; + #𖮏; + #𛰀; + #𛰁; + #𛰂; + #𛰃; + #𛰄; + #𛰅; + #𛰆; + #𛰇; + #𛰈; + #𛰉; + #𛰊; + #𛰋; + #𛰌; + #𛰍; + #𛰎; + #𛰏; + #𛰐; + #𛰑; + #𛰒; + #𛰓; + #𛰔; + #𛰕; + #𛰖; + #𛰗; + #𛰘; + #𛰙; + #𛰚; + #𛰛; + #𛰜; + #𛰝; + #𛰞; + #𛰟; + #𛰠; + #𛰡; + #𛰢; + #𛰣; + #𛰤; + #𛰥; + #𛰦; + #𛰧; + #𛰨; + #𛰩; + #𛰪; + #𛰫; + #𛰬; + #𛰭; + #𛰮; + #𛰯; + #𛰰; + #𛰱; + #𛰲; + #𛰳; + #𛰴; + #𛰵; + #𛰶; + #𛰷; + #𛰸; + #𛰹; + #𛰺; + #𛰻; + #𛰼; + #𛰽; + #𛰾; + #𛰿; + #𛱀; + #𛱁; + #𛱂; + #𛱃; + #𛱄; + #𛱅; + #𛱆; + #𛱇; + #𛱈; + #𛱉; + #𛱊; + #𛱋; + #𛱌; + #𛱍; + #𛱎; + #𛱏; + #𛱐; + #𛱑; + #𛱒; + #𛱓; + #𛱔; + #𛱕; + #𛱖; + #𛱗; + #𛱘; + #𛱙; + #𛱚; + #𛱛; + #𛱜; + #𛱝; + #𛱞; + #𛱟; + #𛱠; + #𛱡; + #𛱢; + #𛱣; + #𛱤; + #𛱥; + #𛱦; + #𛱧; + #𛱨; + #𛱩; + #𛱪; + #𛱰; + #𛱱; + #𛱲; + #𛱳; + #𛱴; + #𛱵; + #𛱶; + #𛱷; + #𛱸; + #𛱹; + #𛱺; + #𛱻; + #𛱼; + #𛲀; + #𛲁; + #𛲂; + #𛲃; + #𛲄; + #𛲅; + #𛲆; + #𛲇; + #𛲈; + #𛲐; + #𛲑; + #𛲒; + #𛲓; + #𛲔; + #𛲕; + #𛲖; + #𛲗; + #𛲘; + #𛲙; + #𞠀; + #𞠁; + #𞠂; + #𞠃; + #𞠄; + #𞠅; + #𞠆; + #𞠇; + #𞠈; + #𞠉; + #𞠊; + #𞠋; + #𞠌; + #𞠍; + #𞠎; + #𞠏; + #𞠐; + #𞠑; + #𞠒; + #𞠓; + #𞠔; + #𞠕; + #𞠖; + #𞠗; + #𞠘; + #𞠙; + #𞠚; + #𞠛; + #𞠜; + #𞠝; + #𞠞; + #𞠟; + #𞠠; + #𞠡; + #𞠢; + #𞠣; + #𞠤; + #𞠥; + #𞠦; + #𞠧; + #𞠨; + #𞠩; + #𞠪; + #𞠫; + #𞠬; + #𞠭; + #𞠮; + #𞠯; + #𞠰; + #𞠱; + #𞠲; + #𞠳; + #𞠴; + #𞠵; + #𞠶; + #𞠷; + #𞠸; + #𞠹; + #𞠺; + #𞠻; + #𞠼; + #𞠽; + #𞠾; + #𞠿; + #𞡀; + #𞡁; + #𞡂; + #𞡃; + #𞡄; + #𞡅; + #𞡆; + #𞡇; + #𞡈; + #𞡉; + #𞡊; + #𞡋; + #𞡌; + #𞡍; + #𞡎; + #𞡏; + #𞡐; + #𞡑; + #𞡒; + #𞡓; + #𞡔; + #𞡕; + #𞡖; + #𞡗; + #𞡘; + #𞡙; + #𞡚; + #𞡛; + #𞡜; + #𞡝; + #𞡞; + #𞡟; + #𞡠; + #𞡡; + #𞡢; + #𞡣; + #𞡤; + #𞡥; + #𞡦; + #𞡧; + #𞡨; + #𞡩; + #𞡪; + #𞡫; + #𞡬; + #𞡭; + #𞡮; + #𞡯; + #𞡰; + #𞡱; + #𞡲; + #𞡳; + #𞡴; + #𞡵; + #𞡶; + #𞡷; + #𞡸; + #𞡹; + #𞡺; + #𞡻; + #𞡼; + #𞡽; + #𞡾; + #𞡿; + #𞢀; + #𞢁; + #𞢂; + #𞢃; + #𞢄; + #𞢅; + #𞢆; + #𞢇; + #𞢈; + #𞢉; + #𞢊; + #𞢋; + #𞢌; + #𞢍; + #𞢎; + #𞢏; + #𞢐; + #𞢑; + #𞢒; + #𞢓; + #𞢔; + #𞢕; + #𞢖; + #𞢗; + #𞢘; + #𞢙; + #𞢚; + #𞢛; + #𞢜; + #𞢝; + #𞢞; + #𞢟; + #𞢠; + #𞢡; + #𞢢; + #𞢣; + #𞢤; + #𞢥; + #𞢦; + #𞢧; + #𞢨; + #𞢩; + #𞢪; + #𞢫; + #𞢬; + #𞢭; + #𞢮; + #𞢯; + #𞢰; + #𞢱; + #𞢲; + #𞢳; + #𞢴; + #𞢵; + #𞢶; + #𞢷; + #𞢸; + #𞢹; + #𞢺; + #𞢻; + #𞢼; + #𞢽; + #𞢾; + #𞢿; + #𞣀; + #𞣁; + #𞣂; + #𞣃; + #𞣄; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0-escaped.js new file mode 100644 index 000000000..926edf69a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0-escaped.js @@ -0,0 +1,1739 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v7.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u037F; +var \u0528; +var \u0529; +var \u052A; +var \u052B; +var \u052C; +var \u052D; +var \u052E; +var \u052F; +var \u08A1; +var \u08AD; +var \u08AE; +var \u08AF; +var \u08B0; +var \u08B1; +var \u08B2; +var \u0978; +var \u0980; +var \u0C34; +var \u16F1; +var \u16F2; +var \u16F3; +var \u16F4; +var \u16F5; +var \u16F6; +var \u16F7; +var \u16F8; +var \u191D; +var \u191E; +var \uA698; +var \uA699; +var \uA69A; +var \uA69B; +var \uA69C; +var \uA69D; +var \uA794; +var \uA795; +var \uA796; +var \uA797; +var \uA798; +var \uA799; +var \uA79A; +var \uA79B; +var \uA79C; +var \uA79D; +var \uA79E; +var \uA79F; +var \uA7AB; +var \uA7AC; +var \uA7AD; +var \uA7B0; +var \uA7B1; +var \uA7F7; +var \uA9E0; +var \uA9E1; +var \uA9E2; +var \uA9E3; +var \uA9E4; +var \uA9E6; +var \uA9E7; +var \uA9E8; +var \uA9E9; +var \uA9EA; +var \uA9EB; +var \uA9EC; +var \uA9ED; +var \uA9EE; +var \uA9EF; +var \uA9FA; +var \uA9FB; +var \uA9FC; +var \uA9FD; +var \uA9FE; +var \uAA7E; +var \uAA7F; +var \uAB30; +var \uAB31; +var \uAB32; +var \uAB33; +var \uAB34; +var \uAB35; +var \uAB36; +var \uAB37; +var \uAB38; +var \uAB39; +var \uAB3A; +var \uAB3B; +var \uAB3C; +var \uAB3D; +var \uAB3E; +var \uAB3F; +var \uAB40; +var \uAB41; +var \uAB42; +var \uAB43; +var \uAB44; +var \uAB45; +var \uAB46; +var \uAB47; +var \uAB48; +var \uAB49; +var \uAB4A; +var \uAB4B; +var \uAB4C; +var \uAB4D; +var \uAB4E; +var \uAB4F; +var \uAB50; +var \uAB51; +var \uAB52; +var \uAB53; +var \uAB54; +var \uAB55; +var \uAB56; +var \uAB57; +var \uAB58; +var \uAB59; +var \uAB5A; +var \uAB5C; +var \uAB5D; +var \uAB5E; +var \uAB5F; +var \uAB64; +var \uAB65; +var \u{1031F}; +var \u{10350}; +var \u{10351}; +var \u{10352}; +var \u{10353}; +var \u{10354}; +var \u{10355}; +var \u{10356}; +var \u{10357}; +var \u{10358}; +var \u{10359}; +var \u{1035A}; +var \u{1035B}; +var \u{1035C}; +var \u{1035D}; +var \u{1035E}; +var \u{1035F}; +var \u{10360}; +var \u{10361}; +var \u{10362}; +var \u{10363}; +var \u{10364}; +var \u{10365}; +var \u{10366}; +var \u{10367}; +var \u{10368}; +var \u{10369}; +var \u{1036A}; +var \u{1036B}; +var \u{1036C}; +var \u{1036D}; +var \u{1036E}; +var \u{1036F}; +var \u{10370}; +var \u{10371}; +var \u{10372}; +var \u{10373}; +var \u{10374}; +var \u{10375}; +var \u{10500}; +var \u{10501}; +var \u{10502}; +var \u{10503}; +var \u{10504}; +var \u{10505}; +var \u{10506}; +var \u{10507}; +var \u{10508}; +var \u{10509}; +var \u{1050A}; +var \u{1050B}; +var \u{1050C}; +var \u{1050D}; +var \u{1050E}; +var \u{1050F}; +var \u{10510}; +var \u{10511}; +var \u{10512}; +var \u{10513}; +var \u{10514}; +var \u{10515}; +var \u{10516}; +var \u{10517}; +var \u{10518}; +var \u{10519}; +var \u{1051A}; +var \u{1051B}; +var \u{1051C}; +var \u{1051D}; +var \u{1051E}; +var \u{1051F}; +var \u{10520}; +var \u{10521}; +var \u{10522}; +var \u{10523}; +var \u{10524}; +var \u{10525}; +var \u{10526}; +var \u{10527}; +var \u{10530}; +var \u{10531}; +var \u{10532}; +var \u{10533}; +var \u{10534}; +var \u{10535}; +var \u{10536}; +var \u{10537}; +var \u{10538}; +var \u{10539}; +var \u{1053A}; +var \u{1053B}; +var \u{1053C}; +var \u{1053D}; +var \u{1053E}; +var \u{1053F}; +var \u{10540}; +var \u{10541}; +var \u{10542}; +var \u{10543}; +var \u{10544}; +var \u{10545}; +var \u{10546}; +var \u{10547}; +var \u{10548}; +var \u{10549}; +var \u{1054A}; +var \u{1054B}; +var \u{1054C}; +var \u{1054D}; +var \u{1054E}; +var \u{1054F}; +var \u{10550}; +var \u{10551}; +var \u{10552}; +var \u{10553}; +var \u{10554}; +var \u{10555}; +var \u{10556}; +var \u{10557}; +var \u{10558}; +var \u{10559}; +var \u{1055A}; +var \u{1055B}; +var \u{1055C}; +var \u{1055D}; +var \u{1055E}; +var \u{1055F}; +var \u{10560}; +var \u{10561}; +var \u{10562}; +var \u{10563}; +var \u{10600}; +var \u{10601}; +var \u{10602}; +var \u{10603}; +var \u{10604}; +var \u{10605}; +var \u{10606}; +var \u{10607}; +var \u{10608}; +var \u{10609}; +var \u{1060A}; +var \u{1060B}; +var \u{1060C}; +var \u{1060D}; +var \u{1060E}; +var \u{1060F}; +var \u{10610}; +var \u{10611}; +var \u{10612}; +var \u{10613}; +var \u{10614}; +var \u{10615}; +var \u{10616}; +var \u{10617}; +var \u{10618}; +var \u{10619}; +var \u{1061A}; +var \u{1061B}; +var \u{1061C}; +var \u{1061D}; +var \u{1061E}; +var \u{1061F}; +var \u{10620}; +var \u{10621}; +var \u{10622}; +var \u{10623}; +var \u{10624}; +var \u{10625}; +var \u{10626}; +var \u{10627}; +var \u{10628}; +var \u{10629}; +var \u{1062A}; +var \u{1062B}; +var \u{1062C}; +var \u{1062D}; +var \u{1062E}; +var \u{1062F}; +var \u{10630}; +var \u{10631}; +var \u{10632}; +var \u{10633}; +var \u{10634}; +var \u{10635}; +var \u{10636}; +var \u{10637}; +var \u{10638}; +var \u{10639}; +var \u{1063A}; +var \u{1063B}; +var \u{1063C}; +var \u{1063D}; +var \u{1063E}; +var \u{1063F}; +var \u{10640}; +var \u{10641}; +var \u{10642}; +var \u{10643}; +var \u{10644}; +var \u{10645}; +var \u{10646}; +var \u{10647}; +var \u{10648}; +var \u{10649}; +var \u{1064A}; +var \u{1064B}; +var \u{1064C}; +var \u{1064D}; +var \u{1064E}; +var \u{1064F}; +var \u{10650}; +var \u{10651}; +var \u{10652}; +var \u{10653}; +var \u{10654}; +var \u{10655}; +var \u{10656}; +var \u{10657}; +var \u{10658}; +var \u{10659}; +var \u{1065A}; +var \u{1065B}; +var \u{1065C}; +var \u{1065D}; +var \u{1065E}; +var \u{1065F}; +var \u{10660}; +var \u{10661}; +var \u{10662}; +var \u{10663}; +var \u{10664}; +var \u{10665}; +var \u{10666}; +var \u{10667}; +var \u{10668}; +var \u{10669}; +var \u{1066A}; +var \u{1066B}; +var \u{1066C}; +var \u{1066D}; +var \u{1066E}; +var \u{1066F}; +var \u{10670}; +var \u{10671}; +var \u{10672}; +var \u{10673}; +var \u{10674}; +var \u{10675}; +var \u{10676}; +var \u{10677}; +var \u{10678}; +var \u{10679}; +var \u{1067A}; +var \u{1067B}; +var \u{1067C}; +var \u{1067D}; +var \u{1067E}; +var \u{1067F}; +var \u{10680}; +var \u{10681}; +var \u{10682}; +var \u{10683}; +var \u{10684}; +var \u{10685}; +var \u{10686}; +var \u{10687}; +var \u{10688}; +var \u{10689}; +var \u{1068A}; +var \u{1068B}; +var \u{1068C}; +var \u{1068D}; +var \u{1068E}; +var \u{1068F}; +var \u{10690}; +var \u{10691}; +var \u{10692}; +var \u{10693}; +var \u{10694}; +var \u{10695}; +var \u{10696}; +var \u{10697}; +var \u{10698}; +var \u{10699}; +var \u{1069A}; +var \u{1069B}; +var \u{1069C}; +var \u{1069D}; +var \u{1069E}; +var \u{1069F}; +var \u{106A0}; +var \u{106A1}; +var \u{106A2}; +var \u{106A3}; +var \u{106A4}; +var \u{106A5}; +var \u{106A6}; +var \u{106A7}; +var \u{106A8}; +var \u{106A9}; +var \u{106AA}; +var \u{106AB}; +var \u{106AC}; +var \u{106AD}; +var \u{106AE}; +var \u{106AF}; +var \u{106B0}; +var \u{106B1}; +var \u{106B2}; +var \u{106B3}; +var \u{106B4}; +var \u{106B5}; +var \u{106B6}; +var \u{106B7}; +var \u{106B8}; +var \u{106B9}; +var \u{106BA}; +var \u{106BB}; +var \u{106BC}; +var \u{106BD}; +var \u{106BE}; +var \u{106BF}; +var \u{106C0}; +var \u{106C1}; +var \u{106C2}; +var \u{106C3}; +var \u{106C4}; +var \u{106C5}; +var \u{106C6}; +var \u{106C7}; +var \u{106C8}; +var \u{106C9}; +var \u{106CA}; +var \u{106CB}; +var \u{106CC}; +var \u{106CD}; +var \u{106CE}; +var \u{106CF}; +var \u{106D0}; +var \u{106D1}; +var \u{106D2}; +var \u{106D3}; +var \u{106D4}; +var \u{106D5}; +var \u{106D6}; +var \u{106D7}; +var \u{106D8}; +var \u{106D9}; +var \u{106DA}; +var \u{106DB}; +var \u{106DC}; +var \u{106DD}; +var \u{106DE}; +var \u{106DF}; +var \u{106E0}; +var \u{106E1}; +var \u{106E2}; +var \u{106E3}; +var \u{106E4}; +var \u{106E5}; +var \u{106E6}; +var \u{106E7}; +var \u{106E8}; +var \u{106E9}; +var \u{106EA}; +var \u{106EB}; +var \u{106EC}; +var \u{106ED}; +var \u{106EE}; +var \u{106EF}; +var \u{106F0}; +var \u{106F1}; +var \u{106F2}; +var \u{106F3}; +var \u{106F4}; +var \u{106F5}; +var \u{106F6}; +var \u{106F7}; +var \u{106F8}; +var \u{106F9}; +var \u{106FA}; +var \u{106FB}; +var \u{106FC}; +var \u{106FD}; +var \u{106FE}; +var \u{106FF}; +var \u{10700}; +var \u{10701}; +var \u{10702}; +var \u{10703}; +var \u{10704}; +var \u{10705}; +var \u{10706}; +var \u{10707}; +var \u{10708}; +var \u{10709}; +var \u{1070A}; +var \u{1070B}; +var \u{1070C}; +var \u{1070D}; +var \u{1070E}; +var \u{1070F}; +var \u{10710}; +var \u{10711}; +var \u{10712}; +var \u{10713}; +var \u{10714}; +var \u{10715}; +var \u{10716}; +var \u{10717}; +var \u{10718}; +var \u{10719}; +var \u{1071A}; +var \u{1071B}; +var \u{1071C}; +var \u{1071D}; +var \u{1071E}; +var \u{1071F}; +var \u{10720}; +var \u{10721}; +var \u{10722}; +var \u{10723}; +var \u{10724}; +var \u{10725}; +var \u{10726}; +var \u{10727}; +var \u{10728}; +var \u{10729}; +var \u{1072A}; +var \u{1072B}; +var \u{1072C}; +var \u{1072D}; +var \u{1072E}; +var \u{1072F}; +var \u{10730}; +var \u{10731}; +var \u{10732}; +var \u{10733}; +var \u{10734}; +var \u{10735}; +var \u{10736}; +var \u{10740}; +var \u{10741}; +var \u{10742}; +var \u{10743}; +var \u{10744}; +var \u{10745}; +var \u{10746}; +var \u{10747}; +var \u{10748}; +var \u{10749}; +var \u{1074A}; +var \u{1074B}; +var \u{1074C}; +var \u{1074D}; +var \u{1074E}; +var \u{1074F}; +var \u{10750}; +var \u{10751}; +var \u{10752}; +var \u{10753}; +var \u{10754}; +var \u{10755}; +var \u{10760}; +var \u{10761}; +var \u{10762}; +var \u{10763}; +var \u{10764}; +var \u{10765}; +var \u{10766}; +var \u{10767}; +var \u{10860}; +var \u{10861}; +var \u{10862}; +var \u{10863}; +var \u{10864}; +var \u{10865}; +var \u{10866}; +var \u{10867}; +var \u{10868}; +var \u{10869}; +var \u{1086A}; +var \u{1086B}; +var \u{1086C}; +var \u{1086D}; +var \u{1086E}; +var \u{1086F}; +var \u{10870}; +var \u{10871}; +var \u{10872}; +var \u{10873}; +var \u{10874}; +var \u{10875}; +var \u{10876}; +var \u{10880}; +var \u{10881}; +var \u{10882}; +var \u{10883}; +var \u{10884}; +var \u{10885}; +var \u{10886}; +var \u{10887}; +var \u{10888}; +var \u{10889}; +var \u{1088A}; +var \u{1088B}; +var \u{1088C}; +var \u{1088D}; +var \u{1088E}; +var \u{1088F}; +var \u{10890}; +var \u{10891}; +var \u{10892}; +var \u{10893}; +var \u{10894}; +var \u{10895}; +var \u{10896}; +var \u{10897}; +var \u{10898}; +var \u{10899}; +var \u{1089A}; +var \u{1089B}; +var \u{1089C}; +var \u{1089D}; +var \u{1089E}; +var \u{10A80}; +var \u{10A81}; +var \u{10A82}; +var \u{10A83}; +var \u{10A84}; +var \u{10A85}; +var \u{10A86}; +var \u{10A87}; +var \u{10A88}; +var \u{10A89}; +var \u{10A8A}; +var \u{10A8B}; +var \u{10A8C}; +var \u{10A8D}; +var \u{10A8E}; +var \u{10A8F}; +var \u{10A90}; +var \u{10A91}; +var \u{10A92}; +var \u{10A93}; +var \u{10A94}; +var \u{10A95}; +var \u{10A96}; +var \u{10A97}; +var \u{10A98}; +var \u{10A99}; +var \u{10A9A}; +var \u{10A9B}; +var \u{10A9C}; +var \u{10AC0}; +var \u{10AC1}; +var \u{10AC2}; +var \u{10AC3}; +var \u{10AC4}; +var \u{10AC5}; +var \u{10AC6}; +var \u{10AC7}; +var \u{10AC9}; +var \u{10ACA}; +var \u{10ACB}; +var \u{10ACC}; +var \u{10ACD}; +var \u{10ACE}; +var \u{10ACF}; +var \u{10AD0}; +var \u{10AD1}; +var \u{10AD2}; +var \u{10AD3}; +var \u{10AD4}; +var \u{10AD5}; +var \u{10AD6}; +var \u{10AD7}; +var \u{10AD8}; +var \u{10AD9}; +var \u{10ADA}; +var \u{10ADB}; +var \u{10ADC}; +var \u{10ADD}; +var \u{10ADE}; +var \u{10ADF}; +var \u{10AE0}; +var \u{10AE1}; +var \u{10AE2}; +var \u{10AE3}; +var \u{10AE4}; +var \u{10B80}; +var \u{10B81}; +var \u{10B82}; +var \u{10B83}; +var \u{10B84}; +var \u{10B85}; +var \u{10B86}; +var \u{10B87}; +var \u{10B88}; +var \u{10B89}; +var \u{10B8A}; +var \u{10B8B}; +var \u{10B8C}; +var \u{10B8D}; +var \u{10B8E}; +var \u{10B8F}; +var \u{10B90}; +var \u{10B91}; +var \u{11150}; +var \u{11151}; +var \u{11152}; +var \u{11153}; +var \u{11154}; +var \u{11155}; +var \u{11156}; +var \u{11157}; +var \u{11158}; +var \u{11159}; +var \u{1115A}; +var \u{1115B}; +var \u{1115C}; +var \u{1115D}; +var \u{1115E}; +var \u{1115F}; +var \u{11160}; +var \u{11161}; +var \u{11162}; +var \u{11163}; +var \u{11164}; +var \u{11165}; +var \u{11166}; +var \u{11167}; +var \u{11168}; +var \u{11169}; +var \u{1116A}; +var \u{1116B}; +var \u{1116C}; +var \u{1116D}; +var \u{1116E}; +var \u{1116F}; +var \u{11170}; +var \u{11171}; +var \u{11172}; +var \u{11176}; +var \u{111DA}; +var \u{11200}; +var \u{11201}; +var \u{11202}; +var \u{11203}; +var \u{11204}; +var \u{11205}; +var \u{11206}; +var \u{11207}; +var \u{11208}; +var \u{11209}; +var \u{1120A}; +var \u{1120B}; +var \u{1120C}; +var \u{1120D}; +var \u{1120E}; +var \u{1120F}; +var \u{11210}; +var \u{11211}; +var \u{11213}; +var \u{11214}; +var \u{11215}; +var \u{11216}; +var \u{11217}; +var \u{11218}; +var \u{11219}; +var \u{1121A}; +var \u{1121B}; +var \u{1121C}; +var \u{1121D}; +var \u{1121E}; +var \u{1121F}; +var \u{11220}; +var \u{11221}; +var \u{11222}; +var \u{11223}; +var \u{11224}; +var \u{11225}; +var \u{11226}; +var \u{11227}; +var \u{11228}; +var \u{11229}; +var \u{1122A}; +var \u{1122B}; +var \u{112B0}; +var \u{112B1}; +var \u{112B2}; +var \u{112B3}; +var \u{112B4}; +var \u{112B5}; +var \u{112B6}; +var \u{112B7}; +var \u{112B8}; +var \u{112B9}; +var \u{112BA}; +var \u{112BB}; +var \u{112BC}; +var \u{112BD}; +var \u{112BE}; +var \u{112BF}; +var \u{112C0}; +var \u{112C1}; +var \u{112C2}; +var \u{112C3}; +var \u{112C4}; +var \u{112C5}; +var \u{112C6}; +var \u{112C7}; +var \u{112C8}; +var \u{112C9}; +var \u{112CA}; +var \u{112CB}; +var \u{112CC}; +var \u{112CD}; +var \u{112CE}; +var \u{112CF}; +var \u{112D0}; +var \u{112D1}; +var \u{112D2}; +var \u{112D3}; +var \u{112D4}; +var \u{112D5}; +var \u{112D6}; +var \u{112D7}; +var \u{112D8}; +var \u{112D9}; +var \u{112DA}; +var \u{112DB}; +var \u{112DC}; +var \u{112DD}; +var \u{112DE}; +var \u{11305}; +var \u{11306}; +var \u{11307}; +var \u{11308}; +var \u{11309}; +var \u{1130A}; +var \u{1130B}; +var \u{1130C}; +var \u{1130F}; +var \u{11310}; +var \u{11313}; +var \u{11314}; +var \u{11315}; +var \u{11316}; +var \u{11317}; +var \u{11318}; +var \u{11319}; +var \u{1131A}; +var \u{1131B}; +var \u{1131C}; +var \u{1131D}; +var \u{1131E}; +var \u{1131F}; +var \u{11320}; +var \u{11321}; +var \u{11322}; +var \u{11323}; +var \u{11324}; +var \u{11325}; +var \u{11326}; +var \u{11327}; +var \u{11328}; +var \u{1132A}; +var \u{1132B}; +var \u{1132C}; +var \u{1132D}; +var \u{1132E}; +var \u{1132F}; +var \u{11330}; +var \u{11332}; +var \u{11333}; +var \u{11335}; +var \u{11336}; +var \u{11337}; +var \u{11338}; +var \u{11339}; +var \u{1133D}; +var \u{1135D}; +var \u{1135E}; +var \u{1135F}; +var \u{11360}; +var \u{11361}; +var \u{11480}; +var \u{11481}; +var \u{11482}; +var \u{11483}; +var \u{11484}; +var \u{11485}; +var \u{11486}; +var \u{11487}; +var \u{11488}; +var \u{11489}; +var \u{1148A}; +var \u{1148B}; +var \u{1148C}; +var \u{1148D}; +var \u{1148E}; +var \u{1148F}; +var \u{11490}; +var \u{11491}; +var \u{11492}; +var \u{11493}; +var \u{11494}; +var \u{11495}; +var \u{11496}; +var \u{11497}; +var \u{11498}; +var \u{11499}; +var \u{1149A}; +var \u{1149B}; +var \u{1149C}; +var \u{1149D}; +var \u{1149E}; +var \u{1149F}; +var \u{114A0}; +var \u{114A1}; +var \u{114A2}; +var \u{114A3}; +var \u{114A4}; +var \u{114A5}; +var \u{114A6}; +var \u{114A7}; +var \u{114A8}; +var \u{114A9}; +var \u{114AA}; +var \u{114AB}; +var \u{114AC}; +var \u{114AD}; +var \u{114AE}; +var \u{114AF}; +var \u{114C4}; +var \u{114C5}; +var \u{114C7}; +var \u{11580}; +var \u{11581}; +var \u{11582}; +var \u{11583}; +var \u{11584}; +var \u{11585}; +var \u{11586}; +var \u{11587}; +var \u{11588}; +var \u{11589}; +var \u{1158A}; +var \u{1158B}; +var \u{1158C}; +var \u{1158D}; +var \u{1158E}; +var \u{1158F}; +var \u{11590}; +var \u{11591}; +var \u{11592}; +var \u{11593}; +var \u{11594}; +var \u{11595}; +var \u{11596}; +var \u{11597}; +var \u{11598}; +var \u{11599}; +var \u{1159A}; +var \u{1159B}; +var \u{1159C}; +var \u{1159D}; +var \u{1159E}; +var \u{1159F}; +var \u{115A0}; +var \u{115A1}; +var \u{115A2}; +var \u{115A3}; +var \u{115A4}; +var \u{115A5}; +var \u{115A6}; +var \u{115A7}; +var \u{115A8}; +var \u{115A9}; +var \u{115AA}; +var \u{115AB}; +var \u{115AC}; +var \u{115AD}; +var \u{115AE}; +var \u{11600}; +var \u{11601}; +var \u{11602}; +var \u{11603}; +var \u{11604}; +var \u{11605}; +var \u{11606}; +var \u{11607}; +var \u{11608}; +var \u{11609}; +var \u{1160A}; +var \u{1160B}; +var \u{1160C}; +var \u{1160D}; +var \u{1160E}; +var \u{1160F}; +var \u{11610}; +var \u{11611}; +var \u{11612}; +var \u{11613}; +var \u{11614}; +var \u{11615}; +var \u{11616}; +var \u{11617}; +var \u{11618}; +var \u{11619}; +var \u{1161A}; +var \u{1161B}; +var \u{1161C}; +var \u{1161D}; +var \u{1161E}; +var \u{1161F}; +var \u{11620}; +var \u{11621}; +var \u{11622}; +var \u{11623}; +var \u{11624}; +var \u{11625}; +var \u{11626}; +var \u{11627}; +var \u{11628}; +var \u{11629}; +var \u{1162A}; +var \u{1162B}; +var \u{1162C}; +var \u{1162D}; +var \u{1162E}; +var \u{1162F}; +var \u{11644}; +var \u{118A0}; +var \u{118A1}; +var \u{118A2}; +var \u{118A3}; +var \u{118A4}; +var \u{118A5}; +var \u{118A6}; +var \u{118A7}; +var \u{118A8}; +var \u{118A9}; +var \u{118AA}; +var \u{118AB}; +var \u{118AC}; +var \u{118AD}; +var \u{118AE}; +var \u{118AF}; +var \u{118B0}; +var \u{118B1}; +var \u{118B2}; +var \u{118B3}; +var \u{118B4}; +var \u{118B5}; +var \u{118B6}; +var \u{118B7}; +var \u{118B8}; +var \u{118B9}; +var \u{118BA}; +var \u{118BB}; +var \u{118BC}; +var \u{118BD}; +var \u{118BE}; +var \u{118BF}; +var \u{118C0}; +var \u{118C1}; +var \u{118C2}; +var \u{118C3}; +var \u{118C4}; +var \u{118C5}; +var \u{118C6}; +var \u{118C7}; +var \u{118C8}; +var \u{118C9}; +var \u{118CA}; +var \u{118CB}; +var \u{118CC}; +var \u{118CD}; +var \u{118CE}; +var \u{118CF}; +var \u{118D0}; +var \u{118D1}; +var \u{118D2}; +var \u{118D3}; +var \u{118D4}; +var \u{118D5}; +var \u{118D6}; +var \u{118D7}; +var \u{118D8}; +var \u{118D9}; +var \u{118DA}; +var \u{118DB}; +var \u{118DC}; +var \u{118DD}; +var \u{118DE}; +var \u{118DF}; +var \u{118FF}; +var \u{11AC0}; +var \u{11AC1}; +var \u{11AC2}; +var \u{11AC3}; +var \u{11AC4}; +var \u{11AC5}; +var \u{11AC6}; +var \u{11AC7}; +var \u{11AC8}; +var \u{11AC9}; +var \u{11ACA}; +var \u{11ACB}; +var \u{11ACC}; +var \u{11ACD}; +var \u{11ACE}; +var \u{11ACF}; +var \u{11AD0}; +var \u{11AD1}; +var \u{11AD2}; +var \u{11AD3}; +var \u{11AD4}; +var \u{11AD5}; +var \u{11AD6}; +var \u{11AD7}; +var \u{11AD8}; +var \u{11AD9}; +var \u{11ADA}; +var \u{11ADB}; +var \u{11ADC}; +var \u{11ADD}; +var \u{11ADE}; +var \u{11ADF}; +var \u{11AE0}; +var \u{11AE1}; +var \u{11AE2}; +var \u{11AE3}; +var \u{11AE4}; +var \u{11AE5}; +var \u{11AE6}; +var \u{11AE7}; +var \u{11AE8}; +var \u{11AE9}; +var \u{11AEA}; +var \u{11AEB}; +var \u{11AEC}; +var \u{11AED}; +var \u{11AEE}; +var \u{11AEF}; +var \u{11AF0}; +var \u{11AF1}; +var \u{11AF2}; +var \u{11AF3}; +var \u{11AF4}; +var \u{11AF5}; +var \u{11AF6}; +var \u{11AF7}; +var \u{11AF8}; +var \u{1236F}; +var \u{12370}; +var \u{12371}; +var \u{12372}; +var \u{12373}; +var \u{12374}; +var \u{12375}; +var \u{12376}; +var \u{12377}; +var \u{12378}; +var \u{12379}; +var \u{1237A}; +var \u{1237B}; +var \u{1237C}; +var \u{1237D}; +var \u{1237E}; +var \u{1237F}; +var \u{12380}; +var \u{12381}; +var \u{12382}; +var \u{12383}; +var \u{12384}; +var \u{12385}; +var \u{12386}; +var \u{12387}; +var \u{12388}; +var \u{12389}; +var \u{1238A}; +var \u{1238B}; +var \u{1238C}; +var \u{1238D}; +var \u{1238E}; +var \u{1238F}; +var \u{12390}; +var \u{12391}; +var \u{12392}; +var \u{12393}; +var \u{12394}; +var \u{12395}; +var \u{12396}; +var \u{12397}; +var \u{12398}; +var \u{12463}; +var \u{12464}; +var \u{12465}; +var \u{12466}; +var \u{12467}; +var \u{12468}; +var \u{12469}; +var \u{1246A}; +var \u{1246B}; +var \u{1246C}; +var \u{1246D}; +var \u{1246E}; +var \u{16A40}; +var \u{16A41}; +var \u{16A42}; +var \u{16A43}; +var \u{16A44}; +var \u{16A45}; +var \u{16A46}; +var \u{16A47}; +var \u{16A48}; +var \u{16A49}; +var \u{16A4A}; +var \u{16A4B}; +var \u{16A4C}; +var \u{16A4D}; +var \u{16A4E}; +var \u{16A4F}; +var \u{16A50}; +var \u{16A51}; +var \u{16A52}; +var \u{16A53}; +var \u{16A54}; +var \u{16A55}; +var \u{16A56}; +var \u{16A57}; +var \u{16A58}; +var \u{16A59}; +var \u{16A5A}; +var \u{16A5B}; +var \u{16A5C}; +var \u{16A5D}; +var \u{16A5E}; +var \u{16AD0}; +var \u{16AD1}; +var \u{16AD2}; +var \u{16AD3}; +var \u{16AD4}; +var \u{16AD5}; +var \u{16AD6}; +var \u{16AD7}; +var \u{16AD8}; +var \u{16AD9}; +var \u{16ADA}; +var \u{16ADB}; +var \u{16ADC}; +var \u{16ADD}; +var \u{16ADE}; +var \u{16ADF}; +var \u{16AE0}; +var \u{16AE1}; +var \u{16AE2}; +var \u{16AE3}; +var \u{16AE4}; +var \u{16AE5}; +var \u{16AE6}; +var \u{16AE7}; +var \u{16AE8}; +var \u{16AE9}; +var \u{16AEA}; +var \u{16AEB}; +var \u{16AEC}; +var \u{16AED}; +var \u{16B00}; +var \u{16B01}; +var \u{16B02}; +var \u{16B03}; +var \u{16B04}; +var \u{16B05}; +var \u{16B06}; +var \u{16B07}; +var \u{16B08}; +var \u{16B09}; +var \u{16B0A}; +var \u{16B0B}; +var \u{16B0C}; +var \u{16B0D}; +var \u{16B0E}; +var \u{16B0F}; +var \u{16B10}; +var \u{16B11}; +var \u{16B12}; +var \u{16B13}; +var \u{16B14}; +var \u{16B15}; +var \u{16B16}; +var \u{16B17}; +var \u{16B18}; +var \u{16B19}; +var \u{16B1A}; +var \u{16B1B}; +var \u{16B1C}; +var \u{16B1D}; +var \u{16B1E}; +var \u{16B1F}; +var \u{16B20}; +var \u{16B21}; +var \u{16B22}; +var \u{16B23}; +var \u{16B24}; +var \u{16B25}; +var \u{16B26}; +var \u{16B27}; +var \u{16B28}; +var \u{16B29}; +var \u{16B2A}; +var \u{16B2B}; +var \u{16B2C}; +var \u{16B2D}; +var \u{16B2E}; +var \u{16B2F}; +var \u{16B40}; +var \u{16B41}; +var \u{16B42}; +var \u{16B43}; +var \u{16B63}; +var \u{16B64}; +var \u{16B65}; +var \u{16B66}; +var \u{16B67}; +var \u{16B68}; +var \u{16B69}; +var \u{16B6A}; +var \u{16B6B}; +var \u{16B6C}; +var \u{16B6D}; +var \u{16B6E}; +var \u{16B6F}; +var \u{16B70}; +var \u{16B71}; +var \u{16B72}; +var \u{16B73}; +var \u{16B74}; +var \u{16B75}; +var \u{16B76}; +var \u{16B77}; +var \u{16B7D}; +var \u{16B7E}; +var \u{16B7F}; +var \u{16B80}; +var \u{16B81}; +var \u{16B82}; +var \u{16B83}; +var \u{16B84}; +var \u{16B85}; +var \u{16B86}; +var \u{16B87}; +var \u{16B88}; +var \u{16B89}; +var \u{16B8A}; +var \u{16B8B}; +var \u{16B8C}; +var \u{16B8D}; +var \u{16B8E}; +var \u{16B8F}; +var \u{1BC00}; +var \u{1BC01}; +var \u{1BC02}; +var \u{1BC03}; +var \u{1BC04}; +var \u{1BC05}; +var \u{1BC06}; +var \u{1BC07}; +var \u{1BC08}; +var \u{1BC09}; +var \u{1BC0A}; +var \u{1BC0B}; +var \u{1BC0C}; +var \u{1BC0D}; +var \u{1BC0E}; +var \u{1BC0F}; +var \u{1BC10}; +var \u{1BC11}; +var \u{1BC12}; +var \u{1BC13}; +var \u{1BC14}; +var \u{1BC15}; +var \u{1BC16}; +var \u{1BC17}; +var \u{1BC18}; +var \u{1BC19}; +var \u{1BC1A}; +var \u{1BC1B}; +var \u{1BC1C}; +var \u{1BC1D}; +var \u{1BC1E}; +var \u{1BC1F}; +var \u{1BC20}; +var \u{1BC21}; +var \u{1BC22}; +var \u{1BC23}; +var \u{1BC24}; +var \u{1BC25}; +var \u{1BC26}; +var \u{1BC27}; +var \u{1BC28}; +var \u{1BC29}; +var \u{1BC2A}; +var \u{1BC2B}; +var \u{1BC2C}; +var \u{1BC2D}; +var \u{1BC2E}; +var \u{1BC2F}; +var \u{1BC30}; +var \u{1BC31}; +var \u{1BC32}; +var \u{1BC33}; +var \u{1BC34}; +var \u{1BC35}; +var \u{1BC36}; +var \u{1BC37}; +var \u{1BC38}; +var \u{1BC39}; +var \u{1BC3A}; +var \u{1BC3B}; +var \u{1BC3C}; +var \u{1BC3D}; +var \u{1BC3E}; +var \u{1BC3F}; +var \u{1BC40}; +var \u{1BC41}; +var \u{1BC42}; +var \u{1BC43}; +var \u{1BC44}; +var \u{1BC45}; +var \u{1BC46}; +var \u{1BC47}; +var \u{1BC48}; +var \u{1BC49}; +var \u{1BC4A}; +var \u{1BC4B}; +var \u{1BC4C}; +var \u{1BC4D}; +var \u{1BC4E}; +var \u{1BC4F}; +var \u{1BC50}; +var \u{1BC51}; +var \u{1BC52}; +var \u{1BC53}; +var \u{1BC54}; +var \u{1BC55}; +var \u{1BC56}; +var \u{1BC57}; +var \u{1BC58}; +var \u{1BC59}; +var \u{1BC5A}; +var \u{1BC5B}; +var \u{1BC5C}; +var \u{1BC5D}; +var \u{1BC5E}; +var \u{1BC5F}; +var \u{1BC60}; +var \u{1BC61}; +var \u{1BC62}; +var \u{1BC63}; +var \u{1BC64}; +var \u{1BC65}; +var \u{1BC66}; +var \u{1BC67}; +var \u{1BC68}; +var \u{1BC69}; +var \u{1BC6A}; +var \u{1BC70}; +var \u{1BC71}; +var \u{1BC72}; +var \u{1BC73}; +var \u{1BC74}; +var \u{1BC75}; +var \u{1BC76}; +var \u{1BC77}; +var \u{1BC78}; +var \u{1BC79}; +var \u{1BC7A}; +var \u{1BC7B}; +var \u{1BC7C}; +var \u{1BC80}; +var \u{1BC81}; +var \u{1BC82}; +var \u{1BC83}; +var \u{1BC84}; +var \u{1BC85}; +var \u{1BC86}; +var \u{1BC87}; +var \u{1BC88}; +var \u{1BC90}; +var \u{1BC91}; +var \u{1BC92}; +var \u{1BC93}; +var \u{1BC94}; +var \u{1BC95}; +var \u{1BC96}; +var \u{1BC97}; +var \u{1BC98}; +var \u{1BC99}; +var \u{1E800}; +var \u{1E801}; +var \u{1E802}; +var \u{1E803}; +var \u{1E804}; +var \u{1E805}; +var \u{1E806}; +var \u{1E807}; +var \u{1E808}; +var \u{1E809}; +var \u{1E80A}; +var \u{1E80B}; +var \u{1E80C}; +var \u{1E80D}; +var \u{1E80E}; +var \u{1E80F}; +var \u{1E810}; +var \u{1E811}; +var \u{1E812}; +var \u{1E813}; +var \u{1E814}; +var \u{1E815}; +var \u{1E816}; +var \u{1E817}; +var \u{1E818}; +var \u{1E819}; +var \u{1E81A}; +var \u{1E81B}; +var \u{1E81C}; +var \u{1E81D}; +var \u{1E81E}; +var \u{1E81F}; +var \u{1E820}; +var \u{1E821}; +var \u{1E822}; +var \u{1E823}; +var \u{1E824}; +var \u{1E825}; +var \u{1E826}; +var \u{1E827}; +var \u{1E828}; +var \u{1E829}; +var \u{1E82A}; +var \u{1E82B}; +var \u{1E82C}; +var \u{1E82D}; +var \u{1E82E}; +var \u{1E82F}; +var \u{1E830}; +var \u{1E831}; +var \u{1E832}; +var \u{1E833}; +var \u{1E834}; +var \u{1E835}; +var \u{1E836}; +var \u{1E837}; +var \u{1E838}; +var \u{1E839}; +var \u{1E83A}; +var \u{1E83B}; +var \u{1E83C}; +var \u{1E83D}; +var \u{1E83E}; +var \u{1E83F}; +var \u{1E840}; +var \u{1E841}; +var \u{1E842}; +var \u{1E843}; +var \u{1E844}; +var \u{1E845}; +var \u{1E846}; +var \u{1E847}; +var \u{1E848}; +var \u{1E849}; +var \u{1E84A}; +var \u{1E84B}; +var \u{1E84C}; +var \u{1E84D}; +var \u{1E84E}; +var \u{1E84F}; +var \u{1E850}; +var \u{1E851}; +var \u{1E852}; +var \u{1E853}; +var \u{1E854}; +var \u{1E855}; +var \u{1E856}; +var \u{1E857}; +var \u{1E858}; +var \u{1E859}; +var \u{1E85A}; +var \u{1E85B}; +var \u{1E85C}; +var \u{1E85D}; +var \u{1E85E}; +var \u{1E85F}; +var \u{1E860}; +var \u{1E861}; +var \u{1E862}; +var \u{1E863}; +var \u{1E864}; +var \u{1E865}; +var \u{1E866}; +var \u{1E867}; +var \u{1E868}; +var \u{1E869}; +var \u{1E86A}; +var \u{1E86B}; +var \u{1E86C}; +var \u{1E86D}; +var \u{1E86E}; +var \u{1E86F}; +var \u{1E870}; +var \u{1E871}; +var \u{1E872}; +var \u{1E873}; +var \u{1E874}; +var \u{1E875}; +var \u{1E876}; +var \u{1E877}; +var \u{1E878}; +var \u{1E879}; +var \u{1E87A}; +var \u{1E87B}; +var \u{1E87C}; +var \u{1E87D}; +var \u{1E87E}; +var \u{1E87F}; +var \u{1E880}; +var \u{1E881}; +var \u{1E882}; +var \u{1E883}; +var \u{1E884}; +var \u{1E885}; +var \u{1E886}; +var \u{1E887}; +var \u{1E888}; +var \u{1E889}; +var \u{1E88A}; +var \u{1E88B}; +var \u{1E88C}; +var \u{1E88D}; +var \u{1E88E}; +var \u{1E88F}; +var \u{1E890}; +var \u{1E891}; +var \u{1E892}; +var \u{1E893}; +var \u{1E894}; +var \u{1E895}; +var \u{1E896}; +var \u{1E897}; +var \u{1E898}; +var \u{1E899}; +var \u{1E89A}; +var \u{1E89B}; +var \u{1E89C}; +var \u{1E89D}; +var \u{1E89E}; +var \u{1E89F}; +var \u{1E8A0}; +var \u{1E8A1}; +var \u{1E8A2}; +var \u{1E8A3}; +var \u{1E8A4}; +var \u{1E8A5}; +var \u{1E8A6}; +var \u{1E8A7}; +var \u{1E8A8}; +var \u{1E8A9}; +var \u{1E8AA}; +var \u{1E8AB}; +var \u{1E8AC}; +var \u{1E8AD}; +var \u{1E8AE}; +var \u{1E8AF}; +var \u{1E8B0}; +var \u{1E8B1}; +var \u{1E8B2}; +var \u{1E8B3}; +var \u{1E8B4}; +var \u{1E8B5}; +var \u{1E8B6}; +var \u{1E8B7}; +var \u{1E8B8}; +var \u{1E8B9}; +var \u{1E8BA}; +var \u{1E8BB}; +var \u{1E8BC}; +var \u{1E8BD}; +var \u{1E8BE}; +var \u{1E8BF}; +var \u{1E8C0}; +var \u{1E8C1}; +var \u{1E8C2}; +var \u{1E8C3}; +var \u{1E8C4}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0.js new file mode 100644 index 000000000..534dc71ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-7.0.0.js @@ -0,0 +1,1737 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v7.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var Ϳ; +var Ԩ; +var ԩ; +var Ԫ; +var ԫ; +var Ԭ; +var ԭ; +var Ԯ; +var ԯ; +var ࢡ; +var ࢭ; +var ࢮ; +var ࢯ; +var ࢰ; +var ࢱ; +var ࢲ; +var ॸ; +var ঀ; +var ఴ; +var ᛱ; +var ᛲ; +var ᛳ; +var ᛴ; +var ᛵ; +var ᛶ; +var ᛷ; +var ᛸ; +var ᤝ; +var ᤞ; +var Ꚙ; +var ꚙ; +var Ꚛ; +var ꚛ; +var ꚜ; +var ꚝ; +var ꞔ; +var ꞕ; +var Ꞗ; +var ꞗ; +var Ꞙ; +var ꞙ; +var Ꞛ; +var ꞛ; +var Ꞝ; +var ꞝ; +var Ꞟ; +var ꞟ; +var Ɜ; +var Ɡ; +var Ɬ; +var Ʞ; +var Ʇ; +var ꟷ; +var ꧠ; +var ꧡ; +var ꧢ; +var ꧣ; +var ꧤ; +var ꧦ; +var ꧧ; +var ꧨ; +var ꧩ; +var ꧪ; +var ꧫ; +var ꧬ; +var ꧭ; +var ꧮ; +var ꧯ; +var ꧺ; +var ꧻ; +var ꧼ; +var ꧽ; +var ꧾ; +var ꩾ; +var ꩿ; +var ꬰ; +var ꬱ; +var ꬲ; +var ꬳ; +var ꬴ; +var ꬵ; +var ꬶ; +var ꬷ; +var ꬸ; +var ꬹ; +var ꬺ; +var ꬻ; +var ꬼ; +var ꬽ; +var ꬾ; +var ꬿ; +var ꭀ; +var ꭁ; +var ꭂ; +var ꭃ; +var ꭄ; +var ꭅ; +var ꭆ; +var ꭇ; +var ꭈ; +var ꭉ; +var ꭊ; +var ꭋ; +var ꭌ; +var ꭍ; +var ꭎ; +var ꭏ; +var ꭐ; +var ꭑ; +var ꭒ; +var ꭓ; +var ꭔ; +var ꭕ; +var ꭖ; +var ꭗ; +var ꭘ; +var ꭙ; +var ꭚ; +var ꭜ; +var ꭝ; +var ꭞ; +var ꭟ; +var ꭤ; +var ꭥ; +var 𐌟; +var 𐍐; +var 𐍑; +var 𐍒; +var 𐍓; +var 𐍔; +var 𐍕; +var 𐍖; +var 𐍗; +var 𐍘; +var 𐍙; +var 𐍚; +var 𐍛; +var 𐍜; +var 𐍝; +var 𐍞; +var 𐍟; +var 𐍠; +var 𐍡; +var 𐍢; +var 𐍣; +var 𐍤; +var 𐍥; +var 𐍦; +var 𐍧; +var 𐍨; +var 𐍩; +var 𐍪; +var 𐍫; +var 𐍬; +var 𐍭; +var 𐍮; +var 𐍯; +var 𐍰; +var 𐍱; +var 𐍲; +var 𐍳; +var 𐍴; +var 𐍵; +var 𐔀; +var 𐔁; +var 𐔂; +var 𐔃; +var 𐔄; +var 𐔅; +var 𐔆; +var 𐔇; +var 𐔈; +var 𐔉; +var 𐔊; +var 𐔋; +var 𐔌; +var 𐔍; +var 𐔎; +var 𐔏; +var 𐔐; +var 𐔑; +var 𐔒; +var 𐔓; +var 𐔔; +var 𐔕; +var 𐔖; +var 𐔗; +var 𐔘; +var 𐔙; +var 𐔚; +var 𐔛; +var 𐔜; +var 𐔝; +var 𐔞; +var 𐔟; +var 𐔠; +var 𐔡; +var 𐔢; +var 𐔣; +var 𐔤; +var 𐔥; +var 𐔦; +var 𐔧; +var 𐔰; +var 𐔱; +var 𐔲; +var 𐔳; +var 𐔴; +var 𐔵; +var 𐔶; +var 𐔷; +var 𐔸; +var 𐔹; +var 𐔺; +var 𐔻; +var 𐔼; +var 𐔽; +var 𐔾; +var 𐔿; +var 𐕀; +var 𐕁; +var 𐕂; +var 𐕃; +var 𐕄; +var 𐕅; +var 𐕆; +var 𐕇; +var 𐕈; +var 𐕉; +var 𐕊; +var 𐕋; +var 𐕌; +var 𐕍; +var 𐕎; +var 𐕏; +var 𐕐; +var 𐕑; +var 𐕒; +var 𐕓; +var 𐕔; +var 𐕕; +var 𐕖; +var 𐕗; +var 𐕘; +var 𐕙; +var 𐕚; +var 𐕛; +var 𐕜; +var 𐕝; +var 𐕞; +var 𐕟; +var 𐕠; +var 𐕡; +var 𐕢; +var 𐕣; +var 𐘀; +var 𐘁; +var 𐘂; +var 𐘃; +var 𐘄; +var 𐘅; +var 𐘆; +var 𐘇; +var 𐘈; +var 𐘉; +var 𐘊; +var 𐘋; +var 𐘌; +var 𐘍; +var 𐘎; +var 𐘏; +var 𐘐; +var 𐘑; +var 𐘒; +var 𐘓; +var 𐘔; +var 𐘕; +var 𐘖; +var 𐘗; +var 𐘘; +var 𐘙; +var 𐘚; +var 𐘛; +var 𐘜; +var 𐘝; +var 𐘞; +var 𐘟; +var 𐘠; +var 𐘡; +var 𐘢; +var 𐘣; +var 𐘤; +var 𐘥; +var 𐘦; +var 𐘧; +var 𐘨; +var 𐘩; +var 𐘪; +var 𐘫; +var 𐘬; +var 𐘭; +var 𐘮; +var 𐘯; +var 𐘰; +var 𐘱; +var 𐘲; +var 𐘳; +var 𐘴; +var 𐘵; +var 𐘶; +var 𐘷; +var 𐘸; +var 𐘹; +var 𐘺; +var 𐘻; +var 𐘼; +var 𐘽; +var 𐘾; +var 𐘿; +var 𐙀; +var 𐙁; +var 𐙂; +var 𐙃; +var 𐙄; +var 𐙅; +var 𐙆; +var 𐙇; +var 𐙈; +var 𐙉; +var 𐙊; +var 𐙋; +var 𐙌; +var 𐙍; +var 𐙎; +var 𐙏; +var 𐙐; +var 𐙑; +var 𐙒; +var 𐙓; +var 𐙔; +var 𐙕; +var 𐙖; +var 𐙗; +var 𐙘; +var 𐙙; +var 𐙚; +var 𐙛; +var 𐙜; +var 𐙝; +var 𐙞; +var 𐙟; +var 𐙠; +var 𐙡; +var 𐙢; +var 𐙣; +var 𐙤; +var 𐙥; +var 𐙦; +var 𐙧; +var 𐙨; +var 𐙩; +var 𐙪; +var 𐙫; +var 𐙬; +var 𐙭; +var 𐙮; +var 𐙯; +var 𐙰; +var 𐙱; +var 𐙲; +var 𐙳; +var 𐙴; +var 𐙵; +var 𐙶; +var 𐙷; +var 𐙸; +var 𐙹; +var 𐙺; +var 𐙻; +var 𐙼; +var 𐙽; +var 𐙾; +var 𐙿; +var 𐚀; +var 𐚁; +var 𐚂; +var 𐚃; +var 𐚄; +var 𐚅; +var 𐚆; +var 𐚇; +var 𐚈; +var 𐚉; +var 𐚊; +var 𐚋; +var 𐚌; +var 𐚍; +var 𐚎; +var 𐚏; +var 𐚐; +var 𐚑; +var 𐚒; +var 𐚓; +var 𐚔; +var 𐚕; +var 𐚖; +var 𐚗; +var 𐚘; +var 𐚙; +var 𐚚; +var 𐚛; +var 𐚜; +var 𐚝; +var 𐚞; +var 𐚟; +var 𐚠; +var 𐚡; +var 𐚢; +var 𐚣; +var 𐚤; +var 𐚥; +var 𐚦; +var 𐚧; +var 𐚨; +var 𐚩; +var 𐚪; +var 𐚫; +var 𐚬; +var 𐚭; +var 𐚮; +var 𐚯; +var 𐚰; +var 𐚱; +var 𐚲; +var 𐚳; +var 𐚴; +var 𐚵; +var 𐚶; +var 𐚷; +var 𐚸; +var 𐚹; +var 𐚺; +var 𐚻; +var 𐚼; +var 𐚽; +var 𐚾; +var 𐚿; +var 𐛀; +var 𐛁; +var 𐛂; +var 𐛃; +var 𐛄; +var 𐛅; +var 𐛆; +var 𐛇; +var 𐛈; +var 𐛉; +var 𐛊; +var 𐛋; +var 𐛌; +var 𐛍; +var 𐛎; +var 𐛏; +var 𐛐; +var 𐛑; +var 𐛒; +var 𐛓; +var 𐛔; +var 𐛕; +var 𐛖; +var 𐛗; +var 𐛘; +var 𐛙; +var 𐛚; +var 𐛛; +var 𐛜; +var 𐛝; +var 𐛞; +var 𐛟; +var 𐛠; +var 𐛡; +var 𐛢; +var 𐛣; +var 𐛤; +var 𐛥; +var 𐛦; +var 𐛧; +var 𐛨; +var 𐛩; +var 𐛪; +var 𐛫; +var 𐛬; +var 𐛭; +var 𐛮; +var 𐛯; +var 𐛰; +var 𐛱; +var 𐛲; +var 𐛳; +var 𐛴; +var 𐛵; +var 𐛶; +var 𐛷; +var 𐛸; +var 𐛹; +var 𐛺; +var 𐛻; +var 𐛼; +var 𐛽; +var 𐛾; +var 𐛿; +var 𐜀; +var 𐜁; +var 𐜂; +var 𐜃; +var 𐜄; +var 𐜅; +var 𐜆; +var 𐜇; +var 𐜈; +var 𐜉; +var 𐜊; +var 𐜋; +var 𐜌; +var 𐜍; +var 𐜎; +var 𐜏; +var 𐜐; +var 𐜑; +var 𐜒; +var 𐜓; +var 𐜔; +var 𐜕; +var 𐜖; +var 𐜗; +var 𐜘; +var 𐜙; +var 𐜚; +var 𐜛; +var 𐜜; +var 𐜝; +var 𐜞; +var 𐜟; +var 𐜠; +var 𐜡; +var 𐜢; +var 𐜣; +var 𐜤; +var 𐜥; +var 𐜦; +var 𐜧; +var 𐜨; +var 𐜩; +var 𐜪; +var 𐜫; +var 𐜬; +var 𐜭; +var 𐜮; +var 𐜯; +var 𐜰; +var 𐜱; +var 𐜲; +var 𐜳; +var 𐜴; +var 𐜵; +var 𐜶; +var 𐝀; +var 𐝁; +var 𐝂; +var 𐝃; +var 𐝄; +var 𐝅; +var 𐝆; +var 𐝇; +var 𐝈; +var 𐝉; +var 𐝊; +var 𐝋; +var 𐝌; +var 𐝍; +var 𐝎; +var 𐝏; +var 𐝐; +var 𐝑; +var 𐝒; +var 𐝓; +var 𐝔; +var 𐝕; +var 𐝠; +var 𐝡; +var 𐝢; +var 𐝣; +var 𐝤; +var 𐝥; +var 𐝦; +var 𐝧; +var 𐡠; +var 𐡡; +var 𐡢; +var 𐡣; +var 𐡤; +var 𐡥; +var 𐡦; +var 𐡧; +var 𐡨; +var 𐡩; +var 𐡪; +var 𐡫; +var 𐡬; +var 𐡭; +var 𐡮; +var 𐡯; +var 𐡰; +var 𐡱; +var 𐡲; +var 𐡳; +var 𐡴; +var 𐡵; +var 𐡶; +var 𐢀; +var 𐢁; +var 𐢂; +var 𐢃; +var 𐢄; +var 𐢅; +var 𐢆; +var 𐢇; +var 𐢈; +var 𐢉; +var 𐢊; +var 𐢋; +var 𐢌; +var 𐢍; +var 𐢎; +var 𐢏; +var 𐢐; +var 𐢑; +var 𐢒; +var 𐢓; +var 𐢔; +var 𐢕; +var 𐢖; +var 𐢗; +var 𐢘; +var 𐢙; +var 𐢚; +var 𐢛; +var 𐢜; +var 𐢝; +var 𐢞; +var 𐪀; +var 𐪁; +var 𐪂; +var 𐪃; +var 𐪄; +var 𐪅; +var 𐪆; +var 𐪇; +var 𐪈; +var 𐪉; +var 𐪊; +var 𐪋; +var 𐪌; +var 𐪍; +var 𐪎; +var 𐪏; +var 𐪐; +var 𐪑; +var 𐪒; +var 𐪓; +var 𐪔; +var 𐪕; +var 𐪖; +var 𐪗; +var 𐪘; +var 𐪙; +var 𐪚; +var 𐪛; +var 𐪜; +var 𐫀; +var 𐫁; +var 𐫂; +var 𐫃; +var 𐫄; +var 𐫅; +var 𐫆; +var 𐫇; +var 𐫉; +var 𐫊; +var 𐫋; +var 𐫌; +var 𐫍; +var 𐫎; +var 𐫏; +var 𐫐; +var 𐫑; +var 𐫒; +var 𐫓; +var 𐫔; +var 𐫕; +var 𐫖; +var 𐫗; +var 𐫘; +var 𐫙; +var 𐫚; +var 𐫛; +var 𐫜; +var 𐫝; +var 𐫞; +var 𐫟; +var 𐫠; +var 𐫡; +var 𐫢; +var 𐫣; +var 𐫤; +var 𐮀; +var 𐮁; +var 𐮂; +var 𐮃; +var 𐮄; +var 𐮅; +var 𐮆; +var 𐮇; +var 𐮈; +var 𐮉; +var 𐮊; +var 𐮋; +var 𐮌; +var 𐮍; +var 𐮎; +var 𐮏; +var 𐮐; +var 𐮑; +var 𑅐; +var 𑅑; +var 𑅒; +var 𑅓; +var 𑅔; +var 𑅕; +var 𑅖; +var 𑅗; +var 𑅘; +var 𑅙; +var 𑅚; +var 𑅛; +var 𑅜; +var 𑅝; +var 𑅞; +var 𑅟; +var 𑅠; +var 𑅡; +var 𑅢; +var 𑅣; +var 𑅤; +var 𑅥; +var 𑅦; +var 𑅧; +var 𑅨; +var 𑅩; +var 𑅪; +var 𑅫; +var 𑅬; +var 𑅭; +var 𑅮; +var 𑅯; +var 𑅰; +var 𑅱; +var 𑅲; +var 𑅶; +var 𑇚; +var 𑈀; +var 𑈁; +var 𑈂; +var 𑈃; +var 𑈄; +var 𑈅; +var 𑈆; +var 𑈇; +var 𑈈; +var 𑈉; +var 𑈊; +var 𑈋; +var 𑈌; +var 𑈍; +var 𑈎; +var 𑈏; +var 𑈐; +var 𑈑; +var 𑈓; +var 𑈔; +var 𑈕; +var 𑈖; +var 𑈗; +var 𑈘; +var 𑈙; +var 𑈚; +var 𑈛; +var 𑈜; +var 𑈝; +var 𑈞; +var 𑈟; +var 𑈠; +var 𑈡; +var 𑈢; +var 𑈣; +var 𑈤; +var 𑈥; +var 𑈦; +var 𑈧; +var 𑈨; +var 𑈩; +var 𑈪; +var 𑈫; +var 𑊰; +var 𑊱; +var 𑊲; +var 𑊳; +var 𑊴; +var 𑊵; +var 𑊶; +var 𑊷; +var 𑊸; +var 𑊹; +var 𑊺; +var 𑊻; +var 𑊼; +var 𑊽; +var 𑊾; +var 𑊿; +var 𑋀; +var 𑋁; +var 𑋂; +var 𑋃; +var 𑋄; +var 𑋅; +var 𑋆; +var 𑋇; +var 𑋈; +var 𑋉; +var 𑋊; +var 𑋋; +var 𑋌; +var 𑋍; +var 𑋎; +var 𑋏; +var 𑋐; +var 𑋑; +var 𑋒; +var 𑋓; +var 𑋔; +var 𑋕; +var 𑋖; +var 𑋗; +var 𑋘; +var 𑋙; +var 𑋚; +var 𑋛; +var 𑋜; +var 𑋝; +var 𑋞; +var 𑌅; +var 𑌆; +var 𑌇; +var 𑌈; +var 𑌉; +var 𑌊; +var 𑌋; +var 𑌌; +var 𑌏; +var 𑌐; +var 𑌓; +var 𑌔; +var 𑌕; +var 𑌖; +var 𑌗; +var 𑌘; +var 𑌙; +var 𑌚; +var 𑌛; +var 𑌜; +var 𑌝; +var 𑌞; +var 𑌟; +var 𑌠; +var 𑌡; +var 𑌢; +var 𑌣; +var 𑌤; +var 𑌥; +var 𑌦; +var 𑌧; +var 𑌨; +var 𑌪; +var 𑌫; +var 𑌬; +var 𑌭; +var 𑌮; +var 𑌯; +var 𑌰; +var 𑌲; +var 𑌳; +var 𑌵; +var 𑌶; +var 𑌷; +var 𑌸; +var 𑌹; +var 𑌽; +var 𑍝; +var 𑍞; +var 𑍟; +var 𑍠; +var 𑍡; +var 𑒀; +var 𑒁; +var 𑒂; +var 𑒃; +var 𑒄; +var 𑒅; +var 𑒆; +var 𑒇; +var 𑒈; +var 𑒉; +var 𑒊; +var 𑒋; +var 𑒌; +var 𑒍; +var 𑒎; +var 𑒏; +var 𑒐; +var 𑒑; +var 𑒒; +var 𑒓; +var 𑒔; +var 𑒕; +var 𑒖; +var 𑒗; +var 𑒘; +var 𑒙; +var 𑒚; +var 𑒛; +var 𑒜; +var 𑒝; +var 𑒞; +var 𑒟; +var 𑒠; +var 𑒡; +var 𑒢; +var 𑒣; +var 𑒤; +var 𑒥; +var 𑒦; +var 𑒧; +var 𑒨; +var 𑒩; +var 𑒪; +var 𑒫; +var 𑒬; +var 𑒭; +var 𑒮; +var 𑒯; +var 𑓄; +var 𑓅; +var 𑓇; +var 𑖀; +var 𑖁; +var 𑖂; +var 𑖃; +var 𑖄; +var 𑖅; +var 𑖆; +var 𑖇; +var 𑖈; +var 𑖉; +var 𑖊; +var 𑖋; +var 𑖌; +var 𑖍; +var 𑖎; +var 𑖏; +var 𑖐; +var 𑖑; +var 𑖒; +var 𑖓; +var 𑖔; +var 𑖕; +var 𑖖; +var 𑖗; +var 𑖘; +var 𑖙; +var 𑖚; +var 𑖛; +var 𑖜; +var 𑖝; +var 𑖞; +var 𑖟; +var 𑖠; +var 𑖡; +var 𑖢; +var 𑖣; +var 𑖤; +var 𑖥; +var 𑖦; +var 𑖧; +var 𑖨; +var 𑖩; +var 𑖪; +var 𑖫; +var 𑖬; +var 𑖭; +var 𑖮; +var 𑘀; +var 𑘁; +var 𑘂; +var 𑘃; +var 𑘄; +var 𑘅; +var 𑘆; +var 𑘇; +var 𑘈; +var 𑘉; +var 𑘊; +var 𑘋; +var 𑘌; +var 𑘍; +var 𑘎; +var 𑘏; +var 𑘐; +var 𑘑; +var 𑘒; +var 𑘓; +var 𑘔; +var 𑘕; +var 𑘖; +var 𑘗; +var 𑘘; +var 𑘙; +var 𑘚; +var 𑘛; +var 𑘜; +var 𑘝; +var 𑘞; +var 𑘟; +var 𑘠; +var 𑘡; +var 𑘢; +var 𑘣; +var 𑘤; +var 𑘥; +var 𑘦; +var 𑘧; +var 𑘨; +var 𑘩; +var 𑘪; +var 𑘫; +var 𑘬; +var 𑘭; +var 𑘮; +var 𑘯; +var 𑙄; +var 𑢠; +var 𑢡; +var 𑢢; +var 𑢣; +var 𑢤; +var 𑢥; +var 𑢦; +var 𑢧; +var 𑢨; +var 𑢩; +var 𑢪; +var 𑢫; +var 𑢬; +var 𑢭; +var 𑢮; +var 𑢯; +var 𑢰; +var 𑢱; +var 𑢲; +var 𑢳; +var 𑢴; +var 𑢵; +var 𑢶; +var 𑢷; +var 𑢸; +var 𑢹; +var 𑢺; +var 𑢻; +var 𑢼; +var 𑢽; +var 𑢾; +var 𑢿; +var 𑣀; +var 𑣁; +var 𑣂; +var 𑣃; +var 𑣄; +var 𑣅; +var 𑣆; +var 𑣇; +var 𑣈; +var 𑣉; +var 𑣊; +var 𑣋; +var 𑣌; +var 𑣍; +var 𑣎; +var 𑣏; +var 𑣐; +var 𑣑; +var 𑣒; +var 𑣓; +var 𑣔; +var 𑣕; +var 𑣖; +var 𑣗; +var 𑣘; +var 𑣙; +var 𑣚; +var 𑣛; +var 𑣜; +var 𑣝; +var 𑣞; +var 𑣟; +var 𑣿; +var 𑫀; +var 𑫁; +var 𑫂; +var 𑫃; +var 𑫄; +var 𑫅; +var 𑫆; +var 𑫇; +var 𑫈; +var 𑫉; +var 𑫊; +var 𑫋; +var 𑫌; +var 𑫍; +var 𑫎; +var 𑫏; +var 𑫐; +var 𑫑; +var 𑫒; +var 𑫓; +var 𑫔; +var 𑫕; +var 𑫖; +var 𑫗; +var 𑫘; +var 𑫙; +var 𑫚; +var 𑫛; +var 𑫜; +var 𑫝; +var 𑫞; +var 𑫟; +var 𑫠; +var 𑫡; +var 𑫢; +var 𑫣; +var 𑫤; +var 𑫥; +var 𑫦; +var 𑫧; +var 𑫨; +var 𑫩; +var 𑫪; +var 𑫫; +var 𑫬; +var 𑫭; +var 𑫮; +var 𑫯; +var 𑫰; +var 𑫱; +var 𑫲; +var 𑫳; +var 𑫴; +var 𑫵; +var 𑫶; +var 𑫷; +var 𑫸; +var 𒍯; +var 𒍰; +var 𒍱; +var 𒍲; +var 𒍳; +var 𒍴; +var 𒍵; +var 𒍶; +var 𒍷; +var 𒍸; +var 𒍹; +var 𒍺; +var 𒍻; +var 𒍼; +var 𒍽; +var 𒍾; +var 𒍿; +var 𒎀; +var 𒎁; +var 𒎂; +var 𒎃; +var 𒎄; +var 𒎅; +var 𒎆; +var 𒎇; +var 𒎈; +var 𒎉; +var 𒎊; +var 𒎋; +var 𒎌; +var 𒎍; +var 𒎎; +var 𒎏; +var 𒎐; +var 𒎑; +var 𒎒; +var 𒎓; +var 𒎔; +var 𒎕; +var 𒎖; +var 𒎗; +var 𒎘; +var 𒑣; +var 𒑤; +var 𒑥; +var 𒑦; +var 𒑧; +var 𒑨; +var 𒑩; +var 𒑪; +var 𒑫; +var 𒑬; +var 𒑭; +var 𒑮; +var 𖩀; +var 𖩁; +var 𖩂; +var 𖩃; +var 𖩄; +var 𖩅; +var 𖩆; +var 𖩇; +var 𖩈; +var 𖩉; +var 𖩊; +var 𖩋; +var 𖩌; +var 𖩍; +var 𖩎; +var 𖩏; +var 𖩐; +var 𖩑; +var 𖩒; +var 𖩓; +var 𖩔; +var 𖩕; +var 𖩖; +var 𖩗; +var 𖩘; +var 𖩙; +var 𖩚; +var 𖩛; +var 𖩜; +var 𖩝; +var 𖩞; +var 𖫐; +var 𖫑; +var 𖫒; +var 𖫓; +var 𖫔; +var 𖫕; +var 𖫖; +var 𖫗; +var 𖫘; +var 𖫙; +var 𖫚; +var 𖫛; +var 𖫜; +var 𖫝; +var 𖫞; +var 𖫟; +var 𖫠; +var 𖫡; +var 𖫢; +var 𖫣; +var 𖫤; +var 𖫥; +var 𖫦; +var 𖫧; +var 𖫨; +var 𖫩; +var 𖫪; +var 𖫫; +var 𖫬; +var 𖫭; +var 𖬀; +var 𖬁; +var 𖬂; +var 𖬃; +var 𖬄; +var 𖬅; +var 𖬆; +var 𖬇; +var 𖬈; +var 𖬉; +var 𖬊; +var 𖬋; +var 𖬌; +var 𖬍; +var 𖬎; +var 𖬏; +var 𖬐; +var 𖬑; +var 𖬒; +var 𖬓; +var 𖬔; +var 𖬕; +var 𖬖; +var 𖬗; +var 𖬘; +var 𖬙; +var 𖬚; +var 𖬛; +var 𖬜; +var 𖬝; +var 𖬞; +var 𖬟; +var 𖬠; +var 𖬡; +var 𖬢; +var 𖬣; +var 𖬤; +var 𖬥; +var 𖬦; +var 𖬧; +var 𖬨; +var 𖬩; +var 𖬪; +var 𖬫; +var 𖬬; +var 𖬭; +var 𖬮; +var 𖬯; +var 𖭀; +var 𖭁; +var 𖭂; +var 𖭃; +var 𖭣; +var 𖭤; +var 𖭥; +var 𖭦; +var 𖭧; +var 𖭨; +var 𖭩; +var 𖭪; +var 𖭫; +var 𖭬; +var 𖭭; +var 𖭮; +var 𖭯; +var 𖭰; +var 𖭱; +var 𖭲; +var 𖭳; +var 𖭴; +var 𖭵; +var 𖭶; +var 𖭷; +var 𖭽; +var 𖭾; +var 𖭿; +var 𖮀; +var 𖮁; +var 𖮂; +var 𖮃; +var 𖮄; +var 𖮅; +var 𖮆; +var 𖮇; +var 𖮈; +var 𖮉; +var 𖮊; +var 𖮋; +var 𖮌; +var 𖮍; +var 𖮎; +var 𖮏; +var 𛰀; +var 𛰁; +var 𛰂; +var 𛰃; +var 𛰄; +var 𛰅; +var 𛰆; +var 𛰇; +var 𛰈; +var 𛰉; +var 𛰊; +var 𛰋; +var 𛰌; +var 𛰍; +var 𛰎; +var 𛰏; +var 𛰐; +var 𛰑; +var 𛰒; +var 𛰓; +var 𛰔; +var 𛰕; +var 𛰖; +var 𛰗; +var 𛰘; +var 𛰙; +var 𛰚; +var 𛰛; +var 𛰜; +var 𛰝; +var 𛰞; +var 𛰟; +var 𛰠; +var 𛰡; +var 𛰢; +var 𛰣; +var 𛰤; +var 𛰥; +var 𛰦; +var 𛰧; +var 𛰨; +var 𛰩; +var 𛰪; +var 𛰫; +var 𛰬; +var 𛰭; +var 𛰮; +var 𛰯; +var 𛰰; +var 𛰱; +var 𛰲; +var 𛰳; +var 𛰴; +var 𛰵; +var 𛰶; +var 𛰷; +var 𛰸; +var 𛰹; +var 𛰺; +var 𛰻; +var 𛰼; +var 𛰽; +var 𛰾; +var 𛰿; +var 𛱀; +var 𛱁; +var 𛱂; +var 𛱃; +var 𛱄; +var 𛱅; +var 𛱆; +var 𛱇; +var 𛱈; +var 𛱉; +var 𛱊; +var 𛱋; +var 𛱌; +var 𛱍; +var 𛱎; +var 𛱏; +var 𛱐; +var 𛱑; +var 𛱒; +var 𛱓; +var 𛱔; +var 𛱕; +var 𛱖; +var 𛱗; +var 𛱘; +var 𛱙; +var 𛱚; +var 𛱛; +var 𛱜; +var 𛱝; +var 𛱞; +var 𛱟; +var 𛱠; +var 𛱡; +var 𛱢; +var 𛱣; +var 𛱤; +var 𛱥; +var 𛱦; +var 𛱧; +var 𛱨; +var 𛱩; +var 𛱪; +var 𛱰; +var 𛱱; +var 𛱲; +var 𛱳; +var 𛱴; +var 𛱵; +var 𛱶; +var 𛱷; +var 𛱸; +var 𛱹; +var 𛱺; +var 𛱻; +var 𛱼; +var 𛲀; +var 𛲁; +var 𛲂; +var 𛲃; +var 𛲄; +var 𛲅; +var 𛲆; +var 𛲇; +var 𛲈; +var 𛲐; +var 𛲑; +var 𛲒; +var 𛲓; +var 𛲔; +var 𛲕; +var 𛲖; +var 𛲗; +var 𛲘; +var 𛲙; +var 𞠀; +var 𞠁; +var 𞠂; +var 𞠃; +var 𞠄; +var 𞠅; +var 𞠆; +var 𞠇; +var 𞠈; +var 𞠉; +var 𞠊; +var 𞠋; +var 𞠌; +var 𞠍; +var 𞠎; +var 𞠏; +var 𞠐; +var 𞠑; +var 𞠒; +var 𞠓; +var 𞠔; +var 𞠕; +var 𞠖; +var 𞠗; +var 𞠘; +var 𞠙; +var 𞠚; +var 𞠛; +var 𞠜; +var 𞠝; +var 𞠞; +var 𞠟; +var 𞠠; +var 𞠡; +var 𞠢; +var 𞠣; +var 𞠤; +var 𞠥; +var 𞠦; +var 𞠧; +var 𞠨; +var 𞠩; +var 𞠪; +var 𞠫; +var 𞠬; +var 𞠭; +var 𞠮; +var 𞠯; +var 𞠰; +var 𞠱; +var 𞠲; +var 𞠳; +var 𞠴; +var 𞠵; +var 𞠶; +var 𞠷; +var 𞠸; +var 𞠹; +var 𞠺; +var 𞠻; +var 𞠼; +var 𞠽; +var 𞠾; +var 𞠿; +var 𞡀; +var 𞡁; +var 𞡂; +var 𞡃; +var 𞡄; +var 𞡅; +var 𞡆; +var 𞡇; +var 𞡈; +var 𞡉; +var 𞡊; +var 𞡋; +var 𞡌; +var 𞡍; +var 𞡎; +var 𞡏; +var 𞡐; +var 𞡑; +var 𞡒; +var 𞡓; +var 𞡔; +var 𞡕; +var 𞡖; +var 𞡗; +var 𞡘; +var 𞡙; +var 𞡚; +var 𞡛; +var 𞡜; +var 𞡝; +var 𞡞; +var 𞡟; +var 𞡠; +var 𞡡; +var 𞡢; +var 𞡣; +var 𞡤; +var 𞡥; +var 𞡦; +var 𞡧; +var 𞡨; +var 𞡩; +var 𞡪; +var 𞡫; +var 𞡬; +var 𞡭; +var 𞡮; +var 𞡯; +var 𞡰; +var 𞡱; +var 𞡲; +var 𞡳; +var 𞡴; +var 𞡵; +var 𞡶; +var 𞡷; +var 𞡸; +var 𞡹; +var 𞡺; +var 𞡻; +var 𞡼; +var 𞡽; +var 𞡾; +var 𞡿; +var 𞢀; +var 𞢁; +var 𞢂; +var 𞢃; +var 𞢄; +var 𞢅; +var 𞢆; +var 𞢇; +var 𞢈; +var 𞢉; +var 𞢊; +var 𞢋; +var 𞢌; +var 𞢍; +var 𞢎; +var 𞢏; +var 𞢐; +var 𞢑; +var 𞢒; +var 𞢓; +var 𞢔; +var 𞢕; +var 𞢖; +var 𞢗; +var 𞢘; +var 𞢙; +var 𞢚; +var 𞢛; +var 𞢜; +var 𞢝; +var 𞢞; +var 𞢟; +var 𞢠; +var 𞢡; +var 𞢢; +var 𞢣; +var 𞢤; +var 𞢥; +var 𞢦; +var 𞢧; +var 𞢨; +var 𞢩; +var 𞢪; +var 𞢫; +var 𞢬; +var 𞢭; +var 𞢮; +var 𞢯; +var 𞢰; +var 𞢱; +var 𞢲; +var 𞢳; +var 𞢴; +var 𞢵; +var 𞢶; +var 𞢷; +var 𞢸; +var 𞢹; +var 𞢺; +var 𞢻; +var 𞢼; +var 𞢽; +var 𞢾; +var 𞢿; +var 𞣀; +var 𞣁; +var 𞣂; +var 𞣃; +var 𞣄; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0-class-escaped.js new file mode 100644 index 000000000..e1e13109b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0-class-escaped.js @@ -0,0 +1,6885 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v8.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u08B3; + #\u08B4; + #\u0AF9; + #\u0C5A; + #\u0D5F; + #\u13F5; + #\u13F8; + #\u13F9; + #\u13FA; + #\u13FB; + #\u13FC; + #\u13FD; + #\u19B0; + #\u19B1; + #\u19B2; + #\u19B3; + #\u19B4; + #\u19B5; + #\u19B6; + #\u19B7; + #\u19B8; + #\u19B9; + #\u19BA; + #\u19BB; + #\u19BC; + #\u19BD; + #\u19BE; + #\u19BF; + #\u19C0; + #\u19C8; + #\u19C9; + #\u9FCD; + #\u9FCE; + #\u9FCF; + #\u9FD0; + #\u9FD1; + #\u9FD2; + #\u9FD3; + #\u9FD4; + #\u9FD5; + #\uA78F; + #\uA7B2; + #\uA7B3; + #\uA7B4; + #\uA7B5; + #\uA7B6; + #\uA7B7; + #\uA8FD; + #\uAB60; + #\uAB61; + #\uAB62; + #\uAB63; + #\uAB70; + #\uAB71; + #\uAB72; + #\uAB73; + #\uAB74; + #\uAB75; + #\uAB76; + #\uAB77; + #\uAB78; + #\uAB79; + #\uAB7A; + #\uAB7B; + #\uAB7C; + #\uAB7D; + #\uAB7E; + #\uAB7F; + #\uAB80; + #\uAB81; + #\uAB82; + #\uAB83; + #\uAB84; + #\uAB85; + #\uAB86; + #\uAB87; + #\uAB88; + #\uAB89; + #\uAB8A; + #\uAB8B; + #\uAB8C; + #\uAB8D; + #\uAB8E; + #\uAB8F; + #\uAB90; + #\uAB91; + #\uAB92; + #\uAB93; + #\uAB94; + #\uAB95; + #\uAB96; + #\uAB97; + #\uAB98; + #\uAB99; + #\uAB9A; + #\uAB9B; + #\uAB9C; + #\uAB9D; + #\uAB9E; + #\uAB9F; + #\uABA0; + #\uABA1; + #\uABA2; + #\uABA3; + #\uABA4; + #\uABA5; + #\uABA6; + #\uABA7; + #\uABA8; + #\uABA9; + #\uABAA; + #\uABAB; + #\uABAC; + #\uABAD; + #\uABAE; + #\uABAF; + #\uABB0; + #\uABB1; + #\uABB2; + #\uABB3; + #\uABB4; + #\uABB5; + #\uABB6; + #\uABB7; + #\uABB8; + #\uABB9; + #\uABBA; + #\uABBB; + #\uABBC; + #\uABBD; + #\uABBE; + #\uABBF; + #\u{108E0}; + #\u{108E1}; + #\u{108E2}; + #\u{108E3}; + #\u{108E4}; + #\u{108E5}; + #\u{108E6}; + #\u{108E7}; + #\u{108E8}; + #\u{108E9}; + #\u{108EA}; + #\u{108EB}; + #\u{108EC}; + #\u{108ED}; + #\u{108EE}; + #\u{108EF}; + #\u{108F0}; + #\u{108F1}; + #\u{108F2}; + #\u{108F4}; + #\u{108F5}; + #\u{10C80}; + #\u{10C81}; + #\u{10C82}; + #\u{10C83}; + #\u{10C84}; + #\u{10C85}; + #\u{10C86}; + #\u{10C87}; + #\u{10C88}; + #\u{10C89}; + #\u{10C8A}; + #\u{10C8B}; + #\u{10C8C}; + #\u{10C8D}; + #\u{10C8E}; + #\u{10C8F}; + #\u{10C90}; + #\u{10C91}; + #\u{10C92}; + #\u{10C93}; + #\u{10C94}; + #\u{10C95}; + #\u{10C96}; + #\u{10C97}; + #\u{10C98}; + #\u{10C99}; + #\u{10C9A}; + #\u{10C9B}; + #\u{10C9C}; + #\u{10C9D}; + #\u{10C9E}; + #\u{10C9F}; + #\u{10CA0}; + #\u{10CA1}; + #\u{10CA2}; + #\u{10CA3}; + #\u{10CA4}; + #\u{10CA5}; + #\u{10CA6}; + #\u{10CA7}; + #\u{10CA8}; + #\u{10CA9}; + #\u{10CAA}; + #\u{10CAB}; + #\u{10CAC}; + #\u{10CAD}; + #\u{10CAE}; + #\u{10CAF}; + #\u{10CB0}; + #\u{10CB1}; + #\u{10CB2}; + #\u{10CC0}; + #\u{10CC1}; + #\u{10CC2}; + #\u{10CC3}; + #\u{10CC4}; + #\u{10CC5}; + #\u{10CC6}; + #\u{10CC7}; + #\u{10CC8}; + #\u{10CC9}; + #\u{10CCA}; + #\u{10CCB}; + #\u{10CCC}; + #\u{10CCD}; + #\u{10CCE}; + #\u{10CCF}; + #\u{10CD0}; + #\u{10CD1}; + #\u{10CD2}; + #\u{10CD3}; + #\u{10CD4}; + #\u{10CD5}; + #\u{10CD6}; + #\u{10CD7}; + #\u{10CD8}; + #\u{10CD9}; + #\u{10CDA}; + #\u{10CDB}; + #\u{10CDC}; + #\u{10CDD}; + #\u{10CDE}; + #\u{10CDF}; + #\u{10CE0}; + #\u{10CE1}; + #\u{10CE2}; + #\u{10CE3}; + #\u{10CE4}; + #\u{10CE5}; + #\u{10CE6}; + #\u{10CE7}; + #\u{10CE8}; + #\u{10CE9}; + #\u{10CEA}; + #\u{10CEB}; + #\u{10CEC}; + #\u{10CED}; + #\u{10CEE}; + #\u{10CEF}; + #\u{10CF0}; + #\u{10CF1}; + #\u{10CF2}; + #\u{111DC}; + #\u{11280}; + #\u{11281}; + #\u{11282}; + #\u{11283}; + #\u{11284}; + #\u{11285}; + #\u{11286}; + #\u{11288}; + #\u{1128A}; + #\u{1128B}; + #\u{1128C}; + #\u{1128D}; + #\u{1128F}; + #\u{11290}; + #\u{11291}; + #\u{11292}; + #\u{11293}; + #\u{11294}; + #\u{11295}; + #\u{11296}; + #\u{11297}; + #\u{11298}; + #\u{11299}; + #\u{1129A}; + #\u{1129B}; + #\u{1129C}; + #\u{1129D}; + #\u{1129F}; + #\u{112A0}; + #\u{112A1}; + #\u{112A2}; + #\u{112A3}; + #\u{112A4}; + #\u{112A5}; + #\u{112A6}; + #\u{112A7}; + #\u{112A8}; + #\u{11350}; + #\u{115D8}; + #\u{115D9}; + #\u{115DA}; + #\u{115DB}; + #\u{11700}; + #\u{11701}; + #\u{11702}; + #\u{11703}; + #\u{11704}; + #\u{11705}; + #\u{11706}; + #\u{11707}; + #\u{11708}; + #\u{11709}; + #\u{1170A}; + #\u{1170B}; + #\u{1170C}; + #\u{1170D}; + #\u{1170E}; + #\u{1170F}; + #\u{11710}; + #\u{11711}; + #\u{11712}; + #\u{11713}; + #\u{11714}; + #\u{11715}; + #\u{11716}; + #\u{11717}; + #\u{11718}; + #\u{11719}; + #\u{12399}; + #\u{12480}; + #\u{12481}; + #\u{12482}; + #\u{12483}; + #\u{12484}; + #\u{12485}; + #\u{12486}; + #\u{12487}; + #\u{12488}; + #\u{12489}; + #\u{1248A}; + #\u{1248B}; + #\u{1248C}; + #\u{1248D}; + #\u{1248E}; + #\u{1248F}; + #\u{12490}; + #\u{12491}; + #\u{12492}; + #\u{12493}; + #\u{12494}; + #\u{12495}; + #\u{12496}; + #\u{12497}; + #\u{12498}; + #\u{12499}; + #\u{1249A}; + #\u{1249B}; + #\u{1249C}; + #\u{1249D}; + #\u{1249E}; + #\u{1249F}; + #\u{124A0}; + #\u{124A1}; + #\u{124A2}; + #\u{124A3}; + #\u{124A4}; + #\u{124A5}; + #\u{124A6}; + #\u{124A7}; + #\u{124A8}; + #\u{124A9}; + #\u{124AA}; + #\u{124AB}; + #\u{124AC}; + #\u{124AD}; + #\u{124AE}; + #\u{124AF}; + #\u{124B0}; + #\u{124B1}; + #\u{124B2}; + #\u{124B3}; + #\u{124B4}; + #\u{124B5}; + #\u{124B6}; + #\u{124B7}; + #\u{124B8}; + #\u{124B9}; + #\u{124BA}; + #\u{124BB}; + #\u{124BC}; + #\u{124BD}; + #\u{124BE}; + #\u{124BF}; + #\u{124C0}; + #\u{124C1}; + #\u{124C2}; + #\u{124C3}; + #\u{124C4}; + #\u{124C5}; + #\u{124C6}; + #\u{124C7}; + #\u{124C8}; + #\u{124C9}; + #\u{124CA}; + #\u{124CB}; + #\u{124CC}; + #\u{124CD}; + #\u{124CE}; + #\u{124CF}; + #\u{124D0}; + #\u{124D1}; + #\u{124D2}; + #\u{124D3}; + #\u{124D4}; + #\u{124D5}; + #\u{124D6}; + #\u{124D7}; + #\u{124D8}; + #\u{124D9}; + #\u{124DA}; + #\u{124DB}; + #\u{124DC}; + #\u{124DD}; + #\u{124DE}; + #\u{124DF}; + #\u{124E0}; + #\u{124E1}; + #\u{124E2}; + #\u{124E3}; + #\u{124E4}; + #\u{124E5}; + #\u{124E6}; + #\u{124E7}; + #\u{124E8}; + #\u{124E9}; + #\u{124EA}; + #\u{124EB}; + #\u{124EC}; + #\u{124ED}; + #\u{124EE}; + #\u{124EF}; + #\u{124F0}; + #\u{124F1}; + #\u{124F2}; + #\u{124F3}; + #\u{124F4}; + #\u{124F5}; + #\u{124F6}; + #\u{124F7}; + #\u{124F8}; + #\u{124F9}; + #\u{124FA}; + #\u{124FB}; + #\u{124FC}; + #\u{124FD}; + #\u{124FE}; + #\u{124FF}; + #\u{12500}; + #\u{12501}; + #\u{12502}; + #\u{12503}; + #\u{12504}; + #\u{12505}; + #\u{12506}; + #\u{12507}; + #\u{12508}; + #\u{12509}; + #\u{1250A}; + #\u{1250B}; + #\u{1250C}; + #\u{1250D}; + #\u{1250E}; + #\u{1250F}; + #\u{12510}; + #\u{12511}; + #\u{12512}; + #\u{12513}; + #\u{12514}; + #\u{12515}; + #\u{12516}; + #\u{12517}; + #\u{12518}; + #\u{12519}; + #\u{1251A}; + #\u{1251B}; + #\u{1251C}; + #\u{1251D}; + #\u{1251E}; + #\u{1251F}; + #\u{12520}; + #\u{12521}; + #\u{12522}; + #\u{12523}; + #\u{12524}; + #\u{12525}; + #\u{12526}; + #\u{12527}; + #\u{12528}; + #\u{12529}; + #\u{1252A}; + #\u{1252B}; + #\u{1252C}; + #\u{1252D}; + #\u{1252E}; + #\u{1252F}; + #\u{12530}; + #\u{12531}; + #\u{12532}; + #\u{12533}; + #\u{12534}; + #\u{12535}; + #\u{12536}; + #\u{12537}; + #\u{12538}; + #\u{12539}; + #\u{1253A}; + #\u{1253B}; + #\u{1253C}; + #\u{1253D}; + #\u{1253E}; + #\u{1253F}; + #\u{12540}; + #\u{12541}; + #\u{12542}; + #\u{12543}; + #\u{14400}; + #\u{14401}; + #\u{14402}; + #\u{14403}; + #\u{14404}; + #\u{14405}; + #\u{14406}; + #\u{14407}; + #\u{14408}; + #\u{14409}; + #\u{1440A}; + #\u{1440B}; + #\u{1440C}; + #\u{1440D}; + #\u{1440E}; + #\u{1440F}; + #\u{14410}; + #\u{14411}; + #\u{14412}; + #\u{14413}; + #\u{14414}; + #\u{14415}; + #\u{14416}; + #\u{14417}; + #\u{14418}; + #\u{14419}; + #\u{1441A}; + #\u{1441B}; + #\u{1441C}; + #\u{1441D}; + #\u{1441E}; + #\u{1441F}; + #\u{14420}; + #\u{14421}; + #\u{14422}; + #\u{14423}; + #\u{14424}; + #\u{14425}; + #\u{14426}; + #\u{14427}; + #\u{14428}; + #\u{14429}; + #\u{1442A}; + #\u{1442B}; + #\u{1442C}; + #\u{1442D}; + #\u{1442E}; + #\u{1442F}; + #\u{14430}; + #\u{14431}; + #\u{14432}; + #\u{14433}; + #\u{14434}; + #\u{14435}; + #\u{14436}; + #\u{14437}; + #\u{14438}; + #\u{14439}; + #\u{1443A}; + #\u{1443B}; + #\u{1443C}; + #\u{1443D}; + #\u{1443E}; + #\u{1443F}; + #\u{14440}; + #\u{14441}; + #\u{14442}; + #\u{14443}; + #\u{14444}; + #\u{14445}; + #\u{14446}; + #\u{14447}; + #\u{14448}; + #\u{14449}; + #\u{1444A}; + #\u{1444B}; + #\u{1444C}; + #\u{1444D}; + #\u{1444E}; + #\u{1444F}; + #\u{14450}; + #\u{14451}; + #\u{14452}; + #\u{14453}; + #\u{14454}; + #\u{14455}; + #\u{14456}; + #\u{14457}; + #\u{14458}; + #\u{14459}; + #\u{1445A}; + #\u{1445B}; + #\u{1445C}; + #\u{1445D}; + #\u{1445E}; + #\u{1445F}; + #\u{14460}; + #\u{14461}; + #\u{14462}; + #\u{14463}; + #\u{14464}; + #\u{14465}; + #\u{14466}; + #\u{14467}; + #\u{14468}; + #\u{14469}; + #\u{1446A}; + #\u{1446B}; + #\u{1446C}; + #\u{1446D}; + #\u{1446E}; + #\u{1446F}; + #\u{14470}; + #\u{14471}; + #\u{14472}; + #\u{14473}; + #\u{14474}; + #\u{14475}; + #\u{14476}; + #\u{14477}; + #\u{14478}; + #\u{14479}; + #\u{1447A}; + #\u{1447B}; + #\u{1447C}; + #\u{1447D}; + #\u{1447E}; + #\u{1447F}; + #\u{14480}; + #\u{14481}; + #\u{14482}; + #\u{14483}; + #\u{14484}; + #\u{14485}; + #\u{14486}; + #\u{14487}; + #\u{14488}; + #\u{14489}; + #\u{1448A}; + #\u{1448B}; + #\u{1448C}; + #\u{1448D}; + #\u{1448E}; + #\u{1448F}; + #\u{14490}; + #\u{14491}; + #\u{14492}; + #\u{14493}; + #\u{14494}; + #\u{14495}; + #\u{14496}; + #\u{14497}; + #\u{14498}; + #\u{14499}; + #\u{1449A}; + #\u{1449B}; + #\u{1449C}; + #\u{1449D}; + #\u{1449E}; + #\u{1449F}; + #\u{144A0}; + #\u{144A1}; + #\u{144A2}; + #\u{144A3}; + #\u{144A4}; + #\u{144A5}; + #\u{144A6}; + #\u{144A7}; + #\u{144A8}; + #\u{144A9}; + #\u{144AA}; + #\u{144AB}; + #\u{144AC}; + #\u{144AD}; + #\u{144AE}; + #\u{144AF}; + #\u{144B0}; + #\u{144B1}; + #\u{144B2}; + #\u{144B3}; + #\u{144B4}; + #\u{144B5}; + #\u{144B6}; + #\u{144B7}; + #\u{144B8}; + #\u{144B9}; + #\u{144BA}; + #\u{144BB}; + #\u{144BC}; + #\u{144BD}; + #\u{144BE}; + #\u{144BF}; + #\u{144C0}; + #\u{144C1}; + #\u{144C2}; + #\u{144C3}; + #\u{144C4}; + #\u{144C5}; + #\u{144C6}; + #\u{144C7}; + #\u{144C8}; + #\u{144C9}; + #\u{144CA}; + #\u{144CB}; + #\u{144CC}; + #\u{144CD}; + #\u{144CE}; + #\u{144CF}; + #\u{144D0}; + #\u{144D1}; + #\u{144D2}; + #\u{144D3}; + #\u{144D4}; + #\u{144D5}; + #\u{144D6}; + #\u{144D7}; + #\u{144D8}; + #\u{144D9}; + #\u{144DA}; + #\u{144DB}; + #\u{144DC}; + #\u{144DD}; + #\u{144DE}; + #\u{144DF}; + #\u{144E0}; + #\u{144E1}; + #\u{144E2}; + #\u{144E3}; + #\u{144E4}; + #\u{144E5}; + #\u{144E6}; + #\u{144E7}; + #\u{144E8}; + #\u{144E9}; + #\u{144EA}; + #\u{144EB}; + #\u{144EC}; + #\u{144ED}; + #\u{144EE}; + #\u{144EF}; + #\u{144F0}; + #\u{144F1}; + #\u{144F2}; + #\u{144F3}; + #\u{144F4}; + #\u{144F5}; + #\u{144F6}; + #\u{144F7}; + #\u{144F8}; + #\u{144F9}; + #\u{144FA}; + #\u{144FB}; + #\u{144FC}; + #\u{144FD}; + #\u{144FE}; + #\u{144FF}; + #\u{14500}; + #\u{14501}; + #\u{14502}; + #\u{14503}; + #\u{14504}; + #\u{14505}; + #\u{14506}; + #\u{14507}; + #\u{14508}; + #\u{14509}; + #\u{1450A}; + #\u{1450B}; + #\u{1450C}; + #\u{1450D}; + #\u{1450E}; + #\u{1450F}; + #\u{14510}; + #\u{14511}; + #\u{14512}; + #\u{14513}; + #\u{14514}; + #\u{14515}; + #\u{14516}; + #\u{14517}; + #\u{14518}; + #\u{14519}; + #\u{1451A}; + #\u{1451B}; + #\u{1451C}; + #\u{1451D}; + #\u{1451E}; + #\u{1451F}; + #\u{14520}; + #\u{14521}; + #\u{14522}; + #\u{14523}; + #\u{14524}; + #\u{14525}; + #\u{14526}; + #\u{14527}; + #\u{14528}; + #\u{14529}; + #\u{1452A}; + #\u{1452B}; + #\u{1452C}; + #\u{1452D}; + #\u{1452E}; + #\u{1452F}; + #\u{14530}; + #\u{14531}; + #\u{14532}; + #\u{14533}; + #\u{14534}; + #\u{14535}; + #\u{14536}; + #\u{14537}; + #\u{14538}; + #\u{14539}; + #\u{1453A}; + #\u{1453B}; + #\u{1453C}; + #\u{1453D}; + #\u{1453E}; + #\u{1453F}; + #\u{14540}; + #\u{14541}; + #\u{14542}; + #\u{14543}; + #\u{14544}; + #\u{14545}; + #\u{14546}; + #\u{14547}; + #\u{14548}; + #\u{14549}; + #\u{1454A}; + #\u{1454B}; + #\u{1454C}; + #\u{1454D}; + #\u{1454E}; + #\u{1454F}; + #\u{14550}; + #\u{14551}; + #\u{14552}; + #\u{14553}; + #\u{14554}; + #\u{14555}; + #\u{14556}; + #\u{14557}; + #\u{14558}; + #\u{14559}; + #\u{1455A}; + #\u{1455B}; + #\u{1455C}; + #\u{1455D}; + #\u{1455E}; + #\u{1455F}; + #\u{14560}; + #\u{14561}; + #\u{14562}; + #\u{14563}; + #\u{14564}; + #\u{14565}; + #\u{14566}; + #\u{14567}; + #\u{14568}; + #\u{14569}; + #\u{1456A}; + #\u{1456B}; + #\u{1456C}; + #\u{1456D}; + #\u{1456E}; + #\u{1456F}; + #\u{14570}; + #\u{14571}; + #\u{14572}; + #\u{14573}; + #\u{14574}; + #\u{14575}; + #\u{14576}; + #\u{14577}; + #\u{14578}; + #\u{14579}; + #\u{1457A}; + #\u{1457B}; + #\u{1457C}; + #\u{1457D}; + #\u{1457E}; + #\u{1457F}; + #\u{14580}; + #\u{14581}; + #\u{14582}; + #\u{14583}; + #\u{14584}; + #\u{14585}; + #\u{14586}; + #\u{14587}; + #\u{14588}; + #\u{14589}; + #\u{1458A}; + #\u{1458B}; + #\u{1458C}; + #\u{1458D}; + #\u{1458E}; + #\u{1458F}; + #\u{14590}; + #\u{14591}; + #\u{14592}; + #\u{14593}; + #\u{14594}; + #\u{14595}; + #\u{14596}; + #\u{14597}; + #\u{14598}; + #\u{14599}; + #\u{1459A}; + #\u{1459B}; + #\u{1459C}; + #\u{1459D}; + #\u{1459E}; + #\u{1459F}; + #\u{145A0}; + #\u{145A1}; + #\u{145A2}; + #\u{145A3}; + #\u{145A4}; + #\u{145A5}; + #\u{145A6}; + #\u{145A7}; + #\u{145A8}; + #\u{145A9}; + #\u{145AA}; + #\u{145AB}; + #\u{145AC}; + #\u{145AD}; + #\u{145AE}; + #\u{145AF}; + #\u{145B0}; + #\u{145B1}; + #\u{145B2}; + #\u{145B3}; + #\u{145B4}; + #\u{145B5}; + #\u{145B6}; + #\u{145B7}; + #\u{145B8}; + #\u{145B9}; + #\u{145BA}; + #\u{145BB}; + #\u{145BC}; + #\u{145BD}; + #\u{145BE}; + #\u{145BF}; + #\u{145C0}; + #\u{145C1}; + #\u{145C2}; + #\u{145C3}; + #\u{145C4}; + #\u{145C5}; + #\u{145C6}; + #\u{145C7}; + #\u{145C8}; + #\u{145C9}; + #\u{145CA}; + #\u{145CB}; + #\u{145CC}; + #\u{145CD}; + #\u{145CE}; + #\u{145CF}; + #\u{145D0}; + #\u{145D1}; + #\u{145D2}; + #\u{145D3}; + #\u{145D4}; + #\u{145D5}; + #\u{145D6}; + #\u{145D7}; + #\u{145D8}; + #\u{145D9}; + #\u{145DA}; + #\u{145DB}; + #\u{145DC}; + #\u{145DD}; + #\u{145DE}; + #\u{145DF}; + #\u{145E0}; + #\u{145E1}; + #\u{145E2}; + #\u{145E3}; + #\u{145E4}; + #\u{145E5}; + #\u{145E6}; + #\u{145E7}; + #\u{145E8}; + #\u{145E9}; + #\u{145EA}; + #\u{145EB}; + #\u{145EC}; + #\u{145ED}; + #\u{145EE}; + #\u{145EF}; + #\u{145F0}; + #\u{145F1}; + #\u{145F2}; + #\u{145F3}; + #\u{145F4}; + #\u{145F5}; + #\u{145F6}; + #\u{145F7}; + #\u{145F8}; + #\u{145F9}; + #\u{145FA}; + #\u{145FB}; + #\u{145FC}; + #\u{145FD}; + #\u{145FE}; + #\u{145FF}; + #\u{14600}; + #\u{14601}; + #\u{14602}; + #\u{14603}; + #\u{14604}; + #\u{14605}; + #\u{14606}; + #\u{14607}; + #\u{14608}; + #\u{14609}; + #\u{1460A}; + #\u{1460B}; + #\u{1460C}; + #\u{1460D}; + #\u{1460E}; + #\u{1460F}; + #\u{14610}; + #\u{14611}; + #\u{14612}; + #\u{14613}; + #\u{14614}; + #\u{14615}; + #\u{14616}; + #\u{14617}; + #\u{14618}; + #\u{14619}; + #\u{1461A}; + #\u{1461B}; + #\u{1461C}; + #\u{1461D}; + #\u{1461E}; + #\u{1461F}; + #\u{14620}; + #\u{14621}; + #\u{14622}; + #\u{14623}; + #\u{14624}; + #\u{14625}; + #\u{14626}; + #\u{14627}; + #\u{14628}; + #\u{14629}; + #\u{1462A}; + #\u{1462B}; + #\u{1462C}; + #\u{1462D}; + #\u{1462E}; + #\u{1462F}; + #\u{14630}; + #\u{14631}; + #\u{14632}; + #\u{14633}; + #\u{14634}; + #\u{14635}; + #\u{14636}; + #\u{14637}; + #\u{14638}; + #\u{14639}; + #\u{1463A}; + #\u{1463B}; + #\u{1463C}; + #\u{1463D}; + #\u{1463E}; + #\u{1463F}; + #\u{14640}; + #\u{14641}; + #\u{14642}; + #\u{14643}; + #\u{14644}; + #\u{14645}; + #\u{14646}; + #\u{2B820}; + #\u{2B821}; + #\u{2B822}; + #\u{2B823}; + #\u{2B824}; + #\u{2B825}; + #\u{2B826}; + #\u{2B827}; + #\u{2B828}; + #\u{2B829}; + #\u{2B82A}; + #\u{2B82B}; + #\u{2B82C}; + #\u{2B82D}; + #\u{2B82E}; + #\u{2B82F}; + #\u{2B830}; + #\u{2B831}; + #\u{2B832}; + #\u{2B833}; + #\u{2B834}; + #\u{2B835}; + #\u{2B836}; + #\u{2B837}; + #\u{2B838}; + #\u{2B839}; + #\u{2B83A}; + #\u{2B83B}; + #\u{2B83C}; + #\u{2B83D}; + #\u{2B83E}; + #\u{2B83F}; + #\u{2B840}; + #\u{2B841}; + #\u{2B842}; + #\u{2B843}; + #\u{2B844}; + #\u{2B845}; + #\u{2B846}; + #\u{2B847}; + #\u{2B848}; + #\u{2B849}; + #\u{2B84A}; + #\u{2B84B}; + #\u{2B84C}; + #\u{2B84D}; + #\u{2B84E}; + #\u{2B84F}; + #\u{2B850}; + #\u{2B851}; + #\u{2B852}; + #\u{2B853}; + #\u{2B854}; + #\u{2B855}; + #\u{2B856}; + #\u{2B857}; + #\u{2B858}; + #\u{2B859}; + #\u{2B85A}; + #\u{2B85B}; + #\u{2B85C}; + #\u{2B85D}; + #\u{2B85E}; + #\u{2B85F}; + #\u{2B860}; + #\u{2B861}; + #\u{2B862}; + #\u{2B863}; + #\u{2B864}; + #\u{2B865}; + #\u{2B866}; + #\u{2B867}; + #\u{2B868}; + #\u{2B869}; + #\u{2B86A}; + #\u{2B86B}; + #\u{2B86C}; + #\u{2B86D}; + #\u{2B86E}; + #\u{2B86F}; + #\u{2B870}; + #\u{2B871}; + #\u{2B872}; + #\u{2B873}; + #\u{2B874}; + #\u{2B875}; + #\u{2B876}; + #\u{2B877}; + #\u{2B878}; + #\u{2B879}; + #\u{2B87A}; + #\u{2B87B}; + #\u{2B87C}; + #\u{2B87D}; + #\u{2B87E}; + #\u{2B87F}; + #\u{2B880}; + #\u{2B881}; + #\u{2B882}; + #\u{2B883}; + #\u{2B884}; + #\u{2B885}; + #\u{2B886}; + #\u{2B887}; + #\u{2B888}; + #\u{2B889}; + #\u{2B88A}; + #\u{2B88B}; + #\u{2B88C}; + #\u{2B88D}; + #\u{2B88E}; + #\u{2B88F}; + #\u{2B890}; + #\u{2B891}; + #\u{2B892}; + #\u{2B893}; + #\u{2B894}; + #\u{2B895}; + #\u{2B896}; + #\u{2B897}; + #\u{2B898}; + #\u{2B899}; + #\u{2B89A}; + #\u{2B89B}; + #\u{2B89C}; + #\u{2B89D}; + #\u{2B89E}; + #\u{2B89F}; + #\u{2B8A0}; + #\u{2B8A1}; + #\u{2B8A2}; + #\u{2B8A3}; + #\u{2B8A4}; + #\u{2B8A5}; + #\u{2B8A6}; + #\u{2B8A7}; + #\u{2B8A8}; + #\u{2B8A9}; + #\u{2B8AA}; + #\u{2B8AB}; + #\u{2B8AC}; + #\u{2B8AD}; + #\u{2B8AE}; + #\u{2B8AF}; + #\u{2B8B0}; + #\u{2B8B1}; + #\u{2B8B2}; + #\u{2B8B3}; + #\u{2B8B4}; + #\u{2B8B5}; + #\u{2B8B6}; + #\u{2B8B7}; + #\u{2B8B8}; + #\u{2B8B9}; + #\u{2B8BA}; + #\u{2B8BB}; + #\u{2B8BC}; + #\u{2B8BD}; + #\u{2B8BE}; + #\u{2B8BF}; + #\u{2B8C0}; + #\u{2B8C1}; + #\u{2B8C2}; + #\u{2B8C3}; + #\u{2B8C4}; + #\u{2B8C5}; + #\u{2B8C6}; + #\u{2B8C7}; + #\u{2B8C8}; + #\u{2B8C9}; + #\u{2B8CA}; + #\u{2B8CB}; + #\u{2B8CC}; + #\u{2B8CD}; + #\u{2B8CE}; + #\u{2B8CF}; + #\u{2B8D0}; + #\u{2B8D1}; + #\u{2B8D2}; + #\u{2B8D3}; + #\u{2B8D4}; + #\u{2B8D5}; + #\u{2B8D6}; + #\u{2B8D7}; + #\u{2B8D8}; + #\u{2B8D9}; + #\u{2B8DA}; + #\u{2B8DB}; + #\u{2B8DC}; + #\u{2B8DD}; + #\u{2B8DE}; + #\u{2B8DF}; + #\u{2B8E0}; + #\u{2B8E1}; + #\u{2B8E2}; + #\u{2B8E3}; + #\u{2B8E4}; + #\u{2B8E5}; + #\u{2B8E6}; + #\u{2B8E7}; + #\u{2B8E8}; + #\u{2B8E9}; + #\u{2B8EA}; + #\u{2B8EB}; + #\u{2B8EC}; + #\u{2B8ED}; + #\u{2B8EE}; + #\u{2B8EF}; + #\u{2B8F0}; + #\u{2B8F1}; + #\u{2B8F2}; + #\u{2B8F3}; + #\u{2B8F4}; + #\u{2B8F5}; + #\u{2B8F6}; + #\u{2B8F7}; + #\u{2B8F8}; + #\u{2B8F9}; + #\u{2B8FA}; + #\u{2B8FB}; + #\u{2B8FC}; + #\u{2B8FD}; + #\u{2B8FE}; + #\u{2B8FF}; + #\u{2B900}; + #\u{2B901}; + #\u{2B902}; + #\u{2B903}; + #\u{2B904}; + #\u{2B905}; + #\u{2B906}; + #\u{2B907}; + #\u{2B908}; + #\u{2B909}; + #\u{2B90A}; + #\u{2B90B}; + #\u{2B90C}; + #\u{2B90D}; + #\u{2B90E}; + #\u{2B90F}; + #\u{2B910}; + #\u{2B911}; + #\u{2B912}; + #\u{2B913}; + #\u{2B914}; + #\u{2B915}; + #\u{2B916}; + #\u{2B917}; + #\u{2B918}; + #\u{2B919}; + #\u{2B91A}; + #\u{2B91B}; + #\u{2B91C}; + #\u{2B91D}; + #\u{2B91E}; + #\u{2B91F}; + #\u{2B920}; + #\u{2B921}; + #\u{2B922}; + #\u{2B923}; + #\u{2B924}; + #\u{2B925}; + #\u{2B926}; + #\u{2B927}; + #\u{2B928}; + #\u{2B929}; + #\u{2B92A}; + #\u{2B92B}; + #\u{2B92C}; + #\u{2B92D}; + #\u{2B92E}; + #\u{2B92F}; + #\u{2B930}; + #\u{2B931}; + #\u{2B932}; + #\u{2B933}; + #\u{2B934}; + #\u{2B935}; + #\u{2B936}; + #\u{2B937}; + #\u{2B938}; + #\u{2B939}; + #\u{2B93A}; + #\u{2B93B}; + #\u{2B93C}; + #\u{2B93D}; + #\u{2B93E}; + #\u{2B93F}; + #\u{2B940}; + #\u{2B941}; + #\u{2B942}; + #\u{2B943}; + #\u{2B944}; + #\u{2B945}; + #\u{2B946}; + #\u{2B947}; + #\u{2B948}; + #\u{2B949}; + #\u{2B94A}; + #\u{2B94B}; + #\u{2B94C}; + #\u{2B94D}; + #\u{2B94E}; + #\u{2B94F}; + #\u{2B950}; + #\u{2B951}; + #\u{2B952}; + #\u{2B953}; + #\u{2B954}; + #\u{2B955}; + #\u{2B956}; + #\u{2B957}; + #\u{2B958}; + #\u{2B959}; + #\u{2B95A}; + #\u{2B95B}; + #\u{2B95C}; + #\u{2B95D}; + #\u{2B95E}; + #\u{2B95F}; + #\u{2B960}; + #\u{2B961}; + #\u{2B962}; + #\u{2B963}; + #\u{2B964}; + #\u{2B965}; + #\u{2B966}; + #\u{2B967}; + #\u{2B968}; + #\u{2B969}; + #\u{2B96A}; + #\u{2B96B}; + #\u{2B96C}; + #\u{2B96D}; + #\u{2B96E}; + #\u{2B96F}; + #\u{2B970}; + #\u{2B971}; + #\u{2B972}; + #\u{2B973}; + #\u{2B974}; + #\u{2B975}; + #\u{2B976}; + #\u{2B977}; + #\u{2B978}; + #\u{2B979}; + #\u{2B97A}; + #\u{2B97B}; + #\u{2B97C}; + #\u{2B97D}; + #\u{2B97E}; + #\u{2B97F}; + #\u{2B980}; + #\u{2B981}; + #\u{2B982}; + #\u{2B983}; + #\u{2B984}; + #\u{2B985}; + #\u{2B986}; + #\u{2B987}; + #\u{2B988}; + #\u{2B989}; + #\u{2B98A}; + #\u{2B98B}; + #\u{2B98C}; + #\u{2B98D}; + #\u{2B98E}; + #\u{2B98F}; + #\u{2B990}; + #\u{2B991}; + #\u{2B992}; + #\u{2B993}; + #\u{2B994}; + #\u{2B995}; + #\u{2B996}; + #\u{2B997}; + #\u{2B998}; + #\u{2B999}; + #\u{2B99A}; + #\u{2B99B}; + #\u{2B99C}; + #\u{2B99D}; + #\u{2B99E}; + #\u{2B99F}; + #\u{2B9A0}; + #\u{2B9A1}; + #\u{2B9A2}; + #\u{2B9A3}; + #\u{2B9A4}; + #\u{2B9A5}; + #\u{2B9A6}; + #\u{2B9A7}; + #\u{2B9A8}; + #\u{2B9A9}; + #\u{2B9AA}; + #\u{2B9AB}; + #\u{2B9AC}; + #\u{2B9AD}; + #\u{2B9AE}; + #\u{2B9AF}; + #\u{2B9B0}; + #\u{2B9B1}; + #\u{2B9B2}; + #\u{2B9B3}; + #\u{2B9B4}; + #\u{2B9B5}; + #\u{2B9B6}; + #\u{2B9B7}; + #\u{2B9B8}; + #\u{2B9B9}; + #\u{2B9BA}; + #\u{2B9BB}; + #\u{2B9BC}; + #\u{2B9BD}; + #\u{2B9BE}; + #\u{2B9BF}; + #\u{2B9C0}; + #\u{2B9C1}; + #\u{2B9C2}; + #\u{2B9C3}; + #\u{2B9C4}; + #\u{2B9C5}; + #\u{2B9C6}; + #\u{2B9C7}; + #\u{2B9C8}; + #\u{2B9C9}; + #\u{2B9CA}; + #\u{2B9CB}; + #\u{2B9CC}; + #\u{2B9CD}; + #\u{2B9CE}; + #\u{2B9CF}; + #\u{2B9D0}; + #\u{2B9D1}; + #\u{2B9D2}; + #\u{2B9D3}; + #\u{2B9D4}; + #\u{2B9D5}; + #\u{2B9D6}; + #\u{2B9D7}; + #\u{2B9D8}; + #\u{2B9D9}; + #\u{2B9DA}; + #\u{2B9DB}; + #\u{2B9DC}; + #\u{2B9DD}; + #\u{2B9DE}; + #\u{2B9DF}; + #\u{2B9E0}; + #\u{2B9E1}; + #\u{2B9E2}; + #\u{2B9E3}; + #\u{2B9E4}; + #\u{2B9E5}; + #\u{2B9E6}; + #\u{2B9E7}; + #\u{2B9E8}; + #\u{2B9E9}; + #\u{2B9EA}; + #\u{2B9EB}; + #\u{2B9EC}; + #\u{2B9ED}; + #\u{2B9EE}; + #\u{2B9EF}; + #\u{2B9F0}; + #\u{2B9F1}; + #\u{2B9F2}; + #\u{2B9F3}; + #\u{2B9F4}; + #\u{2B9F5}; + #\u{2B9F6}; + #\u{2B9F7}; + #\u{2B9F8}; + #\u{2B9F9}; + #\u{2B9FA}; + #\u{2B9FB}; + #\u{2B9FC}; + #\u{2B9FD}; + #\u{2B9FE}; + #\u{2B9FF}; + #\u{2BA00}; + #\u{2BA01}; + #\u{2BA02}; + #\u{2BA03}; + #\u{2BA04}; + #\u{2BA05}; + #\u{2BA06}; + #\u{2BA07}; + #\u{2BA08}; + #\u{2BA09}; + #\u{2BA0A}; + #\u{2BA0B}; + #\u{2BA0C}; + #\u{2BA0D}; + #\u{2BA0E}; + #\u{2BA0F}; + #\u{2BA10}; + #\u{2BA11}; + #\u{2BA12}; + #\u{2BA13}; + #\u{2BA14}; + #\u{2BA15}; + #\u{2BA16}; + #\u{2BA17}; + #\u{2BA18}; + #\u{2BA19}; + #\u{2BA1A}; + #\u{2BA1B}; + #\u{2BA1C}; + #\u{2BA1D}; + #\u{2BA1E}; + #\u{2BA1F}; + #\u{2BA20}; + #\u{2BA21}; + #\u{2BA22}; + #\u{2BA23}; + #\u{2BA24}; + #\u{2BA25}; + #\u{2BA26}; + #\u{2BA27}; + #\u{2BA28}; + #\u{2BA29}; + #\u{2BA2A}; + #\u{2BA2B}; + #\u{2BA2C}; + #\u{2BA2D}; + #\u{2BA2E}; + #\u{2BA2F}; + #\u{2BA30}; + #\u{2BA31}; + #\u{2BA32}; + #\u{2BA33}; + #\u{2BA34}; + #\u{2BA35}; + #\u{2BA36}; + #\u{2BA37}; + #\u{2BA38}; + #\u{2BA39}; + #\u{2BA3A}; + #\u{2BA3B}; + #\u{2BA3C}; + #\u{2BA3D}; + #\u{2BA3E}; + #\u{2BA3F}; + #\u{2BA40}; + #\u{2BA41}; + #\u{2BA42}; + #\u{2BA43}; + #\u{2BA44}; + #\u{2BA45}; + #\u{2BA46}; + #\u{2BA47}; + #\u{2BA48}; + #\u{2BA49}; + #\u{2BA4A}; + #\u{2BA4B}; + #\u{2BA4C}; + #\u{2BA4D}; + #\u{2BA4E}; + #\u{2BA4F}; + #\u{2BA50}; + #\u{2BA51}; + #\u{2BA52}; + #\u{2BA53}; + #\u{2BA54}; + #\u{2BA55}; + #\u{2BA56}; + #\u{2BA57}; + #\u{2BA58}; + #\u{2BA59}; + #\u{2BA5A}; + #\u{2BA5B}; + #\u{2BA5C}; + #\u{2BA5D}; + #\u{2BA5E}; + #\u{2BA5F}; + #\u{2BA60}; + #\u{2BA61}; + #\u{2BA62}; + #\u{2BA63}; + #\u{2BA64}; + #\u{2BA65}; + #\u{2BA66}; + #\u{2BA67}; + #\u{2BA68}; + #\u{2BA69}; + #\u{2BA6A}; + #\u{2BA6B}; + #\u{2BA6C}; + #\u{2BA6D}; + #\u{2BA6E}; + #\u{2BA6F}; + #\u{2BA70}; + #\u{2BA71}; + #\u{2BA72}; + #\u{2BA73}; + #\u{2BA74}; + #\u{2BA75}; + #\u{2BA76}; + #\u{2BA77}; + #\u{2BA78}; + #\u{2BA79}; + #\u{2BA7A}; + #\u{2BA7B}; + #\u{2BA7C}; + #\u{2BA7D}; + #\u{2BA7E}; + #\u{2BA7F}; + #\u{2BA80}; + #\u{2BA81}; + #\u{2BA82}; + #\u{2BA83}; + #\u{2BA84}; + #\u{2BA85}; + #\u{2BA86}; + #\u{2BA87}; + #\u{2BA88}; + #\u{2BA89}; + #\u{2BA8A}; + #\u{2BA8B}; + #\u{2BA8C}; + #\u{2BA8D}; + #\u{2BA8E}; + #\u{2BA8F}; + #\u{2BA90}; + #\u{2BA91}; + #\u{2BA92}; + #\u{2BA93}; + #\u{2BA94}; + #\u{2BA95}; + #\u{2BA96}; + #\u{2BA97}; + #\u{2BA98}; + #\u{2BA99}; + #\u{2BA9A}; + #\u{2BA9B}; + #\u{2BA9C}; + #\u{2BA9D}; + #\u{2BA9E}; + #\u{2BA9F}; + #\u{2BAA0}; + #\u{2BAA1}; + #\u{2BAA2}; + #\u{2BAA3}; + #\u{2BAA4}; + #\u{2BAA5}; + #\u{2BAA6}; + #\u{2BAA7}; + #\u{2BAA8}; + #\u{2BAA9}; + #\u{2BAAA}; + #\u{2BAAB}; + #\u{2BAAC}; + #\u{2BAAD}; + #\u{2BAAE}; + #\u{2BAAF}; + #\u{2BAB0}; + #\u{2BAB1}; + #\u{2BAB2}; + #\u{2BAB3}; + #\u{2BAB4}; + #\u{2BAB5}; + #\u{2BAB6}; + #\u{2BAB7}; + #\u{2BAB8}; + #\u{2BAB9}; + #\u{2BABA}; + #\u{2BABB}; + #\u{2BABC}; + #\u{2BABD}; + #\u{2BABE}; + #\u{2BABF}; + #\u{2BAC0}; + #\u{2BAC1}; + #\u{2BAC2}; + #\u{2BAC3}; + #\u{2BAC4}; + #\u{2BAC5}; + #\u{2BAC6}; + #\u{2BAC7}; + #\u{2BAC8}; + #\u{2BAC9}; + #\u{2BACA}; + #\u{2BACB}; + #\u{2BACC}; + #\u{2BACD}; + #\u{2BACE}; + #\u{2BACF}; + #\u{2BAD0}; + #\u{2BAD1}; + #\u{2BAD2}; + #\u{2BAD3}; + #\u{2BAD4}; + #\u{2BAD5}; + #\u{2BAD6}; + #\u{2BAD7}; + #\u{2BAD8}; + #\u{2BAD9}; + #\u{2BADA}; + #\u{2BADB}; + #\u{2BADC}; + #\u{2BADD}; + #\u{2BADE}; + #\u{2BADF}; + #\u{2BAE0}; + #\u{2BAE1}; + #\u{2BAE2}; + #\u{2BAE3}; + #\u{2BAE4}; + #\u{2BAE5}; + #\u{2BAE6}; + #\u{2BAE7}; + #\u{2BAE8}; + #\u{2BAE9}; + #\u{2BAEA}; + #\u{2BAEB}; + #\u{2BAEC}; + #\u{2BAED}; + #\u{2BAEE}; + #\u{2BAEF}; + #\u{2BAF0}; + #\u{2BAF1}; + #\u{2BAF2}; + #\u{2BAF3}; + #\u{2BAF4}; + #\u{2BAF5}; + #\u{2BAF6}; + #\u{2BAF7}; + #\u{2BAF8}; + #\u{2BAF9}; + #\u{2BAFA}; + #\u{2BAFB}; + #\u{2BAFC}; + #\u{2BAFD}; + #\u{2BAFE}; + #\u{2BAFF}; + #\u{2BB00}; + #\u{2BB01}; + #\u{2BB02}; + #\u{2BB03}; + #\u{2BB04}; + #\u{2BB05}; + #\u{2BB06}; + #\u{2BB07}; + #\u{2BB08}; + #\u{2BB09}; + #\u{2BB0A}; + #\u{2BB0B}; + #\u{2BB0C}; + #\u{2BB0D}; + #\u{2BB0E}; + #\u{2BB0F}; + #\u{2BB10}; + #\u{2BB11}; + #\u{2BB12}; + #\u{2BB13}; + #\u{2BB14}; + #\u{2BB15}; + #\u{2BB16}; + #\u{2BB17}; + #\u{2BB18}; + #\u{2BB19}; + #\u{2BB1A}; + #\u{2BB1B}; + #\u{2BB1C}; + #\u{2BB1D}; + #\u{2BB1E}; + #\u{2BB1F}; + #\u{2BB20}; + #\u{2BB21}; + #\u{2BB22}; + #\u{2BB23}; + #\u{2BB24}; + #\u{2BB25}; + #\u{2BB26}; + #\u{2BB27}; + #\u{2BB28}; + #\u{2BB29}; + #\u{2BB2A}; + #\u{2BB2B}; + #\u{2BB2C}; + #\u{2BB2D}; + #\u{2BB2E}; + #\u{2BB2F}; + #\u{2BB30}; + #\u{2BB31}; + #\u{2BB32}; + #\u{2BB33}; + #\u{2BB34}; + #\u{2BB35}; + #\u{2BB36}; + #\u{2BB37}; + #\u{2BB38}; + #\u{2BB39}; + #\u{2BB3A}; + #\u{2BB3B}; + #\u{2BB3C}; + #\u{2BB3D}; + #\u{2BB3E}; + #\u{2BB3F}; + #\u{2BB40}; + #\u{2BB41}; + #\u{2BB42}; + #\u{2BB43}; + #\u{2BB44}; + #\u{2BB45}; + #\u{2BB46}; + #\u{2BB47}; + #\u{2BB48}; + #\u{2BB49}; + #\u{2BB4A}; + #\u{2BB4B}; + #\u{2BB4C}; + #\u{2BB4D}; + #\u{2BB4E}; + #\u{2BB4F}; + #\u{2BB50}; + #\u{2BB51}; + #\u{2BB52}; + #\u{2BB53}; + #\u{2BB54}; + #\u{2BB55}; + #\u{2BB56}; + #\u{2BB57}; + #\u{2BB58}; + #\u{2BB59}; + #\u{2BB5A}; + #\u{2BB5B}; + #\u{2BB5C}; + #\u{2BB5D}; + #\u{2BB5E}; + #\u{2BB5F}; + #\u{2BB60}; + #\u{2BB61}; + #\u{2BB62}; + #\u{2BB63}; + #\u{2BB64}; + #\u{2BB65}; + #\u{2BB66}; + #\u{2BB67}; + #\u{2BB68}; + #\u{2BB69}; + #\u{2BB6A}; + #\u{2BB6B}; + #\u{2BB6C}; + #\u{2BB6D}; + #\u{2BB6E}; + #\u{2BB6F}; + #\u{2BB70}; + #\u{2BB71}; + #\u{2BB72}; + #\u{2BB73}; + #\u{2BB74}; + #\u{2BB75}; + #\u{2BB76}; + #\u{2BB77}; + #\u{2BB78}; + #\u{2BB79}; + #\u{2BB7A}; + #\u{2BB7B}; + #\u{2BB7C}; + #\u{2BB7D}; + #\u{2BB7E}; + #\u{2BB7F}; + #\u{2BB80}; + #\u{2BB81}; + #\u{2BB82}; + #\u{2BB83}; + #\u{2BB84}; + #\u{2BB85}; + #\u{2BB86}; + #\u{2BB87}; + #\u{2BB88}; + #\u{2BB89}; + #\u{2BB8A}; + #\u{2BB8B}; + #\u{2BB8C}; + #\u{2BB8D}; + #\u{2BB8E}; + #\u{2BB8F}; + #\u{2BB90}; + #\u{2BB91}; + #\u{2BB92}; + #\u{2BB93}; + #\u{2BB94}; + #\u{2BB95}; + #\u{2BB96}; + #\u{2BB97}; + #\u{2BB98}; + #\u{2BB99}; + #\u{2BB9A}; + #\u{2BB9B}; + #\u{2BB9C}; + #\u{2BB9D}; + #\u{2BB9E}; + #\u{2BB9F}; + #\u{2BBA0}; + #\u{2BBA1}; + #\u{2BBA2}; + #\u{2BBA3}; + #\u{2BBA4}; + #\u{2BBA5}; + #\u{2BBA6}; + #\u{2BBA7}; + #\u{2BBA8}; + #\u{2BBA9}; + #\u{2BBAA}; + #\u{2BBAB}; + #\u{2BBAC}; + #\u{2BBAD}; + #\u{2BBAE}; + #\u{2BBAF}; + #\u{2BBB0}; + #\u{2BBB1}; + #\u{2BBB2}; + #\u{2BBB3}; + #\u{2BBB4}; + #\u{2BBB5}; + #\u{2BBB6}; + #\u{2BBB7}; + #\u{2BBB8}; + #\u{2BBB9}; + #\u{2BBBA}; + #\u{2BBBB}; + #\u{2BBBC}; + #\u{2BBBD}; + #\u{2BBBE}; + #\u{2BBBF}; + #\u{2BBC0}; + #\u{2BBC1}; + #\u{2BBC2}; + #\u{2BBC3}; + #\u{2BBC4}; + #\u{2BBC5}; + #\u{2BBC6}; + #\u{2BBC7}; + #\u{2BBC8}; + #\u{2BBC9}; + #\u{2BBCA}; + #\u{2BBCB}; + #\u{2BBCC}; + #\u{2BBCD}; + #\u{2BBCE}; + #\u{2BBCF}; + #\u{2BBD0}; + #\u{2BBD1}; + #\u{2BBD2}; + #\u{2BBD3}; + #\u{2BBD4}; + #\u{2BBD5}; + #\u{2BBD6}; + #\u{2BBD7}; + #\u{2BBD8}; + #\u{2BBD9}; + #\u{2BBDA}; + #\u{2BBDB}; + #\u{2BBDC}; + #\u{2BBDD}; + #\u{2BBDE}; + #\u{2BBDF}; + #\u{2BBE0}; + #\u{2BBE1}; + #\u{2BBE2}; + #\u{2BBE3}; + #\u{2BBE4}; + #\u{2BBE5}; + #\u{2BBE6}; + #\u{2BBE7}; + #\u{2BBE8}; + #\u{2BBE9}; + #\u{2BBEA}; + #\u{2BBEB}; + #\u{2BBEC}; + #\u{2BBED}; + #\u{2BBEE}; + #\u{2BBEF}; + #\u{2BBF0}; + #\u{2BBF1}; + #\u{2BBF2}; + #\u{2BBF3}; + #\u{2BBF4}; + #\u{2BBF5}; + #\u{2BBF6}; + #\u{2BBF7}; + #\u{2BBF8}; + #\u{2BBF9}; + #\u{2BBFA}; + #\u{2BBFB}; + #\u{2BBFC}; + #\u{2BBFD}; + #\u{2BBFE}; + #\u{2BBFF}; + #\u{2BC00}; + #\u{2BC01}; + #\u{2BC02}; + #\u{2BC03}; + #\u{2BC04}; + #\u{2BC05}; + #\u{2BC06}; + #\u{2BC07}; + #\u{2BC08}; + #\u{2BC09}; + #\u{2BC0A}; + #\u{2BC0B}; + #\u{2BC0C}; + #\u{2BC0D}; + #\u{2BC0E}; + #\u{2BC0F}; + #\u{2BC10}; + #\u{2BC11}; + #\u{2BC12}; + #\u{2BC13}; + #\u{2BC14}; + #\u{2BC15}; + #\u{2BC16}; + #\u{2BC17}; + #\u{2BC18}; + #\u{2BC19}; + #\u{2BC1A}; + #\u{2BC1B}; + #\u{2BC1C}; + #\u{2BC1D}; + #\u{2BC1E}; + #\u{2BC1F}; + #\u{2BC20}; + #\u{2BC21}; + #\u{2BC22}; + #\u{2BC23}; + #\u{2BC24}; + #\u{2BC25}; + #\u{2BC26}; + #\u{2BC27}; + #\u{2BC28}; + #\u{2BC29}; + #\u{2BC2A}; + #\u{2BC2B}; + #\u{2BC2C}; + #\u{2BC2D}; + #\u{2BC2E}; + #\u{2BC2F}; + #\u{2BC30}; + #\u{2BC31}; + #\u{2BC32}; + #\u{2BC33}; + #\u{2BC34}; + #\u{2BC35}; + #\u{2BC36}; + #\u{2BC37}; + #\u{2BC38}; + #\u{2BC39}; + #\u{2BC3A}; + #\u{2BC3B}; + #\u{2BC3C}; + #\u{2BC3D}; + #\u{2BC3E}; + #\u{2BC3F}; + #\u{2BC40}; + #\u{2BC41}; + #\u{2BC42}; + #\u{2BC43}; + #\u{2BC44}; + #\u{2BC45}; + #\u{2BC46}; + #\u{2BC47}; + #\u{2BC48}; + #\u{2BC49}; + #\u{2BC4A}; + #\u{2BC4B}; + #\u{2BC4C}; + #\u{2BC4D}; + #\u{2BC4E}; + #\u{2BC4F}; + #\u{2BC50}; + #\u{2BC51}; + #\u{2BC52}; + #\u{2BC53}; + #\u{2BC54}; + #\u{2BC55}; + #\u{2BC56}; + #\u{2BC57}; + #\u{2BC58}; + #\u{2BC59}; + #\u{2BC5A}; + #\u{2BC5B}; + #\u{2BC5C}; + #\u{2BC5D}; + #\u{2BC5E}; + #\u{2BC5F}; + #\u{2BC60}; + #\u{2BC61}; + #\u{2BC62}; + #\u{2BC63}; + #\u{2BC64}; + #\u{2BC65}; + #\u{2BC66}; + #\u{2BC67}; + #\u{2BC68}; + #\u{2BC69}; + #\u{2BC6A}; + #\u{2BC6B}; + #\u{2BC6C}; + #\u{2BC6D}; + #\u{2BC6E}; + #\u{2BC6F}; + #\u{2BC70}; + #\u{2BC71}; + #\u{2BC72}; + #\u{2BC73}; + #\u{2BC74}; + #\u{2BC75}; + #\u{2BC76}; + #\u{2BC77}; + #\u{2BC78}; + #\u{2BC79}; + #\u{2BC7A}; + #\u{2BC7B}; + #\u{2BC7C}; + #\u{2BC7D}; + #\u{2BC7E}; + #\u{2BC7F}; + #\u{2BC80}; + #\u{2BC81}; + #\u{2BC82}; + #\u{2BC83}; + #\u{2BC84}; + #\u{2BC85}; + #\u{2BC86}; + #\u{2BC87}; + #\u{2BC88}; + #\u{2BC89}; + #\u{2BC8A}; + #\u{2BC8B}; + #\u{2BC8C}; + #\u{2BC8D}; + #\u{2BC8E}; + #\u{2BC8F}; + #\u{2BC90}; + #\u{2BC91}; + #\u{2BC92}; + #\u{2BC93}; + #\u{2BC94}; + #\u{2BC95}; + #\u{2BC96}; + #\u{2BC97}; + #\u{2BC98}; + #\u{2BC99}; + #\u{2BC9A}; + #\u{2BC9B}; + #\u{2BC9C}; + #\u{2BC9D}; + #\u{2BC9E}; + #\u{2BC9F}; + #\u{2BCA0}; + #\u{2BCA1}; + #\u{2BCA2}; + #\u{2BCA3}; + #\u{2BCA4}; + #\u{2BCA5}; + #\u{2BCA6}; + #\u{2BCA7}; + #\u{2BCA8}; + #\u{2BCA9}; + #\u{2BCAA}; + #\u{2BCAB}; + #\u{2BCAC}; + #\u{2BCAD}; + #\u{2BCAE}; + #\u{2BCAF}; + #\u{2BCB0}; + #\u{2BCB1}; + #\u{2BCB2}; + #\u{2BCB3}; + #\u{2BCB4}; + #\u{2BCB5}; + #\u{2BCB6}; + #\u{2BCB7}; + #\u{2BCB8}; + #\u{2BCB9}; + #\u{2BCBA}; + #\u{2BCBB}; + #\u{2BCBC}; + #\u{2BCBD}; + #\u{2BCBE}; + #\u{2BCBF}; + #\u{2BCC0}; + #\u{2BCC1}; + #\u{2BCC2}; + #\u{2BCC3}; + #\u{2BCC4}; + #\u{2BCC5}; + #\u{2BCC6}; + #\u{2BCC7}; + #\u{2BCC8}; + #\u{2BCC9}; + #\u{2BCCA}; + #\u{2BCCB}; + #\u{2BCCC}; + #\u{2BCCD}; + #\u{2BCCE}; + #\u{2BCCF}; + #\u{2BCD0}; + #\u{2BCD1}; + #\u{2BCD2}; + #\u{2BCD3}; + #\u{2BCD4}; + #\u{2BCD5}; + #\u{2BCD6}; + #\u{2BCD7}; + #\u{2BCD8}; + #\u{2BCD9}; + #\u{2BCDA}; + #\u{2BCDB}; + #\u{2BCDC}; + #\u{2BCDD}; + #\u{2BCDE}; + #\u{2BCDF}; + #\u{2BCE0}; + #\u{2BCE1}; + #\u{2BCE2}; + #\u{2BCE3}; + #\u{2BCE4}; + #\u{2BCE5}; + #\u{2BCE6}; + #\u{2BCE7}; + #\u{2BCE8}; + #\u{2BCE9}; + #\u{2BCEA}; + #\u{2BCEB}; + #\u{2BCEC}; + #\u{2BCED}; + #\u{2BCEE}; + #\u{2BCEF}; + #\u{2BCF0}; + #\u{2BCF1}; + #\u{2BCF2}; + #\u{2BCF3}; + #\u{2BCF4}; + #\u{2BCF5}; + #\u{2BCF6}; + #\u{2BCF7}; + #\u{2BCF8}; + #\u{2BCF9}; + #\u{2BCFA}; + #\u{2BCFB}; + #\u{2BCFC}; + #\u{2BCFD}; + #\u{2BCFE}; + #\u{2BCFF}; + #\u{2BD00}; + #\u{2BD01}; + #\u{2BD02}; + #\u{2BD03}; + #\u{2BD04}; + #\u{2BD05}; + #\u{2BD06}; + #\u{2BD07}; + #\u{2BD08}; + #\u{2BD09}; + #\u{2BD0A}; + #\u{2BD0B}; + #\u{2BD0C}; + #\u{2BD0D}; + #\u{2BD0E}; + #\u{2BD0F}; + #\u{2BD10}; + #\u{2BD11}; + #\u{2BD12}; + #\u{2BD13}; + #\u{2BD14}; + #\u{2BD15}; + #\u{2BD16}; + #\u{2BD17}; + #\u{2BD18}; + #\u{2BD19}; + #\u{2BD1A}; + #\u{2BD1B}; + #\u{2BD1C}; + #\u{2BD1D}; + #\u{2BD1E}; + #\u{2BD1F}; + #\u{2BD20}; + #\u{2BD21}; + #\u{2BD22}; + #\u{2BD23}; + #\u{2BD24}; + #\u{2BD25}; + #\u{2BD26}; + #\u{2BD27}; + #\u{2BD28}; + #\u{2BD29}; + #\u{2BD2A}; + #\u{2BD2B}; + #\u{2BD2C}; + #\u{2BD2D}; + #\u{2BD2E}; + #\u{2BD2F}; + #\u{2BD30}; + #\u{2BD31}; + #\u{2BD32}; + #\u{2BD33}; + #\u{2BD34}; + #\u{2BD35}; + #\u{2BD36}; + #\u{2BD37}; + #\u{2BD38}; + #\u{2BD39}; + #\u{2BD3A}; + #\u{2BD3B}; + #\u{2BD3C}; + #\u{2BD3D}; + #\u{2BD3E}; + #\u{2BD3F}; + #\u{2BD40}; + #\u{2BD41}; + #\u{2BD42}; + #\u{2BD43}; + #\u{2BD44}; + #\u{2BD45}; + #\u{2BD46}; + #\u{2BD47}; + #\u{2BD48}; + #\u{2BD49}; + #\u{2BD4A}; + #\u{2BD4B}; + #\u{2BD4C}; + #\u{2BD4D}; + #\u{2BD4E}; + #\u{2BD4F}; + #\u{2BD50}; + #\u{2BD51}; + #\u{2BD52}; + #\u{2BD53}; + #\u{2BD54}; + #\u{2BD55}; + #\u{2BD56}; + #\u{2BD57}; + #\u{2BD58}; + #\u{2BD59}; + #\u{2BD5A}; + #\u{2BD5B}; + #\u{2BD5C}; + #\u{2BD5D}; + #\u{2BD5E}; + #\u{2BD5F}; + #\u{2BD60}; + #\u{2BD61}; + #\u{2BD62}; + #\u{2BD63}; + #\u{2BD64}; + #\u{2BD65}; + #\u{2BD66}; + #\u{2BD67}; + #\u{2BD68}; + #\u{2BD69}; + #\u{2BD6A}; + #\u{2BD6B}; + #\u{2BD6C}; + #\u{2BD6D}; + #\u{2BD6E}; + #\u{2BD6F}; + #\u{2BD70}; + #\u{2BD71}; + #\u{2BD72}; + #\u{2BD73}; + #\u{2BD74}; + #\u{2BD75}; + #\u{2BD76}; + #\u{2BD77}; + #\u{2BD78}; + #\u{2BD79}; + #\u{2BD7A}; + #\u{2BD7B}; + #\u{2BD7C}; + #\u{2BD7D}; + #\u{2BD7E}; + #\u{2BD7F}; + #\u{2BD80}; + #\u{2BD81}; + #\u{2BD82}; + #\u{2BD83}; + #\u{2BD84}; + #\u{2BD85}; + #\u{2BD86}; + #\u{2BD87}; + #\u{2BD88}; + #\u{2BD89}; + #\u{2BD8A}; + #\u{2BD8B}; + #\u{2BD8C}; + #\u{2BD8D}; + #\u{2BD8E}; + #\u{2BD8F}; + #\u{2BD90}; + #\u{2BD91}; + #\u{2BD92}; + #\u{2BD93}; + #\u{2BD94}; + #\u{2BD95}; + #\u{2BD96}; + #\u{2BD97}; + #\u{2BD98}; + #\u{2BD99}; + #\u{2BD9A}; + #\u{2BD9B}; + #\u{2BD9C}; + #\u{2BD9D}; + #\u{2BD9E}; + #\u{2BD9F}; + #\u{2BDA0}; + #\u{2BDA1}; + #\u{2BDA2}; + #\u{2BDA3}; + #\u{2BDA4}; + #\u{2BDA5}; + #\u{2BDA6}; + #\u{2BDA7}; + #\u{2BDA8}; + #\u{2BDA9}; + #\u{2BDAA}; + #\u{2BDAB}; + #\u{2BDAC}; + #\u{2BDAD}; + #\u{2BDAE}; + #\u{2BDAF}; + #\u{2BDB0}; + #\u{2BDB1}; + #\u{2BDB2}; + #\u{2BDB3}; + #\u{2BDB4}; + #\u{2BDB5}; + #\u{2BDB6}; + #\u{2BDB7}; + #\u{2BDB8}; + #\u{2BDB9}; + #\u{2BDBA}; + #\u{2BDBB}; + #\u{2BDBC}; + #\u{2BDBD}; + #\u{2BDBE}; + #\u{2BDBF}; + #\u{2BDC0}; + #\u{2BDC1}; + #\u{2BDC2}; + #\u{2BDC3}; + #\u{2BDC4}; + #\u{2BDC5}; + #\u{2BDC6}; + #\u{2BDC7}; + #\u{2BDC8}; + #\u{2BDC9}; + #\u{2BDCA}; + #\u{2BDCB}; + #\u{2BDCC}; + #\u{2BDCD}; + #\u{2BDCE}; + #\u{2BDCF}; + #\u{2BDD0}; + #\u{2BDD1}; + #\u{2BDD2}; + #\u{2BDD3}; + #\u{2BDD4}; + #\u{2BDD5}; + #\u{2BDD6}; + #\u{2BDD7}; + #\u{2BDD8}; + #\u{2BDD9}; + #\u{2BDDA}; + #\u{2BDDB}; + #\u{2BDDC}; + #\u{2BDDD}; + #\u{2BDDE}; + #\u{2BDDF}; + #\u{2BDE0}; + #\u{2BDE1}; + #\u{2BDE2}; + #\u{2BDE3}; + #\u{2BDE4}; + #\u{2BDE5}; + #\u{2BDE6}; + #\u{2BDE7}; + #\u{2BDE8}; + #\u{2BDE9}; + #\u{2BDEA}; + #\u{2BDEB}; + #\u{2BDEC}; + #\u{2BDED}; + #\u{2BDEE}; + #\u{2BDEF}; + #\u{2BDF0}; + #\u{2BDF1}; + #\u{2BDF2}; + #\u{2BDF3}; + #\u{2BDF4}; + #\u{2BDF5}; + #\u{2BDF6}; + #\u{2BDF7}; + #\u{2BDF8}; + #\u{2BDF9}; + #\u{2BDFA}; + #\u{2BDFB}; + #\u{2BDFC}; + #\u{2BDFD}; + #\u{2BDFE}; + #\u{2BDFF}; + #\u{2BE00}; + #\u{2BE01}; + #\u{2BE02}; + #\u{2BE03}; + #\u{2BE04}; + #\u{2BE05}; + #\u{2BE06}; + #\u{2BE07}; + #\u{2BE08}; + #\u{2BE09}; + #\u{2BE0A}; + #\u{2BE0B}; + #\u{2BE0C}; + #\u{2BE0D}; + #\u{2BE0E}; + #\u{2BE0F}; + #\u{2BE10}; + #\u{2BE11}; + #\u{2BE12}; + #\u{2BE13}; + #\u{2BE14}; + #\u{2BE15}; + #\u{2BE16}; + #\u{2BE17}; + #\u{2BE18}; + #\u{2BE19}; + #\u{2BE1A}; + #\u{2BE1B}; + #\u{2BE1C}; + #\u{2BE1D}; + #\u{2BE1E}; + #\u{2BE1F}; + #\u{2BE20}; + #\u{2BE21}; + #\u{2BE22}; + #\u{2BE23}; + #\u{2BE24}; + #\u{2BE25}; + #\u{2BE26}; + #\u{2BE27}; + #\u{2BE28}; + #\u{2BE29}; + #\u{2BE2A}; + #\u{2BE2B}; + #\u{2BE2C}; + #\u{2BE2D}; + #\u{2BE2E}; + #\u{2BE2F}; + #\u{2BE30}; + #\u{2BE31}; + #\u{2BE32}; + #\u{2BE33}; + #\u{2BE34}; + #\u{2BE35}; + #\u{2BE36}; + #\u{2BE37}; + #\u{2BE38}; + #\u{2BE39}; + #\u{2BE3A}; + #\u{2BE3B}; + #\u{2BE3C}; + #\u{2BE3D}; + #\u{2BE3E}; + #\u{2BE3F}; + #\u{2BE40}; + #\u{2BE41}; + #\u{2BE42}; + #\u{2BE43}; + #\u{2BE44}; + #\u{2BE45}; + #\u{2BE46}; + #\u{2BE47}; + #\u{2BE48}; + #\u{2BE49}; + #\u{2BE4A}; + #\u{2BE4B}; + #\u{2BE4C}; + #\u{2BE4D}; + #\u{2BE4E}; + #\u{2BE4F}; + #\u{2BE50}; + #\u{2BE51}; + #\u{2BE52}; + #\u{2BE53}; + #\u{2BE54}; + #\u{2BE55}; + #\u{2BE56}; + #\u{2BE57}; + #\u{2BE58}; + #\u{2BE59}; + #\u{2BE5A}; + #\u{2BE5B}; + #\u{2BE5C}; + #\u{2BE5D}; + #\u{2BE5E}; + #\u{2BE5F}; + #\u{2BE60}; + #\u{2BE61}; + #\u{2BE62}; + #\u{2BE63}; + #\u{2BE64}; + #\u{2BE65}; + #\u{2BE66}; + #\u{2BE67}; + #\u{2BE68}; + #\u{2BE69}; + #\u{2BE6A}; + #\u{2BE6B}; + #\u{2BE6C}; + #\u{2BE6D}; + #\u{2BE6E}; + #\u{2BE6F}; + #\u{2BE70}; + #\u{2BE71}; + #\u{2BE72}; + #\u{2BE73}; + #\u{2BE74}; + #\u{2BE75}; + #\u{2BE76}; + #\u{2BE77}; + #\u{2BE78}; + #\u{2BE79}; + #\u{2BE7A}; + #\u{2BE7B}; + #\u{2BE7C}; + #\u{2BE7D}; + #\u{2BE7E}; + #\u{2BE7F}; + #\u{2BE80}; + #\u{2BE81}; + #\u{2BE82}; + #\u{2BE83}; + #\u{2BE84}; + #\u{2BE85}; + #\u{2BE86}; + #\u{2BE87}; + #\u{2BE88}; + #\u{2BE89}; + #\u{2BE8A}; + #\u{2BE8B}; + #\u{2BE8C}; + #\u{2BE8D}; + #\u{2BE8E}; + #\u{2BE8F}; + #\u{2BE90}; + #\u{2BE91}; + #\u{2BE92}; + #\u{2BE93}; + #\u{2BE94}; + #\u{2BE95}; + #\u{2BE96}; + #\u{2BE97}; + #\u{2BE98}; + #\u{2BE99}; + #\u{2BE9A}; + #\u{2BE9B}; + #\u{2BE9C}; + #\u{2BE9D}; + #\u{2BE9E}; + #\u{2BE9F}; + #\u{2BEA0}; + #\u{2BEA1}; + #\u{2BEA2}; + #\u{2BEA3}; + #\u{2BEA4}; + #\u{2BEA5}; + #\u{2BEA6}; + #\u{2BEA7}; + #\u{2BEA8}; + #\u{2BEA9}; + #\u{2BEAA}; + #\u{2BEAB}; + #\u{2BEAC}; + #\u{2BEAD}; + #\u{2BEAE}; + #\u{2BEAF}; + #\u{2BEB0}; + #\u{2BEB1}; + #\u{2BEB2}; + #\u{2BEB3}; + #\u{2BEB4}; + #\u{2BEB5}; + #\u{2BEB6}; + #\u{2BEB7}; + #\u{2BEB8}; + #\u{2BEB9}; + #\u{2BEBA}; + #\u{2BEBB}; + #\u{2BEBC}; + #\u{2BEBD}; + #\u{2BEBE}; + #\u{2BEBF}; + #\u{2BEC0}; + #\u{2BEC1}; + #\u{2BEC2}; + #\u{2BEC3}; + #\u{2BEC4}; + #\u{2BEC5}; + #\u{2BEC6}; + #\u{2BEC7}; + #\u{2BEC8}; + #\u{2BEC9}; + #\u{2BECA}; + #\u{2BECB}; + #\u{2BECC}; + #\u{2BECD}; + #\u{2BECE}; + #\u{2BECF}; + #\u{2BED0}; + #\u{2BED1}; + #\u{2BED2}; + #\u{2BED3}; + #\u{2BED4}; + #\u{2BED5}; + #\u{2BED6}; + #\u{2BED7}; + #\u{2BED8}; + #\u{2BED9}; + #\u{2BEDA}; + #\u{2BEDB}; + #\u{2BEDC}; + #\u{2BEDD}; + #\u{2BEDE}; + #\u{2BEDF}; + #\u{2BEE0}; + #\u{2BEE1}; + #\u{2BEE2}; + #\u{2BEE3}; + #\u{2BEE4}; + #\u{2BEE5}; + #\u{2BEE6}; + #\u{2BEE7}; + #\u{2BEE8}; + #\u{2BEE9}; + #\u{2BEEA}; + #\u{2BEEB}; + #\u{2BEEC}; + #\u{2BEED}; + #\u{2BEEE}; + #\u{2BEEF}; + #\u{2BEF0}; + #\u{2BEF1}; + #\u{2BEF2}; + #\u{2BEF3}; + #\u{2BEF4}; + #\u{2BEF5}; + #\u{2BEF6}; + #\u{2BEF7}; + #\u{2BEF8}; + #\u{2BEF9}; + #\u{2BEFA}; + #\u{2BEFB}; + #\u{2BEFC}; + #\u{2BEFD}; + #\u{2BEFE}; + #\u{2BEFF}; + #\u{2BF00}; + #\u{2BF01}; + #\u{2BF02}; + #\u{2BF03}; + #\u{2BF04}; + #\u{2BF05}; + #\u{2BF06}; + #\u{2BF07}; + #\u{2BF08}; + #\u{2BF09}; + #\u{2BF0A}; + #\u{2BF0B}; + #\u{2BF0C}; + #\u{2BF0D}; + #\u{2BF0E}; + #\u{2BF0F}; + #\u{2BF10}; + #\u{2BF11}; + #\u{2BF12}; + #\u{2BF13}; + #\u{2BF14}; + #\u{2BF15}; + #\u{2BF16}; + #\u{2BF17}; + #\u{2BF18}; + #\u{2BF19}; + #\u{2BF1A}; + #\u{2BF1B}; + #\u{2BF1C}; + #\u{2BF1D}; + #\u{2BF1E}; + #\u{2BF1F}; + #\u{2BF20}; + #\u{2BF21}; + #\u{2BF22}; + #\u{2BF23}; + #\u{2BF24}; + #\u{2BF25}; + #\u{2BF26}; + #\u{2BF27}; + #\u{2BF28}; + #\u{2BF29}; + #\u{2BF2A}; + #\u{2BF2B}; + #\u{2BF2C}; + #\u{2BF2D}; + #\u{2BF2E}; + #\u{2BF2F}; + #\u{2BF30}; + #\u{2BF31}; + #\u{2BF32}; + #\u{2BF33}; + #\u{2BF34}; + #\u{2BF35}; + #\u{2BF36}; + #\u{2BF37}; + #\u{2BF38}; + #\u{2BF39}; + #\u{2BF3A}; + #\u{2BF3B}; + #\u{2BF3C}; + #\u{2BF3D}; + #\u{2BF3E}; + #\u{2BF3F}; + #\u{2BF40}; + #\u{2BF41}; + #\u{2BF42}; + #\u{2BF43}; + #\u{2BF44}; + #\u{2BF45}; + #\u{2BF46}; + #\u{2BF47}; + #\u{2BF48}; + #\u{2BF49}; + #\u{2BF4A}; + #\u{2BF4B}; + #\u{2BF4C}; + #\u{2BF4D}; + #\u{2BF4E}; + #\u{2BF4F}; + #\u{2BF50}; + #\u{2BF51}; + #\u{2BF52}; + #\u{2BF53}; + #\u{2BF54}; + #\u{2BF55}; + #\u{2BF56}; + #\u{2BF57}; + #\u{2BF58}; + #\u{2BF59}; + #\u{2BF5A}; + #\u{2BF5B}; + #\u{2BF5C}; + #\u{2BF5D}; + #\u{2BF5E}; + #\u{2BF5F}; + #\u{2BF60}; + #\u{2BF61}; + #\u{2BF62}; + #\u{2BF63}; + #\u{2BF64}; + #\u{2BF65}; + #\u{2BF66}; + #\u{2BF67}; + #\u{2BF68}; + #\u{2BF69}; + #\u{2BF6A}; + #\u{2BF6B}; + #\u{2BF6C}; + #\u{2BF6D}; + #\u{2BF6E}; + #\u{2BF6F}; + #\u{2BF70}; + #\u{2BF71}; + #\u{2BF72}; + #\u{2BF73}; + #\u{2BF74}; + #\u{2BF75}; + #\u{2BF76}; + #\u{2BF77}; + #\u{2BF78}; + #\u{2BF79}; + #\u{2BF7A}; + #\u{2BF7B}; + #\u{2BF7C}; + #\u{2BF7D}; + #\u{2BF7E}; + #\u{2BF7F}; + #\u{2BF80}; + #\u{2BF81}; + #\u{2BF82}; + #\u{2BF83}; + #\u{2BF84}; + #\u{2BF85}; + #\u{2BF86}; + #\u{2BF87}; + #\u{2BF88}; + #\u{2BF89}; + #\u{2BF8A}; + #\u{2BF8B}; + #\u{2BF8C}; + #\u{2BF8D}; + #\u{2BF8E}; + #\u{2BF8F}; + #\u{2BF90}; + #\u{2BF91}; + #\u{2BF92}; + #\u{2BF93}; + #\u{2BF94}; + #\u{2BF95}; + #\u{2BF96}; + #\u{2BF97}; + #\u{2BF98}; + #\u{2BF99}; + #\u{2BF9A}; + #\u{2BF9B}; + #\u{2BF9C}; + #\u{2BF9D}; + #\u{2BF9E}; + #\u{2BF9F}; + #\u{2BFA0}; + #\u{2BFA1}; + #\u{2BFA2}; + #\u{2BFA3}; + #\u{2BFA4}; + #\u{2BFA5}; + #\u{2BFA6}; + #\u{2BFA7}; + #\u{2BFA8}; + #\u{2BFA9}; + #\u{2BFAA}; + #\u{2BFAB}; + #\u{2BFAC}; + #\u{2BFAD}; + #\u{2BFAE}; + #\u{2BFAF}; + #\u{2BFB0}; + #\u{2BFB1}; + #\u{2BFB2}; + #\u{2BFB3}; + #\u{2BFB4}; + #\u{2BFB5}; + #\u{2BFB6}; + #\u{2BFB7}; + #\u{2BFB8}; + #\u{2BFB9}; + #\u{2BFBA}; + #\u{2BFBB}; + #\u{2BFBC}; + #\u{2BFBD}; + #\u{2BFBE}; + #\u{2BFBF}; + #\u{2BFC0}; + #\u{2BFC1}; + #\u{2BFC2}; + #\u{2BFC3}; + #\u{2BFC4}; + #\u{2BFC5}; + #\u{2BFC6}; + #\u{2BFC7}; + #\u{2BFC8}; + #\u{2BFC9}; + #\u{2BFCA}; + #\u{2BFCB}; + #\u{2BFCC}; + #\u{2BFCD}; + #\u{2BFCE}; + #\u{2BFCF}; + #\u{2BFD0}; + #\u{2BFD1}; + #\u{2BFD2}; + #\u{2BFD3}; + #\u{2BFD4}; + #\u{2BFD5}; + #\u{2BFD6}; + #\u{2BFD7}; + #\u{2BFD8}; + #\u{2BFD9}; + #\u{2BFDA}; + #\u{2BFDB}; + #\u{2BFDC}; + #\u{2BFDD}; + #\u{2BFDE}; + #\u{2BFDF}; + #\u{2BFE0}; + #\u{2BFE1}; + #\u{2BFE2}; + #\u{2BFE3}; + #\u{2BFE4}; + #\u{2BFE5}; + #\u{2BFE6}; + #\u{2BFE7}; + #\u{2BFE8}; + #\u{2BFE9}; + #\u{2BFEA}; + #\u{2BFEB}; + #\u{2BFEC}; + #\u{2BFED}; + #\u{2BFEE}; + #\u{2BFEF}; + #\u{2BFF0}; + #\u{2BFF1}; + #\u{2BFF2}; + #\u{2BFF3}; + #\u{2BFF4}; + #\u{2BFF5}; + #\u{2BFF6}; + #\u{2BFF7}; + #\u{2BFF8}; + #\u{2BFF9}; + #\u{2BFFA}; + #\u{2BFFB}; + #\u{2BFFC}; + #\u{2BFFD}; + #\u{2BFFE}; + #\u{2BFFF}; + #\u{2C000}; + #\u{2C001}; + #\u{2C002}; + #\u{2C003}; + #\u{2C004}; + #\u{2C005}; + #\u{2C006}; + #\u{2C007}; + #\u{2C008}; + #\u{2C009}; + #\u{2C00A}; + #\u{2C00B}; + #\u{2C00C}; + #\u{2C00D}; + #\u{2C00E}; + #\u{2C00F}; + #\u{2C010}; + #\u{2C011}; + #\u{2C012}; + #\u{2C013}; + #\u{2C014}; + #\u{2C015}; + #\u{2C016}; + #\u{2C017}; + #\u{2C018}; + #\u{2C019}; + #\u{2C01A}; + #\u{2C01B}; + #\u{2C01C}; + #\u{2C01D}; + #\u{2C01E}; + #\u{2C01F}; + #\u{2C020}; + #\u{2C021}; + #\u{2C022}; + #\u{2C023}; + #\u{2C024}; + #\u{2C025}; + #\u{2C026}; + #\u{2C027}; + #\u{2C028}; + #\u{2C029}; + #\u{2C02A}; + #\u{2C02B}; + #\u{2C02C}; + #\u{2C02D}; + #\u{2C02E}; + #\u{2C02F}; + #\u{2C030}; + #\u{2C031}; + #\u{2C032}; + #\u{2C033}; + #\u{2C034}; + #\u{2C035}; + #\u{2C036}; + #\u{2C037}; + #\u{2C038}; + #\u{2C039}; + #\u{2C03A}; + #\u{2C03B}; + #\u{2C03C}; + #\u{2C03D}; + #\u{2C03E}; + #\u{2C03F}; + #\u{2C040}; + #\u{2C041}; + #\u{2C042}; + #\u{2C043}; + #\u{2C044}; + #\u{2C045}; + #\u{2C046}; + #\u{2C047}; + #\u{2C048}; + #\u{2C049}; + #\u{2C04A}; + #\u{2C04B}; + #\u{2C04C}; + #\u{2C04D}; + #\u{2C04E}; + #\u{2C04F}; + #\u{2C050}; + #\u{2C051}; + #\u{2C052}; + #\u{2C053}; + #\u{2C054}; + #\u{2C055}; + #\u{2C056}; + #\u{2C057}; + #\u{2C058}; + #\u{2C059}; + #\u{2C05A}; + #\u{2C05B}; + #\u{2C05C}; + #\u{2C05D}; + #\u{2C05E}; + #\u{2C05F}; + #\u{2C060}; + #\u{2C061}; + #\u{2C062}; + #\u{2C063}; + #\u{2C064}; + #\u{2C065}; + #\u{2C066}; + #\u{2C067}; + #\u{2C068}; + #\u{2C069}; + #\u{2C06A}; + #\u{2C06B}; + #\u{2C06C}; + #\u{2C06D}; + #\u{2C06E}; + #\u{2C06F}; + #\u{2C070}; + #\u{2C071}; + #\u{2C072}; + #\u{2C073}; + #\u{2C074}; + #\u{2C075}; + #\u{2C076}; + #\u{2C077}; + #\u{2C078}; + #\u{2C079}; + #\u{2C07A}; + #\u{2C07B}; + #\u{2C07C}; + #\u{2C07D}; + #\u{2C07E}; + #\u{2C07F}; + #\u{2C080}; + #\u{2C081}; + #\u{2C082}; + #\u{2C083}; + #\u{2C084}; + #\u{2C085}; + #\u{2C086}; + #\u{2C087}; + #\u{2C088}; + #\u{2C089}; + #\u{2C08A}; + #\u{2C08B}; + #\u{2C08C}; + #\u{2C08D}; + #\u{2C08E}; + #\u{2C08F}; + #\u{2C090}; + #\u{2C091}; + #\u{2C092}; + #\u{2C093}; + #\u{2C094}; + #\u{2C095}; + #\u{2C096}; + #\u{2C097}; + #\u{2C098}; + #\u{2C099}; + #\u{2C09A}; + #\u{2C09B}; + #\u{2C09C}; + #\u{2C09D}; + #\u{2C09E}; + #\u{2C09F}; + #\u{2C0A0}; + #\u{2C0A1}; + #\u{2C0A2}; + #\u{2C0A3}; + #\u{2C0A4}; + #\u{2C0A5}; + #\u{2C0A6}; + #\u{2C0A7}; + #\u{2C0A8}; + #\u{2C0A9}; + #\u{2C0AA}; + #\u{2C0AB}; + #\u{2C0AC}; + #\u{2C0AD}; + #\u{2C0AE}; + #\u{2C0AF}; + #\u{2C0B0}; + #\u{2C0B1}; + #\u{2C0B2}; + #\u{2C0B3}; + #\u{2C0B4}; + #\u{2C0B5}; + #\u{2C0B6}; + #\u{2C0B7}; + #\u{2C0B8}; + #\u{2C0B9}; + #\u{2C0BA}; + #\u{2C0BB}; + #\u{2C0BC}; + #\u{2C0BD}; + #\u{2C0BE}; + #\u{2C0BF}; + #\u{2C0C0}; + #\u{2C0C1}; + #\u{2C0C2}; + #\u{2C0C3}; + #\u{2C0C4}; + #\u{2C0C5}; + #\u{2C0C6}; + #\u{2C0C7}; + #\u{2C0C8}; + #\u{2C0C9}; + #\u{2C0CA}; + #\u{2C0CB}; + #\u{2C0CC}; + #\u{2C0CD}; + #\u{2C0CE}; + #\u{2C0CF}; + #\u{2C0D0}; + #\u{2C0D1}; + #\u{2C0D2}; + #\u{2C0D3}; + #\u{2C0D4}; + #\u{2C0D5}; + #\u{2C0D6}; + #\u{2C0D7}; + #\u{2C0D8}; + #\u{2C0D9}; + #\u{2C0DA}; + #\u{2C0DB}; + #\u{2C0DC}; + #\u{2C0DD}; + #\u{2C0DE}; + #\u{2C0DF}; + #\u{2C0E0}; + #\u{2C0E1}; + #\u{2C0E2}; + #\u{2C0E3}; + #\u{2C0E4}; + #\u{2C0E5}; + #\u{2C0E6}; + #\u{2C0E7}; + #\u{2C0E8}; + #\u{2C0E9}; + #\u{2C0EA}; + #\u{2C0EB}; + #\u{2C0EC}; + #\u{2C0ED}; + #\u{2C0EE}; + #\u{2C0EF}; + #\u{2C0F0}; + #\u{2C0F1}; + #\u{2C0F2}; + #\u{2C0F3}; + #\u{2C0F4}; + #\u{2C0F5}; + #\u{2C0F6}; + #\u{2C0F7}; + #\u{2C0F8}; + #\u{2C0F9}; + #\u{2C0FA}; + #\u{2C0FB}; + #\u{2C0FC}; + #\u{2C0FD}; + #\u{2C0FE}; + #\u{2C0FF}; + #\u{2C100}; + #\u{2C101}; + #\u{2C102}; + #\u{2C103}; + #\u{2C104}; + #\u{2C105}; + #\u{2C106}; + #\u{2C107}; + #\u{2C108}; + #\u{2C109}; + #\u{2C10A}; + #\u{2C10B}; + #\u{2C10C}; + #\u{2C10D}; + #\u{2C10E}; + #\u{2C10F}; + #\u{2C110}; + #\u{2C111}; + #\u{2C112}; + #\u{2C113}; + #\u{2C114}; + #\u{2C115}; + #\u{2C116}; + #\u{2C117}; + #\u{2C118}; + #\u{2C119}; + #\u{2C11A}; + #\u{2C11B}; + #\u{2C11C}; + #\u{2C11D}; + #\u{2C11E}; + #\u{2C11F}; + #\u{2C120}; + #\u{2C121}; + #\u{2C122}; + #\u{2C123}; + #\u{2C124}; + #\u{2C125}; + #\u{2C126}; + #\u{2C127}; + #\u{2C128}; + #\u{2C129}; + #\u{2C12A}; + #\u{2C12B}; + #\u{2C12C}; + #\u{2C12D}; + #\u{2C12E}; + #\u{2C12F}; + #\u{2C130}; + #\u{2C131}; + #\u{2C132}; + #\u{2C133}; + #\u{2C134}; + #\u{2C135}; + #\u{2C136}; + #\u{2C137}; + #\u{2C138}; + #\u{2C139}; + #\u{2C13A}; + #\u{2C13B}; + #\u{2C13C}; + #\u{2C13D}; + #\u{2C13E}; + #\u{2C13F}; + #\u{2C140}; + #\u{2C141}; + #\u{2C142}; + #\u{2C143}; + #\u{2C144}; + #\u{2C145}; + #\u{2C146}; + #\u{2C147}; + #\u{2C148}; + #\u{2C149}; + #\u{2C14A}; + #\u{2C14B}; + #\u{2C14C}; + #\u{2C14D}; + #\u{2C14E}; + #\u{2C14F}; + #\u{2C150}; + #\u{2C151}; + #\u{2C152}; + #\u{2C153}; + #\u{2C154}; + #\u{2C155}; + #\u{2C156}; + #\u{2C157}; + #\u{2C158}; + #\u{2C159}; + #\u{2C15A}; + #\u{2C15B}; + #\u{2C15C}; + #\u{2C15D}; + #\u{2C15E}; + #\u{2C15F}; + #\u{2C160}; + #\u{2C161}; + #\u{2C162}; + #\u{2C163}; + #\u{2C164}; + #\u{2C165}; + #\u{2C166}; + #\u{2C167}; + #\u{2C168}; + #\u{2C169}; + #\u{2C16A}; + #\u{2C16B}; + #\u{2C16C}; + #\u{2C16D}; + #\u{2C16E}; + #\u{2C16F}; + #\u{2C170}; + #\u{2C171}; + #\u{2C172}; + #\u{2C173}; + #\u{2C174}; + #\u{2C175}; + #\u{2C176}; + #\u{2C177}; + #\u{2C178}; + #\u{2C179}; + #\u{2C17A}; + #\u{2C17B}; + #\u{2C17C}; + #\u{2C17D}; + #\u{2C17E}; + #\u{2C17F}; + #\u{2C180}; + #\u{2C181}; + #\u{2C182}; + #\u{2C183}; + #\u{2C184}; + #\u{2C185}; + #\u{2C186}; + #\u{2C187}; + #\u{2C188}; + #\u{2C189}; + #\u{2C18A}; + #\u{2C18B}; + #\u{2C18C}; + #\u{2C18D}; + #\u{2C18E}; + #\u{2C18F}; + #\u{2C190}; + #\u{2C191}; + #\u{2C192}; + #\u{2C193}; + #\u{2C194}; + #\u{2C195}; + #\u{2C196}; + #\u{2C197}; + #\u{2C198}; + #\u{2C199}; + #\u{2C19A}; + #\u{2C19B}; + #\u{2C19C}; + #\u{2C19D}; + #\u{2C19E}; + #\u{2C19F}; + #\u{2C1A0}; + #\u{2C1A1}; + #\u{2C1A2}; + #\u{2C1A3}; + #\u{2C1A4}; + #\u{2C1A5}; + #\u{2C1A6}; + #\u{2C1A7}; + #\u{2C1A8}; + #\u{2C1A9}; + #\u{2C1AA}; + #\u{2C1AB}; + #\u{2C1AC}; + #\u{2C1AD}; + #\u{2C1AE}; + #\u{2C1AF}; + #\u{2C1B0}; + #\u{2C1B1}; + #\u{2C1B2}; + #\u{2C1B3}; + #\u{2C1B4}; + #\u{2C1B5}; + #\u{2C1B6}; + #\u{2C1B7}; + #\u{2C1B8}; + #\u{2C1B9}; + #\u{2C1BA}; + #\u{2C1BB}; + #\u{2C1BC}; + #\u{2C1BD}; + #\u{2C1BE}; + #\u{2C1BF}; + #\u{2C1C0}; + #\u{2C1C1}; + #\u{2C1C2}; + #\u{2C1C3}; + #\u{2C1C4}; + #\u{2C1C5}; + #\u{2C1C6}; + #\u{2C1C7}; + #\u{2C1C8}; + #\u{2C1C9}; + #\u{2C1CA}; + #\u{2C1CB}; + #\u{2C1CC}; + #\u{2C1CD}; + #\u{2C1CE}; + #\u{2C1CF}; + #\u{2C1D0}; + #\u{2C1D1}; + #\u{2C1D2}; + #\u{2C1D3}; + #\u{2C1D4}; + #\u{2C1D5}; + #\u{2C1D6}; + #\u{2C1D7}; + #\u{2C1D8}; + #\u{2C1D9}; + #\u{2C1DA}; + #\u{2C1DB}; + #\u{2C1DC}; + #\u{2C1DD}; + #\u{2C1DE}; + #\u{2C1DF}; + #\u{2C1E0}; + #\u{2C1E1}; + #\u{2C1E2}; + #\u{2C1E3}; + #\u{2C1E4}; + #\u{2C1E5}; + #\u{2C1E6}; + #\u{2C1E7}; + #\u{2C1E8}; + #\u{2C1E9}; + #\u{2C1EA}; + #\u{2C1EB}; + #\u{2C1EC}; + #\u{2C1ED}; + #\u{2C1EE}; + #\u{2C1EF}; + #\u{2C1F0}; + #\u{2C1F1}; + #\u{2C1F2}; + #\u{2C1F3}; + #\u{2C1F4}; + #\u{2C1F5}; + #\u{2C1F6}; + #\u{2C1F7}; + #\u{2C1F8}; + #\u{2C1F9}; + #\u{2C1FA}; + #\u{2C1FB}; + #\u{2C1FC}; + #\u{2C1FD}; + #\u{2C1FE}; + #\u{2C1FF}; + #\u{2C200}; + #\u{2C201}; + #\u{2C202}; + #\u{2C203}; + #\u{2C204}; + #\u{2C205}; + #\u{2C206}; + #\u{2C207}; + #\u{2C208}; + #\u{2C209}; + #\u{2C20A}; + #\u{2C20B}; + #\u{2C20C}; + #\u{2C20D}; + #\u{2C20E}; + #\u{2C20F}; + #\u{2C210}; + #\u{2C211}; + #\u{2C212}; + #\u{2C213}; + #\u{2C214}; + #\u{2C215}; + #\u{2C216}; + #\u{2C217}; + #\u{2C218}; + #\u{2C219}; + #\u{2C21A}; + #\u{2C21B}; + #\u{2C21C}; + #\u{2C21D}; + #\u{2C21E}; + #\u{2C21F}; + #\u{2C220}; + #\u{2C221}; + #\u{2C222}; + #\u{2C223}; + #\u{2C224}; + #\u{2C225}; + #\u{2C226}; + #\u{2C227}; + #\u{2C228}; + #\u{2C229}; + #\u{2C22A}; + #\u{2C22B}; + #\u{2C22C}; + #\u{2C22D}; + #\u{2C22E}; + #\u{2C22F}; + #\u{2C230}; + #\u{2C231}; + #\u{2C232}; + #\u{2C233}; + #\u{2C234}; + #\u{2C235}; + #\u{2C236}; + #\u{2C237}; + #\u{2C238}; + #\u{2C239}; + #\u{2C23A}; + #\u{2C23B}; + #\u{2C23C}; + #\u{2C23D}; + #\u{2C23E}; + #\u{2C23F}; + #\u{2C240}; + #\u{2C241}; + #\u{2C242}; + #\u{2C243}; + #\u{2C244}; + #\u{2C245}; + #\u{2C246}; + #\u{2C247}; + #\u{2C248}; + #\u{2C249}; + #\u{2C24A}; + #\u{2C24B}; + #\u{2C24C}; + #\u{2C24D}; + #\u{2C24E}; + #\u{2C24F}; + #\u{2C250}; + #\u{2C251}; + #\u{2C252}; + #\u{2C253}; + #\u{2C254}; + #\u{2C255}; + #\u{2C256}; + #\u{2C257}; + #\u{2C258}; + #\u{2C259}; + #\u{2C25A}; + #\u{2C25B}; + #\u{2C25C}; + #\u{2C25D}; + #\u{2C25E}; + #\u{2C25F}; + #\u{2C260}; + #\u{2C261}; + #\u{2C262}; + #\u{2C263}; + #\u{2C264}; + #\u{2C265}; + #\u{2C266}; + #\u{2C267}; + #\u{2C268}; + #\u{2C269}; + #\u{2C26A}; + #\u{2C26B}; + #\u{2C26C}; + #\u{2C26D}; + #\u{2C26E}; + #\u{2C26F}; + #\u{2C270}; + #\u{2C271}; + #\u{2C272}; + #\u{2C273}; + #\u{2C274}; + #\u{2C275}; + #\u{2C276}; + #\u{2C277}; + #\u{2C278}; + #\u{2C279}; + #\u{2C27A}; + #\u{2C27B}; + #\u{2C27C}; + #\u{2C27D}; + #\u{2C27E}; + #\u{2C27F}; + #\u{2C280}; + #\u{2C281}; + #\u{2C282}; + #\u{2C283}; + #\u{2C284}; + #\u{2C285}; + #\u{2C286}; + #\u{2C287}; + #\u{2C288}; + #\u{2C289}; + #\u{2C28A}; + #\u{2C28B}; + #\u{2C28C}; + #\u{2C28D}; + #\u{2C28E}; + #\u{2C28F}; + #\u{2C290}; + #\u{2C291}; + #\u{2C292}; + #\u{2C293}; + #\u{2C294}; + #\u{2C295}; + #\u{2C296}; + #\u{2C297}; + #\u{2C298}; + #\u{2C299}; + #\u{2C29A}; + #\u{2C29B}; + #\u{2C29C}; + #\u{2C29D}; + #\u{2C29E}; + #\u{2C29F}; + #\u{2C2A0}; + #\u{2C2A1}; + #\u{2C2A2}; + #\u{2C2A3}; + #\u{2C2A4}; + #\u{2C2A5}; + #\u{2C2A6}; + #\u{2C2A7}; + #\u{2C2A8}; + #\u{2C2A9}; + #\u{2C2AA}; + #\u{2C2AB}; + #\u{2C2AC}; + #\u{2C2AD}; + #\u{2C2AE}; + #\u{2C2AF}; + #\u{2C2B0}; + #\u{2C2B1}; + #\u{2C2B2}; + #\u{2C2B3}; + #\u{2C2B4}; + #\u{2C2B5}; + #\u{2C2B6}; + #\u{2C2B7}; + #\u{2C2B8}; + #\u{2C2B9}; + #\u{2C2BA}; + #\u{2C2BB}; + #\u{2C2BC}; + #\u{2C2BD}; + #\u{2C2BE}; + #\u{2C2BF}; + #\u{2C2C0}; + #\u{2C2C1}; + #\u{2C2C2}; + #\u{2C2C3}; + #\u{2C2C4}; + #\u{2C2C5}; + #\u{2C2C6}; + #\u{2C2C7}; + #\u{2C2C8}; + #\u{2C2C9}; + #\u{2C2CA}; + #\u{2C2CB}; + #\u{2C2CC}; + #\u{2C2CD}; + #\u{2C2CE}; + #\u{2C2CF}; + #\u{2C2D0}; + #\u{2C2D1}; + #\u{2C2D2}; + #\u{2C2D3}; + #\u{2C2D4}; + #\u{2C2D5}; + #\u{2C2D6}; + #\u{2C2D7}; + #\u{2C2D8}; + #\u{2C2D9}; + #\u{2C2DA}; + #\u{2C2DB}; + #\u{2C2DC}; + #\u{2C2DD}; + #\u{2C2DE}; + #\u{2C2DF}; + #\u{2C2E0}; + #\u{2C2E1}; + #\u{2C2E2}; + #\u{2C2E3}; + #\u{2C2E4}; + #\u{2C2E5}; + #\u{2C2E6}; + #\u{2C2E7}; + #\u{2C2E8}; + #\u{2C2E9}; + #\u{2C2EA}; + #\u{2C2EB}; + #\u{2C2EC}; + #\u{2C2ED}; + #\u{2C2EE}; + #\u{2C2EF}; + #\u{2C2F0}; + #\u{2C2F1}; + #\u{2C2F2}; + #\u{2C2F3}; + #\u{2C2F4}; + #\u{2C2F5}; + #\u{2C2F6}; + #\u{2C2F7}; + #\u{2C2F8}; + #\u{2C2F9}; + #\u{2C2FA}; + #\u{2C2FB}; + #\u{2C2FC}; + #\u{2C2FD}; + #\u{2C2FE}; + #\u{2C2FF}; + #\u{2C300}; + #\u{2C301}; + #\u{2C302}; + #\u{2C303}; + #\u{2C304}; + #\u{2C305}; + #\u{2C306}; + #\u{2C307}; + #\u{2C308}; + #\u{2C309}; + #\u{2C30A}; + #\u{2C30B}; + #\u{2C30C}; + #\u{2C30D}; + #\u{2C30E}; + #\u{2C30F}; + #\u{2C310}; + #\u{2C311}; + #\u{2C312}; + #\u{2C313}; + #\u{2C314}; + #\u{2C315}; + #\u{2C316}; + #\u{2C317}; + #\u{2C318}; + #\u{2C319}; + #\u{2C31A}; + #\u{2C31B}; + #\u{2C31C}; + #\u{2C31D}; + #\u{2C31E}; + #\u{2C31F}; + #\u{2C320}; + #\u{2C321}; + #\u{2C322}; + #\u{2C323}; + #\u{2C324}; + #\u{2C325}; + #\u{2C326}; + #\u{2C327}; + #\u{2C328}; + #\u{2C329}; + #\u{2C32A}; + #\u{2C32B}; + #\u{2C32C}; + #\u{2C32D}; + #\u{2C32E}; + #\u{2C32F}; + #\u{2C330}; + #\u{2C331}; + #\u{2C332}; + #\u{2C333}; + #\u{2C334}; + #\u{2C335}; + #\u{2C336}; + #\u{2C337}; + #\u{2C338}; + #\u{2C339}; + #\u{2C33A}; + #\u{2C33B}; + #\u{2C33C}; + #\u{2C33D}; + #\u{2C33E}; + #\u{2C33F}; + #\u{2C340}; + #\u{2C341}; + #\u{2C342}; + #\u{2C343}; + #\u{2C344}; + #\u{2C345}; + #\u{2C346}; + #\u{2C347}; + #\u{2C348}; + #\u{2C349}; + #\u{2C34A}; + #\u{2C34B}; + #\u{2C34C}; + #\u{2C34D}; + #\u{2C34E}; + #\u{2C34F}; + #\u{2C350}; + #\u{2C351}; + #\u{2C352}; + #\u{2C353}; + #\u{2C354}; + #\u{2C355}; + #\u{2C356}; + #\u{2C357}; + #\u{2C358}; + #\u{2C359}; + #\u{2C35A}; + #\u{2C35B}; + #\u{2C35C}; + #\u{2C35D}; + #\u{2C35E}; + #\u{2C35F}; + #\u{2C360}; + #\u{2C361}; + #\u{2C362}; + #\u{2C363}; + #\u{2C364}; + #\u{2C365}; + #\u{2C366}; + #\u{2C367}; + #\u{2C368}; + #\u{2C369}; + #\u{2C36A}; + #\u{2C36B}; + #\u{2C36C}; + #\u{2C36D}; + #\u{2C36E}; + #\u{2C36F}; + #\u{2C370}; + #\u{2C371}; + #\u{2C372}; + #\u{2C373}; + #\u{2C374}; + #\u{2C375}; + #\u{2C376}; + #\u{2C377}; + #\u{2C378}; + #\u{2C379}; + #\u{2C37A}; + #\u{2C37B}; + #\u{2C37C}; + #\u{2C37D}; + #\u{2C37E}; + #\u{2C37F}; + #\u{2C380}; + #\u{2C381}; + #\u{2C382}; + #\u{2C383}; + #\u{2C384}; + #\u{2C385}; + #\u{2C386}; + #\u{2C387}; + #\u{2C388}; + #\u{2C389}; + #\u{2C38A}; + #\u{2C38B}; + #\u{2C38C}; + #\u{2C38D}; + #\u{2C38E}; + #\u{2C38F}; + #\u{2C390}; + #\u{2C391}; + #\u{2C392}; + #\u{2C393}; + #\u{2C394}; + #\u{2C395}; + #\u{2C396}; + #\u{2C397}; + #\u{2C398}; + #\u{2C399}; + #\u{2C39A}; + #\u{2C39B}; + #\u{2C39C}; + #\u{2C39D}; + #\u{2C39E}; + #\u{2C39F}; + #\u{2C3A0}; + #\u{2C3A1}; + #\u{2C3A2}; + #\u{2C3A3}; + #\u{2C3A4}; + #\u{2C3A5}; + #\u{2C3A6}; + #\u{2C3A7}; + #\u{2C3A8}; + #\u{2C3A9}; + #\u{2C3AA}; + #\u{2C3AB}; + #\u{2C3AC}; + #\u{2C3AD}; + #\u{2C3AE}; + #\u{2C3AF}; + #\u{2C3B0}; + #\u{2C3B1}; + #\u{2C3B2}; + #\u{2C3B3}; + #\u{2C3B4}; + #\u{2C3B5}; + #\u{2C3B6}; + #\u{2C3B7}; + #\u{2C3B8}; + #\u{2C3B9}; + #\u{2C3BA}; + #\u{2C3BB}; + #\u{2C3BC}; + #\u{2C3BD}; + #\u{2C3BE}; + #\u{2C3BF}; + #\u{2C3C0}; + #\u{2C3C1}; + #\u{2C3C2}; + #\u{2C3C3}; + #\u{2C3C4}; + #\u{2C3C5}; + #\u{2C3C6}; + #\u{2C3C7}; + #\u{2C3C8}; + #\u{2C3C9}; + #\u{2C3CA}; + #\u{2C3CB}; + #\u{2C3CC}; + #\u{2C3CD}; + #\u{2C3CE}; + #\u{2C3CF}; + #\u{2C3D0}; + #\u{2C3D1}; + #\u{2C3D2}; + #\u{2C3D3}; + #\u{2C3D4}; + #\u{2C3D5}; + #\u{2C3D6}; + #\u{2C3D7}; + #\u{2C3D8}; + #\u{2C3D9}; + #\u{2C3DA}; + #\u{2C3DB}; + #\u{2C3DC}; + #\u{2C3DD}; + #\u{2C3DE}; + #\u{2C3DF}; + #\u{2C3E0}; + #\u{2C3E1}; + #\u{2C3E2}; + #\u{2C3E3}; + #\u{2C3E4}; + #\u{2C3E5}; + #\u{2C3E6}; + #\u{2C3E7}; + #\u{2C3E8}; + #\u{2C3E9}; + #\u{2C3EA}; + #\u{2C3EB}; + #\u{2C3EC}; + #\u{2C3ED}; + #\u{2C3EE}; + #\u{2C3EF}; + #\u{2C3F0}; + #\u{2C3F1}; + #\u{2C3F2}; + #\u{2C3F3}; + #\u{2C3F4}; + #\u{2C3F5}; + #\u{2C3F6}; + #\u{2C3F7}; + #\u{2C3F8}; + #\u{2C3F9}; + #\u{2C3FA}; + #\u{2C3FB}; + #\u{2C3FC}; + #\u{2C3FD}; + #\u{2C3FE}; + #\u{2C3FF}; + #\u{2C400}; + #\u{2C401}; + #\u{2C402}; + #\u{2C403}; + #\u{2C404}; + #\u{2C405}; + #\u{2C406}; + #\u{2C407}; + #\u{2C408}; + #\u{2C409}; + #\u{2C40A}; + #\u{2C40B}; + #\u{2C40C}; + #\u{2C40D}; + #\u{2C40E}; + #\u{2C40F}; + #\u{2C410}; + #\u{2C411}; + #\u{2C412}; + #\u{2C413}; + #\u{2C414}; + #\u{2C415}; + #\u{2C416}; + #\u{2C417}; + #\u{2C418}; + #\u{2C419}; + #\u{2C41A}; + #\u{2C41B}; + #\u{2C41C}; + #\u{2C41D}; + #\u{2C41E}; + #\u{2C41F}; + #\u{2C420}; + #\u{2C421}; + #\u{2C422}; + #\u{2C423}; + #\u{2C424}; + #\u{2C425}; + #\u{2C426}; + #\u{2C427}; + #\u{2C428}; + #\u{2C429}; + #\u{2C42A}; + #\u{2C42B}; + #\u{2C42C}; + #\u{2C42D}; + #\u{2C42E}; + #\u{2C42F}; + #\u{2C430}; + #\u{2C431}; + #\u{2C432}; + #\u{2C433}; + #\u{2C434}; + #\u{2C435}; + #\u{2C436}; + #\u{2C437}; + #\u{2C438}; + #\u{2C439}; + #\u{2C43A}; + #\u{2C43B}; + #\u{2C43C}; + #\u{2C43D}; + #\u{2C43E}; + #\u{2C43F}; + #\u{2C440}; + #\u{2C441}; + #\u{2C442}; + #\u{2C443}; + #\u{2C444}; + #\u{2C445}; + #\u{2C446}; + #\u{2C447}; + #\u{2C448}; + #\u{2C449}; + #\u{2C44A}; + #\u{2C44B}; + #\u{2C44C}; + #\u{2C44D}; + #\u{2C44E}; + #\u{2C44F}; + #\u{2C450}; + #\u{2C451}; + #\u{2C452}; + #\u{2C453}; + #\u{2C454}; + #\u{2C455}; + #\u{2C456}; + #\u{2C457}; + #\u{2C458}; + #\u{2C459}; + #\u{2C45A}; + #\u{2C45B}; + #\u{2C45C}; + #\u{2C45D}; + #\u{2C45E}; + #\u{2C45F}; + #\u{2C460}; + #\u{2C461}; + #\u{2C462}; + #\u{2C463}; + #\u{2C464}; + #\u{2C465}; + #\u{2C466}; + #\u{2C467}; + #\u{2C468}; + #\u{2C469}; + #\u{2C46A}; + #\u{2C46B}; + #\u{2C46C}; + #\u{2C46D}; + #\u{2C46E}; + #\u{2C46F}; + #\u{2C470}; + #\u{2C471}; + #\u{2C472}; + #\u{2C473}; + #\u{2C474}; + #\u{2C475}; + #\u{2C476}; + #\u{2C477}; + #\u{2C478}; + #\u{2C479}; + #\u{2C47A}; + #\u{2C47B}; + #\u{2C47C}; + #\u{2C47D}; + #\u{2C47E}; + #\u{2C47F}; + #\u{2C480}; + #\u{2C481}; + #\u{2C482}; + #\u{2C483}; + #\u{2C484}; + #\u{2C485}; + #\u{2C486}; + #\u{2C487}; + #\u{2C488}; + #\u{2C489}; + #\u{2C48A}; + #\u{2C48B}; + #\u{2C48C}; + #\u{2C48D}; + #\u{2C48E}; + #\u{2C48F}; + #\u{2C490}; + #\u{2C491}; + #\u{2C492}; + #\u{2C493}; + #\u{2C494}; + #\u{2C495}; + #\u{2C496}; + #\u{2C497}; + #\u{2C498}; + #\u{2C499}; + #\u{2C49A}; + #\u{2C49B}; + #\u{2C49C}; + #\u{2C49D}; + #\u{2C49E}; + #\u{2C49F}; + #\u{2C4A0}; + #\u{2C4A1}; + #\u{2C4A2}; + #\u{2C4A3}; + #\u{2C4A4}; + #\u{2C4A5}; + #\u{2C4A6}; + #\u{2C4A7}; + #\u{2C4A8}; + #\u{2C4A9}; + #\u{2C4AA}; + #\u{2C4AB}; + #\u{2C4AC}; + #\u{2C4AD}; + #\u{2C4AE}; + #\u{2C4AF}; + #\u{2C4B0}; + #\u{2C4B1}; + #\u{2C4B2}; + #\u{2C4B3}; + #\u{2C4B4}; + #\u{2C4B5}; + #\u{2C4B6}; + #\u{2C4B7}; + #\u{2C4B8}; + #\u{2C4B9}; + #\u{2C4BA}; + #\u{2C4BB}; + #\u{2C4BC}; + #\u{2C4BD}; + #\u{2C4BE}; + #\u{2C4BF}; + #\u{2C4C0}; + #\u{2C4C1}; + #\u{2C4C2}; + #\u{2C4C3}; + #\u{2C4C4}; + #\u{2C4C5}; + #\u{2C4C6}; + #\u{2C4C7}; + #\u{2C4C8}; + #\u{2C4C9}; + #\u{2C4CA}; + #\u{2C4CB}; + #\u{2C4CC}; + #\u{2C4CD}; + #\u{2C4CE}; + #\u{2C4CF}; + #\u{2C4D0}; + #\u{2C4D1}; + #\u{2C4D2}; + #\u{2C4D3}; + #\u{2C4D4}; + #\u{2C4D5}; + #\u{2C4D6}; + #\u{2C4D7}; + #\u{2C4D8}; + #\u{2C4D9}; + #\u{2C4DA}; + #\u{2C4DB}; + #\u{2C4DC}; + #\u{2C4DD}; + #\u{2C4DE}; + #\u{2C4DF}; + #\u{2C4E0}; + #\u{2C4E1}; + #\u{2C4E2}; + #\u{2C4E3}; + #\u{2C4E4}; + #\u{2C4E5}; + #\u{2C4E6}; + #\u{2C4E7}; + #\u{2C4E8}; + #\u{2C4E9}; + #\u{2C4EA}; + #\u{2C4EB}; + #\u{2C4EC}; + #\u{2C4ED}; + #\u{2C4EE}; + #\u{2C4EF}; + #\u{2C4F0}; + #\u{2C4F1}; + #\u{2C4F2}; + #\u{2C4F3}; + #\u{2C4F4}; + #\u{2C4F5}; + #\u{2C4F6}; + #\u{2C4F7}; + #\u{2C4F8}; + #\u{2C4F9}; + #\u{2C4FA}; + #\u{2C4FB}; + #\u{2C4FC}; + #\u{2C4FD}; + #\u{2C4FE}; + #\u{2C4FF}; + #\u{2C500}; + #\u{2C501}; + #\u{2C502}; + #\u{2C503}; + #\u{2C504}; + #\u{2C505}; + #\u{2C506}; + #\u{2C507}; + #\u{2C508}; + #\u{2C509}; + #\u{2C50A}; + #\u{2C50B}; + #\u{2C50C}; + #\u{2C50D}; + #\u{2C50E}; + #\u{2C50F}; + #\u{2C510}; + #\u{2C511}; + #\u{2C512}; + #\u{2C513}; + #\u{2C514}; + #\u{2C515}; + #\u{2C516}; + #\u{2C517}; + #\u{2C518}; + #\u{2C519}; + #\u{2C51A}; + #\u{2C51B}; + #\u{2C51C}; + #\u{2C51D}; + #\u{2C51E}; + #\u{2C51F}; + #\u{2C520}; + #\u{2C521}; + #\u{2C522}; + #\u{2C523}; + #\u{2C524}; + #\u{2C525}; + #\u{2C526}; + #\u{2C527}; + #\u{2C528}; + #\u{2C529}; + #\u{2C52A}; + #\u{2C52B}; + #\u{2C52C}; + #\u{2C52D}; + #\u{2C52E}; + #\u{2C52F}; + #\u{2C530}; + #\u{2C531}; + #\u{2C532}; + #\u{2C533}; + #\u{2C534}; + #\u{2C535}; + #\u{2C536}; + #\u{2C537}; + #\u{2C538}; + #\u{2C539}; + #\u{2C53A}; + #\u{2C53B}; + #\u{2C53C}; + #\u{2C53D}; + #\u{2C53E}; + #\u{2C53F}; + #\u{2C540}; + #\u{2C541}; + #\u{2C542}; + #\u{2C543}; + #\u{2C544}; + #\u{2C545}; + #\u{2C546}; + #\u{2C547}; + #\u{2C548}; + #\u{2C549}; + #\u{2C54A}; + #\u{2C54B}; + #\u{2C54C}; + #\u{2C54D}; + #\u{2C54E}; + #\u{2C54F}; + #\u{2C550}; + #\u{2C551}; + #\u{2C552}; + #\u{2C553}; + #\u{2C554}; + #\u{2C555}; + #\u{2C556}; + #\u{2C557}; + #\u{2C558}; + #\u{2C559}; + #\u{2C55A}; + #\u{2C55B}; + #\u{2C55C}; + #\u{2C55D}; + #\u{2C55E}; + #\u{2C55F}; + #\u{2C560}; + #\u{2C561}; + #\u{2C562}; + #\u{2C563}; + #\u{2C564}; + #\u{2C565}; + #\u{2C566}; + #\u{2C567}; + #\u{2C568}; + #\u{2C569}; + #\u{2C56A}; + #\u{2C56B}; + #\u{2C56C}; + #\u{2C56D}; + #\u{2C56E}; + #\u{2C56F}; + #\u{2C570}; + #\u{2C571}; + #\u{2C572}; + #\u{2C573}; + #\u{2C574}; + #\u{2C575}; + #\u{2C576}; + #\u{2C577}; + #\u{2C578}; + #\u{2C579}; + #\u{2C57A}; + #\u{2C57B}; + #\u{2C57C}; + #\u{2C57D}; + #\u{2C57E}; + #\u{2C57F}; + #\u{2C580}; + #\u{2C581}; + #\u{2C582}; + #\u{2C583}; + #\u{2C584}; + #\u{2C585}; + #\u{2C586}; + #\u{2C587}; + #\u{2C588}; + #\u{2C589}; + #\u{2C58A}; + #\u{2C58B}; + #\u{2C58C}; + #\u{2C58D}; + #\u{2C58E}; + #\u{2C58F}; + #\u{2C590}; + #\u{2C591}; + #\u{2C592}; + #\u{2C593}; + #\u{2C594}; + #\u{2C595}; + #\u{2C596}; + #\u{2C597}; + #\u{2C598}; + #\u{2C599}; + #\u{2C59A}; + #\u{2C59B}; + #\u{2C59C}; + #\u{2C59D}; + #\u{2C59E}; + #\u{2C59F}; + #\u{2C5A0}; + #\u{2C5A1}; + #\u{2C5A2}; + #\u{2C5A3}; + #\u{2C5A4}; + #\u{2C5A5}; + #\u{2C5A6}; + #\u{2C5A7}; + #\u{2C5A8}; + #\u{2C5A9}; + #\u{2C5AA}; + #\u{2C5AB}; + #\u{2C5AC}; + #\u{2C5AD}; + #\u{2C5AE}; + #\u{2C5AF}; + #\u{2C5B0}; + #\u{2C5B1}; + #\u{2C5B2}; + #\u{2C5B3}; + #\u{2C5B4}; + #\u{2C5B5}; + #\u{2C5B6}; + #\u{2C5B7}; + #\u{2C5B8}; + #\u{2C5B9}; + #\u{2C5BA}; + #\u{2C5BB}; + #\u{2C5BC}; + #\u{2C5BD}; + #\u{2C5BE}; + #\u{2C5BF}; + #\u{2C5C0}; + #\u{2C5C1}; + #\u{2C5C2}; + #\u{2C5C3}; + #\u{2C5C4}; + #\u{2C5C5}; + #\u{2C5C6}; + #\u{2C5C7}; + #\u{2C5C8}; + #\u{2C5C9}; + #\u{2C5CA}; + #\u{2C5CB}; + #\u{2C5CC}; + #\u{2C5CD}; + #\u{2C5CE}; + #\u{2C5CF}; + #\u{2C5D0}; + #\u{2C5D1}; + #\u{2C5D2}; + #\u{2C5D3}; + #\u{2C5D4}; + #\u{2C5D5}; + #\u{2C5D6}; + #\u{2C5D7}; + #\u{2C5D8}; + #\u{2C5D9}; + #\u{2C5DA}; + #\u{2C5DB}; + #\u{2C5DC}; + #\u{2C5DD}; + #\u{2C5DE}; + #\u{2C5DF}; + #\u{2C5E0}; + #\u{2C5E1}; + #\u{2C5E2}; + #\u{2C5E3}; + #\u{2C5E4}; + #\u{2C5E5}; + #\u{2C5E6}; + #\u{2C5E7}; + #\u{2C5E8}; + #\u{2C5E9}; + #\u{2C5EA}; + #\u{2C5EB}; + #\u{2C5EC}; + #\u{2C5ED}; + #\u{2C5EE}; + #\u{2C5EF}; + #\u{2C5F0}; + #\u{2C5F1}; + #\u{2C5F2}; + #\u{2C5F3}; + #\u{2C5F4}; + #\u{2C5F5}; + #\u{2C5F6}; + #\u{2C5F7}; + #\u{2C5F8}; + #\u{2C5F9}; + #\u{2C5FA}; + #\u{2C5FB}; + #\u{2C5FC}; + #\u{2C5FD}; + #\u{2C5FE}; + #\u{2C5FF}; + #\u{2C600}; + #\u{2C601}; + #\u{2C602}; + #\u{2C603}; + #\u{2C604}; + #\u{2C605}; + #\u{2C606}; + #\u{2C607}; + #\u{2C608}; + #\u{2C609}; + #\u{2C60A}; + #\u{2C60B}; + #\u{2C60C}; + #\u{2C60D}; + #\u{2C60E}; + #\u{2C60F}; + #\u{2C610}; + #\u{2C611}; + #\u{2C612}; + #\u{2C613}; + #\u{2C614}; + #\u{2C615}; + #\u{2C616}; + #\u{2C617}; + #\u{2C618}; + #\u{2C619}; + #\u{2C61A}; + #\u{2C61B}; + #\u{2C61C}; + #\u{2C61D}; + #\u{2C61E}; + #\u{2C61F}; + #\u{2C620}; + #\u{2C621}; + #\u{2C622}; + #\u{2C623}; + #\u{2C624}; + #\u{2C625}; + #\u{2C626}; + #\u{2C627}; + #\u{2C628}; + #\u{2C629}; + #\u{2C62A}; + #\u{2C62B}; + #\u{2C62C}; + #\u{2C62D}; + #\u{2C62E}; + #\u{2C62F}; + #\u{2C630}; + #\u{2C631}; + #\u{2C632}; + #\u{2C633}; + #\u{2C634}; + #\u{2C635}; + #\u{2C636}; + #\u{2C637}; + #\u{2C638}; + #\u{2C639}; + #\u{2C63A}; + #\u{2C63B}; + #\u{2C63C}; + #\u{2C63D}; + #\u{2C63E}; + #\u{2C63F}; + #\u{2C640}; + #\u{2C641}; + #\u{2C642}; + #\u{2C643}; + #\u{2C644}; + #\u{2C645}; + #\u{2C646}; + #\u{2C647}; + #\u{2C648}; + #\u{2C649}; + #\u{2C64A}; + #\u{2C64B}; + #\u{2C64C}; + #\u{2C64D}; + #\u{2C64E}; + #\u{2C64F}; + #\u{2C650}; + #\u{2C651}; + #\u{2C652}; + #\u{2C653}; + #\u{2C654}; + #\u{2C655}; + #\u{2C656}; + #\u{2C657}; + #\u{2C658}; + #\u{2C659}; + #\u{2C65A}; + #\u{2C65B}; + #\u{2C65C}; + #\u{2C65D}; + #\u{2C65E}; + #\u{2C65F}; + #\u{2C660}; + #\u{2C661}; + #\u{2C662}; + #\u{2C663}; + #\u{2C664}; + #\u{2C665}; + #\u{2C666}; + #\u{2C667}; + #\u{2C668}; + #\u{2C669}; + #\u{2C66A}; + #\u{2C66B}; + #\u{2C66C}; + #\u{2C66D}; + #\u{2C66E}; + #\u{2C66F}; + #\u{2C670}; + #\u{2C671}; + #\u{2C672}; + #\u{2C673}; + #\u{2C674}; + #\u{2C675}; + #\u{2C676}; + #\u{2C677}; + #\u{2C678}; + #\u{2C679}; + #\u{2C67A}; + #\u{2C67B}; + #\u{2C67C}; + #\u{2C67D}; + #\u{2C67E}; + #\u{2C67F}; + #\u{2C680}; + #\u{2C681}; + #\u{2C682}; + #\u{2C683}; + #\u{2C684}; + #\u{2C685}; + #\u{2C686}; + #\u{2C687}; + #\u{2C688}; + #\u{2C689}; + #\u{2C68A}; + #\u{2C68B}; + #\u{2C68C}; + #\u{2C68D}; + #\u{2C68E}; + #\u{2C68F}; + #\u{2C690}; + #\u{2C691}; + #\u{2C692}; + #\u{2C693}; + #\u{2C694}; + #\u{2C695}; + #\u{2C696}; + #\u{2C697}; + #\u{2C698}; + #\u{2C699}; + #\u{2C69A}; + #\u{2C69B}; + #\u{2C69C}; + #\u{2C69D}; + #\u{2C69E}; + #\u{2C69F}; + #\u{2C6A0}; + #\u{2C6A1}; + #\u{2C6A2}; + #\u{2C6A3}; + #\u{2C6A4}; + #\u{2C6A5}; + #\u{2C6A6}; + #\u{2C6A7}; + #\u{2C6A8}; + #\u{2C6A9}; + #\u{2C6AA}; + #\u{2C6AB}; + #\u{2C6AC}; + #\u{2C6AD}; + #\u{2C6AE}; + #\u{2C6AF}; + #\u{2C6B0}; + #\u{2C6B1}; + #\u{2C6B2}; + #\u{2C6B3}; + #\u{2C6B4}; + #\u{2C6B5}; + #\u{2C6B6}; + #\u{2C6B7}; + #\u{2C6B8}; + #\u{2C6B9}; + #\u{2C6BA}; + #\u{2C6BB}; + #\u{2C6BC}; + #\u{2C6BD}; + #\u{2C6BE}; + #\u{2C6BF}; + #\u{2C6C0}; + #\u{2C6C1}; + #\u{2C6C2}; + #\u{2C6C3}; + #\u{2C6C4}; + #\u{2C6C5}; + #\u{2C6C6}; + #\u{2C6C7}; + #\u{2C6C8}; + #\u{2C6C9}; + #\u{2C6CA}; + #\u{2C6CB}; + #\u{2C6CC}; + #\u{2C6CD}; + #\u{2C6CE}; + #\u{2C6CF}; + #\u{2C6D0}; + #\u{2C6D1}; + #\u{2C6D2}; + #\u{2C6D3}; + #\u{2C6D4}; + #\u{2C6D5}; + #\u{2C6D6}; + #\u{2C6D7}; + #\u{2C6D8}; + #\u{2C6D9}; + #\u{2C6DA}; + #\u{2C6DB}; + #\u{2C6DC}; + #\u{2C6DD}; + #\u{2C6DE}; + #\u{2C6DF}; + #\u{2C6E0}; + #\u{2C6E1}; + #\u{2C6E2}; + #\u{2C6E3}; + #\u{2C6E4}; + #\u{2C6E5}; + #\u{2C6E6}; + #\u{2C6E7}; + #\u{2C6E8}; + #\u{2C6E9}; + #\u{2C6EA}; + #\u{2C6EB}; + #\u{2C6EC}; + #\u{2C6ED}; + #\u{2C6EE}; + #\u{2C6EF}; + #\u{2C6F0}; + #\u{2C6F1}; + #\u{2C6F2}; + #\u{2C6F3}; + #\u{2C6F4}; + #\u{2C6F5}; + #\u{2C6F6}; + #\u{2C6F7}; + #\u{2C6F8}; + #\u{2C6F9}; + #\u{2C6FA}; + #\u{2C6FB}; + #\u{2C6FC}; + #\u{2C6FD}; + #\u{2C6FE}; + #\u{2C6FF}; + #\u{2C700}; + #\u{2C701}; + #\u{2C702}; + #\u{2C703}; + #\u{2C704}; + #\u{2C705}; + #\u{2C706}; + #\u{2C707}; + #\u{2C708}; + #\u{2C709}; + #\u{2C70A}; + #\u{2C70B}; + #\u{2C70C}; + #\u{2C70D}; + #\u{2C70E}; + #\u{2C70F}; + #\u{2C710}; + #\u{2C711}; + #\u{2C712}; + #\u{2C713}; + #\u{2C714}; + #\u{2C715}; + #\u{2C716}; + #\u{2C717}; + #\u{2C718}; + #\u{2C719}; + #\u{2C71A}; + #\u{2C71B}; + #\u{2C71C}; + #\u{2C71D}; + #\u{2C71E}; + #\u{2C71F}; + #\u{2C720}; + #\u{2C721}; + #\u{2C722}; + #\u{2C723}; + #\u{2C724}; + #\u{2C725}; + #\u{2C726}; + #\u{2C727}; + #\u{2C728}; + #\u{2C729}; + #\u{2C72A}; + #\u{2C72B}; + #\u{2C72C}; + #\u{2C72D}; + #\u{2C72E}; + #\u{2C72F}; + #\u{2C730}; + #\u{2C731}; + #\u{2C732}; + #\u{2C733}; + #\u{2C734}; + #\u{2C735}; + #\u{2C736}; + #\u{2C737}; + #\u{2C738}; + #\u{2C739}; + #\u{2C73A}; + #\u{2C73B}; + #\u{2C73C}; + #\u{2C73D}; + #\u{2C73E}; + #\u{2C73F}; + #\u{2C740}; + #\u{2C741}; + #\u{2C742}; + #\u{2C743}; + #\u{2C744}; + #\u{2C745}; + #\u{2C746}; + #\u{2C747}; + #\u{2C748}; + #\u{2C749}; + #\u{2C74A}; + #\u{2C74B}; + #\u{2C74C}; + #\u{2C74D}; + #\u{2C74E}; + #\u{2C74F}; + #\u{2C750}; + #\u{2C751}; + #\u{2C752}; + #\u{2C753}; + #\u{2C754}; + #\u{2C755}; + #\u{2C756}; + #\u{2C757}; + #\u{2C758}; + #\u{2C759}; + #\u{2C75A}; + #\u{2C75B}; + #\u{2C75C}; + #\u{2C75D}; + #\u{2C75E}; + #\u{2C75F}; + #\u{2C760}; + #\u{2C761}; + #\u{2C762}; + #\u{2C763}; + #\u{2C764}; + #\u{2C765}; + #\u{2C766}; + #\u{2C767}; + #\u{2C768}; + #\u{2C769}; + #\u{2C76A}; + #\u{2C76B}; + #\u{2C76C}; + #\u{2C76D}; + #\u{2C76E}; + #\u{2C76F}; + #\u{2C770}; + #\u{2C771}; + #\u{2C772}; + #\u{2C773}; + #\u{2C774}; + #\u{2C775}; + #\u{2C776}; + #\u{2C777}; + #\u{2C778}; + #\u{2C779}; + #\u{2C77A}; + #\u{2C77B}; + #\u{2C77C}; + #\u{2C77D}; + #\u{2C77E}; + #\u{2C77F}; + #\u{2C780}; + #\u{2C781}; + #\u{2C782}; + #\u{2C783}; + #\u{2C784}; + #\u{2C785}; + #\u{2C786}; + #\u{2C787}; + #\u{2C788}; + #\u{2C789}; + #\u{2C78A}; + #\u{2C78B}; + #\u{2C78C}; + #\u{2C78D}; + #\u{2C78E}; + #\u{2C78F}; + #\u{2C790}; + #\u{2C791}; + #\u{2C792}; + #\u{2C793}; + #\u{2C794}; + #\u{2C795}; + #\u{2C796}; + #\u{2C797}; + #\u{2C798}; + #\u{2C799}; + #\u{2C79A}; + #\u{2C79B}; + #\u{2C79C}; + #\u{2C79D}; + #\u{2C79E}; + #\u{2C79F}; + #\u{2C7A0}; + #\u{2C7A1}; + #\u{2C7A2}; + #\u{2C7A3}; + #\u{2C7A4}; + #\u{2C7A5}; + #\u{2C7A6}; + #\u{2C7A7}; + #\u{2C7A8}; + #\u{2C7A9}; + #\u{2C7AA}; + #\u{2C7AB}; + #\u{2C7AC}; + #\u{2C7AD}; + #\u{2C7AE}; + #\u{2C7AF}; + #\u{2C7B0}; + #\u{2C7B1}; + #\u{2C7B2}; + #\u{2C7B3}; + #\u{2C7B4}; + #\u{2C7B5}; + #\u{2C7B6}; + #\u{2C7B7}; + #\u{2C7B8}; + #\u{2C7B9}; + #\u{2C7BA}; + #\u{2C7BB}; + #\u{2C7BC}; + #\u{2C7BD}; + #\u{2C7BE}; + #\u{2C7BF}; + #\u{2C7C0}; + #\u{2C7C1}; + #\u{2C7C2}; + #\u{2C7C3}; + #\u{2C7C4}; + #\u{2C7C5}; + #\u{2C7C6}; + #\u{2C7C7}; + #\u{2C7C8}; + #\u{2C7C9}; + #\u{2C7CA}; + #\u{2C7CB}; + #\u{2C7CC}; + #\u{2C7CD}; + #\u{2C7CE}; + #\u{2C7CF}; + #\u{2C7D0}; + #\u{2C7D1}; + #\u{2C7D2}; + #\u{2C7D3}; + #\u{2C7D4}; + #\u{2C7D5}; + #\u{2C7D6}; + #\u{2C7D7}; + #\u{2C7D8}; + #\u{2C7D9}; + #\u{2C7DA}; + #\u{2C7DB}; + #\u{2C7DC}; + #\u{2C7DD}; + #\u{2C7DE}; + #\u{2C7DF}; + #\u{2C7E0}; + #\u{2C7E1}; + #\u{2C7E2}; + #\u{2C7E3}; + #\u{2C7E4}; + #\u{2C7E5}; + #\u{2C7E6}; + #\u{2C7E7}; + #\u{2C7E8}; + #\u{2C7E9}; + #\u{2C7EA}; + #\u{2C7EB}; + #\u{2C7EC}; + #\u{2C7ED}; + #\u{2C7EE}; + #\u{2C7EF}; + #\u{2C7F0}; + #\u{2C7F1}; + #\u{2C7F2}; + #\u{2C7F3}; + #\u{2C7F4}; + #\u{2C7F5}; + #\u{2C7F6}; + #\u{2C7F7}; + #\u{2C7F8}; + #\u{2C7F9}; + #\u{2C7FA}; + #\u{2C7FB}; + #\u{2C7FC}; + #\u{2C7FD}; + #\u{2C7FE}; + #\u{2C7FF}; + #\u{2C800}; + #\u{2C801}; + #\u{2C802}; + #\u{2C803}; + #\u{2C804}; + #\u{2C805}; + #\u{2C806}; + #\u{2C807}; + #\u{2C808}; + #\u{2C809}; + #\u{2C80A}; + #\u{2C80B}; + #\u{2C80C}; + #\u{2C80D}; + #\u{2C80E}; + #\u{2C80F}; + #\u{2C810}; + #\u{2C811}; + #\u{2C812}; + #\u{2C813}; + #\u{2C814}; + #\u{2C815}; + #\u{2C816}; + #\u{2C817}; + #\u{2C818}; + #\u{2C819}; + #\u{2C81A}; + #\u{2C81B}; + #\u{2C81C}; + #\u{2C81D}; + #\u{2C81E}; + #\u{2C81F}; + #\u{2C820}; + #\u{2C821}; + #\u{2C822}; + #\u{2C823}; + #\u{2C824}; + #\u{2C825}; + #\u{2C826}; + #\u{2C827}; + #\u{2C828}; + #\u{2C829}; + #\u{2C82A}; + #\u{2C82B}; + #\u{2C82C}; + #\u{2C82D}; + #\u{2C82E}; + #\u{2C82F}; + #\u{2C830}; + #\u{2C831}; + #\u{2C832}; + #\u{2C833}; + #\u{2C834}; + #\u{2C835}; + #\u{2C836}; + #\u{2C837}; + #\u{2C838}; + #\u{2C839}; + #\u{2C83A}; + #\u{2C83B}; + #\u{2C83C}; + #\u{2C83D}; + #\u{2C83E}; + #\u{2C83F}; + #\u{2C840}; + #\u{2C841}; + #\u{2C842}; + #\u{2C843}; + #\u{2C844}; + #\u{2C845}; + #\u{2C846}; + #\u{2C847}; + #\u{2C848}; + #\u{2C849}; + #\u{2C84A}; + #\u{2C84B}; + #\u{2C84C}; + #\u{2C84D}; + #\u{2C84E}; + #\u{2C84F}; + #\u{2C850}; + #\u{2C851}; + #\u{2C852}; + #\u{2C853}; + #\u{2C854}; + #\u{2C855}; + #\u{2C856}; + #\u{2C857}; + #\u{2C858}; + #\u{2C859}; + #\u{2C85A}; + #\u{2C85B}; + #\u{2C85C}; + #\u{2C85D}; + #\u{2C85E}; + #\u{2C85F}; + #\u{2C860}; + #\u{2C861}; + #\u{2C862}; + #\u{2C863}; + #\u{2C864}; + #\u{2C865}; + #\u{2C866}; + #\u{2C867}; + #\u{2C868}; + #\u{2C869}; + #\u{2C86A}; + #\u{2C86B}; + #\u{2C86C}; + #\u{2C86D}; + #\u{2C86E}; + #\u{2C86F}; + #\u{2C870}; + #\u{2C871}; + #\u{2C872}; + #\u{2C873}; + #\u{2C874}; + #\u{2C875}; + #\u{2C876}; + #\u{2C877}; + #\u{2C878}; + #\u{2C879}; + #\u{2C87A}; + #\u{2C87B}; + #\u{2C87C}; + #\u{2C87D}; + #\u{2C87E}; + #\u{2C87F}; + #\u{2C880}; + #\u{2C881}; + #\u{2C882}; + #\u{2C883}; + #\u{2C884}; + #\u{2C885}; + #\u{2C886}; + #\u{2C887}; + #\u{2C888}; + #\u{2C889}; + #\u{2C88A}; + #\u{2C88B}; + #\u{2C88C}; + #\u{2C88D}; + #\u{2C88E}; + #\u{2C88F}; + #\u{2C890}; + #\u{2C891}; + #\u{2C892}; + #\u{2C893}; + #\u{2C894}; + #\u{2C895}; + #\u{2C896}; + #\u{2C897}; + #\u{2C898}; + #\u{2C899}; + #\u{2C89A}; + #\u{2C89B}; + #\u{2C89C}; + #\u{2C89D}; + #\u{2C89E}; + #\u{2C89F}; + #\u{2C8A0}; + #\u{2C8A1}; + #\u{2C8A2}; + #\u{2C8A3}; + #\u{2C8A4}; + #\u{2C8A5}; + #\u{2C8A6}; + #\u{2C8A7}; + #\u{2C8A8}; + #\u{2C8A9}; + #\u{2C8AA}; + #\u{2C8AB}; + #\u{2C8AC}; + #\u{2C8AD}; + #\u{2C8AE}; + #\u{2C8AF}; + #\u{2C8B0}; + #\u{2C8B1}; + #\u{2C8B2}; + #\u{2C8B3}; + #\u{2C8B4}; + #\u{2C8B5}; + #\u{2C8B6}; + #\u{2C8B7}; + #\u{2C8B8}; + #\u{2C8B9}; + #\u{2C8BA}; + #\u{2C8BB}; + #\u{2C8BC}; + #\u{2C8BD}; + #\u{2C8BE}; + #\u{2C8BF}; + #\u{2C8C0}; + #\u{2C8C1}; + #\u{2C8C2}; + #\u{2C8C3}; + #\u{2C8C4}; + #\u{2C8C5}; + #\u{2C8C6}; + #\u{2C8C7}; + #\u{2C8C8}; + #\u{2C8C9}; + #\u{2C8CA}; + #\u{2C8CB}; + #\u{2C8CC}; + #\u{2C8CD}; + #\u{2C8CE}; + #\u{2C8CF}; + #\u{2C8D0}; + #\u{2C8D1}; + #\u{2C8D2}; + #\u{2C8D3}; + #\u{2C8D4}; + #\u{2C8D5}; + #\u{2C8D6}; + #\u{2C8D7}; + #\u{2C8D8}; + #\u{2C8D9}; + #\u{2C8DA}; + #\u{2C8DB}; + #\u{2C8DC}; + #\u{2C8DD}; + #\u{2C8DE}; + #\u{2C8DF}; + #\u{2C8E0}; + #\u{2C8E1}; + #\u{2C8E2}; + #\u{2C8E3}; + #\u{2C8E4}; + #\u{2C8E5}; + #\u{2C8E6}; + #\u{2C8E7}; + #\u{2C8E8}; + #\u{2C8E9}; + #\u{2C8EA}; + #\u{2C8EB}; + #\u{2C8EC}; + #\u{2C8ED}; + #\u{2C8EE}; + #\u{2C8EF}; + #\u{2C8F0}; + #\u{2C8F1}; + #\u{2C8F2}; + #\u{2C8F3}; + #\u{2C8F4}; + #\u{2C8F5}; + #\u{2C8F6}; + #\u{2C8F7}; + #\u{2C8F8}; + #\u{2C8F9}; + #\u{2C8FA}; + #\u{2C8FB}; + #\u{2C8FC}; + #\u{2C8FD}; + #\u{2C8FE}; + #\u{2C8FF}; + #\u{2C900}; + #\u{2C901}; + #\u{2C902}; + #\u{2C903}; + #\u{2C904}; + #\u{2C905}; + #\u{2C906}; + #\u{2C907}; + #\u{2C908}; + #\u{2C909}; + #\u{2C90A}; + #\u{2C90B}; + #\u{2C90C}; + #\u{2C90D}; + #\u{2C90E}; + #\u{2C90F}; + #\u{2C910}; + #\u{2C911}; + #\u{2C912}; + #\u{2C913}; + #\u{2C914}; + #\u{2C915}; + #\u{2C916}; + #\u{2C917}; + #\u{2C918}; + #\u{2C919}; + #\u{2C91A}; + #\u{2C91B}; + #\u{2C91C}; + #\u{2C91D}; + #\u{2C91E}; + #\u{2C91F}; + #\u{2C920}; + #\u{2C921}; + #\u{2C922}; + #\u{2C923}; + #\u{2C924}; + #\u{2C925}; + #\u{2C926}; + #\u{2C927}; + #\u{2C928}; + #\u{2C929}; + #\u{2C92A}; + #\u{2C92B}; + #\u{2C92C}; + #\u{2C92D}; + #\u{2C92E}; + #\u{2C92F}; + #\u{2C930}; + #\u{2C931}; + #\u{2C932}; + #\u{2C933}; + #\u{2C934}; + #\u{2C935}; + #\u{2C936}; + #\u{2C937}; + #\u{2C938}; + #\u{2C939}; + #\u{2C93A}; + #\u{2C93B}; + #\u{2C93C}; + #\u{2C93D}; + #\u{2C93E}; + #\u{2C93F}; + #\u{2C940}; + #\u{2C941}; + #\u{2C942}; + #\u{2C943}; + #\u{2C944}; + #\u{2C945}; + #\u{2C946}; + #\u{2C947}; + #\u{2C948}; + #\u{2C949}; + #\u{2C94A}; + #\u{2C94B}; + #\u{2C94C}; + #\u{2C94D}; + #\u{2C94E}; + #\u{2C94F}; + #\u{2C950}; + #\u{2C951}; + #\u{2C952}; + #\u{2C953}; + #\u{2C954}; + #\u{2C955}; + #\u{2C956}; + #\u{2C957}; + #\u{2C958}; + #\u{2C959}; + #\u{2C95A}; + #\u{2C95B}; + #\u{2C95C}; + #\u{2C95D}; + #\u{2C95E}; + #\u{2C95F}; + #\u{2C960}; + #\u{2C961}; + #\u{2C962}; + #\u{2C963}; + #\u{2C964}; + #\u{2C965}; + #\u{2C966}; + #\u{2C967}; + #\u{2C968}; + #\u{2C969}; + #\u{2C96A}; + #\u{2C96B}; + #\u{2C96C}; + #\u{2C96D}; + #\u{2C96E}; + #\u{2C96F}; + #\u{2C970}; + #\u{2C971}; + #\u{2C972}; + #\u{2C973}; + #\u{2C974}; + #\u{2C975}; + #\u{2C976}; + #\u{2C977}; + #\u{2C978}; + #\u{2C979}; + #\u{2C97A}; + #\u{2C97B}; + #\u{2C97C}; + #\u{2C97D}; + #\u{2C97E}; + #\u{2C97F}; + #\u{2C980}; + #\u{2C981}; + #\u{2C982}; + #\u{2C983}; + #\u{2C984}; + #\u{2C985}; + #\u{2C986}; + #\u{2C987}; + #\u{2C988}; + #\u{2C989}; + #\u{2C98A}; + #\u{2C98B}; + #\u{2C98C}; + #\u{2C98D}; + #\u{2C98E}; + #\u{2C98F}; + #\u{2C990}; + #\u{2C991}; + #\u{2C992}; + #\u{2C993}; + #\u{2C994}; + #\u{2C995}; + #\u{2C996}; + #\u{2C997}; + #\u{2C998}; + #\u{2C999}; + #\u{2C99A}; + #\u{2C99B}; + #\u{2C99C}; + #\u{2C99D}; + #\u{2C99E}; + #\u{2C99F}; + #\u{2C9A0}; + #\u{2C9A1}; + #\u{2C9A2}; + #\u{2C9A3}; + #\u{2C9A4}; + #\u{2C9A5}; + #\u{2C9A6}; + #\u{2C9A7}; + #\u{2C9A8}; + #\u{2C9A9}; + #\u{2C9AA}; + #\u{2C9AB}; + #\u{2C9AC}; + #\u{2C9AD}; + #\u{2C9AE}; + #\u{2C9AF}; + #\u{2C9B0}; + #\u{2C9B1}; + #\u{2C9B2}; + #\u{2C9B3}; + #\u{2C9B4}; + #\u{2C9B5}; + #\u{2C9B6}; + #\u{2C9B7}; + #\u{2C9B8}; + #\u{2C9B9}; + #\u{2C9BA}; + #\u{2C9BB}; + #\u{2C9BC}; + #\u{2C9BD}; + #\u{2C9BE}; + #\u{2C9BF}; + #\u{2C9C0}; + #\u{2C9C1}; + #\u{2C9C2}; + #\u{2C9C3}; + #\u{2C9C4}; + #\u{2C9C5}; + #\u{2C9C6}; + #\u{2C9C7}; + #\u{2C9C8}; + #\u{2C9C9}; + #\u{2C9CA}; + #\u{2C9CB}; + #\u{2C9CC}; + #\u{2C9CD}; + #\u{2C9CE}; + #\u{2C9CF}; + #\u{2C9D0}; + #\u{2C9D1}; + #\u{2C9D2}; + #\u{2C9D3}; + #\u{2C9D4}; + #\u{2C9D5}; + #\u{2C9D6}; + #\u{2C9D7}; + #\u{2C9D8}; + #\u{2C9D9}; + #\u{2C9DA}; + #\u{2C9DB}; + #\u{2C9DC}; + #\u{2C9DD}; + #\u{2C9DE}; + #\u{2C9DF}; + #\u{2C9E0}; + #\u{2C9E1}; + #\u{2C9E2}; + #\u{2C9E3}; + #\u{2C9E4}; + #\u{2C9E5}; + #\u{2C9E6}; + #\u{2C9E7}; + #\u{2C9E8}; + #\u{2C9E9}; + #\u{2C9EA}; + #\u{2C9EB}; + #\u{2C9EC}; + #\u{2C9ED}; + #\u{2C9EE}; + #\u{2C9EF}; + #\u{2C9F0}; + #\u{2C9F1}; + #\u{2C9F2}; + #\u{2C9F3}; + #\u{2C9F4}; + #\u{2C9F5}; + #\u{2C9F6}; + #\u{2C9F7}; + #\u{2C9F8}; + #\u{2C9F9}; + #\u{2C9FA}; + #\u{2C9FB}; + #\u{2C9FC}; + #\u{2C9FD}; + #\u{2C9FE}; + #\u{2C9FF}; + #\u{2CA00}; + #\u{2CA01}; + #\u{2CA02}; + #\u{2CA03}; + #\u{2CA04}; + #\u{2CA05}; + #\u{2CA06}; + #\u{2CA07}; + #\u{2CA08}; + #\u{2CA09}; + #\u{2CA0A}; + #\u{2CA0B}; + #\u{2CA0C}; + #\u{2CA0D}; + #\u{2CA0E}; + #\u{2CA0F}; + #\u{2CA10}; + #\u{2CA11}; + #\u{2CA12}; + #\u{2CA13}; + #\u{2CA14}; + #\u{2CA15}; + #\u{2CA16}; + #\u{2CA17}; + #\u{2CA18}; + #\u{2CA19}; + #\u{2CA1A}; + #\u{2CA1B}; + #\u{2CA1C}; + #\u{2CA1D}; + #\u{2CA1E}; + #\u{2CA1F}; + #\u{2CA20}; + #\u{2CA21}; + #\u{2CA22}; + #\u{2CA23}; + #\u{2CA24}; + #\u{2CA25}; + #\u{2CA26}; + #\u{2CA27}; + #\u{2CA28}; + #\u{2CA29}; + #\u{2CA2A}; + #\u{2CA2B}; + #\u{2CA2C}; + #\u{2CA2D}; + #\u{2CA2E}; + #\u{2CA2F}; + #\u{2CA30}; + #\u{2CA31}; + #\u{2CA32}; + #\u{2CA33}; + #\u{2CA34}; + #\u{2CA35}; + #\u{2CA36}; + #\u{2CA37}; + #\u{2CA38}; + #\u{2CA39}; + #\u{2CA3A}; + #\u{2CA3B}; + #\u{2CA3C}; + #\u{2CA3D}; + #\u{2CA3E}; + #\u{2CA3F}; + #\u{2CA40}; + #\u{2CA41}; + #\u{2CA42}; + #\u{2CA43}; + #\u{2CA44}; + #\u{2CA45}; + #\u{2CA46}; + #\u{2CA47}; + #\u{2CA48}; + #\u{2CA49}; + #\u{2CA4A}; + #\u{2CA4B}; + #\u{2CA4C}; + #\u{2CA4D}; + #\u{2CA4E}; + #\u{2CA4F}; + #\u{2CA50}; + #\u{2CA51}; + #\u{2CA52}; + #\u{2CA53}; + #\u{2CA54}; + #\u{2CA55}; + #\u{2CA56}; + #\u{2CA57}; + #\u{2CA58}; + #\u{2CA59}; + #\u{2CA5A}; + #\u{2CA5B}; + #\u{2CA5C}; + #\u{2CA5D}; + #\u{2CA5E}; + #\u{2CA5F}; + #\u{2CA60}; + #\u{2CA61}; + #\u{2CA62}; + #\u{2CA63}; + #\u{2CA64}; + #\u{2CA65}; + #\u{2CA66}; + #\u{2CA67}; + #\u{2CA68}; + #\u{2CA69}; + #\u{2CA6A}; + #\u{2CA6B}; + #\u{2CA6C}; + #\u{2CA6D}; + #\u{2CA6E}; + #\u{2CA6F}; + #\u{2CA70}; + #\u{2CA71}; + #\u{2CA72}; + #\u{2CA73}; + #\u{2CA74}; + #\u{2CA75}; + #\u{2CA76}; + #\u{2CA77}; + #\u{2CA78}; + #\u{2CA79}; + #\u{2CA7A}; + #\u{2CA7B}; + #\u{2CA7C}; + #\u{2CA7D}; + #\u{2CA7E}; + #\u{2CA7F}; + #\u{2CA80}; + #\u{2CA81}; + #\u{2CA82}; + #\u{2CA83}; + #\u{2CA84}; + #\u{2CA85}; + #\u{2CA86}; + #\u{2CA87}; + #\u{2CA88}; + #\u{2CA89}; + #\u{2CA8A}; + #\u{2CA8B}; + #\u{2CA8C}; + #\u{2CA8D}; + #\u{2CA8E}; + #\u{2CA8F}; + #\u{2CA90}; + #\u{2CA91}; + #\u{2CA92}; + #\u{2CA93}; + #\u{2CA94}; + #\u{2CA95}; + #\u{2CA96}; + #\u{2CA97}; + #\u{2CA98}; + #\u{2CA99}; + #\u{2CA9A}; + #\u{2CA9B}; + #\u{2CA9C}; + #\u{2CA9D}; + #\u{2CA9E}; + #\u{2CA9F}; + #\u{2CAA0}; + #\u{2CAA1}; + #\u{2CAA2}; + #\u{2CAA3}; + #\u{2CAA4}; + #\u{2CAA5}; + #\u{2CAA6}; + #\u{2CAA7}; + #\u{2CAA8}; + #\u{2CAA9}; + #\u{2CAAA}; + #\u{2CAAB}; + #\u{2CAAC}; + #\u{2CAAD}; + #\u{2CAAE}; + #\u{2CAAF}; + #\u{2CAB0}; + #\u{2CAB1}; + #\u{2CAB2}; + #\u{2CAB3}; + #\u{2CAB4}; + #\u{2CAB5}; + #\u{2CAB6}; + #\u{2CAB7}; + #\u{2CAB8}; + #\u{2CAB9}; + #\u{2CABA}; + #\u{2CABB}; + #\u{2CABC}; + #\u{2CABD}; + #\u{2CABE}; + #\u{2CABF}; + #\u{2CAC0}; + #\u{2CAC1}; + #\u{2CAC2}; + #\u{2CAC3}; + #\u{2CAC4}; + #\u{2CAC5}; + #\u{2CAC6}; + #\u{2CAC7}; + #\u{2CAC8}; + #\u{2CAC9}; + #\u{2CACA}; + #\u{2CACB}; + #\u{2CACC}; + #\u{2CACD}; + #\u{2CACE}; + #\u{2CACF}; + #\u{2CAD0}; + #\u{2CAD1}; + #\u{2CAD2}; + #\u{2CAD3}; + #\u{2CAD4}; + #\u{2CAD5}; + #\u{2CAD6}; + #\u{2CAD7}; + #\u{2CAD8}; + #\u{2CAD9}; + #\u{2CADA}; + #\u{2CADB}; + #\u{2CADC}; + #\u{2CADD}; + #\u{2CADE}; + #\u{2CADF}; + #\u{2CAE0}; + #\u{2CAE1}; + #\u{2CAE2}; + #\u{2CAE3}; + #\u{2CAE4}; + #\u{2CAE5}; + #\u{2CAE6}; + #\u{2CAE7}; + #\u{2CAE8}; + #\u{2CAE9}; + #\u{2CAEA}; + #\u{2CAEB}; + #\u{2CAEC}; + #\u{2CAED}; + #\u{2CAEE}; + #\u{2CAEF}; + #\u{2CAF0}; + #\u{2CAF1}; + #\u{2CAF2}; + #\u{2CAF3}; + #\u{2CAF4}; + #\u{2CAF5}; + #\u{2CAF6}; + #\u{2CAF7}; + #\u{2CAF8}; + #\u{2CAF9}; + #\u{2CAFA}; + #\u{2CAFB}; + #\u{2CAFC}; + #\u{2CAFD}; + #\u{2CAFE}; + #\u{2CAFF}; + #\u{2CB00}; + #\u{2CB01}; + #\u{2CB02}; + #\u{2CB03}; + #\u{2CB04}; + #\u{2CB05}; + #\u{2CB06}; + #\u{2CB07}; + #\u{2CB08}; + #\u{2CB09}; + #\u{2CB0A}; + #\u{2CB0B}; + #\u{2CB0C}; + #\u{2CB0D}; + #\u{2CB0E}; + #\u{2CB0F}; + #\u{2CB10}; + #\u{2CB11}; + #\u{2CB12}; + #\u{2CB13}; + #\u{2CB14}; + #\u{2CB15}; + #\u{2CB16}; + #\u{2CB17}; + #\u{2CB18}; + #\u{2CB19}; + #\u{2CB1A}; + #\u{2CB1B}; + #\u{2CB1C}; + #\u{2CB1D}; + #\u{2CB1E}; + #\u{2CB1F}; + #\u{2CB20}; + #\u{2CB21}; + #\u{2CB22}; + #\u{2CB23}; + #\u{2CB24}; + #\u{2CB25}; + #\u{2CB26}; + #\u{2CB27}; + #\u{2CB28}; + #\u{2CB29}; + #\u{2CB2A}; + #\u{2CB2B}; + #\u{2CB2C}; + #\u{2CB2D}; + #\u{2CB2E}; + #\u{2CB2F}; + #\u{2CB30}; + #\u{2CB31}; + #\u{2CB32}; + #\u{2CB33}; + #\u{2CB34}; + #\u{2CB35}; + #\u{2CB36}; + #\u{2CB37}; + #\u{2CB38}; + #\u{2CB39}; + #\u{2CB3A}; + #\u{2CB3B}; + #\u{2CB3C}; + #\u{2CB3D}; + #\u{2CB3E}; + #\u{2CB3F}; + #\u{2CB40}; + #\u{2CB41}; + #\u{2CB42}; + #\u{2CB43}; + #\u{2CB44}; + #\u{2CB45}; + #\u{2CB46}; + #\u{2CB47}; + #\u{2CB48}; + #\u{2CB49}; + #\u{2CB4A}; + #\u{2CB4B}; + #\u{2CB4C}; + #\u{2CB4D}; + #\u{2CB4E}; + #\u{2CB4F}; + #\u{2CB50}; + #\u{2CB51}; + #\u{2CB52}; + #\u{2CB53}; + #\u{2CB54}; + #\u{2CB55}; + #\u{2CB56}; + #\u{2CB57}; + #\u{2CB58}; + #\u{2CB59}; + #\u{2CB5A}; + #\u{2CB5B}; + #\u{2CB5C}; + #\u{2CB5D}; + #\u{2CB5E}; + #\u{2CB5F}; + #\u{2CB60}; + #\u{2CB61}; + #\u{2CB62}; + #\u{2CB63}; + #\u{2CB64}; + #\u{2CB65}; + #\u{2CB66}; + #\u{2CB67}; + #\u{2CB68}; + #\u{2CB69}; + #\u{2CB6A}; + #\u{2CB6B}; + #\u{2CB6C}; + #\u{2CB6D}; + #\u{2CB6E}; + #\u{2CB6F}; + #\u{2CB70}; + #\u{2CB71}; + #\u{2CB72}; + #\u{2CB73}; + #\u{2CB74}; + #\u{2CB75}; + #\u{2CB76}; + #\u{2CB77}; + #\u{2CB78}; + #\u{2CB79}; + #\u{2CB7A}; + #\u{2CB7B}; + #\u{2CB7C}; + #\u{2CB7D}; + #\u{2CB7E}; + #\u{2CB7F}; + #\u{2CB80}; + #\u{2CB81}; + #\u{2CB82}; + #\u{2CB83}; + #\u{2CB84}; + #\u{2CB85}; + #\u{2CB86}; + #\u{2CB87}; + #\u{2CB88}; + #\u{2CB89}; + #\u{2CB8A}; + #\u{2CB8B}; + #\u{2CB8C}; + #\u{2CB8D}; + #\u{2CB8E}; + #\u{2CB8F}; + #\u{2CB90}; + #\u{2CB91}; + #\u{2CB92}; + #\u{2CB93}; + #\u{2CB94}; + #\u{2CB95}; + #\u{2CB96}; + #\u{2CB97}; + #\u{2CB98}; + #\u{2CB99}; + #\u{2CB9A}; + #\u{2CB9B}; + #\u{2CB9C}; + #\u{2CB9D}; + #\u{2CB9E}; + #\u{2CB9F}; + #\u{2CBA0}; + #\u{2CBA1}; + #\u{2CBA2}; + #\u{2CBA3}; + #\u{2CBA4}; + #\u{2CBA5}; + #\u{2CBA6}; + #\u{2CBA7}; + #\u{2CBA8}; + #\u{2CBA9}; + #\u{2CBAA}; + #\u{2CBAB}; + #\u{2CBAC}; + #\u{2CBAD}; + #\u{2CBAE}; + #\u{2CBAF}; + #\u{2CBB0}; + #\u{2CBB1}; + #\u{2CBB2}; + #\u{2CBB3}; + #\u{2CBB4}; + #\u{2CBB5}; + #\u{2CBB6}; + #\u{2CBB7}; + #\u{2CBB8}; + #\u{2CBB9}; + #\u{2CBBA}; + #\u{2CBBB}; + #\u{2CBBC}; + #\u{2CBBD}; + #\u{2CBBE}; + #\u{2CBBF}; + #\u{2CBC0}; + #\u{2CBC1}; + #\u{2CBC2}; + #\u{2CBC3}; + #\u{2CBC4}; + #\u{2CBC5}; + #\u{2CBC6}; + #\u{2CBC7}; + #\u{2CBC8}; + #\u{2CBC9}; + #\u{2CBCA}; + #\u{2CBCB}; + #\u{2CBCC}; + #\u{2CBCD}; + #\u{2CBCE}; + #\u{2CBCF}; + #\u{2CBD0}; + #\u{2CBD1}; + #\u{2CBD2}; + #\u{2CBD3}; + #\u{2CBD4}; + #\u{2CBD5}; + #\u{2CBD6}; + #\u{2CBD7}; + #\u{2CBD8}; + #\u{2CBD9}; + #\u{2CBDA}; + #\u{2CBDB}; + #\u{2CBDC}; + #\u{2CBDD}; + #\u{2CBDE}; + #\u{2CBDF}; + #\u{2CBE0}; + #\u{2CBE1}; + #\u{2CBE2}; + #\u{2CBE3}; + #\u{2CBE4}; + #\u{2CBE5}; + #\u{2CBE6}; + #\u{2CBE7}; + #\u{2CBE8}; + #\u{2CBE9}; + #\u{2CBEA}; + #\u{2CBEB}; + #\u{2CBEC}; + #\u{2CBED}; + #\u{2CBEE}; + #\u{2CBEF}; + #\u{2CBF0}; + #\u{2CBF1}; + #\u{2CBF2}; + #\u{2CBF3}; + #\u{2CBF4}; + #\u{2CBF5}; + #\u{2CBF6}; + #\u{2CBF7}; + #\u{2CBF8}; + #\u{2CBF9}; + #\u{2CBFA}; + #\u{2CBFB}; + #\u{2CBFC}; + #\u{2CBFD}; + #\u{2CBFE}; + #\u{2CBFF}; + #\u{2CC00}; + #\u{2CC01}; + #\u{2CC02}; + #\u{2CC03}; + #\u{2CC04}; + #\u{2CC05}; + #\u{2CC06}; + #\u{2CC07}; + #\u{2CC08}; + #\u{2CC09}; + #\u{2CC0A}; + #\u{2CC0B}; + #\u{2CC0C}; + #\u{2CC0D}; + #\u{2CC0E}; + #\u{2CC0F}; + #\u{2CC10}; + #\u{2CC11}; + #\u{2CC12}; + #\u{2CC13}; + #\u{2CC14}; + #\u{2CC15}; + #\u{2CC16}; + #\u{2CC17}; + #\u{2CC18}; + #\u{2CC19}; + #\u{2CC1A}; + #\u{2CC1B}; + #\u{2CC1C}; + #\u{2CC1D}; + #\u{2CC1E}; + #\u{2CC1F}; + #\u{2CC20}; + #\u{2CC21}; + #\u{2CC22}; + #\u{2CC23}; + #\u{2CC24}; + #\u{2CC25}; + #\u{2CC26}; + #\u{2CC27}; + #\u{2CC28}; + #\u{2CC29}; + #\u{2CC2A}; + #\u{2CC2B}; + #\u{2CC2C}; + #\u{2CC2D}; + #\u{2CC2E}; + #\u{2CC2F}; + #\u{2CC30}; + #\u{2CC31}; + #\u{2CC32}; + #\u{2CC33}; + #\u{2CC34}; + #\u{2CC35}; + #\u{2CC36}; + #\u{2CC37}; + #\u{2CC38}; + #\u{2CC39}; + #\u{2CC3A}; + #\u{2CC3B}; + #\u{2CC3C}; + #\u{2CC3D}; + #\u{2CC3E}; + #\u{2CC3F}; + #\u{2CC40}; + #\u{2CC41}; + #\u{2CC42}; + #\u{2CC43}; + #\u{2CC44}; + #\u{2CC45}; + #\u{2CC46}; + #\u{2CC47}; + #\u{2CC48}; + #\u{2CC49}; + #\u{2CC4A}; + #\u{2CC4B}; + #\u{2CC4C}; + #\u{2CC4D}; + #\u{2CC4E}; + #\u{2CC4F}; + #\u{2CC50}; + #\u{2CC51}; + #\u{2CC52}; + #\u{2CC53}; + #\u{2CC54}; + #\u{2CC55}; + #\u{2CC56}; + #\u{2CC57}; + #\u{2CC58}; + #\u{2CC59}; + #\u{2CC5A}; + #\u{2CC5B}; + #\u{2CC5C}; + #\u{2CC5D}; + #\u{2CC5E}; + #\u{2CC5F}; + #\u{2CC60}; + #\u{2CC61}; + #\u{2CC62}; + #\u{2CC63}; + #\u{2CC64}; + #\u{2CC65}; + #\u{2CC66}; + #\u{2CC67}; + #\u{2CC68}; + #\u{2CC69}; + #\u{2CC6A}; + #\u{2CC6B}; + #\u{2CC6C}; + #\u{2CC6D}; + #\u{2CC6E}; + #\u{2CC6F}; + #\u{2CC70}; + #\u{2CC71}; + #\u{2CC72}; + #\u{2CC73}; + #\u{2CC74}; + #\u{2CC75}; + #\u{2CC76}; + #\u{2CC77}; + #\u{2CC78}; + #\u{2CC79}; + #\u{2CC7A}; + #\u{2CC7B}; + #\u{2CC7C}; + #\u{2CC7D}; + #\u{2CC7E}; + #\u{2CC7F}; + #\u{2CC80}; + #\u{2CC81}; + #\u{2CC82}; + #\u{2CC83}; + #\u{2CC84}; + #\u{2CC85}; + #\u{2CC86}; + #\u{2CC87}; + #\u{2CC88}; + #\u{2CC89}; + #\u{2CC8A}; + #\u{2CC8B}; + #\u{2CC8C}; + #\u{2CC8D}; + #\u{2CC8E}; + #\u{2CC8F}; + #\u{2CC90}; + #\u{2CC91}; + #\u{2CC92}; + #\u{2CC93}; + #\u{2CC94}; + #\u{2CC95}; + #\u{2CC96}; + #\u{2CC97}; + #\u{2CC98}; + #\u{2CC99}; + #\u{2CC9A}; + #\u{2CC9B}; + #\u{2CC9C}; + #\u{2CC9D}; + #\u{2CC9E}; + #\u{2CC9F}; + #\u{2CCA0}; + #\u{2CCA1}; + #\u{2CCA2}; + #\u{2CCA3}; + #\u{2CCA4}; + #\u{2CCA5}; + #\u{2CCA6}; + #\u{2CCA7}; + #\u{2CCA8}; + #\u{2CCA9}; + #\u{2CCAA}; + #\u{2CCAB}; + #\u{2CCAC}; + #\u{2CCAD}; + #\u{2CCAE}; + #\u{2CCAF}; + #\u{2CCB0}; + #\u{2CCB1}; + #\u{2CCB2}; + #\u{2CCB3}; + #\u{2CCB4}; + #\u{2CCB5}; + #\u{2CCB6}; + #\u{2CCB7}; + #\u{2CCB8}; + #\u{2CCB9}; + #\u{2CCBA}; + #\u{2CCBB}; + #\u{2CCBC}; + #\u{2CCBD}; + #\u{2CCBE}; + #\u{2CCBF}; + #\u{2CCC0}; + #\u{2CCC1}; + #\u{2CCC2}; + #\u{2CCC3}; + #\u{2CCC4}; + #\u{2CCC5}; + #\u{2CCC6}; + #\u{2CCC7}; + #\u{2CCC8}; + #\u{2CCC9}; + #\u{2CCCA}; + #\u{2CCCB}; + #\u{2CCCC}; + #\u{2CCCD}; + #\u{2CCCE}; + #\u{2CCCF}; + #\u{2CCD0}; + #\u{2CCD1}; + #\u{2CCD2}; + #\u{2CCD3}; + #\u{2CCD4}; + #\u{2CCD5}; + #\u{2CCD6}; + #\u{2CCD7}; + #\u{2CCD8}; + #\u{2CCD9}; + #\u{2CCDA}; + #\u{2CCDB}; + #\u{2CCDC}; + #\u{2CCDD}; + #\u{2CCDE}; + #\u{2CCDF}; + #\u{2CCE0}; + #\u{2CCE1}; + #\u{2CCE2}; + #\u{2CCE3}; + #\u{2CCE4}; + #\u{2CCE5}; + #\u{2CCE6}; + #\u{2CCE7}; + #\u{2CCE8}; + #\u{2CCE9}; + #\u{2CCEA}; + #\u{2CCEB}; + #\u{2CCEC}; + #\u{2CCED}; + #\u{2CCEE}; + #\u{2CCEF}; + #\u{2CCF0}; + #\u{2CCF1}; + #\u{2CCF2}; + #\u{2CCF3}; + #\u{2CCF4}; + #\u{2CCF5}; + #\u{2CCF6}; + #\u{2CCF7}; + #\u{2CCF8}; + #\u{2CCF9}; + #\u{2CCFA}; + #\u{2CCFB}; + #\u{2CCFC}; + #\u{2CCFD}; + #\u{2CCFE}; + #\u{2CCFF}; + #\u{2CD00}; + #\u{2CD01}; + #\u{2CD02}; + #\u{2CD03}; + #\u{2CD04}; + #\u{2CD05}; + #\u{2CD06}; + #\u{2CD07}; + #\u{2CD08}; + #\u{2CD09}; + #\u{2CD0A}; + #\u{2CD0B}; + #\u{2CD0C}; + #\u{2CD0D}; + #\u{2CD0E}; + #\u{2CD0F}; + #\u{2CD10}; + #\u{2CD11}; + #\u{2CD12}; + #\u{2CD13}; + #\u{2CD14}; + #\u{2CD15}; + #\u{2CD16}; + #\u{2CD17}; + #\u{2CD18}; + #\u{2CD19}; + #\u{2CD1A}; + #\u{2CD1B}; + #\u{2CD1C}; + #\u{2CD1D}; + #\u{2CD1E}; + #\u{2CD1F}; + #\u{2CD20}; + #\u{2CD21}; + #\u{2CD22}; + #\u{2CD23}; + #\u{2CD24}; + #\u{2CD25}; + #\u{2CD26}; + #\u{2CD27}; + #\u{2CD28}; + #\u{2CD29}; + #\u{2CD2A}; + #\u{2CD2B}; + #\u{2CD2C}; + #\u{2CD2D}; + #\u{2CD2E}; + #\u{2CD2F}; + #\u{2CD30}; + #\u{2CD31}; + #\u{2CD32}; + #\u{2CD33}; + #\u{2CD34}; + #\u{2CD35}; + #\u{2CD36}; + #\u{2CD37}; + #\u{2CD38}; + #\u{2CD39}; + #\u{2CD3A}; + #\u{2CD3B}; + #\u{2CD3C}; + #\u{2CD3D}; + #\u{2CD3E}; + #\u{2CD3F}; + #\u{2CD40}; + #\u{2CD41}; + #\u{2CD42}; + #\u{2CD43}; + #\u{2CD44}; + #\u{2CD45}; + #\u{2CD46}; + #\u{2CD47}; + #\u{2CD48}; + #\u{2CD49}; + #\u{2CD4A}; + #\u{2CD4B}; + #\u{2CD4C}; + #\u{2CD4D}; + #\u{2CD4E}; + #\u{2CD4F}; + #\u{2CD50}; + #\u{2CD51}; + #\u{2CD52}; + #\u{2CD53}; + #\u{2CD54}; + #\u{2CD55}; + #\u{2CD56}; + #\u{2CD57}; + #\u{2CD58}; + #\u{2CD59}; + #\u{2CD5A}; + #\u{2CD5B}; + #\u{2CD5C}; + #\u{2CD5D}; + #\u{2CD5E}; + #\u{2CD5F}; + #\u{2CD60}; + #\u{2CD61}; + #\u{2CD62}; + #\u{2CD63}; + #\u{2CD64}; + #\u{2CD65}; + #\u{2CD66}; + #\u{2CD67}; + #\u{2CD68}; + #\u{2CD69}; + #\u{2CD6A}; + #\u{2CD6B}; + #\u{2CD6C}; + #\u{2CD6D}; + #\u{2CD6E}; + #\u{2CD6F}; + #\u{2CD70}; + #\u{2CD71}; + #\u{2CD72}; + #\u{2CD73}; + #\u{2CD74}; + #\u{2CD75}; + #\u{2CD76}; + #\u{2CD77}; + #\u{2CD78}; + #\u{2CD79}; + #\u{2CD7A}; + #\u{2CD7B}; + #\u{2CD7C}; + #\u{2CD7D}; + #\u{2CD7E}; + #\u{2CD7F}; + #\u{2CD80}; + #\u{2CD81}; + #\u{2CD82}; + #\u{2CD83}; + #\u{2CD84}; + #\u{2CD85}; + #\u{2CD86}; + #\u{2CD87}; + #\u{2CD88}; + #\u{2CD89}; + #\u{2CD8A}; + #\u{2CD8B}; + #\u{2CD8C}; + #\u{2CD8D}; + #\u{2CD8E}; + #\u{2CD8F}; + #\u{2CD90}; + #\u{2CD91}; + #\u{2CD92}; + #\u{2CD93}; + #\u{2CD94}; + #\u{2CD95}; + #\u{2CD96}; + #\u{2CD97}; + #\u{2CD98}; + #\u{2CD99}; + #\u{2CD9A}; + #\u{2CD9B}; + #\u{2CD9C}; + #\u{2CD9D}; + #\u{2CD9E}; + #\u{2CD9F}; + #\u{2CDA0}; + #\u{2CDA1}; + #\u{2CDA2}; + #\u{2CDA3}; + #\u{2CDA4}; + #\u{2CDA5}; + #\u{2CDA6}; + #\u{2CDA7}; + #\u{2CDA8}; + #\u{2CDA9}; + #\u{2CDAA}; + #\u{2CDAB}; + #\u{2CDAC}; + #\u{2CDAD}; + #\u{2CDAE}; + #\u{2CDAF}; + #\u{2CDB0}; + #\u{2CDB1}; + #\u{2CDB2}; + #\u{2CDB3}; + #\u{2CDB4}; + #\u{2CDB5}; + #\u{2CDB6}; + #\u{2CDB7}; + #\u{2CDB8}; + #\u{2CDB9}; + #\u{2CDBA}; + #\u{2CDBB}; + #\u{2CDBC}; + #\u{2CDBD}; + #\u{2CDBE}; + #\u{2CDBF}; + #\u{2CDC0}; + #\u{2CDC1}; + #\u{2CDC2}; + #\u{2CDC3}; + #\u{2CDC4}; + #\u{2CDC5}; + #\u{2CDC6}; + #\u{2CDC7}; + #\u{2CDC8}; + #\u{2CDC9}; + #\u{2CDCA}; + #\u{2CDCB}; + #\u{2CDCC}; + #\u{2CDCD}; + #\u{2CDCE}; + #\u{2CDCF}; + #\u{2CDD0}; + #\u{2CDD1}; + #\u{2CDD2}; + #\u{2CDD3}; + #\u{2CDD4}; + #\u{2CDD5}; + #\u{2CDD6}; + #\u{2CDD7}; + #\u{2CDD8}; + #\u{2CDD9}; + #\u{2CDDA}; + #\u{2CDDB}; + #\u{2CDDC}; + #\u{2CDDD}; + #\u{2CDDE}; + #\u{2CDDF}; + #\u{2CDE0}; + #\u{2CDE1}; + #\u{2CDE2}; + #\u{2CDE3}; + #\u{2CDE4}; + #\u{2CDE5}; + #\u{2CDE6}; + #\u{2CDE7}; + #\u{2CDE8}; + #\u{2CDE9}; + #\u{2CDEA}; + #\u{2CDEB}; + #\u{2CDEC}; + #\u{2CDED}; + #\u{2CDEE}; + #\u{2CDEF}; + #\u{2CDF0}; + #\u{2CDF1}; + #\u{2CDF2}; + #\u{2CDF3}; + #\u{2CDF4}; + #\u{2CDF5}; + #\u{2CDF6}; + #\u{2CDF7}; + #\u{2CDF8}; + #\u{2CDF9}; + #\u{2CDFA}; + #\u{2CDFB}; + #\u{2CDFC}; + #\u{2CDFD}; + #\u{2CDFE}; + #\u{2CDFF}; + #\u{2CE00}; + #\u{2CE01}; + #\u{2CE02}; + #\u{2CE03}; + #\u{2CE04}; + #\u{2CE05}; + #\u{2CE06}; + #\u{2CE07}; + #\u{2CE08}; + #\u{2CE09}; + #\u{2CE0A}; + #\u{2CE0B}; + #\u{2CE0C}; + #\u{2CE0D}; + #\u{2CE0E}; + #\u{2CE0F}; + #\u{2CE10}; + #\u{2CE11}; + #\u{2CE12}; + #\u{2CE13}; + #\u{2CE14}; + #\u{2CE15}; + #\u{2CE16}; + #\u{2CE17}; + #\u{2CE18}; + #\u{2CE19}; + #\u{2CE1A}; + #\u{2CE1B}; + #\u{2CE1C}; + #\u{2CE1D}; + #\u{2CE1E}; + #\u{2CE1F}; + #\u{2CE20}; + #\u{2CE21}; + #\u{2CE22}; + #\u{2CE23}; + #\u{2CE24}; + #\u{2CE25}; + #\u{2CE26}; + #\u{2CE27}; + #\u{2CE28}; + #\u{2CE29}; + #\u{2CE2A}; + #\u{2CE2B}; + #\u{2CE2C}; + #\u{2CE2D}; + #\u{2CE2E}; + #\u{2CE2F}; + #\u{2CE30}; + #\u{2CE31}; + #\u{2CE32}; + #\u{2CE33}; + #\u{2CE34}; + #\u{2CE35}; + #\u{2CE36}; + #\u{2CE37}; + #\u{2CE38}; + #\u{2CE39}; + #\u{2CE3A}; + #\u{2CE3B}; + #\u{2CE3C}; + #\u{2CE3D}; + #\u{2CE3E}; + #\u{2CE3F}; + #\u{2CE40}; + #\u{2CE41}; + #\u{2CE42}; + #\u{2CE43}; + #\u{2CE44}; + #\u{2CE45}; + #\u{2CE46}; + #\u{2CE47}; + #\u{2CE48}; + #\u{2CE49}; + #\u{2CE4A}; + #\u{2CE4B}; + #\u{2CE4C}; + #\u{2CE4D}; + #\u{2CE4E}; + #\u{2CE4F}; + #\u{2CE50}; + #\u{2CE51}; + #\u{2CE52}; + #\u{2CE53}; + #\u{2CE54}; + #\u{2CE55}; + #\u{2CE56}; + #\u{2CE57}; + #\u{2CE58}; + #\u{2CE59}; + #\u{2CE5A}; + #\u{2CE5B}; + #\u{2CE5C}; + #\u{2CE5D}; + #\u{2CE5E}; + #\u{2CE5F}; + #\u{2CE60}; + #\u{2CE61}; + #\u{2CE62}; + #\u{2CE63}; + #\u{2CE64}; + #\u{2CE65}; + #\u{2CE66}; + #\u{2CE67}; + #\u{2CE68}; + #\u{2CE69}; + #\u{2CE6A}; + #\u{2CE6B}; + #\u{2CE6C}; + #\u{2CE6D}; + #\u{2CE6E}; + #\u{2CE6F}; + #\u{2CE70}; + #\u{2CE71}; + #\u{2CE72}; + #\u{2CE73}; + #\u{2CE74}; + #\u{2CE75}; + #\u{2CE76}; + #\u{2CE77}; + #\u{2CE78}; + #\u{2CE79}; + #\u{2CE7A}; + #\u{2CE7B}; + #\u{2CE7C}; + #\u{2CE7D}; + #\u{2CE7E}; + #\u{2CE7F}; + #\u{2CE80}; + #\u{2CE81}; + #\u{2CE82}; + #\u{2CE83}; + #\u{2CE84}; + #\u{2CE85}; + #\u{2CE86}; + #\u{2CE87}; + #\u{2CE88}; + #\u{2CE89}; + #\u{2CE8A}; + #\u{2CE8B}; + #\u{2CE8C}; + #\u{2CE8D}; + #\u{2CE8E}; + #\u{2CE8F}; + #\u{2CE90}; + #\u{2CE91}; + #\u{2CE92}; + #\u{2CE93}; + #\u{2CE94}; + #\u{2CE95}; + #\u{2CE96}; + #\u{2CE97}; + #\u{2CE98}; + #\u{2CE99}; + #\u{2CE9A}; + #\u{2CE9B}; + #\u{2CE9C}; + #\u{2CE9D}; + #\u{2CE9E}; + #\u{2CE9F}; + #\u{2CEA0}; + #\u{2CEA1}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0-class.js new file mode 100644 index 000000000..437a6c9d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0-class.js @@ -0,0 +1,6882 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v8.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #ࢳ; + #ࢴ; + #ૹ; + #ౚ; + #ൟ; + #Ᏽ; + #ᏸ; + #ᏹ; + #ᏺ; + #ᏻ; + #ᏼ; + #ᏽ; + #ᦰ; + #ᦱ; + #ᦲ; + #ᦳ; + #ᦴ; + #ᦵ; + #ᦶ; + #ᦷ; + #ᦸ; + #ᦹ; + #ᦺ; + #ᦻ; + #ᦼ; + #ᦽ; + #ᦾ; + #ᦿ; + #ᧀ; + #ᧈ; + #ᧉ; + #鿍; + #鿎; + #鿏; + #鿐; + #鿑; + #鿒; + #鿓; + #鿔; + #鿕; + #ꞏ; + #Ʝ; + #Ꭓ; + #Ꞵ; + #ꞵ; + #Ꞷ; + #ꞷ; + #ꣽ; + #ꭠ; + #ꭡ; + #ꭢ; + #ꭣ; + #ꭰ; + #ꭱ; + #ꭲ; + #ꭳ; + #ꭴ; + #ꭵ; + #ꭶ; + #ꭷ; + #ꭸ; + #ꭹ; + #ꭺ; + #ꭻ; + #ꭼ; + #ꭽ; + #ꭾ; + #ꭿ; + #ꮀ; + #ꮁ; + #ꮂ; + #ꮃ; + #ꮄ; + #ꮅ; + #ꮆ; + #ꮇ; + #ꮈ; + #ꮉ; + #ꮊ; + #ꮋ; + #ꮌ; + #ꮍ; + #ꮎ; + #ꮏ; + #ꮐ; + #ꮑ; + #ꮒ; + #ꮓ; + #ꮔ; + #ꮕ; + #ꮖ; + #ꮗ; + #ꮘ; + #ꮙ; + #ꮚ; + #ꮛ; + #ꮜ; + #ꮝ; + #ꮞ; + #ꮟ; + #ꮠ; + #ꮡ; + #ꮢ; + #ꮣ; + #ꮤ; + #ꮥ; + #ꮦ; + #ꮧ; + #ꮨ; + #ꮩ; + #ꮪ; + #ꮫ; + #ꮬ; + #ꮭ; + #ꮮ; + #ꮯ; + #ꮰ; + #ꮱ; + #ꮲ; + #ꮳ; + #ꮴ; + #ꮵ; + #ꮶ; + #ꮷ; + #ꮸ; + #ꮹ; + #ꮺ; + #ꮻ; + #ꮼ; + #ꮽ; + #ꮾ; + #ꮿ; + #𐣠; + #𐣡; + #𐣢; + #𐣣; + #𐣤; + #𐣥; + #𐣦; + #𐣧; + #𐣨; + #𐣩; + #𐣪; + #𐣫; + #𐣬; + #𐣭; + #𐣮; + #𐣯; + #𐣰; + #𐣱; + #𐣲; + #𐣴; + #𐣵; + #𐲀; + #𐲁; + #𐲂; + #𐲃; + #𐲄; + #𐲅; + #𐲆; + #𐲇; + #𐲈; + #𐲉; + #𐲊; + #𐲋; + #𐲌; + #𐲍; + #𐲎; + #𐲏; + #𐲐; + #𐲑; + #𐲒; + #𐲓; + #𐲔; + #𐲕; + #𐲖; + #𐲗; + #𐲘; + #𐲙; + #𐲚; + #𐲛; + #𐲜; + #𐲝; + #𐲞; + #𐲟; + #𐲠; + #𐲡; + #𐲢; + #𐲣; + #𐲤; + #𐲥; + #𐲦; + #𐲧; + #𐲨; + #𐲩; + #𐲪; + #𐲫; + #𐲬; + #𐲭; + #𐲮; + #𐲯; + #𐲰; + #𐲱; + #𐲲; + #𐳀; + #𐳁; + #𐳂; + #𐳃; + #𐳄; + #𐳅; + #𐳆; + #𐳇; + #𐳈; + #𐳉; + #𐳊; + #𐳋; + #𐳌; + #𐳍; + #𐳎; + #𐳏; + #𐳐; + #𐳑; + #𐳒; + #𐳓; + #𐳔; + #𐳕; + #𐳖; + #𐳗; + #𐳘; + #𐳙; + #𐳚; + #𐳛; + #𐳜; + #𐳝; + #𐳞; + #𐳟; + #𐳠; + #𐳡; + #𐳢; + #𐳣; + #𐳤; + #𐳥; + #𐳦; + #𐳧; + #𐳨; + #𐳩; + #𐳪; + #𐳫; + #𐳬; + #𐳭; + #𐳮; + #𐳯; + #𐳰; + #𐳱; + #𐳲; + #𑇜; + #𑊀; + #𑊁; + #𑊂; + #𑊃; + #𑊄; + #𑊅; + #𑊆; + #𑊈; + #𑊊; + #𑊋; + #𑊌; + #𑊍; + #𑊏; + #𑊐; + #𑊑; + #𑊒; + #𑊓; + #𑊔; + #𑊕; + #𑊖; + #𑊗; + #𑊘; + #𑊙; + #𑊚; + #𑊛; + #𑊜; + #𑊝; + #𑊟; + #𑊠; + #𑊡; + #𑊢; + #𑊣; + #𑊤; + #𑊥; + #𑊦; + #𑊧; + #𑊨; + #𑍐; + #𑗘; + #𑗙; + #𑗚; + #𑗛; + #𑜀; + #𑜁; + #𑜂; + #𑜃; + #𑜄; + #𑜅; + #𑜆; + #𑜇; + #𑜈; + #𑜉; + #𑜊; + #𑜋; + #𑜌; + #𑜍; + #𑜎; + #𑜏; + #𑜐; + #𑜑; + #𑜒; + #𑜓; + #𑜔; + #𑜕; + #𑜖; + #𑜗; + #𑜘; + #𑜙; + #𒎙; + #𒒀; + #𒒁; + #𒒂; + #𒒃; + #𒒄; + #𒒅; + #𒒆; + #𒒇; + #𒒈; + #𒒉; + #𒒊; + #𒒋; + #𒒌; + #𒒍; + #𒒎; + #𒒏; + #𒒐; + #𒒑; + #𒒒; + #𒒓; + #𒒔; + #𒒕; + #𒒖; + #𒒗; + #𒒘; + #𒒙; + #𒒚; + #𒒛; + #𒒜; + #𒒝; + #𒒞; + #𒒟; + #𒒠; + #𒒡; + #𒒢; + #𒒣; + #𒒤; + #𒒥; + #𒒦; + #𒒧; + #𒒨; + #𒒩; + #𒒪; + #𒒫; + #𒒬; + #𒒭; + #𒒮; + #𒒯; + #𒒰; + #𒒱; + #𒒲; + #𒒳; + #𒒴; + #𒒵; + #𒒶; + #𒒷; + #𒒸; + #𒒹; + #𒒺; + #𒒻; + #𒒼; + #𒒽; + #𒒾; + #𒒿; + #𒓀; + #𒓁; + #𒓂; + #𒓃; + #𒓄; + #𒓅; + #𒓆; + #𒓇; + #𒓈; + #𒓉; + #𒓊; + #𒓋; + #𒓌; + #𒓍; + #𒓎; + #𒓏; + #𒓐; + #𒓑; + #𒓒; + #𒓓; + #𒓔; + #𒓕; + #𒓖; + #𒓗; + #𒓘; + #𒓙; + #𒓚; + #𒓛; + #𒓜; + #𒓝; + #𒓞; + #𒓟; + #𒓠; + #𒓡; + #𒓢; + #𒓣; + #𒓤; + #𒓥; + #𒓦; + #𒓧; + #𒓨; + #𒓩; + #𒓪; + #𒓫; + #𒓬; + #𒓭; + #𒓮; + #𒓯; + #𒓰; + #𒓱; + #𒓲; + #𒓳; + #𒓴; + #𒓵; + #𒓶; + #𒓷; + #𒓸; + #𒓹; + #𒓺; + #𒓻; + #𒓼; + #𒓽; + #𒓾; + #𒓿; + #𒔀; + #𒔁; + #𒔂; + #𒔃; + #𒔄; + #𒔅; + #𒔆; + #𒔇; + #𒔈; + #𒔉; + #𒔊; + #𒔋; + #𒔌; + #𒔍; + #𒔎; + #𒔏; + #𒔐; + #𒔑; + #𒔒; + #𒔓; + #𒔔; + #𒔕; + #𒔖; + #𒔗; + #𒔘; + #𒔙; + #𒔚; + #𒔛; + #𒔜; + #𒔝; + #𒔞; + #𒔟; + #𒔠; + #𒔡; + #𒔢; + #𒔣; + #𒔤; + #𒔥; + #𒔦; + #𒔧; + #𒔨; + #𒔩; + #𒔪; + #𒔫; + #𒔬; + #𒔭; + #𒔮; + #𒔯; + #𒔰; + #𒔱; + #𒔲; + #𒔳; + #𒔴; + #𒔵; + #𒔶; + #𒔷; + #𒔸; + #𒔹; + #𒔺; + #𒔻; + #𒔼; + #𒔽; + #𒔾; + #𒔿; + #𒕀; + #𒕁; + #𒕂; + #𒕃; + #𔐀; + #𔐁; + #𔐂; + #𔐃; + #𔐄; + #𔐅; + #𔐆; + #𔐇; + #𔐈; + #𔐉; + #𔐊; + #𔐋; + #𔐌; + #𔐍; + #𔐎; + #𔐏; + #𔐐; + #𔐑; + #𔐒; + #𔐓; + #𔐔; + #𔐕; + #𔐖; + #𔐗; + #𔐘; + #𔐙; + #𔐚; + #𔐛; + #𔐜; + #𔐝; + #𔐞; + #𔐟; + #𔐠; + #𔐡; + #𔐢; + #𔐣; + #𔐤; + #𔐥; + #𔐦; + #𔐧; + #𔐨; + #𔐩; + #𔐪; + #𔐫; + #𔐬; + #𔐭; + #𔐮; + #𔐯; + #𔐰; + #𔐱; + #𔐲; + #𔐳; + #𔐴; + #𔐵; + #𔐶; + #𔐷; + #𔐸; + #𔐹; + #𔐺; + #𔐻; + #𔐼; + #𔐽; + #𔐾; + #𔐿; + #𔑀; + #𔑁; + #𔑂; + #𔑃; + #𔑄; + #𔑅; + #𔑆; + #𔑇; + #𔑈; + #𔑉; + #𔑊; + #𔑋; + #𔑌; + #𔑍; + #𔑎; + #𔑏; + #𔑐; + #𔑑; + #𔑒; + #𔑓; + #𔑔; + #𔑕; + #𔑖; + #𔑗; + #𔑘; + #𔑙; + #𔑚; + #𔑛; + #𔑜; + #𔑝; + #𔑞; + #𔑟; + #𔑠; + #𔑡; + #𔑢; + #𔑣; + #𔑤; + #𔑥; + #𔑦; + #𔑧; + #𔑨; + #𔑩; + #𔑪; + #𔑫; + #𔑬; + #𔑭; + #𔑮; + #𔑯; + #𔑰; + #𔑱; + #𔑲; + #𔑳; + #𔑴; + #𔑵; + #𔑶; + #𔑷; + #𔑸; + #𔑹; + #𔑺; + #𔑻; + #𔑼; + #𔑽; + #𔑾; + #𔑿; + #𔒀; + #𔒁; + #𔒂; + #𔒃; + #𔒄; + #𔒅; + #𔒆; + #𔒇; + #𔒈; + #𔒉; + #𔒊; + #𔒋; + #𔒌; + #𔒍; + #𔒎; + #𔒏; + #𔒐; + #𔒑; + #𔒒; + #𔒓; + #𔒔; + #𔒕; + #𔒖; + #𔒗; + #𔒘; + #𔒙; + #𔒚; + #𔒛; + #𔒜; + #𔒝; + #𔒞; + #𔒟; + #𔒠; + #𔒡; + #𔒢; + #𔒣; + #𔒤; + #𔒥; + #𔒦; + #𔒧; + #𔒨; + #𔒩; + #𔒪; + #𔒫; + #𔒬; + #𔒭; + #𔒮; + #𔒯; + #𔒰; + #𔒱; + #𔒲; + #𔒳; + #𔒴; + #𔒵; + #𔒶; + #𔒷; + #𔒸; + #𔒹; + #𔒺; + #𔒻; + #𔒼; + #𔒽; + #𔒾; + #𔒿; + #𔓀; + #𔓁; + #𔓂; + #𔓃; + #𔓄; + #𔓅; + #𔓆; + #𔓇; + #𔓈; + #𔓉; + #𔓊; + #𔓋; + #𔓌; + #𔓍; + #𔓎; + #𔓏; + #𔓐; + #𔓑; + #𔓒; + #𔓓; + #𔓔; + #𔓕; + #𔓖; + #𔓗; + #𔓘; + #𔓙; + #𔓚; + #𔓛; + #𔓜; + #𔓝; + #𔓞; + #𔓟; + #𔓠; + #𔓡; + #𔓢; + #𔓣; + #𔓤; + #𔓥; + #𔓦; + #𔓧; + #𔓨; + #𔓩; + #𔓪; + #𔓫; + #𔓬; + #𔓭; + #𔓮; + #𔓯; + #𔓰; + #𔓱; + #𔓲; + #𔓳; + #𔓴; + #𔓵; + #𔓶; + #𔓷; + #𔓸; + #𔓹; + #𔓺; + #𔓻; + #𔓼; + #𔓽; + #𔓾; + #𔓿; + #𔔀; + #𔔁; + #𔔂; + #𔔃; + #𔔄; + #𔔅; + #𔔆; + #𔔇; + #𔔈; + #𔔉; + #𔔊; + #𔔋; + #𔔌; + #𔔍; + #𔔎; + #𔔏; + #𔔐; + #𔔑; + #𔔒; + #𔔓; + #𔔔; + #𔔕; + #𔔖; + #𔔗; + #𔔘; + #𔔙; + #𔔚; + #𔔛; + #𔔜; + #𔔝; + #𔔞; + #𔔟; + #𔔠; + #𔔡; + #𔔢; + #𔔣; + #𔔤; + #𔔥; + #𔔦; + #𔔧; + #𔔨; + #𔔩; + #𔔪; + #𔔫; + #𔔬; + #𔔭; + #𔔮; + #𔔯; + #𔔰; + #𔔱; + #𔔲; + #𔔳; + #𔔴; + #𔔵; + #𔔶; + #𔔷; + #𔔸; + #𔔹; + #𔔺; + #𔔻; + #𔔼; + #𔔽; + #𔔾; + #𔔿; + #𔕀; + #𔕁; + #𔕂; + #𔕃; + #𔕄; + #𔕅; + #𔕆; + #𔕇; + #𔕈; + #𔕉; + #𔕊; + #𔕋; + #𔕌; + #𔕍; + #𔕎; + #𔕏; + #𔕐; + #𔕑; + #𔕒; + #𔕓; + #𔕔; + #𔕕; + #𔕖; + #𔕗; + #𔕘; + #𔕙; + #𔕚; + #𔕛; + #𔕜; + #𔕝; + #𔕞; + #𔕟; + #𔕠; + #𔕡; + #𔕢; + #𔕣; + #𔕤; + #𔕥; + #𔕦; + #𔕧; + #𔕨; + #𔕩; + #𔕪; + #𔕫; + #𔕬; + #𔕭; + #𔕮; + #𔕯; + #𔕰; + #𔕱; + #𔕲; + #𔕳; + #𔕴; + #𔕵; + #𔕶; + #𔕷; + #𔕸; + #𔕹; + #𔕺; + #𔕻; + #𔕼; + #𔕽; + #𔕾; + #𔕿; + #𔖀; + #𔖁; + #𔖂; + #𔖃; + #𔖄; + #𔖅; + #𔖆; + #𔖇; + #𔖈; + #𔖉; + #𔖊; + #𔖋; + #𔖌; + #𔖍; + #𔖎; + #𔖏; + #𔖐; + #𔖑; + #𔖒; + #𔖓; + #𔖔; + #𔖕; + #𔖖; + #𔖗; + #𔖘; + #𔖙; + #𔖚; + #𔖛; + #𔖜; + #𔖝; + #𔖞; + #𔖟; + #𔖠; + #𔖡; + #𔖢; + #𔖣; + #𔖤; + #𔖥; + #𔖦; + #𔖧; + #𔖨; + #𔖩; + #𔖪; + #𔖫; + #𔖬; + #𔖭; + #𔖮; + #𔖯; + #𔖰; + #𔖱; + #𔖲; + #𔖳; + #𔖴; + #𔖵; + #𔖶; + #𔖷; + #𔖸; + #𔖹; + #𔖺; + #𔖻; + #𔖼; + #𔖽; + #𔖾; + #𔖿; + #𔗀; + #𔗁; + #𔗂; + #𔗃; + #𔗄; + #𔗅; + #𔗆; + #𔗇; + #𔗈; + #𔗉; + #𔗊; + #𔗋; + #𔗌; + #𔗍; + #𔗎; + #𔗏; + #𔗐; + #𔗑; + #𔗒; + #𔗓; + #𔗔; + #𔗕; + #𔗖; + #𔗗; + #𔗘; + #𔗙; + #𔗚; + #𔗛; + #𔗜; + #𔗝; + #𔗞; + #𔗟; + #𔗠; + #𔗡; + #𔗢; + #𔗣; + #𔗤; + #𔗥; + #𔗦; + #𔗧; + #𔗨; + #𔗩; + #𔗪; + #𔗫; + #𔗬; + #𔗭; + #𔗮; + #𔗯; + #𔗰; + #𔗱; + #𔗲; + #𔗳; + #𔗴; + #𔗵; + #𔗶; + #𔗷; + #𔗸; + #𔗹; + #𔗺; + #𔗻; + #𔗼; + #𔗽; + #𔗾; + #𔗿; + #𔘀; + #𔘁; + #𔘂; + #𔘃; + #𔘄; + #𔘅; + #𔘆; + #𔘇; + #𔘈; + #𔘉; + #𔘊; + #𔘋; + #𔘌; + #𔘍; + #𔘎; + #𔘏; + #𔘐; + #𔘑; + #𔘒; + #𔘓; + #𔘔; + #𔘕; + #𔘖; + #𔘗; + #𔘘; + #𔘙; + #𔘚; + #𔘛; + #𔘜; + #𔘝; + #𔘞; + #𔘟; + #𔘠; + #𔘡; + #𔘢; + #𔘣; + #𔘤; + #𔘥; + #𔘦; + #𔘧; + #𔘨; + #𔘩; + #𔘪; + #𔘫; + #𔘬; + #𔘭; + #𔘮; + #𔘯; + #𔘰; + #𔘱; + #𔘲; + #𔘳; + #𔘴; + #𔘵; + #𔘶; + #𔘷; + #𔘸; + #𔘹; + #𔘺; + #𔘻; + #𔘼; + #𔘽; + #𔘾; + #𔘿; + #𔙀; + #𔙁; + #𔙂; + #𔙃; + #𔙄; + #𔙅; + #𔙆; + #𫠠; + #𫠡; + #𫠢; + #𫠣; + #𫠤; + #𫠥; + #𫠦; + #𫠧; + #𫠨; + #𫠩; + #𫠪; + #𫠫; + #𫠬; + #𫠭; + #𫠮; + #𫠯; + #𫠰; + #𫠱; + #𫠲; + #𫠳; + #𫠴; + #𫠵; + #𫠶; + #𫠷; + #𫠸; + #𫠹; + #𫠺; + #𫠻; + #𫠼; + #𫠽; + #𫠾; + #𫠿; + #𫡀; + #𫡁; + #𫡂; + #𫡃; + #𫡄; + #𫡅; + #𫡆; + #𫡇; + #𫡈; + #𫡉; + #𫡊; + #𫡋; + #𫡌; + #𫡍; + #𫡎; + #𫡏; + #𫡐; + #𫡑; + #𫡒; + #𫡓; + #𫡔; + #𫡕; + #𫡖; + #𫡗; + #𫡘; + #𫡙; + #𫡚; + #𫡛; + #𫡜; + #𫡝; + #𫡞; + #𫡟; + #𫡠; + #𫡡; + #𫡢; + #𫡣; + #𫡤; + #𫡥; + #𫡦; + #𫡧; + #𫡨; + #𫡩; + #𫡪; + #𫡫; + #𫡬; + #𫡭; + #𫡮; + #𫡯; + #𫡰; + #𫡱; + #𫡲; + #𫡳; + #𫡴; + #𫡵; + #𫡶; + #𫡷; + #𫡸; + #𫡹; + #𫡺; + #𫡻; + #𫡼; + #𫡽; + #𫡾; + #𫡿; + #𫢀; + #𫢁; + #𫢂; + #𫢃; + #𫢄; + #𫢅; + #𫢆; + #𫢇; + #𫢈; + #𫢉; + #𫢊; + #𫢋; + #𫢌; + #𫢍; + #𫢎; + #𫢏; + #𫢐; + #𫢑; + #𫢒; + #𫢓; + #𫢔; + #𫢕; + #𫢖; + #𫢗; + #𫢘; + #𫢙; + #𫢚; + #𫢛; + #𫢜; + #𫢝; + #𫢞; + #𫢟; + #𫢠; + #𫢡; + #𫢢; + #𫢣; + #𫢤; + #𫢥; + #𫢦; + #𫢧; + #𫢨; + #𫢩; + #𫢪; + #𫢫; + #𫢬; + #𫢭; + #𫢮; + #𫢯; + #𫢰; + #𫢱; + #𫢲; + #𫢳; + #𫢴; + #𫢵; + #𫢶; + #𫢷; + #𫢸; + #𫢹; + #𫢺; + #𫢻; + #𫢼; + #𫢽; + #𫢾; + #𫢿; + #𫣀; + #𫣁; + #𫣂; + #𫣃; + #𫣄; + #𫣅; + #𫣆; + #𫣇; + #𫣈; + #𫣉; + #𫣊; + #𫣋; + #𫣌; + #𫣍; + #𫣎; + #𫣏; + #𫣐; + #𫣑; + #𫣒; + #𫣓; + #𫣔; + #𫣕; + #𫣖; + #𫣗; + #𫣘; + #𫣙; + #𫣚; + #𫣛; + #𫣜; + #𫣝; + #𫣞; + #𫣟; + #𫣠; + #𫣡; + #𫣢; + #𫣣; + #𫣤; + #𫣥; + #𫣦; + #𫣧; + #𫣨; + #𫣩; + #𫣪; + #𫣫; + #𫣬; + #𫣭; + #𫣮; + #𫣯; + #𫣰; + #𫣱; + #𫣲; + #𫣳; + #𫣴; + #𫣵; + #𫣶; + #𫣷; + #𫣸; + #𫣹; + #𫣺; + #𫣻; + #𫣼; + #𫣽; + #𫣾; + #𫣿; + #𫤀; + #𫤁; + #𫤂; + #𫤃; + #𫤄; + #𫤅; + #𫤆; + #𫤇; + #𫤈; + #𫤉; + #𫤊; + #𫤋; + #𫤌; + #𫤍; + #𫤎; + #𫤏; + #𫤐; + #𫤑; + #𫤒; + #𫤓; + #𫤔; + #𫤕; + #𫤖; + #𫤗; + #𫤘; + #𫤙; + #𫤚; + #𫤛; + #𫤜; + #𫤝; + #𫤞; + #𫤟; + #𫤠; + #𫤡; + #𫤢; + #𫤣; + #𫤤; + #𫤥; + #𫤦; + #𫤧; + #𫤨; + #𫤩; + #𫤪; + #𫤫; + #𫤬; + #𫤭; + #𫤮; + #𫤯; + #𫤰; + #𫤱; + #𫤲; + #𫤳; + #𫤴; + #𫤵; + #𫤶; + #𫤷; + #𫤸; + #𫤹; + #𫤺; + #𫤻; + #𫤼; + #𫤽; + #𫤾; + #𫤿; + #𫥀; + #𫥁; + #𫥂; + #𫥃; + #𫥄; + #𫥅; + #𫥆; + #𫥇; + #𫥈; + #𫥉; + #𫥊; + #𫥋; + #𫥌; + #𫥍; + #𫥎; + #𫥏; + #𫥐; + #𫥑; + #𫥒; + #𫥓; + #𫥔; + #𫥕; + #𫥖; + #𫥗; + #𫥘; + #𫥙; + #𫥚; + #𫥛; + #𫥜; + #𫥝; + #𫥞; + #𫥟; + #𫥠; + #𫥡; + #𫥢; + #𫥣; + #𫥤; + #𫥥; + #𫥦; + #𫥧; + #𫥨; + #𫥩; + #𫥪; + #𫥫; + #𫥬; + #𫥭; + #𫥮; + #𫥯; + #𫥰; + #𫥱; + #𫥲; + #𫥳; + #𫥴; + #𫥵; + #𫥶; + #𫥷; + #𫥸; + #𫥹; + #𫥺; + #𫥻; + #𫥼; + #𫥽; + #𫥾; + #𫥿; + #𫦀; + #𫦁; + #𫦂; + #𫦃; + #𫦄; + #𫦅; + #𫦆; + #𫦇; + #𫦈; + #𫦉; + #𫦊; + #𫦋; + #𫦌; + #𫦍; + #𫦎; + #𫦏; + #𫦐; + #𫦑; + #𫦒; + #𫦓; + #𫦔; + #𫦕; + #𫦖; + #𫦗; + #𫦘; + #𫦙; + #𫦚; + #𫦛; + #𫦜; + #𫦝; + #𫦞; + #𫦟; + #𫦠; + #𫦡; + #𫦢; + #𫦣; + #𫦤; + #𫦥; + #𫦦; + #𫦧; + #𫦨; + #𫦩; + #𫦪; + #𫦫; + #𫦬; + #𫦭; + #𫦮; + #𫦯; + #𫦰; + #𫦱; + #𫦲; + #𫦳; + #𫦴; + #𫦵; + #𫦶; + #𫦷; + #𫦸; + #𫦹; + #𫦺; + #𫦻; + #𫦼; + #𫦽; + #𫦾; + #𫦿; + #𫧀; + #𫧁; + #𫧂; + #𫧃; + #𫧄; + #𫧅; + #𫧆; + #𫧇; + #𫧈; + #𫧉; + #𫧊; + #𫧋; + #𫧌; + #𫧍; + #𫧎; + #𫧏; + #𫧐; + #𫧑; + #𫧒; + #𫧓; + #𫧔; + #𫧕; + #𫧖; + #𫧗; + #𫧘; + #𫧙; + #𫧚; + #𫧛; + #𫧜; + #𫧝; + #𫧞; + #𫧟; + #𫧠; + #𫧡; + #𫧢; + #𫧣; + #𫧤; + #𫧥; + #𫧦; + #𫧧; + #𫧨; + #𫧩; + #𫧪; + #𫧫; + #𫧬; + #𫧭; + #𫧮; + #𫧯; + #𫧰; + #𫧱; + #𫧲; + #𫧳; + #𫧴; + #𫧵; + #𫧶; + #𫧷; + #𫧸; + #𫧹; + #𫧺; + #𫧻; + #𫧼; + #𫧽; + #𫧾; + #𫧿; + #𫨀; + #𫨁; + #𫨂; + #𫨃; + #𫨄; + #𫨅; + #𫨆; + #𫨇; + #𫨈; + #𫨉; + #𫨊; + #𫨋; + #𫨌; + #𫨍; + #𫨎; + #𫨏; + #𫨐; + #𫨑; + #𫨒; + #𫨓; + #𫨔; + #𫨕; + #𫨖; + #𫨗; + #𫨘; + #𫨙; + #𫨚; + #𫨛; + #𫨜; + #𫨝; + #𫨞; + #𫨟; + #𫨠; + #𫨡; + #𫨢; + #𫨣; + #𫨤; + #𫨥; + #𫨦; + #𫨧; + #𫨨; + #𫨩; + #𫨪; + #𫨫; + #𫨬; + #𫨭; + #𫨮; + #𫨯; + #𫨰; + #𫨱; + #𫨲; + #𫨳; + #𫨴; + #𫨵; + #𫨶; + #𫨷; + #𫨸; + #𫨹; + #𫨺; + #𫨻; + #𫨼; + #𫨽; + #𫨾; + #𫨿; + #𫩀; + #𫩁; + #𫩂; + #𫩃; + #𫩄; + #𫩅; + #𫩆; + #𫩇; + #𫩈; + #𫩉; + #𫩊; + #𫩋; + #𫩌; + #𫩍; + #𫩎; + #𫩏; + #𫩐; + #𫩑; + #𫩒; + #𫩓; + #𫩔; + #𫩕; + #𫩖; + #𫩗; + #𫩘; + #𫩙; + #𫩚; + #𫩛; + #𫩜; + #𫩝; + #𫩞; + #𫩟; + #𫩠; + #𫩡; + #𫩢; + #𫩣; + #𫩤; + #𫩥; + #𫩦; + #𫩧; + #𫩨; + #𫩩; + #𫩪; + #𫩫; + #𫩬; + #𫩭; + #𫩮; + #𫩯; + #𫩰; + #𫩱; + #𫩲; + #𫩳; + #𫩴; + #𫩵; + #𫩶; + #𫩷; + #𫩸; + #𫩹; + #𫩺; + #𫩻; + #𫩼; + #𫩽; + #𫩾; + #𫩿; + #𫪀; + #𫪁; + #𫪂; + #𫪃; + #𫪄; + #𫪅; + #𫪆; + #𫪇; + #𫪈; + #𫪉; + #𫪊; + #𫪋; + #𫪌; + #𫪍; + #𫪎; + #𫪏; + #𫪐; + #𫪑; + #𫪒; + #𫪓; + #𫪔; + #𫪕; + #𫪖; + #𫪗; + #𫪘; + #𫪙; + #𫪚; + #𫪛; + #𫪜; + #𫪝; + #𫪞; + #𫪟; + #𫪠; + #𫪡; + #𫪢; + #𫪣; + #𫪤; + #𫪥; + #𫪦; + #𫪧; + #𫪨; + #𫪩; + #𫪪; + #𫪫; + #𫪬; + #𫪭; + #𫪮; + #𫪯; + #𫪰; + #𫪱; + #𫪲; + #𫪳; + #𫪴; + #𫪵; + #𫪶; + #𫪷; + #𫪸; + #𫪹; + #𫪺; + #𫪻; + #𫪼; + #𫪽; + #𫪾; + #𫪿; + #𫫀; + #𫫁; + #𫫂; + #𫫃; + #𫫄; + #𫫅; + #𫫆; + #𫫇; + #𫫈; + #𫫉; + #𫫊; + #𫫋; + #𫫌; + #𫫍; + #𫫎; + #𫫏; + #𫫐; + #𫫑; + #𫫒; + #𫫓; + #𫫔; + #𫫕; + #𫫖; + #𫫗; + #𫫘; + #𫫙; + #𫫚; + #𫫛; + #𫫜; + #𫫝; + #𫫞; + #𫫟; + #𫫠; + #𫫡; + #𫫢; + #𫫣; + #𫫤; + #𫫥; + #𫫦; + #𫫧; + #𫫨; + #𫫩; + #𫫪; + #𫫫; + #𫫬; + #𫫭; + #𫫮; + #𫫯; + #𫫰; + #𫫱; + #𫫲; + #𫫳; + #𫫴; + #𫫵; + #𫫶; + #𫫷; + #𫫸; + #𫫹; + #𫫺; + #𫫻; + #𫫼; + #𫫽; + #𫫾; + #𫫿; + #𫬀; + #𫬁; + #𫬂; + #𫬃; + #𫬄; + #𫬅; + #𫬆; + #𫬇; + #𫬈; + #𫬉; + #𫬊; + #𫬋; + #𫬌; + #𫬍; + #𫬎; + #𫬏; + #𫬐; + #𫬑; + #𫬒; + #𫬓; + #𫬔; + #𫬕; + #𫬖; + #𫬗; + #𫬘; + #𫬙; + #𫬚; + #𫬛; + #𫬜; + #𫬝; + #𫬞; + #𫬟; + #𫬠; + #𫬡; + #𫬢; + #𫬣; + #𫬤; + #𫬥; + #𫬦; + #𫬧; + #𫬨; + #𫬩; + #𫬪; + #𫬫; + #𫬬; + #𫬭; + #𫬮; + #𫬯; + #𫬰; + #𫬱; + #𫬲; + #𫬳; + #𫬴; + #𫬵; + #𫬶; + #𫬷; + #𫬸; + #𫬹; + #𫬺; + #𫬻; + #𫬼; + #𫬽; + #𫬾; + #𫬿; + #𫭀; + #𫭁; + #𫭂; + #𫭃; + #𫭄; + #𫭅; + #𫭆; + #𫭇; + #𫭈; + #𫭉; + #𫭊; + #𫭋; + #𫭌; + #𫭍; + #𫭎; + #𫭏; + #𫭐; + #𫭑; + #𫭒; + #𫭓; + #𫭔; + #𫭕; + #𫭖; + #𫭗; + #𫭘; + #𫭙; + #𫭚; + #𫭛; + #𫭜; + #𫭝; + #𫭞; + #𫭟; + #𫭠; + #𫭡; + #𫭢; + #𫭣; + #𫭤; + #𫭥; + #𫭦; + #𫭧; + #𫭨; + #𫭩; + #𫭪; + #𫭫; + #𫭬; + #𫭭; + #𫭮; + #𫭯; + #𫭰; + #𫭱; + #𫭲; + #𫭳; + #𫭴; + #𫭵; + #𫭶; + #𫭷; + #𫭸; + #𫭹; + #𫭺; + #𫭻; + #𫭼; + #𫭽; + #𫭾; + #𫭿; + #𫮀; + #𫮁; + #𫮂; + #𫮃; + #𫮄; + #𫮅; + #𫮆; + #𫮇; + #𫮈; + #𫮉; + #𫮊; + #𫮋; + #𫮌; + #𫮍; + #𫮎; + #𫮏; + #𫮐; + #𫮑; + #𫮒; + #𫮓; + #𫮔; + #𫮕; + #𫮖; + #𫮗; + #𫮘; + #𫮙; + #𫮚; + #𫮛; + #𫮜; + #𫮝; + #𫮞; + #𫮟; + #𫮠; + #𫮡; + #𫮢; + #𫮣; + #𫮤; + #𫮥; + #𫮦; + #𫮧; + #𫮨; + #𫮩; + #𫮪; + #𫮫; + #𫮬; + #𫮭; + #𫮮; + #𫮯; + #𫮰; + #𫮱; + #𫮲; + #𫮳; + #𫮴; + #𫮵; + #𫮶; + #𫮷; + #𫮸; + #𫮹; + #𫮺; + #𫮻; + #𫮼; + #𫮽; + #𫮾; + #𫮿; + #𫯀; + #𫯁; + #𫯂; + #𫯃; + #𫯄; + #𫯅; + #𫯆; + #𫯇; + #𫯈; + #𫯉; + #𫯊; + #𫯋; + #𫯌; + #𫯍; + #𫯎; + #𫯏; + #𫯐; + #𫯑; + #𫯒; + #𫯓; + #𫯔; + #𫯕; + #𫯖; + #𫯗; + #𫯘; + #𫯙; + #𫯚; + #𫯛; + #𫯜; + #𫯝; + #𫯞; + #𫯟; + #𫯠; + #𫯡; + #𫯢; + #𫯣; + #𫯤; + #𫯥; + #𫯦; + #𫯧; + #𫯨; + #𫯩; + #𫯪; + #𫯫; + #𫯬; + #𫯭; + #𫯮; + #𫯯; + #𫯰; + #𫯱; + #𫯲; + #𫯳; + #𫯴; + #𫯵; + #𫯶; + #𫯷; + #𫯸; + #𫯹; + #𫯺; + #𫯻; + #𫯼; + #𫯽; + #𫯾; + #𫯿; + #𫰀; + #𫰁; + #𫰂; + #𫰃; + #𫰄; + #𫰅; + #𫰆; + #𫰇; + #𫰈; + #𫰉; + #𫰊; + #𫰋; + #𫰌; + #𫰍; + #𫰎; + #𫰏; + #𫰐; + #𫰑; + #𫰒; + #𫰓; + #𫰔; + #𫰕; + #𫰖; + #𫰗; + #𫰘; + #𫰙; + #𫰚; + #𫰛; + #𫰜; + #𫰝; + #𫰞; + #𫰟; + #𫰠; + #𫰡; + #𫰢; + #𫰣; + #𫰤; + #𫰥; + #𫰦; + #𫰧; + #𫰨; + #𫰩; + #𫰪; + #𫰫; + #𫰬; + #𫰭; + #𫰮; + #𫰯; + #𫰰; + #𫰱; + #𫰲; + #𫰳; + #𫰴; + #𫰵; + #𫰶; + #𫰷; + #𫰸; + #𫰹; + #𫰺; + #𫰻; + #𫰼; + #𫰽; + #𫰾; + #𫰿; + #𫱀; + #𫱁; + #𫱂; + #𫱃; + #𫱄; + #𫱅; + #𫱆; + #𫱇; + #𫱈; + #𫱉; + #𫱊; + #𫱋; + #𫱌; + #𫱍; + #𫱎; + #𫱏; + #𫱐; + #𫱑; + #𫱒; + #𫱓; + #𫱔; + #𫱕; + #𫱖; + #𫱗; + #𫱘; + #𫱙; + #𫱚; + #𫱛; + #𫱜; + #𫱝; + #𫱞; + #𫱟; + #𫱠; + #𫱡; + #𫱢; + #𫱣; + #𫱤; + #𫱥; + #𫱦; + #𫱧; + #𫱨; + #𫱩; + #𫱪; + #𫱫; + #𫱬; + #𫱭; + #𫱮; + #𫱯; + #𫱰; + #𫱱; + #𫱲; + #𫱳; + #𫱴; + #𫱵; + #𫱶; + #𫱷; + #𫱸; + #𫱹; + #𫱺; + #𫱻; + #𫱼; + #𫱽; + #𫱾; + #𫱿; + #𫲀; + #𫲁; + #𫲂; + #𫲃; + #𫲄; + #𫲅; + #𫲆; + #𫲇; + #𫲈; + #𫲉; + #𫲊; + #𫲋; + #𫲌; + #𫲍; + #𫲎; + #𫲏; + #𫲐; + #𫲑; + #𫲒; + #𫲓; + #𫲔; + #𫲕; + #𫲖; + #𫲗; + #𫲘; + #𫲙; + #𫲚; + #𫲛; + #𫲜; + #𫲝; + #𫲞; + #𫲟; + #𫲠; + #𫲡; + #𫲢; + #𫲣; + #𫲤; + #𫲥; + #𫲦; + #𫲧; + #𫲨; + #𫲩; + #𫲪; + #𫲫; + #𫲬; + #𫲭; + #𫲮; + #𫲯; + #𫲰; + #𫲱; + #𫲲; + #𫲳; + #𫲴; + #𫲵; + #𫲶; + #𫲷; + #𫲸; + #𫲹; + #𫲺; + #𫲻; + #𫲼; + #𫲽; + #𫲾; + #𫲿; + #𫳀; + #𫳁; + #𫳂; + #𫳃; + #𫳄; + #𫳅; + #𫳆; + #𫳇; + #𫳈; + #𫳉; + #𫳊; + #𫳋; + #𫳌; + #𫳍; + #𫳎; + #𫳏; + #𫳐; + #𫳑; + #𫳒; + #𫳓; + #𫳔; + #𫳕; + #𫳖; + #𫳗; + #𫳘; + #𫳙; + #𫳚; + #𫳛; + #𫳜; + #𫳝; + #𫳞; + #𫳟; + #𫳠; + #𫳡; + #𫳢; + #𫳣; + #𫳤; + #𫳥; + #𫳦; + #𫳧; + #𫳨; + #𫳩; + #𫳪; + #𫳫; + #𫳬; + #𫳭; + #𫳮; + #𫳯; + #𫳰; + #𫳱; + #𫳲; + #𫳳; + #𫳴; + #𫳵; + #𫳶; + #𫳷; + #𫳸; + #𫳹; + #𫳺; + #𫳻; + #𫳼; + #𫳽; + #𫳾; + #𫳿; + #𫴀; + #𫴁; + #𫴂; + #𫴃; + #𫴄; + #𫴅; + #𫴆; + #𫴇; + #𫴈; + #𫴉; + #𫴊; + #𫴋; + #𫴌; + #𫴍; + #𫴎; + #𫴏; + #𫴐; + #𫴑; + #𫴒; + #𫴓; + #𫴔; + #𫴕; + #𫴖; + #𫴗; + #𫴘; + #𫴙; + #𫴚; + #𫴛; + #𫴜; + #𫴝; + #𫴞; + #𫴟; + #𫴠; + #𫴡; + #𫴢; + #𫴣; + #𫴤; + #𫴥; + #𫴦; + #𫴧; + #𫴨; + #𫴩; + #𫴪; + #𫴫; + #𫴬; + #𫴭; + #𫴮; + #𫴯; + #𫴰; + #𫴱; + #𫴲; + #𫴳; + #𫴴; + #𫴵; + #𫴶; + #𫴷; + #𫴸; + #𫴹; + #𫴺; + #𫴻; + #𫴼; + #𫴽; + #𫴾; + #𫴿; + #𫵀; + #𫵁; + #𫵂; + #𫵃; + #𫵄; + #𫵅; + #𫵆; + #𫵇; + #𫵈; + #𫵉; + #𫵊; + #𫵋; + #𫵌; + #𫵍; + #𫵎; + #𫵏; + #𫵐; + #𫵑; + #𫵒; + #𫵓; + #𫵔; + #𫵕; + #𫵖; + #𫵗; + #𫵘; + #𫵙; + #𫵚; + #𫵛; + #𫵜; + #𫵝; + #𫵞; + #𫵟; + #𫵠; + #𫵡; + #𫵢; + #𫵣; + #𫵤; + #𫵥; + #𫵦; + #𫵧; + #𫵨; + #𫵩; + #𫵪; + #𫵫; + #𫵬; + #𫵭; + #𫵮; + #𫵯; + #𫵰; + #𫵱; + #𫵲; + #𫵳; + #𫵴; + #𫵵; + #𫵶; + #𫵷; + #𫵸; + #𫵹; + #𫵺; + #𫵻; + #𫵼; + #𫵽; + #𫵾; + #𫵿; + #𫶀; + #𫶁; + #𫶂; + #𫶃; + #𫶄; + #𫶅; + #𫶆; + #𫶇; + #𫶈; + #𫶉; + #𫶊; + #𫶋; + #𫶌; + #𫶍; + #𫶎; + #𫶏; + #𫶐; + #𫶑; + #𫶒; + #𫶓; + #𫶔; + #𫶕; + #𫶖; + #𫶗; + #𫶘; + #𫶙; + #𫶚; + #𫶛; + #𫶜; + #𫶝; + #𫶞; + #𫶟; + #𫶠; + #𫶡; + #𫶢; + #𫶣; + #𫶤; + #𫶥; + #𫶦; + #𫶧; + #𫶨; + #𫶩; + #𫶪; + #𫶫; + #𫶬; + #𫶭; + #𫶮; + #𫶯; + #𫶰; + #𫶱; + #𫶲; + #𫶳; + #𫶴; + #𫶵; + #𫶶; + #𫶷; + #𫶸; + #𫶹; + #𫶺; + #𫶻; + #𫶼; + #𫶽; + #𫶾; + #𫶿; + #𫷀; + #𫷁; + #𫷂; + #𫷃; + #𫷄; + #𫷅; + #𫷆; + #𫷇; + #𫷈; + #𫷉; + #𫷊; + #𫷋; + #𫷌; + #𫷍; + #𫷎; + #𫷏; + #𫷐; + #𫷑; + #𫷒; + #𫷓; + #𫷔; + #𫷕; + #𫷖; + #𫷗; + #𫷘; + #𫷙; + #𫷚; + #𫷛; + #𫷜; + #𫷝; + #𫷞; + #𫷟; + #𫷠; + #𫷡; + #𫷢; + #𫷣; + #𫷤; + #𫷥; + #𫷦; + #𫷧; + #𫷨; + #𫷩; + #𫷪; + #𫷫; + #𫷬; + #𫷭; + #𫷮; + #𫷯; + #𫷰; + #𫷱; + #𫷲; + #𫷳; + #𫷴; + #𫷵; + #𫷶; + #𫷷; + #𫷸; + #𫷹; + #𫷺; + #𫷻; + #𫷼; + #𫷽; + #𫷾; + #𫷿; + #𫸀; + #𫸁; + #𫸂; + #𫸃; + #𫸄; + #𫸅; + #𫸆; + #𫸇; + #𫸈; + #𫸉; + #𫸊; + #𫸋; + #𫸌; + #𫸍; + #𫸎; + #𫸏; + #𫸐; + #𫸑; + #𫸒; + #𫸓; + #𫸔; + #𫸕; + #𫸖; + #𫸗; + #𫸘; + #𫸙; + #𫸚; + #𫸛; + #𫸜; + #𫸝; + #𫸞; + #𫸟; + #𫸠; + #𫸡; + #𫸢; + #𫸣; + #𫸤; + #𫸥; + #𫸦; + #𫸧; + #𫸨; + #𫸩; + #𫸪; + #𫸫; + #𫸬; + #𫸭; + #𫸮; + #𫸯; + #𫸰; + #𫸱; + #𫸲; + #𫸳; + #𫸴; + #𫸵; + #𫸶; + #𫸷; + #𫸸; + #𫸹; + #𫸺; + #𫸻; + #𫸼; + #𫸽; + #𫸾; + #𫸿; + #𫹀; + #𫹁; + #𫹂; + #𫹃; + #𫹄; + #𫹅; + #𫹆; + #𫹇; + #𫹈; + #𫹉; + #𫹊; + #𫹋; + #𫹌; + #𫹍; + #𫹎; + #𫹏; + #𫹐; + #𫹑; + #𫹒; + #𫹓; + #𫹔; + #𫹕; + #𫹖; + #𫹗; + #𫹘; + #𫹙; + #𫹚; + #𫹛; + #𫹜; + #𫹝; + #𫹞; + #𫹟; + #𫹠; + #𫹡; + #𫹢; + #𫹣; + #𫹤; + #𫹥; + #𫹦; + #𫹧; + #𫹨; + #𫹩; + #𫹪; + #𫹫; + #𫹬; + #𫹭; + #𫹮; + #𫹯; + #𫹰; + #𫹱; + #𫹲; + #𫹳; + #𫹴; + #𫹵; + #𫹶; + #𫹷; + #𫹸; + #𫹹; + #𫹺; + #𫹻; + #𫹼; + #𫹽; + #𫹾; + #𫹿; + #𫺀; + #𫺁; + #𫺂; + #𫺃; + #𫺄; + #𫺅; + #𫺆; + #𫺇; + #𫺈; + #𫺉; + #𫺊; + #𫺋; + #𫺌; + #𫺍; + #𫺎; + #𫺏; + #𫺐; + #𫺑; + #𫺒; + #𫺓; + #𫺔; + #𫺕; + #𫺖; + #𫺗; + #𫺘; + #𫺙; + #𫺚; + #𫺛; + #𫺜; + #𫺝; + #𫺞; + #𫺟; + #𫺠; + #𫺡; + #𫺢; + #𫺣; + #𫺤; + #𫺥; + #𫺦; + #𫺧; + #𫺨; + #𫺩; + #𫺪; + #𫺫; + #𫺬; + #𫺭; + #𫺮; + #𫺯; + #𫺰; + #𫺱; + #𫺲; + #𫺳; + #𫺴; + #𫺵; + #𫺶; + #𫺷; + #𫺸; + #𫺹; + #𫺺; + #𫺻; + #𫺼; + #𫺽; + #𫺾; + #𫺿; + #𫻀; + #𫻁; + #𫻂; + #𫻃; + #𫻄; + #𫻅; + #𫻆; + #𫻇; + #𫻈; + #𫻉; + #𫻊; + #𫻋; + #𫻌; + #𫻍; + #𫻎; + #𫻏; + #𫻐; + #𫻑; + #𫻒; + #𫻓; + #𫻔; + #𫻕; + #𫻖; + #𫻗; + #𫻘; + #𫻙; + #𫻚; + #𫻛; + #𫻜; + #𫻝; + #𫻞; + #𫻟; + #𫻠; + #𫻡; + #𫻢; + #𫻣; + #𫻤; + #𫻥; + #𫻦; + #𫻧; + #𫻨; + #𫻩; + #𫻪; + #𫻫; + #𫻬; + #𫻭; + #𫻮; + #𫻯; + #𫻰; + #𫻱; + #𫻲; + #𫻳; + #𫻴; + #𫻵; + #𫻶; + #𫻷; + #𫻸; + #𫻹; + #𫻺; + #𫻻; + #𫻼; + #𫻽; + #𫻾; + #𫻿; + #𫼀; + #𫼁; + #𫼂; + #𫼃; + #𫼄; + #𫼅; + #𫼆; + #𫼇; + #𫼈; + #𫼉; + #𫼊; + #𫼋; + #𫼌; + #𫼍; + #𫼎; + #𫼏; + #𫼐; + #𫼑; + #𫼒; + #𫼓; + #𫼔; + #𫼕; + #𫼖; + #𫼗; + #𫼘; + #𫼙; + #𫼚; + #𫼛; + #𫼜; + #𫼝; + #𫼞; + #𫼟; + #𫼠; + #𫼡; + #𫼢; + #𫼣; + #𫼤; + #𫼥; + #𫼦; + #𫼧; + #𫼨; + #𫼩; + #𫼪; + #𫼫; + #𫼬; + #𫼭; + #𫼮; + #𫼯; + #𫼰; + #𫼱; + #𫼲; + #𫼳; + #𫼴; + #𫼵; + #𫼶; + #𫼷; + #𫼸; + #𫼹; + #𫼺; + #𫼻; + #𫼼; + #𫼽; + #𫼾; + #𫼿; + #𫽀; + #𫽁; + #𫽂; + #𫽃; + #𫽄; + #𫽅; + #𫽆; + #𫽇; + #𫽈; + #𫽉; + #𫽊; + #𫽋; + #𫽌; + #𫽍; + #𫽎; + #𫽏; + #𫽐; + #𫽑; + #𫽒; + #𫽓; + #𫽔; + #𫽕; + #𫽖; + #𫽗; + #𫽘; + #𫽙; + #𫽚; + #𫽛; + #𫽜; + #𫽝; + #𫽞; + #𫽟; + #𫽠; + #𫽡; + #𫽢; + #𫽣; + #𫽤; + #𫽥; + #𫽦; + #𫽧; + #𫽨; + #𫽩; + #𫽪; + #𫽫; + #𫽬; + #𫽭; + #𫽮; + #𫽯; + #𫽰; + #𫽱; + #𫽲; + #𫽳; + #𫽴; + #𫽵; + #𫽶; + #𫽷; + #𫽸; + #𫽹; + #𫽺; + #𫽻; + #𫽼; + #𫽽; + #𫽾; + #𫽿; + #𫾀; + #𫾁; + #𫾂; + #𫾃; + #𫾄; + #𫾅; + #𫾆; + #𫾇; + #𫾈; + #𫾉; + #𫾊; + #𫾋; + #𫾌; + #𫾍; + #𫾎; + #𫾏; + #𫾐; + #𫾑; + #𫾒; + #𫾓; + #𫾔; + #𫾕; + #𫾖; + #𫾗; + #𫾘; + #𫾙; + #𫾚; + #𫾛; + #𫾜; + #𫾝; + #𫾞; + #𫾟; + #𫾠; + #𫾡; + #𫾢; + #𫾣; + #𫾤; + #𫾥; + #𫾦; + #𫾧; + #𫾨; + #𫾩; + #𫾪; + #𫾫; + #𫾬; + #𫾭; + #𫾮; + #𫾯; + #𫾰; + #𫾱; + #𫾲; + #𫾳; + #𫾴; + #𫾵; + #𫾶; + #𫾷; + #𫾸; + #𫾹; + #𫾺; + #𫾻; + #𫾼; + #𫾽; + #𫾾; + #𫾿; + #𫿀; + #𫿁; + #𫿂; + #𫿃; + #𫿄; + #𫿅; + #𫿆; + #𫿇; + #𫿈; + #𫿉; + #𫿊; + #𫿋; + #𫿌; + #𫿍; + #𫿎; + #𫿏; + #𫿐; + #𫿑; + #𫿒; + #𫿓; + #𫿔; + #𫿕; + #𫿖; + #𫿗; + #𫿘; + #𫿙; + #𫿚; + #𫿛; + #𫿜; + #𫿝; + #𫿞; + #𫿟; + #𫿠; + #𫿡; + #𫿢; + #𫿣; + #𫿤; + #𫿥; + #𫿦; + #𫿧; + #𫿨; + #𫿩; + #𫿪; + #𫿫; + #𫿬; + #𫿭; + #𫿮; + #𫿯; + #𫿰; + #𫿱; + #𫿲; + #𫿳; + #𫿴; + #𫿵; + #𫿶; + #𫿷; + #𫿸; + #𫿹; + #𫿺; + #𫿻; + #𫿼; + #𫿽; + #𫿾; + #𫿿; + #𬀀; + #𬀁; + #𬀂; + #𬀃; + #𬀄; + #𬀅; + #𬀆; + #𬀇; + #𬀈; + #𬀉; + #𬀊; + #𬀋; + #𬀌; + #𬀍; + #𬀎; + #𬀏; + #𬀐; + #𬀑; + #𬀒; + #𬀓; + #𬀔; + #𬀕; + #𬀖; + #𬀗; + #𬀘; + #𬀙; + #𬀚; + #𬀛; + #𬀜; + #𬀝; + #𬀞; + #𬀟; + #𬀠; + #𬀡; + #𬀢; + #𬀣; + #𬀤; + #𬀥; + #𬀦; + #𬀧; + #𬀨; + #𬀩; + #𬀪; + #𬀫; + #𬀬; + #𬀭; + #𬀮; + #𬀯; + #𬀰; + #𬀱; + #𬀲; + #𬀳; + #𬀴; + #𬀵; + #𬀶; + #𬀷; + #𬀸; + #𬀹; + #𬀺; + #𬀻; + #𬀼; + #𬀽; + #𬀾; + #𬀿; + #𬁀; + #𬁁; + #𬁂; + #𬁃; + #𬁄; + #𬁅; + #𬁆; + #𬁇; + #𬁈; + #𬁉; + #𬁊; + #𬁋; + #𬁌; + #𬁍; + #𬁎; + #𬁏; + #𬁐; + #𬁑; + #𬁒; + #𬁓; + #𬁔; + #𬁕; + #𬁖; + #𬁗; + #𬁘; + #𬁙; + #𬁚; + #𬁛; + #𬁜; + #𬁝; + #𬁞; + #𬁟; + #𬁠; + #𬁡; + #𬁢; + #𬁣; + #𬁤; + #𬁥; + #𬁦; + #𬁧; + #𬁨; + #𬁩; + #𬁪; + #𬁫; + #𬁬; + #𬁭; + #𬁮; + #𬁯; + #𬁰; + #𬁱; + #𬁲; + #𬁳; + #𬁴; + #𬁵; + #𬁶; + #𬁷; + #𬁸; + #𬁹; + #𬁺; + #𬁻; + #𬁼; + #𬁽; + #𬁾; + #𬁿; + #𬂀; + #𬂁; + #𬂂; + #𬂃; + #𬂄; + #𬂅; + #𬂆; + #𬂇; + #𬂈; + #𬂉; + #𬂊; + #𬂋; + #𬂌; + #𬂍; + #𬂎; + #𬂏; + #𬂐; + #𬂑; + #𬂒; + #𬂓; + #𬂔; + #𬂕; + #𬂖; + #𬂗; + #𬂘; + #𬂙; + #𬂚; + #𬂛; + #𬂜; + #𬂝; + #𬂞; + #𬂟; + #𬂠; + #𬂡; + #𬂢; + #𬂣; + #𬂤; + #𬂥; + #𬂦; + #𬂧; + #𬂨; + #𬂩; + #𬂪; + #𬂫; + #𬂬; + #𬂭; + #𬂮; + #𬂯; + #𬂰; + #𬂱; + #𬂲; + #𬂳; + #𬂴; + #𬂵; + #𬂶; + #𬂷; + #𬂸; + #𬂹; + #𬂺; + #𬂻; + #𬂼; + #𬂽; + #𬂾; + #𬂿; + #𬃀; + #𬃁; + #𬃂; + #𬃃; + #𬃄; + #𬃅; + #𬃆; + #𬃇; + #𬃈; + #𬃉; + #𬃊; + #𬃋; + #𬃌; + #𬃍; + #𬃎; + #𬃏; + #𬃐; + #𬃑; + #𬃒; + #𬃓; + #𬃔; + #𬃕; + #𬃖; + #𬃗; + #𬃘; + #𬃙; + #𬃚; + #𬃛; + #𬃜; + #𬃝; + #𬃞; + #𬃟; + #𬃠; + #𬃡; + #𬃢; + #𬃣; + #𬃤; + #𬃥; + #𬃦; + #𬃧; + #𬃨; + #𬃩; + #𬃪; + #𬃫; + #𬃬; + #𬃭; + #𬃮; + #𬃯; + #𬃰; + #𬃱; + #𬃲; + #𬃳; + #𬃴; + #𬃵; + #𬃶; + #𬃷; + #𬃸; + #𬃹; + #𬃺; + #𬃻; + #𬃼; + #𬃽; + #𬃾; + #𬃿; + #𬄀; + #𬄁; + #𬄂; + #𬄃; + #𬄄; + #𬄅; + #𬄆; + #𬄇; + #𬄈; + #𬄉; + #𬄊; + #𬄋; + #𬄌; + #𬄍; + #𬄎; + #𬄏; + #𬄐; + #𬄑; + #𬄒; + #𬄓; + #𬄔; + #𬄕; + #𬄖; + #𬄗; + #𬄘; + #𬄙; + #𬄚; + #𬄛; + #𬄜; + #𬄝; + #𬄞; + #𬄟; + #𬄠; + #𬄡; + #𬄢; + #𬄣; + #𬄤; + #𬄥; + #𬄦; + #𬄧; + #𬄨; + #𬄩; + #𬄪; + #𬄫; + #𬄬; + #𬄭; + #𬄮; + #𬄯; + #𬄰; + #𬄱; + #𬄲; + #𬄳; + #𬄴; + #𬄵; + #𬄶; + #𬄷; + #𬄸; + #𬄹; + #𬄺; + #𬄻; + #𬄼; + #𬄽; + #𬄾; + #𬄿; + #𬅀; + #𬅁; + #𬅂; + #𬅃; + #𬅄; + #𬅅; + #𬅆; + #𬅇; + #𬅈; + #𬅉; + #𬅊; + #𬅋; + #𬅌; + #𬅍; + #𬅎; + #𬅏; + #𬅐; + #𬅑; + #𬅒; + #𬅓; + #𬅔; + #𬅕; + #𬅖; + #𬅗; + #𬅘; + #𬅙; + #𬅚; + #𬅛; + #𬅜; + #𬅝; + #𬅞; + #𬅟; + #𬅠; + #𬅡; + #𬅢; + #𬅣; + #𬅤; + #𬅥; + #𬅦; + #𬅧; + #𬅨; + #𬅩; + #𬅪; + #𬅫; + #𬅬; + #𬅭; + #𬅮; + #𬅯; + #𬅰; + #𬅱; + #𬅲; + #𬅳; + #𬅴; + #𬅵; + #𬅶; + #𬅷; + #𬅸; + #𬅹; + #𬅺; + #𬅻; + #𬅼; + #𬅽; + #𬅾; + #𬅿; + #𬆀; + #𬆁; + #𬆂; + #𬆃; + #𬆄; + #𬆅; + #𬆆; + #𬆇; + #𬆈; + #𬆉; + #𬆊; + #𬆋; + #𬆌; + #𬆍; + #𬆎; + #𬆏; + #𬆐; + #𬆑; + #𬆒; + #𬆓; + #𬆔; + #𬆕; + #𬆖; + #𬆗; + #𬆘; + #𬆙; + #𬆚; + #𬆛; + #𬆜; + #𬆝; + #𬆞; + #𬆟; + #𬆠; + #𬆡; + #𬆢; + #𬆣; + #𬆤; + #𬆥; + #𬆦; + #𬆧; + #𬆨; + #𬆩; + #𬆪; + #𬆫; + #𬆬; + #𬆭; + #𬆮; + #𬆯; + #𬆰; + #𬆱; + #𬆲; + #𬆳; + #𬆴; + #𬆵; + #𬆶; + #𬆷; + #𬆸; + #𬆹; + #𬆺; + #𬆻; + #𬆼; + #𬆽; + #𬆾; + #𬆿; + #𬇀; + #𬇁; + #𬇂; + #𬇃; + #𬇄; + #𬇅; + #𬇆; + #𬇇; + #𬇈; + #𬇉; + #𬇊; + #𬇋; + #𬇌; + #𬇍; + #𬇎; + #𬇏; + #𬇐; + #𬇑; + #𬇒; + #𬇓; + #𬇔; + #𬇕; + #𬇖; + #𬇗; + #𬇘; + #𬇙; + #𬇚; + #𬇛; + #𬇜; + #𬇝; + #𬇞; + #𬇟; + #𬇠; + #𬇡; + #𬇢; + #𬇣; + #𬇤; + #𬇥; + #𬇦; + #𬇧; + #𬇨; + #𬇩; + #𬇪; + #𬇫; + #𬇬; + #𬇭; + #𬇮; + #𬇯; + #𬇰; + #𬇱; + #𬇲; + #𬇳; + #𬇴; + #𬇵; + #𬇶; + #𬇷; + #𬇸; + #𬇹; + #𬇺; + #𬇻; + #𬇼; + #𬇽; + #𬇾; + #𬇿; + #𬈀; + #𬈁; + #𬈂; + #𬈃; + #𬈄; + #𬈅; + #𬈆; + #𬈇; + #𬈈; + #𬈉; + #𬈊; + #𬈋; + #𬈌; + #𬈍; + #𬈎; + #𬈏; + #𬈐; + #𬈑; + #𬈒; + #𬈓; + #𬈔; + #𬈕; + #𬈖; + #𬈗; + #𬈘; + #𬈙; + #𬈚; + #𬈛; + #𬈜; + #𬈝; + #𬈞; + #𬈟; + #𬈠; + #𬈡; + #𬈢; + #𬈣; + #𬈤; + #𬈥; + #𬈦; + #𬈧; + #𬈨; + #𬈩; + #𬈪; + #𬈫; + #𬈬; + #𬈭; + #𬈮; + #𬈯; + #𬈰; + #𬈱; + #𬈲; + #𬈳; + #𬈴; + #𬈵; + #𬈶; + #𬈷; + #𬈸; + #𬈹; + #𬈺; + #𬈻; + #𬈼; + #𬈽; + #𬈾; + #𬈿; + #𬉀; + #𬉁; + #𬉂; + #𬉃; + #𬉄; + #𬉅; + #𬉆; + #𬉇; + #𬉈; + #𬉉; + #𬉊; + #𬉋; + #𬉌; + #𬉍; + #𬉎; + #𬉏; + #𬉐; + #𬉑; + #𬉒; + #𬉓; + #𬉔; + #𬉕; + #𬉖; + #𬉗; + #𬉘; + #𬉙; + #𬉚; + #𬉛; + #𬉜; + #𬉝; + #𬉞; + #𬉟; + #𬉠; + #𬉡; + #𬉢; + #𬉣; + #𬉤; + #𬉥; + #𬉦; + #𬉧; + #𬉨; + #𬉩; + #𬉪; + #𬉫; + #𬉬; + #𬉭; + #𬉮; + #𬉯; + #𬉰; + #𬉱; + #𬉲; + #𬉳; + #𬉴; + #𬉵; + #𬉶; + #𬉷; + #𬉸; + #𬉹; + #𬉺; + #𬉻; + #𬉼; + #𬉽; + #𬉾; + #𬉿; + #𬊀; + #𬊁; + #𬊂; + #𬊃; + #𬊄; + #𬊅; + #𬊆; + #𬊇; + #𬊈; + #𬊉; + #𬊊; + #𬊋; + #𬊌; + #𬊍; + #𬊎; + #𬊏; + #𬊐; + #𬊑; + #𬊒; + #𬊓; + #𬊔; + #𬊕; + #𬊖; + #𬊗; + #𬊘; + #𬊙; + #𬊚; + #𬊛; + #𬊜; + #𬊝; + #𬊞; + #𬊟; + #𬊠; + #𬊡; + #𬊢; + #𬊣; + #𬊤; + #𬊥; + #𬊦; + #𬊧; + #𬊨; + #𬊩; + #𬊪; + #𬊫; + #𬊬; + #𬊭; + #𬊮; + #𬊯; + #𬊰; + #𬊱; + #𬊲; + #𬊳; + #𬊴; + #𬊵; + #𬊶; + #𬊷; + #𬊸; + #𬊹; + #𬊺; + #𬊻; + #𬊼; + #𬊽; + #𬊾; + #𬊿; + #𬋀; + #𬋁; + #𬋂; + #𬋃; + #𬋄; + #𬋅; + #𬋆; + #𬋇; + #𬋈; + #𬋉; + #𬋊; + #𬋋; + #𬋌; + #𬋍; + #𬋎; + #𬋏; + #𬋐; + #𬋑; + #𬋒; + #𬋓; + #𬋔; + #𬋕; + #𬋖; + #𬋗; + #𬋘; + #𬋙; + #𬋚; + #𬋛; + #𬋜; + #𬋝; + #𬋞; + #𬋟; + #𬋠; + #𬋡; + #𬋢; + #𬋣; + #𬋤; + #𬋥; + #𬋦; + #𬋧; + #𬋨; + #𬋩; + #𬋪; + #𬋫; + #𬋬; + #𬋭; + #𬋮; + #𬋯; + #𬋰; + #𬋱; + #𬋲; + #𬋳; + #𬋴; + #𬋵; + #𬋶; + #𬋷; + #𬋸; + #𬋹; + #𬋺; + #𬋻; + #𬋼; + #𬋽; + #𬋾; + #𬋿; + #𬌀; + #𬌁; + #𬌂; + #𬌃; + #𬌄; + #𬌅; + #𬌆; + #𬌇; + #𬌈; + #𬌉; + #𬌊; + #𬌋; + #𬌌; + #𬌍; + #𬌎; + #𬌏; + #𬌐; + #𬌑; + #𬌒; + #𬌓; + #𬌔; + #𬌕; + #𬌖; + #𬌗; + #𬌘; + #𬌙; + #𬌚; + #𬌛; + #𬌜; + #𬌝; + #𬌞; + #𬌟; + #𬌠; + #𬌡; + #𬌢; + #𬌣; + #𬌤; + #𬌥; + #𬌦; + #𬌧; + #𬌨; + #𬌩; + #𬌪; + #𬌫; + #𬌬; + #𬌭; + #𬌮; + #𬌯; + #𬌰; + #𬌱; + #𬌲; + #𬌳; + #𬌴; + #𬌵; + #𬌶; + #𬌷; + #𬌸; + #𬌹; + #𬌺; + #𬌻; + #𬌼; + #𬌽; + #𬌾; + #𬌿; + #𬍀; + #𬍁; + #𬍂; + #𬍃; + #𬍄; + #𬍅; + #𬍆; + #𬍇; + #𬍈; + #𬍉; + #𬍊; + #𬍋; + #𬍌; + #𬍍; + #𬍎; + #𬍏; + #𬍐; + #𬍑; + #𬍒; + #𬍓; + #𬍔; + #𬍕; + #𬍖; + #𬍗; + #𬍘; + #𬍙; + #𬍚; + #𬍛; + #𬍜; + #𬍝; + #𬍞; + #𬍟; + #𬍠; + #𬍡; + #𬍢; + #𬍣; + #𬍤; + #𬍥; + #𬍦; + #𬍧; + #𬍨; + #𬍩; + #𬍪; + #𬍫; + #𬍬; + #𬍭; + #𬍮; + #𬍯; + #𬍰; + #𬍱; + #𬍲; + #𬍳; + #𬍴; + #𬍵; + #𬍶; + #𬍷; + #𬍸; + #𬍹; + #𬍺; + #𬍻; + #𬍼; + #𬍽; + #𬍾; + #𬍿; + #𬎀; + #𬎁; + #𬎂; + #𬎃; + #𬎄; + #𬎅; + #𬎆; + #𬎇; + #𬎈; + #𬎉; + #𬎊; + #𬎋; + #𬎌; + #𬎍; + #𬎎; + #𬎏; + #𬎐; + #𬎑; + #𬎒; + #𬎓; + #𬎔; + #𬎕; + #𬎖; + #𬎗; + #𬎘; + #𬎙; + #𬎚; + #𬎛; + #𬎜; + #𬎝; + #𬎞; + #𬎟; + #𬎠; + #𬎡; + #𬎢; + #𬎣; + #𬎤; + #𬎥; + #𬎦; + #𬎧; + #𬎨; + #𬎩; + #𬎪; + #𬎫; + #𬎬; + #𬎭; + #𬎮; + #𬎯; + #𬎰; + #𬎱; + #𬎲; + #𬎳; + #𬎴; + #𬎵; + #𬎶; + #𬎷; + #𬎸; + #𬎹; + #𬎺; + #𬎻; + #𬎼; + #𬎽; + #𬎾; + #𬎿; + #𬏀; + #𬏁; + #𬏂; + #𬏃; + #𬏄; + #𬏅; + #𬏆; + #𬏇; + #𬏈; + #𬏉; + #𬏊; + #𬏋; + #𬏌; + #𬏍; + #𬏎; + #𬏏; + #𬏐; + #𬏑; + #𬏒; + #𬏓; + #𬏔; + #𬏕; + #𬏖; + #𬏗; + #𬏘; + #𬏙; + #𬏚; + #𬏛; + #𬏜; + #𬏝; + #𬏞; + #𬏟; + #𬏠; + #𬏡; + #𬏢; + #𬏣; + #𬏤; + #𬏥; + #𬏦; + #𬏧; + #𬏨; + #𬏩; + #𬏪; + #𬏫; + #𬏬; + #𬏭; + #𬏮; + #𬏯; + #𬏰; + #𬏱; + #𬏲; + #𬏳; + #𬏴; + #𬏵; + #𬏶; + #𬏷; + #𬏸; + #𬏹; + #𬏺; + #𬏻; + #𬏼; + #𬏽; + #𬏾; + #𬏿; + #𬐀; + #𬐁; + #𬐂; + #𬐃; + #𬐄; + #𬐅; + #𬐆; + #𬐇; + #𬐈; + #𬐉; + #𬐊; + #𬐋; + #𬐌; + #𬐍; + #𬐎; + #𬐏; + #𬐐; + #𬐑; + #𬐒; + #𬐓; + #𬐔; + #𬐕; + #𬐖; + #𬐗; + #𬐘; + #𬐙; + #𬐚; + #𬐛; + #𬐜; + #𬐝; + #𬐞; + #𬐟; + #𬐠; + #𬐡; + #𬐢; + #𬐣; + #𬐤; + #𬐥; + #𬐦; + #𬐧; + #𬐨; + #𬐩; + #𬐪; + #𬐫; + #𬐬; + #𬐭; + #𬐮; + #𬐯; + #𬐰; + #𬐱; + #𬐲; + #𬐳; + #𬐴; + #𬐵; + #𬐶; + #𬐷; + #𬐸; + #𬐹; + #𬐺; + #𬐻; + #𬐼; + #𬐽; + #𬐾; + #𬐿; + #𬑀; + #𬑁; + #𬑂; + #𬑃; + #𬑄; + #𬑅; + #𬑆; + #𬑇; + #𬑈; + #𬑉; + #𬑊; + #𬑋; + #𬑌; + #𬑍; + #𬑎; + #𬑏; + #𬑐; + #𬑑; + #𬑒; + #𬑓; + #𬑔; + #𬑕; + #𬑖; + #𬑗; + #𬑘; + #𬑙; + #𬑚; + #𬑛; + #𬑜; + #𬑝; + #𬑞; + #𬑟; + #𬑠; + #𬑡; + #𬑢; + #𬑣; + #𬑤; + #𬑥; + #𬑦; + #𬑧; + #𬑨; + #𬑩; + #𬑪; + #𬑫; + #𬑬; + #𬑭; + #𬑮; + #𬑯; + #𬑰; + #𬑱; + #𬑲; + #𬑳; + #𬑴; + #𬑵; + #𬑶; + #𬑷; + #𬑸; + #𬑹; + #𬑺; + #𬑻; + #𬑼; + #𬑽; + #𬑾; + #𬑿; + #𬒀; + #𬒁; + #𬒂; + #𬒃; + #𬒄; + #𬒅; + #𬒆; + #𬒇; + #𬒈; + #𬒉; + #𬒊; + #𬒋; + #𬒌; + #𬒍; + #𬒎; + #𬒏; + #𬒐; + #𬒑; + #𬒒; + #𬒓; + #𬒔; + #𬒕; + #𬒖; + #𬒗; + #𬒘; + #𬒙; + #𬒚; + #𬒛; + #𬒜; + #𬒝; + #𬒞; + #𬒟; + #𬒠; + #𬒡; + #𬒢; + #𬒣; + #𬒤; + #𬒥; + #𬒦; + #𬒧; + #𬒨; + #𬒩; + #𬒪; + #𬒫; + #𬒬; + #𬒭; + #𬒮; + #𬒯; + #𬒰; + #𬒱; + #𬒲; + #𬒳; + #𬒴; + #𬒵; + #𬒶; + #𬒷; + #𬒸; + #𬒹; + #𬒺; + #𬒻; + #𬒼; + #𬒽; + #𬒾; + #𬒿; + #𬓀; + #𬓁; + #𬓂; + #𬓃; + #𬓄; + #𬓅; + #𬓆; + #𬓇; + #𬓈; + #𬓉; + #𬓊; + #𬓋; + #𬓌; + #𬓍; + #𬓎; + #𬓏; + #𬓐; + #𬓑; + #𬓒; + #𬓓; + #𬓔; + #𬓕; + #𬓖; + #𬓗; + #𬓘; + #𬓙; + #𬓚; + #𬓛; + #𬓜; + #𬓝; + #𬓞; + #𬓟; + #𬓠; + #𬓡; + #𬓢; + #𬓣; + #𬓤; + #𬓥; + #𬓦; + #𬓧; + #𬓨; + #𬓩; + #𬓪; + #𬓫; + #𬓬; + #𬓭; + #𬓮; + #𬓯; + #𬓰; + #𬓱; + #𬓲; + #𬓳; + #𬓴; + #𬓵; + #𬓶; + #𬓷; + #𬓸; + #𬓹; + #𬓺; + #𬓻; + #𬓼; + #𬓽; + #𬓾; + #𬓿; + #𬔀; + #𬔁; + #𬔂; + #𬔃; + #𬔄; + #𬔅; + #𬔆; + #𬔇; + #𬔈; + #𬔉; + #𬔊; + #𬔋; + #𬔌; + #𬔍; + #𬔎; + #𬔏; + #𬔐; + #𬔑; + #𬔒; + #𬔓; + #𬔔; + #𬔕; + #𬔖; + #𬔗; + #𬔘; + #𬔙; + #𬔚; + #𬔛; + #𬔜; + #𬔝; + #𬔞; + #𬔟; + #𬔠; + #𬔡; + #𬔢; + #𬔣; + #𬔤; + #𬔥; + #𬔦; + #𬔧; + #𬔨; + #𬔩; + #𬔪; + #𬔫; + #𬔬; + #𬔭; + #𬔮; + #𬔯; + #𬔰; + #𬔱; + #𬔲; + #𬔳; + #𬔴; + #𬔵; + #𬔶; + #𬔷; + #𬔸; + #𬔹; + #𬔺; + #𬔻; + #𬔼; + #𬔽; + #𬔾; + #𬔿; + #𬕀; + #𬕁; + #𬕂; + #𬕃; + #𬕄; + #𬕅; + #𬕆; + #𬕇; + #𬕈; + #𬕉; + #𬕊; + #𬕋; + #𬕌; + #𬕍; + #𬕎; + #𬕏; + #𬕐; + #𬕑; + #𬕒; + #𬕓; + #𬕔; + #𬕕; + #𬕖; + #𬕗; + #𬕘; + #𬕙; + #𬕚; + #𬕛; + #𬕜; + #𬕝; + #𬕞; + #𬕟; + #𬕠; + #𬕡; + #𬕢; + #𬕣; + #𬕤; + #𬕥; + #𬕦; + #𬕧; + #𬕨; + #𬕩; + #𬕪; + #𬕫; + #𬕬; + #𬕭; + #𬕮; + #𬕯; + #𬕰; + #𬕱; + #𬕲; + #𬕳; + #𬕴; + #𬕵; + #𬕶; + #𬕷; + #𬕸; + #𬕹; + #𬕺; + #𬕻; + #𬕼; + #𬕽; + #𬕾; + #𬕿; + #𬖀; + #𬖁; + #𬖂; + #𬖃; + #𬖄; + #𬖅; + #𬖆; + #𬖇; + #𬖈; + #𬖉; + #𬖊; + #𬖋; + #𬖌; + #𬖍; + #𬖎; + #𬖏; + #𬖐; + #𬖑; + #𬖒; + #𬖓; + #𬖔; + #𬖕; + #𬖖; + #𬖗; + #𬖘; + #𬖙; + #𬖚; + #𬖛; + #𬖜; + #𬖝; + #𬖞; + #𬖟; + #𬖠; + #𬖡; + #𬖢; + #𬖣; + #𬖤; + #𬖥; + #𬖦; + #𬖧; + #𬖨; + #𬖩; + #𬖪; + #𬖫; + #𬖬; + #𬖭; + #𬖮; + #𬖯; + #𬖰; + #𬖱; + #𬖲; + #𬖳; + #𬖴; + #𬖵; + #𬖶; + #𬖷; + #𬖸; + #𬖹; + #𬖺; + #𬖻; + #𬖼; + #𬖽; + #𬖾; + #𬖿; + #𬗀; + #𬗁; + #𬗂; + #𬗃; + #𬗄; + #𬗅; + #𬗆; + #𬗇; + #𬗈; + #𬗉; + #𬗊; + #𬗋; + #𬗌; + #𬗍; + #𬗎; + #𬗏; + #𬗐; + #𬗑; + #𬗒; + #𬗓; + #𬗔; + #𬗕; + #𬗖; + #𬗗; + #𬗘; + #𬗙; + #𬗚; + #𬗛; + #𬗜; + #𬗝; + #𬗞; + #𬗟; + #𬗠; + #𬗡; + #𬗢; + #𬗣; + #𬗤; + #𬗥; + #𬗦; + #𬗧; + #𬗨; + #𬗩; + #𬗪; + #𬗫; + #𬗬; + #𬗭; + #𬗮; + #𬗯; + #𬗰; + #𬗱; + #𬗲; + #𬗳; + #𬗴; + #𬗵; + #𬗶; + #𬗷; + #𬗸; + #𬗹; + #𬗺; + #𬗻; + #𬗼; + #𬗽; + #𬗾; + #𬗿; + #𬘀; + #𬘁; + #𬘂; + #𬘃; + #𬘄; + #𬘅; + #𬘆; + #𬘇; + #𬘈; + #𬘉; + #𬘊; + #𬘋; + #𬘌; + #𬘍; + #𬘎; + #𬘏; + #𬘐; + #𬘑; + #𬘒; + #𬘓; + #𬘔; + #𬘕; + #𬘖; + #𬘗; + #𬘘; + #𬘙; + #𬘚; + #𬘛; + #𬘜; + #𬘝; + #𬘞; + #𬘟; + #𬘠; + #𬘡; + #𬘢; + #𬘣; + #𬘤; + #𬘥; + #𬘦; + #𬘧; + #𬘨; + #𬘩; + #𬘪; + #𬘫; + #𬘬; + #𬘭; + #𬘮; + #𬘯; + #𬘰; + #𬘱; + #𬘲; + #𬘳; + #𬘴; + #𬘵; + #𬘶; + #𬘷; + #𬘸; + #𬘹; + #𬘺; + #𬘻; + #𬘼; + #𬘽; + #𬘾; + #𬘿; + #𬙀; + #𬙁; + #𬙂; + #𬙃; + #𬙄; + #𬙅; + #𬙆; + #𬙇; + #𬙈; + #𬙉; + #𬙊; + #𬙋; + #𬙌; + #𬙍; + #𬙎; + #𬙏; + #𬙐; + #𬙑; + #𬙒; + #𬙓; + #𬙔; + #𬙕; + #𬙖; + #𬙗; + #𬙘; + #𬙙; + #𬙚; + #𬙛; + #𬙜; + #𬙝; + #𬙞; + #𬙟; + #𬙠; + #𬙡; + #𬙢; + #𬙣; + #𬙤; + #𬙥; + #𬙦; + #𬙧; + #𬙨; + #𬙩; + #𬙪; + #𬙫; + #𬙬; + #𬙭; + #𬙮; + #𬙯; + #𬙰; + #𬙱; + #𬙲; + #𬙳; + #𬙴; + #𬙵; + #𬙶; + #𬙷; + #𬙸; + #𬙹; + #𬙺; + #𬙻; + #𬙼; + #𬙽; + #𬙾; + #𬙿; + #𬚀; + #𬚁; + #𬚂; + #𬚃; + #𬚄; + #𬚅; + #𬚆; + #𬚇; + #𬚈; + #𬚉; + #𬚊; + #𬚋; + #𬚌; + #𬚍; + #𬚎; + #𬚏; + #𬚐; + #𬚑; + #𬚒; + #𬚓; + #𬚔; + #𬚕; + #𬚖; + #𬚗; + #𬚘; + #𬚙; + #𬚚; + #𬚛; + #𬚜; + #𬚝; + #𬚞; + #𬚟; + #𬚠; + #𬚡; + #𬚢; + #𬚣; + #𬚤; + #𬚥; + #𬚦; + #𬚧; + #𬚨; + #𬚩; + #𬚪; + #𬚫; + #𬚬; + #𬚭; + #𬚮; + #𬚯; + #𬚰; + #𬚱; + #𬚲; + #𬚳; + #𬚴; + #𬚵; + #𬚶; + #𬚷; + #𬚸; + #𬚹; + #𬚺; + #𬚻; + #𬚼; + #𬚽; + #𬚾; + #𬚿; + #𬛀; + #𬛁; + #𬛂; + #𬛃; + #𬛄; + #𬛅; + #𬛆; + #𬛇; + #𬛈; + #𬛉; + #𬛊; + #𬛋; + #𬛌; + #𬛍; + #𬛎; + #𬛏; + #𬛐; + #𬛑; + #𬛒; + #𬛓; + #𬛔; + #𬛕; + #𬛖; + #𬛗; + #𬛘; + #𬛙; + #𬛚; + #𬛛; + #𬛜; + #𬛝; + #𬛞; + #𬛟; + #𬛠; + #𬛡; + #𬛢; + #𬛣; + #𬛤; + #𬛥; + #𬛦; + #𬛧; + #𬛨; + #𬛩; + #𬛪; + #𬛫; + #𬛬; + #𬛭; + #𬛮; + #𬛯; + #𬛰; + #𬛱; + #𬛲; + #𬛳; + #𬛴; + #𬛵; + #𬛶; + #𬛷; + #𬛸; + #𬛹; + #𬛺; + #𬛻; + #𬛼; + #𬛽; + #𬛾; + #𬛿; + #𬜀; + #𬜁; + #𬜂; + #𬜃; + #𬜄; + #𬜅; + #𬜆; + #𬜇; + #𬜈; + #𬜉; + #𬜊; + #𬜋; + #𬜌; + #𬜍; + #𬜎; + #𬜏; + #𬜐; + #𬜑; + #𬜒; + #𬜓; + #𬜔; + #𬜕; + #𬜖; + #𬜗; + #𬜘; + #𬜙; + #𬜚; + #𬜛; + #𬜜; + #𬜝; + #𬜞; + #𬜟; + #𬜠; + #𬜡; + #𬜢; + #𬜣; + #𬜤; + #𬜥; + #𬜦; + #𬜧; + #𬜨; + #𬜩; + #𬜪; + #𬜫; + #𬜬; + #𬜭; + #𬜮; + #𬜯; + #𬜰; + #𬜱; + #𬜲; + #𬜳; + #𬜴; + #𬜵; + #𬜶; + #𬜷; + #𬜸; + #𬜹; + #𬜺; + #𬜻; + #𬜼; + #𬜽; + #𬜾; + #𬜿; + #𬝀; + #𬝁; + #𬝂; + #𬝃; + #𬝄; + #𬝅; + #𬝆; + #𬝇; + #𬝈; + #𬝉; + #𬝊; + #𬝋; + #𬝌; + #𬝍; + #𬝎; + #𬝏; + #𬝐; + #𬝑; + #𬝒; + #𬝓; + #𬝔; + #𬝕; + #𬝖; + #𬝗; + #𬝘; + #𬝙; + #𬝚; + #𬝛; + #𬝜; + #𬝝; + #𬝞; + #𬝟; + #𬝠; + #𬝡; + #𬝢; + #𬝣; + #𬝤; + #𬝥; + #𬝦; + #𬝧; + #𬝨; + #𬝩; + #𬝪; + #𬝫; + #𬝬; + #𬝭; + #𬝮; + #𬝯; + #𬝰; + #𬝱; + #𬝲; + #𬝳; + #𬝴; + #𬝵; + #𬝶; + #𬝷; + #𬝸; + #𬝹; + #𬝺; + #𬝻; + #𬝼; + #𬝽; + #𬝾; + #𬝿; + #𬞀; + #𬞁; + #𬞂; + #𬞃; + #𬞄; + #𬞅; + #𬞆; + #𬞇; + #𬞈; + #𬞉; + #𬞊; + #𬞋; + #𬞌; + #𬞍; + #𬞎; + #𬞏; + #𬞐; + #𬞑; + #𬞒; + #𬞓; + #𬞔; + #𬞕; + #𬞖; + #𬞗; + #𬞘; + #𬞙; + #𬞚; + #𬞛; + #𬞜; + #𬞝; + #𬞞; + #𬞟; + #𬞠; + #𬞡; + #𬞢; + #𬞣; + #𬞤; + #𬞥; + #𬞦; + #𬞧; + #𬞨; + #𬞩; + #𬞪; + #𬞫; + #𬞬; + #𬞭; + #𬞮; + #𬞯; + #𬞰; + #𬞱; + #𬞲; + #𬞳; + #𬞴; + #𬞵; + #𬞶; + #𬞷; + #𬞸; + #𬞹; + #𬞺; + #𬞻; + #𬞼; + #𬞽; + #𬞾; + #𬞿; + #𬟀; + #𬟁; + #𬟂; + #𬟃; + #𬟄; + #𬟅; + #𬟆; + #𬟇; + #𬟈; + #𬟉; + #𬟊; + #𬟋; + #𬟌; + #𬟍; + #𬟎; + #𬟏; + #𬟐; + #𬟑; + #𬟒; + #𬟓; + #𬟔; + #𬟕; + #𬟖; + #𬟗; + #𬟘; + #𬟙; + #𬟚; + #𬟛; + #𬟜; + #𬟝; + #𬟞; + #𬟟; + #𬟠; + #𬟡; + #𬟢; + #𬟣; + #𬟤; + #𬟥; + #𬟦; + #𬟧; + #𬟨; + #𬟩; + #𬟪; + #𬟫; + #𬟬; + #𬟭; + #𬟮; + #𬟯; + #𬟰; + #𬟱; + #𬟲; + #𬟳; + #𬟴; + #𬟵; + #𬟶; + #𬟷; + #𬟸; + #𬟹; + #𬟺; + #𬟻; + #𬟼; + #𬟽; + #𬟾; + #𬟿; + #𬠀; + #𬠁; + #𬠂; + #𬠃; + #𬠄; + #𬠅; + #𬠆; + #𬠇; + #𬠈; + #𬠉; + #𬠊; + #𬠋; + #𬠌; + #𬠍; + #𬠎; + #𬠏; + #𬠐; + #𬠑; + #𬠒; + #𬠓; + #𬠔; + #𬠕; + #𬠖; + #𬠗; + #𬠘; + #𬠙; + #𬠚; + #𬠛; + #𬠜; + #𬠝; + #𬠞; + #𬠟; + #𬠠; + #𬠡; + #𬠢; + #𬠣; + #𬠤; + #𬠥; + #𬠦; + #𬠧; + #𬠨; + #𬠩; + #𬠪; + #𬠫; + #𬠬; + #𬠭; + #𬠮; + #𬠯; + #𬠰; + #𬠱; + #𬠲; + #𬠳; + #𬠴; + #𬠵; + #𬠶; + #𬠷; + #𬠸; + #𬠹; + #𬠺; + #𬠻; + #𬠼; + #𬠽; + #𬠾; + #𬠿; + #𬡀; + #𬡁; + #𬡂; + #𬡃; + #𬡄; + #𬡅; + #𬡆; + #𬡇; + #𬡈; + #𬡉; + #𬡊; + #𬡋; + #𬡌; + #𬡍; + #𬡎; + #𬡏; + #𬡐; + #𬡑; + #𬡒; + #𬡓; + #𬡔; + #𬡕; + #𬡖; + #𬡗; + #𬡘; + #𬡙; + #𬡚; + #𬡛; + #𬡜; + #𬡝; + #𬡞; + #𬡟; + #𬡠; + #𬡡; + #𬡢; + #𬡣; + #𬡤; + #𬡥; + #𬡦; + #𬡧; + #𬡨; + #𬡩; + #𬡪; + #𬡫; + #𬡬; + #𬡭; + #𬡮; + #𬡯; + #𬡰; + #𬡱; + #𬡲; + #𬡳; + #𬡴; + #𬡵; + #𬡶; + #𬡷; + #𬡸; + #𬡹; + #𬡺; + #𬡻; + #𬡼; + #𬡽; + #𬡾; + #𬡿; + #𬢀; + #𬢁; + #𬢂; + #𬢃; + #𬢄; + #𬢅; + #𬢆; + #𬢇; + #𬢈; + #𬢉; + #𬢊; + #𬢋; + #𬢌; + #𬢍; + #𬢎; + #𬢏; + #𬢐; + #𬢑; + #𬢒; + #𬢓; + #𬢔; + #𬢕; + #𬢖; + #𬢗; + #𬢘; + #𬢙; + #𬢚; + #𬢛; + #𬢜; + #𬢝; + #𬢞; + #𬢟; + #𬢠; + #𬢡; + #𬢢; + #𬢣; + #𬢤; + #𬢥; + #𬢦; + #𬢧; + #𬢨; + #𬢩; + #𬢪; + #𬢫; + #𬢬; + #𬢭; + #𬢮; + #𬢯; + #𬢰; + #𬢱; + #𬢲; + #𬢳; + #𬢴; + #𬢵; + #𬢶; + #𬢷; + #𬢸; + #𬢹; + #𬢺; + #𬢻; + #𬢼; + #𬢽; + #𬢾; + #𬢿; + #𬣀; + #𬣁; + #𬣂; + #𬣃; + #𬣄; + #𬣅; + #𬣆; + #𬣇; + #𬣈; + #𬣉; + #𬣊; + #𬣋; + #𬣌; + #𬣍; + #𬣎; + #𬣏; + #𬣐; + #𬣑; + #𬣒; + #𬣓; + #𬣔; + #𬣕; + #𬣖; + #𬣗; + #𬣘; + #𬣙; + #𬣚; + #𬣛; + #𬣜; + #𬣝; + #𬣞; + #𬣟; + #𬣠; + #𬣡; + #𬣢; + #𬣣; + #𬣤; + #𬣥; + #𬣦; + #𬣧; + #𬣨; + #𬣩; + #𬣪; + #𬣫; + #𬣬; + #𬣭; + #𬣮; + #𬣯; + #𬣰; + #𬣱; + #𬣲; + #𬣳; + #𬣴; + #𬣵; + #𬣶; + #𬣷; + #𬣸; + #𬣹; + #𬣺; + #𬣻; + #𬣼; + #𬣽; + #𬣾; + #𬣿; + #𬤀; + #𬤁; + #𬤂; + #𬤃; + #𬤄; + #𬤅; + #𬤆; + #𬤇; + #𬤈; + #𬤉; + #𬤊; + #𬤋; + #𬤌; + #𬤍; + #𬤎; + #𬤏; + #𬤐; + #𬤑; + #𬤒; + #𬤓; + #𬤔; + #𬤕; + #𬤖; + #𬤗; + #𬤘; + #𬤙; + #𬤚; + #𬤛; + #𬤜; + #𬤝; + #𬤞; + #𬤟; + #𬤠; + #𬤡; + #𬤢; + #𬤣; + #𬤤; + #𬤥; + #𬤦; + #𬤧; + #𬤨; + #𬤩; + #𬤪; + #𬤫; + #𬤬; + #𬤭; + #𬤮; + #𬤯; + #𬤰; + #𬤱; + #𬤲; + #𬤳; + #𬤴; + #𬤵; + #𬤶; + #𬤷; + #𬤸; + #𬤹; + #𬤺; + #𬤻; + #𬤼; + #𬤽; + #𬤾; + #𬤿; + #𬥀; + #𬥁; + #𬥂; + #𬥃; + #𬥄; + #𬥅; + #𬥆; + #𬥇; + #𬥈; + #𬥉; + #𬥊; + #𬥋; + #𬥌; + #𬥍; + #𬥎; + #𬥏; + #𬥐; + #𬥑; + #𬥒; + #𬥓; + #𬥔; + #𬥕; + #𬥖; + #𬥗; + #𬥘; + #𬥙; + #𬥚; + #𬥛; + #𬥜; + #𬥝; + #𬥞; + #𬥟; + #𬥠; + #𬥡; + #𬥢; + #𬥣; + #𬥤; + #𬥥; + #𬥦; + #𬥧; + #𬥨; + #𬥩; + #𬥪; + #𬥫; + #𬥬; + #𬥭; + #𬥮; + #𬥯; + #𬥰; + #𬥱; + #𬥲; + #𬥳; + #𬥴; + #𬥵; + #𬥶; + #𬥷; + #𬥸; + #𬥹; + #𬥺; + #𬥻; + #𬥼; + #𬥽; + #𬥾; + #𬥿; + #𬦀; + #𬦁; + #𬦂; + #𬦃; + #𬦄; + #𬦅; + #𬦆; + #𬦇; + #𬦈; + #𬦉; + #𬦊; + #𬦋; + #𬦌; + #𬦍; + #𬦎; + #𬦏; + #𬦐; + #𬦑; + #𬦒; + #𬦓; + #𬦔; + #𬦕; + #𬦖; + #𬦗; + #𬦘; + #𬦙; + #𬦚; + #𬦛; + #𬦜; + #𬦝; + #𬦞; + #𬦟; + #𬦠; + #𬦡; + #𬦢; + #𬦣; + #𬦤; + #𬦥; + #𬦦; + #𬦧; + #𬦨; + #𬦩; + #𬦪; + #𬦫; + #𬦬; + #𬦭; + #𬦮; + #𬦯; + #𬦰; + #𬦱; + #𬦲; + #𬦳; + #𬦴; + #𬦵; + #𬦶; + #𬦷; + #𬦸; + #𬦹; + #𬦺; + #𬦻; + #𬦼; + #𬦽; + #𬦾; + #𬦿; + #𬧀; + #𬧁; + #𬧂; + #𬧃; + #𬧄; + #𬧅; + #𬧆; + #𬧇; + #𬧈; + #𬧉; + #𬧊; + #𬧋; + #𬧌; + #𬧍; + #𬧎; + #𬧏; + #𬧐; + #𬧑; + #𬧒; + #𬧓; + #𬧔; + #𬧕; + #𬧖; + #𬧗; + #𬧘; + #𬧙; + #𬧚; + #𬧛; + #𬧜; + #𬧝; + #𬧞; + #𬧟; + #𬧠; + #𬧡; + #𬧢; + #𬧣; + #𬧤; + #𬧥; + #𬧦; + #𬧧; + #𬧨; + #𬧩; + #𬧪; + #𬧫; + #𬧬; + #𬧭; + #𬧮; + #𬧯; + #𬧰; + #𬧱; + #𬧲; + #𬧳; + #𬧴; + #𬧵; + #𬧶; + #𬧷; + #𬧸; + #𬧹; + #𬧺; + #𬧻; + #𬧼; + #𬧽; + #𬧾; + #𬧿; + #𬨀; + #𬨁; + #𬨂; + #𬨃; + #𬨄; + #𬨅; + #𬨆; + #𬨇; + #𬨈; + #𬨉; + #𬨊; + #𬨋; + #𬨌; + #𬨍; + #𬨎; + #𬨏; + #𬨐; + #𬨑; + #𬨒; + #𬨓; + #𬨔; + #𬨕; + #𬨖; + #𬨗; + #𬨘; + #𬨙; + #𬨚; + #𬨛; + #𬨜; + #𬨝; + #𬨞; + #𬨟; + #𬨠; + #𬨡; + #𬨢; + #𬨣; + #𬨤; + #𬨥; + #𬨦; + #𬨧; + #𬨨; + #𬨩; + #𬨪; + #𬨫; + #𬨬; + #𬨭; + #𬨮; + #𬨯; + #𬨰; + #𬨱; + #𬨲; + #𬨳; + #𬨴; + #𬨵; + #𬨶; + #𬨷; + #𬨸; + #𬨹; + #𬨺; + #𬨻; + #𬨼; + #𬨽; + #𬨾; + #𬨿; + #𬩀; + #𬩁; + #𬩂; + #𬩃; + #𬩄; + #𬩅; + #𬩆; + #𬩇; + #𬩈; + #𬩉; + #𬩊; + #𬩋; + #𬩌; + #𬩍; + #𬩎; + #𬩏; + #𬩐; + #𬩑; + #𬩒; + #𬩓; + #𬩔; + #𬩕; + #𬩖; + #𬩗; + #𬩘; + #𬩙; + #𬩚; + #𬩛; + #𬩜; + #𬩝; + #𬩞; + #𬩟; + #𬩠; + #𬩡; + #𬩢; + #𬩣; + #𬩤; + #𬩥; + #𬩦; + #𬩧; + #𬩨; + #𬩩; + #𬩪; + #𬩫; + #𬩬; + #𬩭; + #𬩮; + #𬩯; + #𬩰; + #𬩱; + #𬩲; + #𬩳; + #𬩴; + #𬩵; + #𬩶; + #𬩷; + #𬩸; + #𬩹; + #𬩺; + #𬩻; + #𬩼; + #𬩽; + #𬩾; + #𬩿; + #𬪀; + #𬪁; + #𬪂; + #𬪃; + #𬪄; + #𬪅; + #𬪆; + #𬪇; + #𬪈; + #𬪉; + #𬪊; + #𬪋; + #𬪌; + #𬪍; + #𬪎; + #𬪏; + #𬪐; + #𬪑; + #𬪒; + #𬪓; + #𬪔; + #𬪕; + #𬪖; + #𬪗; + #𬪘; + #𬪙; + #𬪚; + #𬪛; + #𬪜; + #𬪝; + #𬪞; + #𬪟; + #𬪠; + #𬪡; + #𬪢; + #𬪣; + #𬪤; + #𬪥; + #𬪦; + #𬪧; + #𬪨; + #𬪩; + #𬪪; + #𬪫; + #𬪬; + #𬪭; + #𬪮; + #𬪯; + #𬪰; + #𬪱; + #𬪲; + #𬪳; + #𬪴; + #𬪵; + #𬪶; + #𬪷; + #𬪸; + #𬪹; + #𬪺; + #𬪻; + #𬪼; + #𬪽; + #𬪾; + #𬪿; + #𬫀; + #𬫁; + #𬫂; + #𬫃; + #𬫄; + #𬫅; + #𬫆; + #𬫇; + #𬫈; + #𬫉; + #𬫊; + #𬫋; + #𬫌; + #𬫍; + #𬫎; + #𬫏; + #𬫐; + #𬫑; + #𬫒; + #𬫓; + #𬫔; + #𬫕; + #𬫖; + #𬫗; + #𬫘; + #𬫙; + #𬫚; + #𬫛; + #𬫜; + #𬫝; + #𬫞; + #𬫟; + #𬫠; + #𬫡; + #𬫢; + #𬫣; + #𬫤; + #𬫥; + #𬫦; + #𬫧; + #𬫨; + #𬫩; + #𬫪; + #𬫫; + #𬫬; + #𬫭; + #𬫮; + #𬫯; + #𬫰; + #𬫱; + #𬫲; + #𬫳; + #𬫴; + #𬫵; + #𬫶; + #𬫷; + #𬫸; + #𬫹; + #𬫺; + #𬫻; + #𬫼; + #𬫽; + #𬫾; + #𬫿; + #𬬀; + #𬬁; + #𬬂; + #𬬃; + #𬬄; + #𬬅; + #𬬆; + #𬬇; + #𬬈; + #𬬉; + #𬬊; + #𬬋; + #𬬌; + #𬬍; + #𬬎; + #𬬏; + #𬬐; + #𬬑; + #𬬒; + #𬬓; + #𬬔; + #𬬕; + #𬬖; + #𬬗; + #𬬘; + #𬬙; + #𬬚; + #𬬛; + #𬬜; + #𬬝; + #𬬞; + #𬬟; + #𬬠; + #𬬡; + #𬬢; + #𬬣; + #𬬤; + #𬬥; + #𬬦; + #𬬧; + #𬬨; + #𬬩; + #𬬪; + #𬬫; + #𬬬; + #𬬭; + #𬬮; + #𬬯; + #𬬰; + #𬬱; + #𬬲; + #𬬳; + #𬬴; + #𬬵; + #𬬶; + #𬬷; + #𬬸; + #𬬹; + #𬬺; + #𬬻; + #𬬼; + #𬬽; + #𬬾; + #𬬿; + #𬭀; + #𬭁; + #𬭂; + #𬭃; + #𬭄; + #𬭅; + #𬭆; + #𬭇; + #𬭈; + #𬭉; + #𬭊; + #𬭋; + #𬭌; + #𬭍; + #𬭎; + #𬭏; + #𬭐; + #𬭑; + #𬭒; + #𬭓; + #𬭔; + #𬭕; + #𬭖; + #𬭗; + #𬭘; + #𬭙; + #𬭚; + #𬭛; + #𬭜; + #𬭝; + #𬭞; + #𬭟; + #𬭠; + #𬭡; + #𬭢; + #𬭣; + #𬭤; + #𬭥; + #𬭦; + #𬭧; + #𬭨; + #𬭩; + #𬭪; + #𬭫; + #𬭬; + #𬭭; + #𬭮; + #𬭯; + #𬭰; + #𬭱; + #𬭲; + #𬭳; + #𬭴; + #𬭵; + #𬭶; + #𬭷; + #𬭸; + #𬭹; + #𬭺; + #𬭻; + #𬭼; + #𬭽; + #𬭾; + #𬭿; + #𬮀; + #𬮁; + #𬮂; + #𬮃; + #𬮄; + #𬮅; + #𬮆; + #𬮇; + #𬮈; + #𬮉; + #𬮊; + #𬮋; + #𬮌; + #𬮍; + #𬮎; + #𬮏; + #𬮐; + #𬮑; + #𬮒; + #𬮓; + #𬮔; + #𬮕; + #𬮖; + #𬮗; + #𬮘; + #𬮙; + #𬮚; + #𬮛; + #𬮜; + #𬮝; + #𬮞; + #𬮟; + #𬮠; + #𬮡; + #𬮢; + #𬮣; + #𬮤; + #𬮥; + #𬮦; + #𬮧; + #𬮨; + #𬮩; + #𬮪; + #𬮫; + #𬮬; + #𬮭; + #𬮮; + #𬮯; + #𬮰; + #𬮱; + #𬮲; + #𬮳; + #𬮴; + #𬮵; + #𬮶; + #𬮷; + #𬮸; + #𬮹; + #𬮺; + #𬮻; + #𬮼; + #𬮽; + #𬮾; + #𬮿; + #𬯀; + #𬯁; + #𬯂; + #𬯃; + #𬯄; + #𬯅; + #𬯆; + #𬯇; + #𬯈; + #𬯉; + #𬯊; + #𬯋; + #𬯌; + #𬯍; + #𬯎; + #𬯏; + #𬯐; + #𬯑; + #𬯒; + #𬯓; + #𬯔; + #𬯕; + #𬯖; + #𬯗; + #𬯘; + #𬯙; + #𬯚; + #𬯛; + #𬯜; + #𬯝; + #𬯞; + #𬯟; + #𬯠; + #𬯡; + #𬯢; + #𬯣; + #𬯤; + #𬯥; + #𬯦; + #𬯧; + #𬯨; + #𬯩; + #𬯪; + #𬯫; + #𬯬; + #𬯭; + #𬯮; + #𬯯; + #𬯰; + #𬯱; + #𬯲; + #𬯳; + #𬯴; + #𬯵; + #𬯶; + #𬯷; + #𬯸; + #𬯹; + #𬯺; + #𬯻; + #𬯼; + #𬯽; + #𬯾; + #𬯿; + #𬰀; + #𬰁; + #𬰂; + #𬰃; + #𬰄; + #𬰅; + #𬰆; + #𬰇; + #𬰈; + #𬰉; + #𬰊; + #𬰋; + #𬰌; + #𬰍; + #𬰎; + #𬰏; + #𬰐; + #𬰑; + #𬰒; + #𬰓; + #𬰔; + #𬰕; + #𬰖; + #𬰗; + #𬰘; + #𬰙; + #𬰚; + #𬰛; + #𬰜; + #𬰝; + #𬰞; + #𬰟; + #𬰠; + #𬰡; + #𬰢; + #𬰣; + #𬰤; + #𬰥; + #𬰦; + #𬰧; + #𬰨; + #𬰩; + #𬰪; + #𬰫; + #𬰬; + #𬰭; + #𬰮; + #𬰯; + #𬰰; + #𬰱; + #𬰲; + #𬰳; + #𬰴; + #𬰵; + #𬰶; + #𬰷; + #𬰸; + #𬰹; + #𬰺; + #𬰻; + #𬰼; + #𬰽; + #𬰾; + #𬰿; + #𬱀; + #𬱁; + #𬱂; + #𬱃; + #𬱄; + #𬱅; + #𬱆; + #𬱇; + #𬱈; + #𬱉; + #𬱊; + #𬱋; + #𬱌; + #𬱍; + #𬱎; + #𬱏; + #𬱐; + #𬱑; + #𬱒; + #𬱓; + #𬱔; + #𬱕; + #𬱖; + #𬱗; + #𬱘; + #𬱙; + #𬱚; + #𬱛; + #𬱜; + #𬱝; + #𬱞; + #𬱟; + #𬱠; + #𬱡; + #𬱢; + #𬱣; + #𬱤; + #𬱥; + #𬱦; + #𬱧; + #𬱨; + #𬱩; + #𬱪; + #𬱫; + #𬱬; + #𬱭; + #𬱮; + #𬱯; + #𬱰; + #𬱱; + #𬱲; + #𬱳; + #𬱴; + #𬱵; + #𬱶; + #𬱷; + #𬱸; + #𬱹; + #𬱺; + #𬱻; + #𬱼; + #𬱽; + #𬱾; + #𬱿; + #𬲀; + #𬲁; + #𬲂; + #𬲃; + #𬲄; + #𬲅; + #𬲆; + #𬲇; + #𬲈; + #𬲉; + #𬲊; + #𬲋; + #𬲌; + #𬲍; + #𬲎; + #𬲏; + #𬲐; + #𬲑; + #𬲒; + #𬲓; + #𬲔; + #𬲕; + #𬲖; + #𬲗; + #𬲘; + #𬲙; + #𬲚; + #𬲛; + #𬲜; + #𬲝; + #𬲞; + #𬲟; + #𬲠; + #𬲡; + #𬲢; + #𬲣; + #𬲤; + #𬲥; + #𬲦; + #𬲧; + #𬲨; + #𬲩; + #𬲪; + #𬲫; + #𬲬; + #𬲭; + #𬲮; + #𬲯; + #𬲰; + #𬲱; + #𬲲; + #𬲳; + #𬲴; + #𬲵; + #𬲶; + #𬲷; + #𬲸; + #𬲹; + #𬲺; + #𬲻; + #𬲼; + #𬲽; + #𬲾; + #𬲿; + #𬳀; + #𬳁; + #𬳂; + #𬳃; + #𬳄; + #𬳅; + #𬳆; + #𬳇; + #𬳈; + #𬳉; + #𬳊; + #𬳋; + #𬳌; + #𬳍; + #𬳎; + #𬳏; + #𬳐; + #𬳑; + #𬳒; + #𬳓; + #𬳔; + #𬳕; + #𬳖; + #𬳗; + #𬳘; + #𬳙; + #𬳚; + #𬳛; + #𬳜; + #𬳝; + #𬳞; + #𬳟; + #𬳠; + #𬳡; + #𬳢; + #𬳣; + #𬳤; + #𬳥; + #𬳦; + #𬳧; + #𬳨; + #𬳩; + #𬳪; + #𬳫; + #𬳬; + #𬳭; + #𬳮; + #𬳯; + #𬳰; + #𬳱; + #𬳲; + #𬳳; + #𬳴; + #𬳵; + #𬳶; + #𬳷; + #𬳸; + #𬳹; + #𬳺; + #𬳻; + #𬳼; + #𬳽; + #𬳾; + #𬳿; + #𬴀; + #𬴁; + #𬴂; + #𬴃; + #𬴄; + #𬴅; + #𬴆; + #𬴇; + #𬴈; + #𬴉; + #𬴊; + #𬴋; + #𬴌; + #𬴍; + #𬴎; + #𬴏; + #𬴐; + #𬴑; + #𬴒; + #𬴓; + #𬴔; + #𬴕; + #𬴖; + #𬴗; + #𬴘; + #𬴙; + #𬴚; + #𬴛; + #𬴜; + #𬴝; + #𬴞; + #𬴟; + #𬴠; + #𬴡; + #𬴢; + #𬴣; + #𬴤; + #𬴥; + #𬴦; + #𬴧; + #𬴨; + #𬴩; + #𬴪; + #𬴫; + #𬴬; + #𬴭; + #𬴮; + #𬴯; + #𬴰; + #𬴱; + #𬴲; + #𬴳; + #𬴴; + #𬴵; + #𬴶; + #𬴷; + #𬴸; + #𬴹; + #𬴺; + #𬴻; + #𬴼; + #𬴽; + #𬴾; + #𬴿; + #𬵀; + #𬵁; + #𬵂; + #𬵃; + #𬵄; + #𬵅; + #𬵆; + #𬵇; + #𬵈; + #𬵉; + #𬵊; + #𬵋; + #𬵌; + #𬵍; + #𬵎; + #𬵏; + #𬵐; + #𬵑; + #𬵒; + #𬵓; + #𬵔; + #𬵕; + #𬵖; + #𬵗; + #𬵘; + #𬵙; + #𬵚; + #𬵛; + #𬵜; + #𬵝; + #𬵞; + #𬵟; + #𬵠; + #𬵡; + #𬵢; + #𬵣; + #𬵤; + #𬵥; + #𬵦; + #𬵧; + #𬵨; + #𬵩; + #𬵪; + #𬵫; + #𬵬; + #𬵭; + #𬵮; + #𬵯; + #𬵰; + #𬵱; + #𬵲; + #𬵳; + #𬵴; + #𬵵; + #𬵶; + #𬵷; + #𬵸; + #𬵹; + #𬵺; + #𬵻; + #𬵼; + #𬵽; + #𬵾; + #𬵿; + #𬶀; + #𬶁; + #𬶂; + #𬶃; + #𬶄; + #𬶅; + #𬶆; + #𬶇; + #𬶈; + #𬶉; + #𬶊; + #𬶋; + #𬶌; + #𬶍; + #𬶎; + #𬶏; + #𬶐; + #𬶑; + #𬶒; + #𬶓; + #𬶔; + #𬶕; + #𬶖; + #𬶗; + #𬶘; + #𬶙; + #𬶚; + #𬶛; + #𬶜; + #𬶝; + #𬶞; + #𬶟; + #𬶠; + #𬶡; + #𬶢; + #𬶣; + #𬶤; + #𬶥; + #𬶦; + #𬶧; + #𬶨; + #𬶩; + #𬶪; + #𬶫; + #𬶬; + #𬶭; + #𬶮; + #𬶯; + #𬶰; + #𬶱; + #𬶲; + #𬶳; + #𬶴; + #𬶵; + #𬶶; + #𬶷; + #𬶸; + #𬶹; + #𬶺; + #𬶻; + #𬶼; + #𬶽; + #𬶾; + #𬶿; + #𬷀; + #𬷁; + #𬷂; + #𬷃; + #𬷄; + #𬷅; + #𬷆; + #𬷇; + #𬷈; + #𬷉; + #𬷊; + #𬷋; + #𬷌; + #𬷍; + #𬷎; + #𬷏; + #𬷐; + #𬷑; + #𬷒; + #𬷓; + #𬷔; + #𬷕; + #𬷖; + #𬷗; + #𬷘; + #𬷙; + #𬷚; + #𬷛; + #𬷜; + #𬷝; + #𬷞; + #𬷟; + #𬷠; + #𬷡; + #𬷢; + #𬷣; + #𬷤; + #𬷥; + #𬷦; + #𬷧; + #𬷨; + #𬷩; + #𬷪; + #𬷫; + #𬷬; + #𬷭; + #𬷮; + #𬷯; + #𬷰; + #𬷱; + #𬷲; + #𬷳; + #𬷴; + #𬷵; + #𬷶; + #𬷷; + #𬷸; + #𬷹; + #𬷺; + #𬷻; + #𬷼; + #𬷽; + #𬷾; + #𬷿; + #𬸀; + #𬸁; + #𬸂; + #𬸃; + #𬸄; + #𬸅; + #𬸆; + #𬸇; + #𬸈; + #𬸉; + #𬸊; + #𬸋; + #𬸌; + #𬸍; + #𬸎; + #𬸏; + #𬸐; + #𬸑; + #𬸒; + #𬸓; + #𬸔; + #𬸕; + #𬸖; + #𬸗; + #𬸘; + #𬸙; + #𬸚; + #𬸛; + #𬸜; + #𬸝; + #𬸞; + #𬸟; + #𬸠; + #𬸡; + #𬸢; + #𬸣; + #𬸤; + #𬸥; + #𬸦; + #𬸧; + #𬸨; + #𬸩; + #𬸪; + #𬸫; + #𬸬; + #𬸭; + #𬸮; + #𬸯; + #𬸰; + #𬸱; + #𬸲; + #𬸳; + #𬸴; + #𬸵; + #𬸶; + #𬸷; + #𬸸; + #𬸹; + #𬸺; + #𬸻; + #𬸼; + #𬸽; + #𬸾; + #𬸿; + #𬹀; + #𬹁; + #𬹂; + #𬹃; + #𬹄; + #𬹅; + #𬹆; + #𬹇; + #𬹈; + #𬹉; + #𬹊; + #𬹋; + #𬹌; + #𬹍; + #𬹎; + #𬹏; + #𬹐; + #𬹑; + #𬹒; + #𬹓; + #𬹔; + #𬹕; + #𬹖; + #𬹗; + #𬹘; + #𬹙; + #𬹚; + #𬹛; + #𬹜; + #𬹝; + #𬹞; + #𬹟; + #𬹠; + #𬹡; + #𬹢; + #𬹣; + #𬹤; + #𬹥; + #𬹦; + #𬹧; + #𬹨; + #𬹩; + #𬹪; + #𬹫; + #𬹬; + #𬹭; + #𬹮; + #𬹯; + #𬹰; + #𬹱; + #𬹲; + #𬹳; + #𬹴; + #𬹵; + #𬹶; + #𬹷; + #𬹸; + #𬹹; + #𬹺; + #𬹻; + #𬹼; + #𬹽; + #𬹾; + #𬹿; + #𬺀; + #𬺁; + #𬺂; + #𬺃; + #𬺄; + #𬺅; + #𬺆; + #𬺇; + #𬺈; + #𬺉; + #𬺊; + #𬺋; + #𬺌; + #𬺍; + #𬺎; + #𬺏; + #𬺐; + #𬺑; + #𬺒; + #𬺓; + #𬺔; + #𬺕; + #𬺖; + #𬺗; + #𬺘; + #𬺙; + #𬺚; + #𬺛; + #𬺜; + #𬺝; + #𬺞; + #𬺟; + #𬺠; + #𬺡; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0-escaped.js new file mode 100644 index 000000000..e0cbb10a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0-escaped.js @@ -0,0 +1,6881 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v8.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u08B3; +var \u08B4; +var \u0AF9; +var \u0C5A; +var \u0D5F; +var \u13F5; +var \u13F8; +var \u13F9; +var \u13FA; +var \u13FB; +var \u13FC; +var \u13FD; +var \u19B0; +var \u19B1; +var \u19B2; +var \u19B3; +var \u19B4; +var \u19B5; +var \u19B6; +var \u19B7; +var \u19B8; +var \u19B9; +var \u19BA; +var \u19BB; +var \u19BC; +var \u19BD; +var \u19BE; +var \u19BF; +var \u19C0; +var \u19C8; +var \u19C9; +var \u9FCD; +var \u9FCE; +var \u9FCF; +var \u9FD0; +var \u9FD1; +var \u9FD2; +var \u9FD3; +var \u9FD4; +var \u9FD5; +var \uA78F; +var \uA7B2; +var \uA7B3; +var \uA7B4; +var \uA7B5; +var \uA7B6; +var \uA7B7; +var \uA8FD; +var \uAB60; +var \uAB61; +var \uAB62; +var \uAB63; +var \uAB70; +var \uAB71; +var \uAB72; +var \uAB73; +var \uAB74; +var \uAB75; +var \uAB76; +var \uAB77; +var \uAB78; +var \uAB79; +var \uAB7A; +var \uAB7B; +var \uAB7C; +var \uAB7D; +var \uAB7E; +var \uAB7F; +var \uAB80; +var \uAB81; +var \uAB82; +var \uAB83; +var \uAB84; +var \uAB85; +var \uAB86; +var \uAB87; +var \uAB88; +var \uAB89; +var \uAB8A; +var \uAB8B; +var \uAB8C; +var \uAB8D; +var \uAB8E; +var \uAB8F; +var \uAB90; +var \uAB91; +var \uAB92; +var \uAB93; +var \uAB94; +var \uAB95; +var \uAB96; +var \uAB97; +var \uAB98; +var \uAB99; +var \uAB9A; +var \uAB9B; +var \uAB9C; +var \uAB9D; +var \uAB9E; +var \uAB9F; +var \uABA0; +var \uABA1; +var \uABA2; +var \uABA3; +var \uABA4; +var \uABA5; +var \uABA6; +var \uABA7; +var \uABA8; +var \uABA9; +var \uABAA; +var \uABAB; +var \uABAC; +var \uABAD; +var \uABAE; +var \uABAF; +var \uABB0; +var \uABB1; +var \uABB2; +var \uABB3; +var \uABB4; +var \uABB5; +var \uABB6; +var \uABB7; +var \uABB8; +var \uABB9; +var \uABBA; +var \uABBB; +var \uABBC; +var \uABBD; +var \uABBE; +var \uABBF; +var \u{108E0}; +var \u{108E1}; +var \u{108E2}; +var \u{108E3}; +var \u{108E4}; +var \u{108E5}; +var \u{108E6}; +var \u{108E7}; +var \u{108E8}; +var \u{108E9}; +var \u{108EA}; +var \u{108EB}; +var \u{108EC}; +var \u{108ED}; +var \u{108EE}; +var \u{108EF}; +var \u{108F0}; +var \u{108F1}; +var \u{108F2}; +var \u{108F4}; +var \u{108F5}; +var \u{10C80}; +var \u{10C81}; +var \u{10C82}; +var \u{10C83}; +var \u{10C84}; +var \u{10C85}; +var \u{10C86}; +var \u{10C87}; +var \u{10C88}; +var \u{10C89}; +var \u{10C8A}; +var \u{10C8B}; +var \u{10C8C}; +var \u{10C8D}; +var \u{10C8E}; +var \u{10C8F}; +var \u{10C90}; +var \u{10C91}; +var \u{10C92}; +var \u{10C93}; +var \u{10C94}; +var \u{10C95}; +var \u{10C96}; +var \u{10C97}; +var \u{10C98}; +var \u{10C99}; +var \u{10C9A}; +var \u{10C9B}; +var \u{10C9C}; +var \u{10C9D}; +var \u{10C9E}; +var \u{10C9F}; +var \u{10CA0}; +var \u{10CA1}; +var \u{10CA2}; +var \u{10CA3}; +var \u{10CA4}; +var \u{10CA5}; +var \u{10CA6}; +var \u{10CA7}; +var \u{10CA8}; +var \u{10CA9}; +var \u{10CAA}; +var \u{10CAB}; +var \u{10CAC}; +var \u{10CAD}; +var \u{10CAE}; +var \u{10CAF}; +var \u{10CB0}; +var \u{10CB1}; +var \u{10CB2}; +var \u{10CC0}; +var \u{10CC1}; +var \u{10CC2}; +var \u{10CC3}; +var \u{10CC4}; +var \u{10CC5}; +var \u{10CC6}; +var \u{10CC7}; +var \u{10CC8}; +var \u{10CC9}; +var \u{10CCA}; +var \u{10CCB}; +var \u{10CCC}; +var \u{10CCD}; +var \u{10CCE}; +var \u{10CCF}; +var \u{10CD0}; +var \u{10CD1}; +var \u{10CD2}; +var \u{10CD3}; +var \u{10CD4}; +var \u{10CD5}; +var \u{10CD6}; +var \u{10CD7}; +var \u{10CD8}; +var \u{10CD9}; +var \u{10CDA}; +var \u{10CDB}; +var \u{10CDC}; +var \u{10CDD}; +var \u{10CDE}; +var \u{10CDF}; +var \u{10CE0}; +var \u{10CE1}; +var \u{10CE2}; +var \u{10CE3}; +var \u{10CE4}; +var \u{10CE5}; +var \u{10CE6}; +var \u{10CE7}; +var \u{10CE8}; +var \u{10CE9}; +var \u{10CEA}; +var \u{10CEB}; +var \u{10CEC}; +var \u{10CED}; +var \u{10CEE}; +var \u{10CEF}; +var \u{10CF0}; +var \u{10CF1}; +var \u{10CF2}; +var \u{111DC}; +var \u{11280}; +var \u{11281}; +var \u{11282}; +var \u{11283}; +var \u{11284}; +var \u{11285}; +var \u{11286}; +var \u{11288}; +var \u{1128A}; +var \u{1128B}; +var \u{1128C}; +var \u{1128D}; +var \u{1128F}; +var \u{11290}; +var \u{11291}; +var \u{11292}; +var \u{11293}; +var \u{11294}; +var \u{11295}; +var \u{11296}; +var \u{11297}; +var \u{11298}; +var \u{11299}; +var \u{1129A}; +var \u{1129B}; +var \u{1129C}; +var \u{1129D}; +var \u{1129F}; +var \u{112A0}; +var \u{112A1}; +var \u{112A2}; +var \u{112A3}; +var \u{112A4}; +var \u{112A5}; +var \u{112A6}; +var \u{112A7}; +var \u{112A8}; +var \u{11350}; +var \u{115D8}; +var \u{115D9}; +var \u{115DA}; +var \u{115DB}; +var \u{11700}; +var \u{11701}; +var \u{11702}; +var \u{11703}; +var \u{11704}; +var \u{11705}; +var \u{11706}; +var \u{11707}; +var \u{11708}; +var \u{11709}; +var \u{1170A}; +var \u{1170B}; +var \u{1170C}; +var \u{1170D}; +var \u{1170E}; +var \u{1170F}; +var \u{11710}; +var \u{11711}; +var \u{11712}; +var \u{11713}; +var \u{11714}; +var \u{11715}; +var \u{11716}; +var \u{11717}; +var \u{11718}; +var \u{11719}; +var \u{12399}; +var \u{12480}; +var \u{12481}; +var \u{12482}; +var \u{12483}; +var \u{12484}; +var \u{12485}; +var \u{12486}; +var \u{12487}; +var \u{12488}; +var \u{12489}; +var \u{1248A}; +var \u{1248B}; +var \u{1248C}; +var \u{1248D}; +var \u{1248E}; +var \u{1248F}; +var \u{12490}; +var \u{12491}; +var \u{12492}; +var \u{12493}; +var \u{12494}; +var \u{12495}; +var \u{12496}; +var \u{12497}; +var \u{12498}; +var \u{12499}; +var \u{1249A}; +var \u{1249B}; +var \u{1249C}; +var \u{1249D}; +var \u{1249E}; +var \u{1249F}; +var \u{124A0}; +var \u{124A1}; +var \u{124A2}; +var \u{124A3}; +var \u{124A4}; +var \u{124A5}; +var \u{124A6}; +var \u{124A7}; +var \u{124A8}; +var \u{124A9}; +var \u{124AA}; +var \u{124AB}; +var \u{124AC}; +var \u{124AD}; +var \u{124AE}; +var \u{124AF}; +var \u{124B0}; +var \u{124B1}; +var \u{124B2}; +var \u{124B3}; +var \u{124B4}; +var \u{124B5}; +var \u{124B6}; +var \u{124B7}; +var \u{124B8}; +var \u{124B9}; +var \u{124BA}; +var \u{124BB}; +var \u{124BC}; +var \u{124BD}; +var \u{124BE}; +var \u{124BF}; +var \u{124C0}; +var \u{124C1}; +var \u{124C2}; +var \u{124C3}; +var \u{124C4}; +var \u{124C5}; +var \u{124C6}; +var \u{124C7}; +var \u{124C8}; +var \u{124C9}; +var \u{124CA}; +var \u{124CB}; +var \u{124CC}; +var \u{124CD}; +var \u{124CE}; +var \u{124CF}; +var \u{124D0}; +var \u{124D1}; +var \u{124D2}; +var \u{124D3}; +var \u{124D4}; +var \u{124D5}; +var \u{124D6}; +var \u{124D7}; +var \u{124D8}; +var \u{124D9}; +var \u{124DA}; +var \u{124DB}; +var \u{124DC}; +var \u{124DD}; +var \u{124DE}; +var \u{124DF}; +var \u{124E0}; +var \u{124E1}; +var \u{124E2}; +var \u{124E3}; +var \u{124E4}; +var \u{124E5}; +var \u{124E6}; +var \u{124E7}; +var \u{124E8}; +var \u{124E9}; +var \u{124EA}; +var \u{124EB}; +var \u{124EC}; +var \u{124ED}; +var \u{124EE}; +var \u{124EF}; +var \u{124F0}; +var \u{124F1}; +var \u{124F2}; +var \u{124F3}; +var \u{124F4}; +var \u{124F5}; +var \u{124F6}; +var \u{124F7}; +var \u{124F8}; +var \u{124F9}; +var \u{124FA}; +var \u{124FB}; +var \u{124FC}; +var \u{124FD}; +var \u{124FE}; +var \u{124FF}; +var \u{12500}; +var \u{12501}; +var \u{12502}; +var \u{12503}; +var \u{12504}; +var \u{12505}; +var \u{12506}; +var \u{12507}; +var \u{12508}; +var \u{12509}; +var \u{1250A}; +var \u{1250B}; +var \u{1250C}; +var \u{1250D}; +var \u{1250E}; +var \u{1250F}; +var \u{12510}; +var \u{12511}; +var \u{12512}; +var \u{12513}; +var \u{12514}; +var \u{12515}; +var \u{12516}; +var \u{12517}; +var \u{12518}; +var \u{12519}; +var \u{1251A}; +var \u{1251B}; +var \u{1251C}; +var \u{1251D}; +var \u{1251E}; +var \u{1251F}; +var \u{12520}; +var \u{12521}; +var \u{12522}; +var \u{12523}; +var \u{12524}; +var \u{12525}; +var \u{12526}; +var \u{12527}; +var \u{12528}; +var \u{12529}; +var \u{1252A}; +var \u{1252B}; +var \u{1252C}; +var \u{1252D}; +var \u{1252E}; +var \u{1252F}; +var \u{12530}; +var \u{12531}; +var \u{12532}; +var \u{12533}; +var \u{12534}; +var \u{12535}; +var \u{12536}; +var \u{12537}; +var \u{12538}; +var \u{12539}; +var \u{1253A}; +var \u{1253B}; +var \u{1253C}; +var \u{1253D}; +var \u{1253E}; +var \u{1253F}; +var \u{12540}; +var \u{12541}; +var \u{12542}; +var \u{12543}; +var \u{14400}; +var \u{14401}; +var \u{14402}; +var \u{14403}; +var \u{14404}; +var \u{14405}; +var \u{14406}; +var \u{14407}; +var \u{14408}; +var \u{14409}; +var \u{1440A}; +var \u{1440B}; +var \u{1440C}; +var \u{1440D}; +var \u{1440E}; +var \u{1440F}; +var \u{14410}; +var \u{14411}; +var \u{14412}; +var \u{14413}; +var \u{14414}; +var \u{14415}; +var \u{14416}; +var \u{14417}; +var \u{14418}; +var \u{14419}; +var \u{1441A}; +var \u{1441B}; +var \u{1441C}; +var \u{1441D}; +var \u{1441E}; +var \u{1441F}; +var \u{14420}; +var \u{14421}; +var \u{14422}; +var \u{14423}; +var \u{14424}; +var \u{14425}; +var \u{14426}; +var \u{14427}; +var \u{14428}; +var \u{14429}; +var \u{1442A}; +var \u{1442B}; +var \u{1442C}; +var \u{1442D}; +var \u{1442E}; +var \u{1442F}; +var \u{14430}; +var \u{14431}; +var \u{14432}; +var \u{14433}; +var \u{14434}; +var \u{14435}; +var \u{14436}; +var \u{14437}; +var \u{14438}; +var \u{14439}; +var \u{1443A}; +var \u{1443B}; +var \u{1443C}; +var \u{1443D}; +var \u{1443E}; +var \u{1443F}; +var \u{14440}; +var \u{14441}; +var \u{14442}; +var \u{14443}; +var \u{14444}; +var \u{14445}; +var \u{14446}; +var \u{14447}; +var \u{14448}; +var \u{14449}; +var \u{1444A}; +var \u{1444B}; +var \u{1444C}; +var \u{1444D}; +var \u{1444E}; +var \u{1444F}; +var \u{14450}; +var \u{14451}; +var \u{14452}; +var \u{14453}; +var \u{14454}; +var \u{14455}; +var \u{14456}; +var \u{14457}; +var \u{14458}; +var \u{14459}; +var \u{1445A}; +var \u{1445B}; +var \u{1445C}; +var \u{1445D}; +var \u{1445E}; +var \u{1445F}; +var \u{14460}; +var \u{14461}; +var \u{14462}; +var \u{14463}; +var \u{14464}; +var \u{14465}; +var \u{14466}; +var \u{14467}; +var \u{14468}; +var \u{14469}; +var \u{1446A}; +var \u{1446B}; +var \u{1446C}; +var \u{1446D}; +var \u{1446E}; +var \u{1446F}; +var \u{14470}; +var \u{14471}; +var \u{14472}; +var \u{14473}; +var \u{14474}; +var \u{14475}; +var \u{14476}; +var \u{14477}; +var \u{14478}; +var \u{14479}; +var \u{1447A}; +var \u{1447B}; +var \u{1447C}; +var \u{1447D}; +var \u{1447E}; +var \u{1447F}; +var \u{14480}; +var \u{14481}; +var \u{14482}; +var \u{14483}; +var \u{14484}; +var \u{14485}; +var \u{14486}; +var \u{14487}; +var \u{14488}; +var \u{14489}; +var \u{1448A}; +var \u{1448B}; +var \u{1448C}; +var \u{1448D}; +var \u{1448E}; +var \u{1448F}; +var \u{14490}; +var \u{14491}; +var \u{14492}; +var \u{14493}; +var \u{14494}; +var \u{14495}; +var \u{14496}; +var \u{14497}; +var \u{14498}; +var \u{14499}; +var \u{1449A}; +var \u{1449B}; +var \u{1449C}; +var \u{1449D}; +var \u{1449E}; +var \u{1449F}; +var \u{144A0}; +var \u{144A1}; +var \u{144A2}; +var \u{144A3}; +var \u{144A4}; +var \u{144A5}; +var \u{144A6}; +var \u{144A7}; +var \u{144A8}; +var \u{144A9}; +var \u{144AA}; +var \u{144AB}; +var \u{144AC}; +var \u{144AD}; +var \u{144AE}; +var \u{144AF}; +var \u{144B0}; +var \u{144B1}; +var \u{144B2}; +var \u{144B3}; +var \u{144B4}; +var \u{144B5}; +var \u{144B6}; +var \u{144B7}; +var \u{144B8}; +var \u{144B9}; +var \u{144BA}; +var \u{144BB}; +var \u{144BC}; +var \u{144BD}; +var \u{144BE}; +var \u{144BF}; +var \u{144C0}; +var \u{144C1}; +var \u{144C2}; +var \u{144C3}; +var \u{144C4}; +var \u{144C5}; +var \u{144C6}; +var \u{144C7}; +var \u{144C8}; +var \u{144C9}; +var \u{144CA}; +var \u{144CB}; +var \u{144CC}; +var \u{144CD}; +var \u{144CE}; +var \u{144CF}; +var \u{144D0}; +var \u{144D1}; +var \u{144D2}; +var \u{144D3}; +var \u{144D4}; +var \u{144D5}; +var \u{144D6}; +var \u{144D7}; +var \u{144D8}; +var \u{144D9}; +var \u{144DA}; +var \u{144DB}; +var \u{144DC}; +var \u{144DD}; +var \u{144DE}; +var \u{144DF}; +var \u{144E0}; +var \u{144E1}; +var \u{144E2}; +var \u{144E3}; +var \u{144E4}; +var \u{144E5}; +var \u{144E6}; +var \u{144E7}; +var \u{144E8}; +var \u{144E9}; +var \u{144EA}; +var \u{144EB}; +var \u{144EC}; +var \u{144ED}; +var \u{144EE}; +var \u{144EF}; +var \u{144F0}; +var \u{144F1}; +var \u{144F2}; +var \u{144F3}; +var \u{144F4}; +var \u{144F5}; +var \u{144F6}; +var \u{144F7}; +var \u{144F8}; +var \u{144F9}; +var \u{144FA}; +var \u{144FB}; +var \u{144FC}; +var \u{144FD}; +var \u{144FE}; +var \u{144FF}; +var \u{14500}; +var \u{14501}; +var \u{14502}; +var \u{14503}; +var \u{14504}; +var \u{14505}; +var \u{14506}; +var \u{14507}; +var \u{14508}; +var \u{14509}; +var \u{1450A}; +var \u{1450B}; +var \u{1450C}; +var \u{1450D}; +var \u{1450E}; +var \u{1450F}; +var \u{14510}; +var \u{14511}; +var \u{14512}; +var \u{14513}; +var \u{14514}; +var \u{14515}; +var \u{14516}; +var \u{14517}; +var \u{14518}; +var \u{14519}; +var \u{1451A}; +var \u{1451B}; +var \u{1451C}; +var \u{1451D}; +var \u{1451E}; +var \u{1451F}; +var \u{14520}; +var \u{14521}; +var \u{14522}; +var \u{14523}; +var \u{14524}; +var \u{14525}; +var \u{14526}; +var \u{14527}; +var \u{14528}; +var \u{14529}; +var \u{1452A}; +var \u{1452B}; +var \u{1452C}; +var \u{1452D}; +var \u{1452E}; +var \u{1452F}; +var \u{14530}; +var \u{14531}; +var \u{14532}; +var \u{14533}; +var \u{14534}; +var \u{14535}; +var \u{14536}; +var \u{14537}; +var \u{14538}; +var \u{14539}; +var \u{1453A}; +var \u{1453B}; +var \u{1453C}; +var \u{1453D}; +var \u{1453E}; +var \u{1453F}; +var \u{14540}; +var \u{14541}; +var \u{14542}; +var \u{14543}; +var \u{14544}; +var \u{14545}; +var \u{14546}; +var \u{14547}; +var \u{14548}; +var \u{14549}; +var \u{1454A}; +var \u{1454B}; +var \u{1454C}; +var \u{1454D}; +var \u{1454E}; +var \u{1454F}; +var \u{14550}; +var \u{14551}; +var \u{14552}; +var \u{14553}; +var \u{14554}; +var \u{14555}; +var \u{14556}; +var \u{14557}; +var \u{14558}; +var \u{14559}; +var \u{1455A}; +var \u{1455B}; +var \u{1455C}; +var \u{1455D}; +var \u{1455E}; +var \u{1455F}; +var \u{14560}; +var \u{14561}; +var \u{14562}; +var \u{14563}; +var \u{14564}; +var \u{14565}; +var \u{14566}; +var \u{14567}; +var \u{14568}; +var \u{14569}; +var \u{1456A}; +var \u{1456B}; +var \u{1456C}; +var \u{1456D}; +var \u{1456E}; +var \u{1456F}; +var \u{14570}; +var \u{14571}; +var \u{14572}; +var \u{14573}; +var \u{14574}; +var \u{14575}; +var \u{14576}; +var \u{14577}; +var \u{14578}; +var \u{14579}; +var \u{1457A}; +var \u{1457B}; +var \u{1457C}; +var \u{1457D}; +var \u{1457E}; +var \u{1457F}; +var \u{14580}; +var \u{14581}; +var \u{14582}; +var \u{14583}; +var \u{14584}; +var \u{14585}; +var \u{14586}; +var \u{14587}; +var \u{14588}; +var \u{14589}; +var \u{1458A}; +var \u{1458B}; +var \u{1458C}; +var \u{1458D}; +var \u{1458E}; +var \u{1458F}; +var \u{14590}; +var \u{14591}; +var \u{14592}; +var \u{14593}; +var \u{14594}; +var \u{14595}; +var \u{14596}; +var \u{14597}; +var \u{14598}; +var \u{14599}; +var \u{1459A}; +var \u{1459B}; +var \u{1459C}; +var \u{1459D}; +var \u{1459E}; +var \u{1459F}; +var \u{145A0}; +var \u{145A1}; +var \u{145A2}; +var \u{145A3}; +var \u{145A4}; +var \u{145A5}; +var \u{145A6}; +var \u{145A7}; +var \u{145A8}; +var \u{145A9}; +var \u{145AA}; +var \u{145AB}; +var \u{145AC}; +var \u{145AD}; +var \u{145AE}; +var \u{145AF}; +var \u{145B0}; +var \u{145B1}; +var \u{145B2}; +var \u{145B3}; +var \u{145B4}; +var \u{145B5}; +var \u{145B6}; +var \u{145B7}; +var \u{145B8}; +var \u{145B9}; +var \u{145BA}; +var \u{145BB}; +var \u{145BC}; +var \u{145BD}; +var \u{145BE}; +var \u{145BF}; +var \u{145C0}; +var \u{145C1}; +var \u{145C2}; +var \u{145C3}; +var \u{145C4}; +var \u{145C5}; +var \u{145C6}; +var \u{145C7}; +var \u{145C8}; +var \u{145C9}; +var \u{145CA}; +var \u{145CB}; +var \u{145CC}; +var \u{145CD}; +var \u{145CE}; +var \u{145CF}; +var \u{145D0}; +var \u{145D1}; +var \u{145D2}; +var \u{145D3}; +var \u{145D4}; +var \u{145D5}; +var \u{145D6}; +var \u{145D7}; +var \u{145D8}; +var \u{145D9}; +var \u{145DA}; +var \u{145DB}; +var \u{145DC}; +var \u{145DD}; +var \u{145DE}; +var \u{145DF}; +var \u{145E0}; +var \u{145E1}; +var \u{145E2}; +var \u{145E3}; +var \u{145E4}; +var \u{145E5}; +var \u{145E6}; +var \u{145E7}; +var \u{145E8}; +var \u{145E9}; +var \u{145EA}; +var \u{145EB}; +var \u{145EC}; +var \u{145ED}; +var \u{145EE}; +var \u{145EF}; +var \u{145F0}; +var \u{145F1}; +var \u{145F2}; +var \u{145F3}; +var \u{145F4}; +var \u{145F5}; +var \u{145F6}; +var \u{145F7}; +var \u{145F8}; +var \u{145F9}; +var \u{145FA}; +var \u{145FB}; +var \u{145FC}; +var \u{145FD}; +var \u{145FE}; +var \u{145FF}; +var \u{14600}; +var \u{14601}; +var \u{14602}; +var \u{14603}; +var \u{14604}; +var \u{14605}; +var \u{14606}; +var \u{14607}; +var \u{14608}; +var \u{14609}; +var \u{1460A}; +var \u{1460B}; +var \u{1460C}; +var \u{1460D}; +var \u{1460E}; +var \u{1460F}; +var \u{14610}; +var \u{14611}; +var \u{14612}; +var \u{14613}; +var \u{14614}; +var \u{14615}; +var \u{14616}; +var \u{14617}; +var \u{14618}; +var \u{14619}; +var \u{1461A}; +var \u{1461B}; +var \u{1461C}; +var \u{1461D}; +var \u{1461E}; +var \u{1461F}; +var \u{14620}; +var \u{14621}; +var \u{14622}; +var \u{14623}; +var \u{14624}; +var \u{14625}; +var \u{14626}; +var \u{14627}; +var \u{14628}; +var \u{14629}; +var \u{1462A}; +var \u{1462B}; +var \u{1462C}; +var \u{1462D}; +var \u{1462E}; +var \u{1462F}; +var \u{14630}; +var \u{14631}; +var \u{14632}; +var \u{14633}; +var \u{14634}; +var \u{14635}; +var \u{14636}; +var \u{14637}; +var \u{14638}; +var \u{14639}; +var \u{1463A}; +var \u{1463B}; +var \u{1463C}; +var \u{1463D}; +var \u{1463E}; +var \u{1463F}; +var \u{14640}; +var \u{14641}; +var \u{14642}; +var \u{14643}; +var \u{14644}; +var \u{14645}; +var \u{14646}; +var \u{2B820}; +var \u{2B821}; +var \u{2B822}; +var \u{2B823}; +var \u{2B824}; +var \u{2B825}; +var \u{2B826}; +var \u{2B827}; +var \u{2B828}; +var \u{2B829}; +var \u{2B82A}; +var \u{2B82B}; +var \u{2B82C}; +var \u{2B82D}; +var \u{2B82E}; +var \u{2B82F}; +var \u{2B830}; +var \u{2B831}; +var \u{2B832}; +var \u{2B833}; +var \u{2B834}; +var \u{2B835}; +var \u{2B836}; +var \u{2B837}; +var \u{2B838}; +var \u{2B839}; +var \u{2B83A}; +var \u{2B83B}; +var \u{2B83C}; +var \u{2B83D}; +var \u{2B83E}; +var \u{2B83F}; +var \u{2B840}; +var \u{2B841}; +var \u{2B842}; +var \u{2B843}; +var \u{2B844}; +var \u{2B845}; +var \u{2B846}; +var \u{2B847}; +var \u{2B848}; +var \u{2B849}; +var \u{2B84A}; +var \u{2B84B}; +var \u{2B84C}; +var \u{2B84D}; +var \u{2B84E}; +var \u{2B84F}; +var \u{2B850}; +var \u{2B851}; +var \u{2B852}; +var \u{2B853}; +var \u{2B854}; +var \u{2B855}; +var \u{2B856}; +var \u{2B857}; +var \u{2B858}; +var \u{2B859}; +var \u{2B85A}; +var \u{2B85B}; +var \u{2B85C}; +var \u{2B85D}; +var \u{2B85E}; +var \u{2B85F}; +var \u{2B860}; +var \u{2B861}; +var \u{2B862}; +var \u{2B863}; +var \u{2B864}; +var \u{2B865}; +var \u{2B866}; +var \u{2B867}; +var \u{2B868}; +var \u{2B869}; +var \u{2B86A}; +var \u{2B86B}; +var \u{2B86C}; +var \u{2B86D}; +var \u{2B86E}; +var \u{2B86F}; +var \u{2B870}; +var \u{2B871}; +var \u{2B872}; +var \u{2B873}; +var \u{2B874}; +var \u{2B875}; +var \u{2B876}; +var \u{2B877}; +var \u{2B878}; +var \u{2B879}; +var \u{2B87A}; +var \u{2B87B}; +var \u{2B87C}; +var \u{2B87D}; +var \u{2B87E}; +var \u{2B87F}; +var \u{2B880}; +var \u{2B881}; +var \u{2B882}; +var \u{2B883}; +var \u{2B884}; +var \u{2B885}; +var \u{2B886}; +var \u{2B887}; +var \u{2B888}; +var \u{2B889}; +var \u{2B88A}; +var \u{2B88B}; +var \u{2B88C}; +var \u{2B88D}; +var \u{2B88E}; +var \u{2B88F}; +var \u{2B890}; +var \u{2B891}; +var \u{2B892}; +var \u{2B893}; +var \u{2B894}; +var \u{2B895}; +var \u{2B896}; +var \u{2B897}; +var \u{2B898}; +var \u{2B899}; +var \u{2B89A}; +var \u{2B89B}; +var \u{2B89C}; +var \u{2B89D}; +var \u{2B89E}; +var \u{2B89F}; +var \u{2B8A0}; +var \u{2B8A1}; +var \u{2B8A2}; +var \u{2B8A3}; +var \u{2B8A4}; +var \u{2B8A5}; +var \u{2B8A6}; +var \u{2B8A7}; +var \u{2B8A8}; +var \u{2B8A9}; +var \u{2B8AA}; +var \u{2B8AB}; +var \u{2B8AC}; +var \u{2B8AD}; +var \u{2B8AE}; +var \u{2B8AF}; +var \u{2B8B0}; +var \u{2B8B1}; +var \u{2B8B2}; +var \u{2B8B3}; +var \u{2B8B4}; +var \u{2B8B5}; +var \u{2B8B6}; +var \u{2B8B7}; +var \u{2B8B8}; +var \u{2B8B9}; +var \u{2B8BA}; +var \u{2B8BB}; +var \u{2B8BC}; +var \u{2B8BD}; +var \u{2B8BE}; +var \u{2B8BF}; +var \u{2B8C0}; +var \u{2B8C1}; +var \u{2B8C2}; +var \u{2B8C3}; +var \u{2B8C4}; +var \u{2B8C5}; +var \u{2B8C6}; +var \u{2B8C7}; +var \u{2B8C8}; +var \u{2B8C9}; +var \u{2B8CA}; +var \u{2B8CB}; +var \u{2B8CC}; +var \u{2B8CD}; +var \u{2B8CE}; +var \u{2B8CF}; +var \u{2B8D0}; +var \u{2B8D1}; +var \u{2B8D2}; +var \u{2B8D3}; +var \u{2B8D4}; +var \u{2B8D5}; +var \u{2B8D6}; +var \u{2B8D7}; +var \u{2B8D8}; +var \u{2B8D9}; +var \u{2B8DA}; +var \u{2B8DB}; +var \u{2B8DC}; +var \u{2B8DD}; +var \u{2B8DE}; +var \u{2B8DF}; +var \u{2B8E0}; +var \u{2B8E1}; +var \u{2B8E2}; +var \u{2B8E3}; +var \u{2B8E4}; +var \u{2B8E5}; +var \u{2B8E6}; +var \u{2B8E7}; +var \u{2B8E8}; +var \u{2B8E9}; +var \u{2B8EA}; +var \u{2B8EB}; +var \u{2B8EC}; +var \u{2B8ED}; +var \u{2B8EE}; +var \u{2B8EF}; +var \u{2B8F0}; +var \u{2B8F1}; +var \u{2B8F2}; +var \u{2B8F3}; +var \u{2B8F4}; +var \u{2B8F5}; +var \u{2B8F6}; +var \u{2B8F7}; +var \u{2B8F8}; +var \u{2B8F9}; +var \u{2B8FA}; +var \u{2B8FB}; +var \u{2B8FC}; +var \u{2B8FD}; +var \u{2B8FE}; +var \u{2B8FF}; +var \u{2B900}; +var \u{2B901}; +var \u{2B902}; +var \u{2B903}; +var \u{2B904}; +var \u{2B905}; +var \u{2B906}; +var \u{2B907}; +var \u{2B908}; +var \u{2B909}; +var \u{2B90A}; +var \u{2B90B}; +var \u{2B90C}; +var \u{2B90D}; +var \u{2B90E}; +var \u{2B90F}; +var \u{2B910}; +var \u{2B911}; +var \u{2B912}; +var \u{2B913}; +var \u{2B914}; +var \u{2B915}; +var \u{2B916}; +var \u{2B917}; +var \u{2B918}; +var \u{2B919}; +var \u{2B91A}; +var \u{2B91B}; +var \u{2B91C}; +var \u{2B91D}; +var \u{2B91E}; +var \u{2B91F}; +var \u{2B920}; +var \u{2B921}; +var \u{2B922}; +var \u{2B923}; +var \u{2B924}; +var \u{2B925}; +var \u{2B926}; +var \u{2B927}; +var \u{2B928}; +var \u{2B929}; +var \u{2B92A}; +var \u{2B92B}; +var \u{2B92C}; +var \u{2B92D}; +var \u{2B92E}; +var \u{2B92F}; +var \u{2B930}; +var \u{2B931}; +var \u{2B932}; +var \u{2B933}; +var \u{2B934}; +var \u{2B935}; +var \u{2B936}; +var \u{2B937}; +var \u{2B938}; +var \u{2B939}; +var \u{2B93A}; +var \u{2B93B}; +var \u{2B93C}; +var \u{2B93D}; +var \u{2B93E}; +var \u{2B93F}; +var \u{2B940}; +var \u{2B941}; +var \u{2B942}; +var \u{2B943}; +var \u{2B944}; +var \u{2B945}; +var \u{2B946}; +var \u{2B947}; +var \u{2B948}; +var \u{2B949}; +var \u{2B94A}; +var \u{2B94B}; +var \u{2B94C}; +var \u{2B94D}; +var \u{2B94E}; +var \u{2B94F}; +var \u{2B950}; +var \u{2B951}; +var \u{2B952}; +var \u{2B953}; +var \u{2B954}; +var \u{2B955}; +var \u{2B956}; +var \u{2B957}; +var \u{2B958}; +var \u{2B959}; +var \u{2B95A}; +var \u{2B95B}; +var \u{2B95C}; +var \u{2B95D}; +var \u{2B95E}; +var \u{2B95F}; +var \u{2B960}; +var \u{2B961}; +var \u{2B962}; +var \u{2B963}; +var \u{2B964}; +var \u{2B965}; +var \u{2B966}; +var \u{2B967}; +var \u{2B968}; +var \u{2B969}; +var \u{2B96A}; +var \u{2B96B}; +var \u{2B96C}; +var \u{2B96D}; +var \u{2B96E}; +var \u{2B96F}; +var \u{2B970}; +var \u{2B971}; +var \u{2B972}; +var \u{2B973}; +var \u{2B974}; +var \u{2B975}; +var \u{2B976}; +var \u{2B977}; +var \u{2B978}; +var \u{2B979}; +var \u{2B97A}; +var \u{2B97B}; +var \u{2B97C}; +var \u{2B97D}; +var \u{2B97E}; +var \u{2B97F}; +var \u{2B980}; +var \u{2B981}; +var \u{2B982}; +var \u{2B983}; +var \u{2B984}; +var \u{2B985}; +var \u{2B986}; +var \u{2B987}; +var \u{2B988}; +var \u{2B989}; +var \u{2B98A}; +var \u{2B98B}; +var \u{2B98C}; +var \u{2B98D}; +var \u{2B98E}; +var \u{2B98F}; +var \u{2B990}; +var \u{2B991}; +var \u{2B992}; +var \u{2B993}; +var \u{2B994}; +var \u{2B995}; +var \u{2B996}; +var \u{2B997}; +var \u{2B998}; +var \u{2B999}; +var \u{2B99A}; +var \u{2B99B}; +var \u{2B99C}; +var \u{2B99D}; +var \u{2B99E}; +var \u{2B99F}; +var \u{2B9A0}; +var \u{2B9A1}; +var \u{2B9A2}; +var \u{2B9A3}; +var \u{2B9A4}; +var \u{2B9A5}; +var \u{2B9A6}; +var \u{2B9A7}; +var \u{2B9A8}; +var \u{2B9A9}; +var \u{2B9AA}; +var \u{2B9AB}; +var \u{2B9AC}; +var \u{2B9AD}; +var \u{2B9AE}; +var \u{2B9AF}; +var \u{2B9B0}; +var \u{2B9B1}; +var \u{2B9B2}; +var \u{2B9B3}; +var \u{2B9B4}; +var \u{2B9B5}; +var \u{2B9B6}; +var \u{2B9B7}; +var \u{2B9B8}; +var \u{2B9B9}; +var \u{2B9BA}; +var \u{2B9BB}; +var \u{2B9BC}; +var \u{2B9BD}; +var \u{2B9BE}; +var \u{2B9BF}; +var \u{2B9C0}; +var \u{2B9C1}; +var \u{2B9C2}; +var \u{2B9C3}; +var \u{2B9C4}; +var \u{2B9C5}; +var \u{2B9C6}; +var \u{2B9C7}; +var \u{2B9C8}; +var \u{2B9C9}; +var \u{2B9CA}; +var \u{2B9CB}; +var \u{2B9CC}; +var \u{2B9CD}; +var \u{2B9CE}; +var \u{2B9CF}; +var \u{2B9D0}; +var \u{2B9D1}; +var \u{2B9D2}; +var \u{2B9D3}; +var \u{2B9D4}; +var \u{2B9D5}; +var \u{2B9D6}; +var \u{2B9D7}; +var \u{2B9D8}; +var \u{2B9D9}; +var \u{2B9DA}; +var \u{2B9DB}; +var \u{2B9DC}; +var \u{2B9DD}; +var \u{2B9DE}; +var \u{2B9DF}; +var \u{2B9E0}; +var \u{2B9E1}; +var \u{2B9E2}; +var \u{2B9E3}; +var \u{2B9E4}; +var \u{2B9E5}; +var \u{2B9E6}; +var \u{2B9E7}; +var \u{2B9E8}; +var \u{2B9E9}; +var \u{2B9EA}; +var \u{2B9EB}; +var \u{2B9EC}; +var \u{2B9ED}; +var \u{2B9EE}; +var \u{2B9EF}; +var \u{2B9F0}; +var \u{2B9F1}; +var \u{2B9F2}; +var \u{2B9F3}; +var \u{2B9F4}; +var \u{2B9F5}; +var \u{2B9F6}; +var \u{2B9F7}; +var \u{2B9F8}; +var \u{2B9F9}; +var \u{2B9FA}; +var \u{2B9FB}; +var \u{2B9FC}; +var \u{2B9FD}; +var \u{2B9FE}; +var \u{2B9FF}; +var \u{2BA00}; +var \u{2BA01}; +var \u{2BA02}; +var \u{2BA03}; +var \u{2BA04}; +var \u{2BA05}; +var \u{2BA06}; +var \u{2BA07}; +var \u{2BA08}; +var \u{2BA09}; +var \u{2BA0A}; +var \u{2BA0B}; +var \u{2BA0C}; +var \u{2BA0D}; +var \u{2BA0E}; +var \u{2BA0F}; +var \u{2BA10}; +var \u{2BA11}; +var \u{2BA12}; +var \u{2BA13}; +var \u{2BA14}; +var \u{2BA15}; +var \u{2BA16}; +var \u{2BA17}; +var \u{2BA18}; +var \u{2BA19}; +var \u{2BA1A}; +var \u{2BA1B}; +var \u{2BA1C}; +var \u{2BA1D}; +var \u{2BA1E}; +var \u{2BA1F}; +var \u{2BA20}; +var \u{2BA21}; +var \u{2BA22}; +var \u{2BA23}; +var \u{2BA24}; +var \u{2BA25}; +var \u{2BA26}; +var \u{2BA27}; +var \u{2BA28}; +var \u{2BA29}; +var \u{2BA2A}; +var \u{2BA2B}; +var \u{2BA2C}; +var \u{2BA2D}; +var \u{2BA2E}; +var \u{2BA2F}; +var \u{2BA30}; +var \u{2BA31}; +var \u{2BA32}; +var \u{2BA33}; +var \u{2BA34}; +var \u{2BA35}; +var \u{2BA36}; +var \u{2BA37}; +var \u{2BA38}; +var \u{2BA39}; +var \u{2BA3A}; +var \u{2BA3B}; +var \u{2BA3C}; +var \u{2BA3D}; +var \u{2BA3E}; +var \u{2BA3F}; +var \u{2BA40}; +var \u{2BA41}; +var \u{2BA42}; +var \u{2BA43}; +var \u{2BA44}; +var \u{2BA45}; +var \u{2BA46}; +var \u{2BA47}; +var \u{2BA48}; +var \u{2BA49}; +var \u{2BA4A}; +var \u{2BA4B}; +var \u{2BA4C}; +var \u{2BA4D}; +var \u{2BA4E}; +var \u{2BA4F}; +var \u{2BA50}; +var \u{2BA51}; +var \u{2BA52}; +var \u{2BA53}; +var \u{2BA54}; +var \u{2BA55}; +var \u{2BA56}; +var \u{2BA57}; +var \u{2BA58}; +var \u{2BA59}; +var \u{2BA5A}; +var \u{2BA5B}; +var \u{2BA5C}; +var \u{2BA5D}; +var \u{2BA5E}; +var \u{2BA5F}; +var \u{2BA60}; +var \u{2BA61}; +var \u{2BA62}; +var \u{2BA63}; +var \u{2BA64}; +var \u{2BA65}; +var \u{2BA66}; +var \u{2BA67}; +var \u{2BA68}; +var \u{2BA69}; +var \u{2BA6A}; +var \u{2BA6B}; +var \u{2BA6C}; +var \u{2BA6D}; +var \u{2BA6E}; +var \u{2BA6F}; +var \u{2BA70}; +var \u{2BA71}; +var \u{2BA72}; +var \u{2BA73}; +var \u{2BA74}; +var \u{2BA75}; +var \u{2BA76}; +var \u{2BA77}; +var \u{2BA78}; +var \u{2BA79}; +var \u{2BA7A}; +var \u{2BA7B}; +var \u{2BA7C}; +var \u{2BA7D}; +var \u{2BA7E}; +var \u{2BA7F}; +var \u{2BA80}; +var \u{2BA81}; +var \u{2BA82}; +var \u{2BA83}; +var \u{2BA84}; +var \u{2BA85}; +var \u{2BA86}; +var \u{2BA87}; +var \u{2BA88}; +var \u{2BA89}; +var \u{2BA8A}; +var \u{2BA8B}; +var \u{2BA8C}; +var \u{2BA8D}; +var \u{2BA8E}; +var \u{2BA8F}; +var \u{2BA90}; +var \u{2BA91}; +var \u{2BA92}; +var \u{2BA93}; +var \u{2BA94}; +var \u{2BA95}; +var \u{2BA96}; +var \u{2BA97}; +var \u{2BA98}; +var \u{2BA99}; +var \u{2BA9A}; +var \u{2BA9B}; +var \u{2BA9C}; +var \u{2BA9D}; +var \u{2BA9E}; +var \u{2BA9F}; +var \u{2BAA0}; +var \u{2BAA1}; +var \u{2BAA2}; +var \u{2BAA3}; +var \u{2BAA4}; +var \u{2BAA5}; +var \u{2BAA6}; +var \u{2BAA7}; +var \u{2BAA8}; +var \u{2BAA9}; +var \u{2BAAA}; +var \u{2BAAB}; +var \u{2BAAC}; +var \u{2BAAD}; +var \u{2BAAE}; +var \u{2BAAF}; +var \u{2BAB0}; +var \u{2BAB1}; +var \u{2BAB2}; +var \u{2BAB3}; +var \u{2BAB4}; +var \u{2BAB5}; +var \u{2BAB6}; +var \u{2BAB7}; +var \u{2BAB8}; +var \u{2BAB9}; +var \u{2BABA}; +var \u{2BABB}; +var \u{2BABC}; +var \u{2BABD}; +var \u{2BABE}; +var \u{2BABF}; +var \u{2BAC0}; +var \u{2BAC1}; +var \u{2BAC2}; +var \u{2BAC3}; +var \u{2BAC4}; +var \u{2BAC5}; +var \u{2BAC6}; +var \u{2BAC7}; +var \u{2BAC8}; +var \u{2BAC9}; +var \u{2BACA}; +var \u{2BACB}; +var \u{2BACC}; +var \u{2BACD}; +var \u{2BACE}; +var \u{2BACF}; +var \u{2BAD0}; +var \u{2BAD1}; +var \u{2BAD2}; +var \u{2BAD3}; +var \u{2BAD4}; +var \u{2BAD5}; +var \u{2BAD6}; +var \u{2BAD7}; +var \u{2BAD8}; +var \u{2BAD9}; +var \u{2BADA}; +var \u{2BADB}; +var \u{2BADC}; +var \u{2BADD}; +var \u{2BADE}; +var \u{2BADF}; +var \u{2BAE0}; +var \u{2BAE1}; +var \u{2BAE2}; +var \u{2BAE3}; +var \u{2BAE4}; +var \u{2BAE5}; +var \u{2BAE6}; +var \u{2BAE7}; +var \u{2BAE8}; +var \u{2BAE9}; +var \u{2BAEA}; +var \u{2BAEB}; +var \u{2BAEC}; +var \u{2BAED}; +var \u{2BAEE}; +var \u{2BAEF}; +var \u{2BAF0}; +var \u{2BAF1}; +var \u{2BAF2}; +var \u{2BAF3}; +var \u{2BAF4}; +var \u{2BAF5}; +var \u{2BAF6}; +var \u{2BAF7}; +var \u{2BAF8}; +var \u{2BAF9}; +var \u{2BAFA}; +var \u{2BAFB}; +var \u{2BAFC}; +var \u{2BAFD}; +var \u{2BAFE}; +var \u{2BAFF}; +var \u{2BB00}; +var \u{2BB01}; +var \u{2BB02}; +var \u{2BB03}; +var \u{2BB04}; +var \u{2BB05}; +var \u{2BB06}; +var \u{2BB07}; +var \u{2BB08}; +var \u{2BB09}; +var \u{2BB0A}; +var \u{2BB0B}; +var \u{2BB0C}; +var \u{2BB0D}; +var \u{2BB0E}; +var \u{2BB0F}; +var \u{2BB10}; +var \u{2BB11}; +var \u{2BB12}; +var \u{2BB13}; +var \u{2BB14}; +var \u{2BB15}; +var \u{2BB16}; +var \u{2BB17}; +var \u{2BB18}; +var \u{2BB19}; +var \u{2BB1A}; +var \u{2BB1B}; +var \u{2BB1C}; +var \u{2BB1D}; +var \u{2BB1E}; +var \u{2BB1F}; +var \u{2BB20}; +var \u{2BB21}; +var \u{2BB22}; +var \u{2BB23}; +var \u{2BB24}; +var \u{2BB25}; +var \u{2BB26}; +var \u{2BB27}; +var \u{2BB28}; +var \u{2BB29}; +var \u{2BB2A}; +var \u{2BB2B}; +var \u{2BB2C}; +var \u{2BB2D}; +var \u{2BB2E}; +var \u{2BB2F}; +var \u{2BB30}; +var \u{2BB31}; +var \u{2BB32}; +var \u{2BB33}; +var \u{2BB34}; +var \u{2BB35}; +var \u{2BB36}; +var \u{2BB37}; +var \u{2BB38}; +var \u{2BB39}; +var \u{2BB3A}; +var \u{2BB3B}; +var \u{2BB3C}; +var \u{2BB3D}; +var \u{2BB3E}; +var \u{2BB3F}; +var \u{2BB40}; +var \u{2BB41}; +var \u{2BB42}; +var \u{2BB43}; +var \u{2BB44}; +var \u{2BB45}; +var \u{2BB46}; +var \u{2BB47}; +var \u{2BB48}; +var \u{2BB49}; +var \u{2BB4A}; +var \u{2BB4B}; +var \u{2BB4C}; +var \u{2BB4D}; +var \u{2BB4E}; +var \u{2BB4F}; +var \u{2BB50}; +var \u{2BB51}; +var \u{2BB52}; +var \u{2BB53}; +var \u{2BB54}; +var \u{2BB55}; +var \u{2BB56}; +var \u{2BB57}; +var \u{2BB58}; +var \u{2BB59}; +var \u{2BB5A}; +var \u{2BB5B}; +var \u{2BB5C}; +var \u{2BB5D}; +var \u{2BB5E}; +var \u{2BB5F}; +var \u{2BB60}; +var \u{2BB61}; +var \u{2BB62}; +var \u{2BB63}; +var \u{2BB64}; +var \u{2BB65}; +var \u{2BB66}; +var \u{2BB67}; +var \u{2BB68}; +var \u{2BB69}; +var \u{2BB6A}; +var \u{2BB6B}; +var \u{2BB6C}; +var \u{2BB6D}; +var \u{2BB6E}; +var \u{2BB6F}; +var \u{2BB70}; +var \u{2BB71}; +var \u{2BB72}; +var \u{2BB73}; +var \u{2BB74}; +var \u{2BB75}; +var \u{2BB76}; +var \u{2BB77}; +var \u{2BB78}; +var \u{2BB79}; +var \u{2BB7A}; +var \u{2BB7B}; +var \u{2BB7C}; +var \u{2BB7D}; +var \u{2BB7E}; +var \u{2BB7F}; +var \u{2BB80}; +var \u{2BB81}; +var \u{2BB82}; +var \u{2BB83}; +var \u{2BB84}; +var \u{2BB85}; +var \u{2BB86}; +var \u{2BB87}; +var \u{2BB88}; +var \u{2BB89}; +var \u{2BB8A}; +var \u{2BB8B}; +var \u{2BB8C}; +var \u{2BB8D}; +var \u{2BB8E}; +var \u{2BB8F}; +var \u{2BB90}; +var \u{2BB91}; +var \u{2BB92}; +var \u{2BB93}; +var \u{2BB94}; +var \u{2BB95}; +var \u{2BB96}; +var \u{2BB97}; +var \u{2BB98}; +var \u{2BB99}; +var \u{2BB9A}; +var \u{2BB9B}; +var \u{2BB9C}; +var \u{2BB9D}; +var \u{2BB9E}; +var \u{2BB9F}; +var \u{2BBA0}; +var \u{2BBA1}; +var \u{2BBA2}; +var \u{2BBA3}; +var \u{2BBA4}; +var \u{2BBA5}; +var \u{2BBA6}; +var \u{2BBA7}; +var \u{2BBA8}; +var \u{2BBA9}; +var \u{2BBAA}; +var \u{2BBAB}; +var \u{2BBAC}; +var \u{2BBAD}; +var \u{2BBAE}; +var \u{2BBAF}; +var \u{2BBB0}; +var \u{2BBB1}; +var \u{2BBB2}; +var \u{2BBB3}; +var \u{2BBB4}; +var \u{2BBB5}; +var \u{2BBB6}; +var \u{2BBB7}; +var \u{2BBB8}; +var \u{2BBB9}; +var \u{2BBBA}; +var \u{2BBBB}; +var \u{2BBBC}; +var \u{2BBBD}; +var \u{2BBBE}; +var \u{2BBBF}; +var \u{2BBC0}; +var \u{2BBC1}; +var \u{2BBC2}; +var \u{2BBC3}; +var \u{2BBC4}; +var \u{2BBC5}; +var \u{2BBC6}; +var \u{2BBC7}; +var \u{2BBC8}; +var \u{2BBC9}; +var \u{2BBCA}; +var \u{2BBCB}; +var \u{2BBCC}; +var \u{2BBCD}; +var \u{2BBCE}; +var \u{2BBCF}; +var \u{2BBD0}; +var \u{2BBD1}; +var \u{2BBD2}; +var \u{2BBD3}; +var \u{2BBD4}; +var \u{2BBD5}; +var \u{2BBD6}; +var \u{2BBD7}; +var \u{2BBD8}; +var \u{2BBD9}; +var \u{2BBDA}; +var \u{2BBDB}; +var \u{2BBDC}; +var \u{2BBDD}; +var \u{2BBDE}; +var \u{2BBDF}; +var \u{2BBE0}; +var \u{2BBE1}; +var \u{2BBE2}; +var \u{2BBE3}; +var \u{2BBE4}; +var \u{2BBE5}; +var \u{2BBE6}; +var \u{2BBE7}; +var \u{2BBE8}; +var \u{2BBE9}; +var \u{2BBEA}; +var \u{2BBEB}; +var \u{2BBEC}; +var \u{2BBED}; +var \u{2BBEE}; +var \u{2BBEF}; +var \u{2BBF0}; +var \u{2BBF1}; +var \u{2BBF2}; +var \u{2BBF3}; +var \u{2BBF4}; +var \u{2BBF5}; +var \u{2BBF6}; +var \u{2BBF7}; +var \u{2BBF8}; +var \u{2BBF9}; +var \u{2BBFA}; +var \u{2BBFB}; +var \u{2BBFC}; +var \u{2BBFD}; +var \u{2BBFE}; +var \u{2BBFF}; +var \u{2BC00}; +var \u{2BC01}; +var \u{2BC02}; +var \u{2BC03}; +var \u{2BC04}; +var \u{2BC05}; +var \u{2BC06}; +var \u{2BC07}; +var \u{2BC08}; +var \u{2BC09}; +var \u{2BC0A}; +var \u{2BC0B}; +var \u{2BC0C}; +var \u{2BC0D}; +var \u{2BC0E}; +var \u{2BC0F}; +var \u{2BC10}; +var \u{2BC11}; +var \u{2BC12}; +var \u{2BC13}; +var \u{2BC14}; +var \u{2BC15}; +var \u{2BC16}; +var \u{2BC17}; +var \u{2BC18}; +var \u{2BC19}; +var \u{2BC1A}; +var \u{2BC1B}; +var \u{2BC1C}; +var \u{2BC1D}; +var \u{2BC1E}; +var \u{2BC1F}; +var \u{2BC20}; +var \u{2BC21}; +var \u{2BC22}; +var \u{2BC23}; +var \u{2BC24}; +var \u{2BC25}; +var \u{2BC26}; +var \u{2BC27}; +var \u{2BC28}; +var \u{2BC29}; +var \u{2BC2A}; +var \u{2BC2B}; +var \u{2BC2C}; +var \u{2BC2D}; +var \u{2BC2E}; +var \u{2BC2F}; +var \u{2BC30}; +var \u{2BC31}; +var \u{2BC32}; +var \u{2BC33}; +var \u{2BC34}; +var \u{2BC35}; +var \u{2BC36}; +var \u{2BC37}; +var \u{2BC38}; +var \u{2BC39}; +var \u{2BC3A}; +var \u{2BC3B}; +var \u{2BC3C}; +var \u{2BC3D}; +var \u{2BC3E}; +var \u{2BC3F}; +var \u{2BC40}; +var \u{2BC41}; +var \u{2BC42}; +var \u{2BC43}; +var \u{2BC44}; +var \u{2BC45}; +var \u{2BC46}; +var \u{2BC47}; +var \u{2BC48}; +var \u{2BC49}; +var \u{2BC4A}; +var \u{2BC4B}; +var \u{2BC4C}; +var \u{2BC4D}; +var \u{2BC4E}; +var \u{2BC4F}; +var \u{2BC50}; +var \u{2BC51}; +var \u{2BC52}; +var \u{2BC53}; +var \u{2BC54}; +var \u{2BC55}; +var \u{2BC56}; +var \u{2BC57}; +var \u{2BC58}; +var \u{2BC59}; +var \u{2BC5A}; +var \u{2BC5B}; +var \u{2BC5C}; +var \u{2BC5D}; +var \u{2BC5E}; +var \u{2BC5F}; +var \u{2BC60}; +var \u{2BC61}; +var \u{2BC62}; +var \u{2BC63}; +var \u{2BC64}; +var \u{2BC65}; +var \u{2BC66}; +var \u{2BC67}; +var \u{2BC68}; +var \u{2BC69}; +var \u{2BC6A}; +var \u{2BC6B}; +var \u{2BC6C}; +var \u{2BC6D}; +var \u{2BC6E}; +var \u{2BC6F}; +var \u{2BC70}; +var \u{2BC71}; +var \u{2BC72}; +var \u{2BC73}; +var \u{2BC74}; +var \u{2BC75}; +var \u{2BC76}; +var \u{2BC77}; +var \u{2BC78}; +var \u{2BC79}; +var \u{2BC7A}; +var \u{2BC7B}; +var \u{2BC7C}; +var \u{2BC7D}; +var \u{2BC7E}; +var \u{2BC7F}; +var \u{2BC80}; +var \u{2BC81}; +var \u{2BC82}; +var \u{2BC83}; +var \u{2BC84}; +var \u{2BC85}; +var \u{2BC86}; +var \u{2BC87}; +var \u{2BC88}; +var \u{2BC89}; +var \u{2BC8A}; +var \u{2BC8B}; +var \u{2BC8C}; +var \u{2BC8D}; +var \u{2BC8E}; +var \u{2BC8F}; +var \u{2BC90}; +var \u{2BC91}; +var \u{2BC92}; +var \u{2BC93}; +var \u{2BC94}; +var \u{2BC95}; +var \u{2BC96}; +var \u{2BC97}; +var \u{2BC98}; +var \u{2BC99}; +var \u{2BC9A}; +var \u{2BC9B}; +var \u{2BC9C}; +var \u{2BC9D}; +var \u{2BC9E}; +var \u{2BC9F}; +var \u{2BCA0}; +var \u{2BCA1}; +var \u{2BCA2}; +var \u{2BCA3}; +var \u{2BCA4}; +var \u{2BCA5}; +var \u{2BCA6}; +var \u{2BCA7}; +var \u{2BCA8}; +var \u{2BCA9}; +var \u{2BCAA}; +var \u{2BCAB}; +var \u{2BCAC}; +var \u{2BCAD}; +var \u{2BCAE}; +var \u{2BCAF}; +var \u{2BCB0}; +var \u{2BCB1}; +var \u{2BCB2}; +var \u{2BCB3}; +var \u{2BCB4}; +var \u{2BCB5}; +var \u{2BCB6}; +var \u{2BCB7}; +var \u{2BCB8}; +var \u{2BCB9}; +var \u{2BCBA}; +var \u{2BCBB}; +var \u{2BCBC}; +var \u{2BCBD}; +var \u{2BCBE}; +var \u{2BCBF}; +var \u{2BCC0}; +var \u{2BCC1}; +var \u{2BCC2}; +var \u{2BCC3}; +var \u{2BCC4}; +var \u{2BCC5}; +var \u{2BCC6}; +var \u{2BCC7}; +var \u{2BCC8}; +var \u{2BCC9}; +var \u{2BCCA}; +var \u{2BCCB}; +var \u{2BCCC}; +var \u{2BCCD}; +var \u{2BCCE}; +var \u{2BCCF}; +var \u{2BCD0}; +var \u{2BCD1}; +var \u{2BCD2}; +var \u{2BCD3}; +var \u{2BCD4}; +var \u{2BCD5}; +var \u{2BCD6}; +var \u{2BCD7}; +var \u{2BCD8}; +var \u{2BCD9}; +var \u{2BCDA}; +var \u{2BCDB}; +var \u{2BCDC}; +var \u{2BCDD}; +var \u{2BCDE}; +var \u{2BCDF}; +var \u{2BCE0}; +var \u{2BCE1}; +var \u{2BCE2}; +var \u{2BCE3}; +var \u{2BCE4}; +var \u{2BCE5}; +var \u{2BCE6}; +var \u{2BCE7}; +var \u{2BCE8}; +var \u{2BCE9}; +var \u{2BCEA}; +var \u{2BCEB}; +var \u{2BCEC}; +var \u{2BCED}; +var \u{2BCEE}; +var \u{2BCEF}; +var \u{2BCF0}; +var \u{2BCF1}; +var \u{2BCF2}; +var \u{2BCF3}; +var \u{2BCF4}; +var \u{2BCF5}; +var \u{2BCF6}; +var \u{2BCF7}; +var \u{2BCF8}; +var \u{2BCF9}; +var \u{2BCFA}; +var \u{2BCFB}; +var \u{2BCFC}; +var \u{2BCFD}; +var \u{2BCFE}; +var \u{2BCFF}; +var \u{2BD00}; +var \u{2BD01}; +var \u{2BD02}; +var \u{2BD03}; +var \u{2BD04}; +var \u{2BD05}; +var \u{2BD06}; +var \u{2BD07}; +var \u{2BD08}; +var \u{2BD09}; +var \u{2BD0A}; +var \u{2BD0B}; +var \u{2BD0C}; +var \u{2BD0D}; +var \u{2BD0E}; +var \u{2BD0F}; +var \u{2BD10}; +var \u{2BD11}; +var \u{2BD12}; +var \u{2BD13}; +var \u{2BD14}; +var \u{2BD15}; +var \u{2BD16}; +var \u{2BD17}; +var \u{2BD18}; +var \u{2BD19}; +var \u{2BD1A}; +var \u{2BD1B}; +var \u{2BD1C}; +var \u{2BD1D}; +var \u{2BD1E}; +var \u{2BD1F}; +var \u{2BD20}; +var \u{2BD21}; +var \u{2BD22}; +var \u{2BD23}; +var \u{2BD24}; +var \u{2BD25}; +var \u{2BD26}; +var \u{2BD27}; +var \u{2BD28}; +var \u{2BD29}; +var \u{2BD2A}; +var \u{2BD2B}; +var \u{2BD2C}; +var \u{2BD2D}; +var \u{2BD2E}; +var \u{2BD2F}; +var \u{2BD30}; +var \u{2BD31}; +var \u{2BD32}; +var \u{2BD33}; +var \u{2BD34}; +var \u{2BD35}; +var \u{2BD36}; +var \u{2BD37}; +var \u{2BD38}; +var \u{2BD39}; +var \u{2BD3A}; +var \u{2BD3B}; +var \u{2BD3C}; +var \u{2BD3D}; +var \u{2BD3E}; +var \u{2BD3F}; +var \u{2BD40}; +var \u{2BD41}; +var \u{2BD42}; +var \u{2BD43}; +var \u{2BD44}; +var \u{2BD45}; +var \u{2BD46}; +var \u{2BD47}; +var \u{2BD48}; +var \u{2BD49}; +var \u{2BD4A}; +var \u{2BD4B}; +var \u{2BD4C}; +var \u{2BD4D}; +var \u{2BD4E}; +var \u{2BD4F}; +var \u{2BD50}; +var \u{2BD51}; +var \u{2BD52}; +var \u{2BD53}; +var \u{2BD54}; +var \u{2BD55}; +var \u{2BD56}; +var \u{2BD57}; +var \u{2BD58}; +var \u{2BD59}; +var \u{2BD5A}; +var \u{2BD5B}; +var \u{2BD5C}; +var \u{2BD5D}; +var \u{2BD5E}; +var \u{2BD5F}; +var \u{2BD60}; +var \u{2BD61}; +var \u{2BD62}; +var \u{2BD63}; +var \u{2BD64}; +var \u{2BD65}; +var \u{2BD66}; +var \u{2BD67}; +var \u{2BD68}; +var \u{2BD69}; +var \u{2BD6A}; +var \u{2BD6B}; +var \u{2BD6C}; +var \u{2BD6D}; +var \u{2BD6E}; +var \u{2BD6F}; +var \u{2BD70}; +var \u{2BD71}; +var \u{2BD72}; +var \u{2BD73}; +var \u{2BD74}; +var \u{2BD75}; +var \u{2BD76}; +var \u{2BD77}; +var \u{2BD78}; +var \u{2BD79}; +var \u{2BD7A}; +var \u{2BD7B}; +var \u{2BD7C}; +var \u{2BD7D}; +var \u{2BD7E}; +var \u{2BD7F}; +var \u{2BD80}; +var \u{2BD81}; +var \u{2BD82}; +var \u{2BD83}; +var \u{2BD84}; +var \u{2BD85}; +var \u{2BD86}; +var \u{2BD87}; +var \u{2BD88}; +var \u{2BD89}; +var \u{2BD8A}; +var \u{2BD8B}; +var \u{2BD8C}; +var \u{2BD8D}; +var \u{2BD8E}; +var \u{2BD8F}; +var \u{2BD90}; +var \u{2BD91}; +var \u{2BD92}; +var \u{2BD93}; +var \u{2BD94}; +var \u{2BD95}; +var \u{2BD96}; +var \u{2BD97}; +var \u{2BD98}; +var \u{2BD99}; +var \u{2BD9A}; +var \u{2BD9B}; +var \u{2BD9C}; +var \u{2BD9D}; +var \u{2BD9E}; +var \u{2BD9F}; +var \u{2BDA0}; +var \u{2BDA1}; +var \u{2BDA2}; +var \u{2BDA3}; +var \u{2BDA4}; +var \u{2BDA5}; +var \u{2BDA6}; +var \u{2BDA7}; +var \u{2BDA8}; +var \u{2BDA9}; +var \u{2BDAA}; +var \u{2BDAB}; +var \u{2BDAC}; +var \u{2BDAD}; +var \u{2BDAE}; +var \u{2BDAF}; +var \u{2BDB0}; +var \u{2BDB1}; +var \u{2BDB2}; +var \u{2BDB3}; +var \u{2BDB4}; +var \u{2BDB5}; +var \u{2BDB6}; +var \u{2BDB7}; +var \u{2BDB8}; +var \u{2BDB9}; +var \u{2BDBA}; +var \u{2BDBB}; +var \u{2BDBC}; +var \u{2BDBD}; +var \u{2BDBE}; +var \u{2BDBF}; +var \u{2BDC0}; +var \u{2BDC1}; +var \u{2BDC2}; +var \u{2BDC3}; +var \u{2BDC4}; +var \u{2BDC5}; +var \u{2BDC6}; +var \u{2BDC7}; +var \u{2BDC8}; +var \u{2BDC9}; +var \u{2BDCA}; +var \u{2BDCB}; +var \u{2BDCC}; +var \u{2BDCD}; +var \u{2BDCE}; +var \u{2BDCF}; +var \u{2BDD0}; +var \u{2BDD1}; +var \u{2BDD2}; +var \u{2BDD3}; +var \u{2BDD4}; +var \u{2BDD5}; +var \u{2BDD6}; +var \u{2BDD7}; +var \u{2BDD8}; +var \u{2BDD9}; +var \u{2BDDA}; +var \u{2BDDB}; +var \u{2BDDC}; +var \u{2BDDD}; +var \u{2BDDE}; +var \u{2BDDF}; +var \u{2BDE0}; +var \u{2BDE1}; +var \u{2BDE2}; +var \u{2BDE3}; +var \u{2BDE4}; +var \u{2BDE5}; +var \u{2BDE6}; +var \u{2BDE7}; +var \u{2BDE8}; +var \u{2BDE9}; +var \u{2BDEA}; +var \u{2BDEB}; +var \u{2BDEC}; +var \u{2BDED}; +var \u{2BDEE}; +var \u{2BDEF}; +var \u{2BDF0}; +var \u{2BDF1}; +var \u{2BDF2}; +var \u{2BDF3}; +var \u{2BDF4}; +var \u{2BDF5}; +var \u{2BDF6}; +var \u{2BDF7}; +var \u{2BDF8}; +var \u{2BDF9}; +var \u{2BDFA}; +var \u{2BDFB}; +var \u{2BDFC}; +var \u{2BDFD}; +var \u{2BDFE}; +var \u{2BDFF}; +var \u{2BE00}; +var \u{2BE01}; +var \u{2BE02}; +var \u{2BE03}; +var \u{2BE04}; +var \u{2BE05}; +var \u{2BE06}; +var \u{2BE07}; +var \u{2BE08}; +var \u{2BE09}; +var \u{2BE0A}; +var \u{2BE0B}; +var \u{2BE0C}; +var \u{2BE0D}; +var \u{2BE0E}; +var \u{2BE0F}; +var \u{2BE10}; +var \u{2BE11}; +var \u{2BE12}; +var \u{2BE13}; +var \u{2BE14}; +var \u{2BE15}; +var \u{2BE16}; +var \u{2BE17}; +var \u{2BE18}; +var \u{2BE19}; +var \u{2BE1A}; +var \u{2BE1B}; +var \u{2BE1C}; +var \u{2BE1D}; +var \u{2BE1E}; +var \u{2BE1F}; +var \u{2BE20}; +var \u{2BE21}; +var \u{2BE22}; +var \u{2BE23}; +var \u{2BE24}; +var \u{2BE25}; +var \u{2BE26}; +var \u{2BE27}; +var \u{2BE28}; +var \u{2BE29}; +var \u{2BE2A}; +var \u{2BE2B}; +var \u{2BE2C}; +var \u{2BE2D}; +var \u{2BE2E}; +var \u{2BE2F}; +var \u{2BE30}; +var \u{2BE31}; +var \u{2BE32}; +var \u{2BE33}; +var \u{2BE34}; +var \u{2BE35}; +var \u{2BE36}; +var \u{2BE37}; +var \u{2BE38}; +var \u{2BE39}; +var \u{2BE3A}; +var \u{2BE3B}; +var \u{2BE3C}; +var \u{2BE3D}; +var \u{2BE3E}; +var \u{2BE3F}; +var \u{2BE40}; +var \u{2BE41}; +var \u{2BE42}; +var \u{2BE43}; +var \u{2BE44}; +var \u{2BE45}; +var \u{2BE46}; +var \u{2BE47}; +var \u{2BE48}; +var \u{2BE49}; +var \u{2BE4A}; +var \u{2BE4B}; +var \u{2BE4C}; +var \u{2BE4D}; +var \u{2BE4E}; +var \u{2BE4F}; +var \u{2BE50}; +var \u{2BE51}; +var \u{2BE52}; +var \u{2BE53}; +var \u{2BE54}; +var \u{2BE55}; +var \u{2BE56}; +var \u{2BE57}; +var \u{2BE58}; +var \u{2BE59}; +var \u{2BE5A}; +var \u{2BE5B}; +var \u{2BE5C}; +var \u{2BE5D}; +var \u{2BE5E}; +var \u{2BE5F}; +var \u{2BE60}; +var \u{2BE61}; +var \u{2BE62}; +var \u{2BE63}; +var \u{2BE64}; +var \u{2BE65}; +var \u{2BE66}; +var \u{2BE67}; +var \u{2BE68}; +var \u{2BE69}; +var \u{2BE6A}; +var \u{2BE6B}; +var \u{2BE6C}; +var \u{2BE6D}; +var \u{2BE6E}; +var \u{2BE6F}; +var \u{2BE70}; +var \u{2BE71}; +var \u{2BE72}; +var \u{2BE73}; +var \u{2BE74}; +var \u{2BE75}; +var \u{2BE76}; +var \u{2BE77}; +var \u{2BE78}; +var \u{2BE79}; +var \u{2BE7A}; +var \u{2BE7B}; +var \u{2BE7C}; +var \u{2BE7D}; +var \u{2BE7E}; +var \u{2BE7F}; +var \u{2BE80}; +var \u{2BE81}; +var \u{2BE82}; +var \u{2BE83}; +var \u{2BE84}; +var \u{2BE85}; +var \u{2BE86}; +var \u{2BE87}; +var \u{2BE88}; +var \u{2BE89}; +var \u{2BE8A}; +var \u{2BE8B}; +var \u{2BE8C}; +var \u{2BE8D}; +var \u{2BE8E}; +var \u{2BE8F}; +var \u{2BE90}; +var \u{2BE91}; +var \u{2BE92}; +var \u{2BE93}; +var \u{2BE94}; +var \u{2BE95}; +var \u{2BE96}; +var \u{2BE97}; +var \u{2BE98}; +var \u{2BE99}; +var \u{2BE9A}; +var \u{2BE9B}; +var \u{2BE9C}; +var \u{2BE9D}; +var \u{2BE9E}; +var \u{2BE9F}; +var \u{2BEA0}; +var \u{2BEA1}; +var \u{2BEA2}; +var \u{2BEA3}; +var \u{2BEA4}; +var \u{2BEA5}; +var \u{2BEA6}; +var \u{2BEA7}; +var \u{2BEA8}; +var \u{2BEA9}; +var \u{2BEAA}; +var \u{2BEAB}; +var \u{2BEAC}; +var \u{2BEAD}; +var \u{2BEAE}; +var \u{2BEAF}; +var \u{2BEB0}; +var \u{2BEB1}; +var \u{2BEB2}; +var \u{2BEB3}; +var \u{2BEB4}; +var \u{2BEB5}; +var \u{2BEB6}; +var \u{2BEB7}; +var \u{2BEB8}; +var \u{2BEB9}; +var \u{2BEBA}; +var \u{2BEBB}; +var \u{2BEBC}; +var \u{2BEBD}; +var \u{2BEBE}; +var \u{2BEBF}; +var \u{2BEC0}; +var \u{2BEC1}; +var \u{2BEC2}; +var \u{2BEC3}; +var \u{2BEC4}; +var \u{2BEC5}; +var \u{2BEC6}; +var \u{2BEC7}; +var \u{2BEC8}; +var \u{2BEC9}; +var \u{2BECA}; +var \u{2BECB}; +var \u{2BECC}; +var \u{2BECD}; +var \u{2BECE}; +var \u{2BECF}; +var \u{2BED0}; +var \u{2BED1}; +var \u{2BED2}; +var \u{2BED3}; +var \u{2BED4}; +var \u{2BED5}; +var \u{2BED6}; +var \u{2BED7}; +var \u{2BED8}; +var \u{2BED9}; +var \u{2BEDA}; +var \u{2BEDB}; +var \u{2BEDC}; +var \u{2BEDD}; +var \u{2BEDE}; +var \u{2BEDF}; +var \u{2BEE0}; +var \u{2BEE1}; +var \u{2BEE2}; +var \u{2BEE3}; +var \u{2BEE4}; +var \u{2BEE5}; +var \u{2BEE6}; +var \u{2BEE7}; +var \u{2BEE8}; +var \u{2BEE9}; +var \u{2BEEA}; +var \u{2BEEB}; +var \u{2BEEC}; +var \u{2BEED}; +var \u{2BEEE}; +var \u{2BEEF}; +var \u{2BEF0}; +var \u{2BEF1}; +var \u{2BEF2}; +var \u{2BEF3}; +var \u{2BEF4}; +var \u{2BEF5}; +var \u{2BEF6}; +var \u{2BEF7}; +var \u{2BEF8}; +var \u{2BEF9}; +var \u{2BEFA}; +var \u{2BEFB}; +var \u{2BEFC}; +var \u{2BEFD}; +var \u{2BEFE}; +var \u{2BEFF}; +var \u{2BF00}; +var \u{2BF01}; +var \u{2BF02}; +var \u{2BF03}; +var \u{2BF04}; +var \u{2BF05}; +var \u{2BF06}; +var \u{2BF07}; +var \u{2BF08}; +var \u{2BF09}; +var \u{2BF0A}; +var \u{2BF0B}; +var \u{2BF0C}; +var \u{2BF0D}; +var \u{2BF0E}; +var \u{2BF0F}; +var \u{2BF10}; +var \u{2BF11}; +var \u{2BF12}; +var \u{2BF13}; +var \u{2BF14}; +var \u{2BF15}; +var \u{2BF16}; +var \u{2BF17}; +var \u{2BF18}; +var \u{2BF19}; +var \u{2BF1A}; +var \u{2BF1B}; +var \u{2BF1C}; +var \u{2BF1D}; +var \u{2BF1E}; +var \u{2BF1F}; +var \u{2BF20}; +var \u{2BF21}; +var \u{2BF22}; +var \u{2BF23}; +var \u{2BF24}; +var \u{2BF25}; +var \u{2BF26}; +var \u{2BF27}; +var \u{2BF28}; +var \u{2BF29}; +var \u{2BF2A}; +var \u{2BF2B}; +var \u{2BF2C}; +var \u{2BF2D}; +var \u{2BF2E}; +var \u{2BF2F}; +var \u{2BF30}; +var \u{2BF31}; +var \u{2BF32}; +var \u{2BF33}; +var \u{2BF34}; +var \u{2BF35}; +var \u{2BF36}; +var \u{2BF37}; +var \u{2BF38}; +var \u{2BF39}; +var \u{2BF3A}; +var \u{2BF3B}; +var \u{2BF3C}; +var \u{2BF3D}; +var \u{2BF3E}; +var \u{2BF3F}; +var \u{2BF40}; +var \u{2BF41}; +var \u{2BF42}; +var \u{2BF43}; +var \u{2BF44}; +var \u{2BF45}; +var \u{2BF46}; +var \u{2BF47}; +var \u{2BF48}; +var \u{2BF49}; +var \u{2BF4A}; +var \u{2BF4B}; +var \u{2BF4C}; +var \u{2BF4D}; +var \u{2BF4E}; +var \u{2BF4F}; +var \u{2BF50}; +var \u{2BF51}; +var \u{2BF52}; +var \u{2BF53}; +var \u{2BF54}; +var \u{2BF55}; +var \u{2BF56}; +var \u{2BF57}; +var \u{2BF58}; +var \u{2BF59}; +var \u{2BF5A}; +var \u{2BF5B}; +var \u{2BF5C}; +var \u{2BF5D}; +var \u{2BF5E}; +var \u{2BF5F}; +var \u{2BF60}; +var \u{2BF61}; +var \u{2BF62}; +var \u{2BF63}; +var \u{2BF64}; +var \u{2BF65}; +var \u{2BF66}; +var \u{2BF67}; +var \u{2BF68}; +var \u{2BF69}; +var \u{2BF6A}; +var \u{2BF6B}; +var \u{2BF6C}; +var \u{2BF6D}; +var \u{2BF6E}; +var \u{2BF6F}; +var \u{2BF70}; +var \u{2BF71}; +var \u{2BF72}; +var \u{2BF73}; +var \u{2BF74}; +var \u{2BF75}; +var \u{2BF76}; +var \u{2BF77}; +var \u{2BF78}; +var \u{2BF79}; +var \u{2BF7A}; +var \u{2BF7B}; +var \u{2BF7C}; +var \u{2BF7D}; +var \u{2BF7E}; +var \u{2BF7F}; +var \u{2BF80}; +var \u{2BF81}; +var \u{2BF82}; +var \u{2BF83}; +var \u{2BF84}; +var \u{2BF85}; +var \u{2BF86}; +var \u{2BF87}; +var \u{2BF88}; +var \u{2BF89}; +var \u{2BF8A}; +var \u{2BF8B}; +var \u{2BF8C}; +var \u{2BF8D}; +var \u{2BF8E}; +var \u{2BF8F}; +var \u{2BF90}; +var \u{2BF91}; +var \u{2BF92}; +var \u{2BF93}; +var \u{2BF94}; +var \u{2BF95}; +var \u{2BF96}; +var \u{2BF97}; +var \u{2BF98}; +var \u{2BF99}; +var \u{2BF9A}; +var \u{2BF9B}; +var \u{2BF9C}; +var \u{2BF9D}; +var \u{2BF9E}; +var \u{2BF9F}; +var \u{2BFA0}; +var \u{2BFA1}; +var \u{2BFA2}; +var \u{2BFA3}; +var \u{2BFA4}; +var \u{2BFA5}; +var \u{2BFA6}; +var \u{2BFA7}; +var \u{2BFA8}; +var \u{2BFA9}; +var \u{2BFAA}; +var \u{2BFAB}; +var \u{2BFAC}; +var \u{2BFAD}; +var \u{2BFAE}; +var \u{2BFAF}; +var \u{2BFB0}; +var \u{2BFB1}; +var \u{2BFB2}; +var \u{2BFB3}; +var \u{2BFB4}; +var \u{2BFB5}; +var \u{2BFB6}; +var \u{2BFB7}; +var \u{2BFB8}; +var \u{2BFB9}; +var \u{2BFBA}; +var \u{2BFBB}; +var \u{2BFBC}; +var \u{2BFBD}; +var \u{2BFBE}; +var \u{2BFBF}; +var \u{2BFC0}; +var \u{2BFC1}; +var \u{2BFC2}; +var \u{2BFC3}; +var \u{2BFC4}; +var \u{2BFC5}; +var \u{2BFC6}; +var \u{2BFC7}; +var \u{2BFC8}; +var \u{2BFC9}; +var \u{2BFCA}; +var \u{2BFCB}; +var \u{2BFCC}; +var \u{2BFCD}; +var \u{2BFCE}; +var \u{2BFCF}; +var \u{2BFD0}; +var \u{2BFD1}; +var \u{2BFD2}; +var \u{2BFD3}; +var \u{2BFD4}; +var \u{2BFD5}; +var \u{2BFD6}; +var \u{2BFD7}; +var \u{2BFD8}; +var \u{2BFD9}; +var \u{2BFDA}; +var \u{2BFDB}; +var \u{2BFDC}; +var \u{2BFDD}; +var \u{2BFDE}; +var \u{2BFDF}; +var \u{2BFE0}; +var \u{2BFE1}; +var \u{2BFE2}; +var \u{2BFE3}; +var \u{2BFE4}; +var \u{2BFE5}; +var \u{2BFE6}; +var \u{2BFE7}; +var \u{2BFE8}; +var \u{2BFE9}; +var \u{2BFEA}; +var \u{2BFEB}; +var \u{2BFEC}; +var \u{2BFED}; +var \u{2BFEE}; +var \u{2BFEF}; +var \u{2BFF0}; +var \u{2BFF1}; +var \u{2BFF2}; +var \u{2BFF3}; +var \u{2BFF4}; +var \u{2BFF5}; +var \u{2BFF6}; +var \u{2BFF7}; +var \u{2BFF8}; +var \u{2BFF9}; +var \u{2BFFA}; +var \u{2BFFB}; +var \u{2BFFC}; +var \u{2BFFD}; +var \u{2BFFE}; +var \u{2BFFF}; +var \u{2C000}; +var \u{2C001}; +var \u{2C002}; +var \u{2C003}; +var \u{2C004}; +var \u{2C005}; +var \u{2C006}; +var \u{2C007}; +var \u{2C008}; +var \u{2C009}; +var \u{2C00A}; +var \u{2C00B}; +var \u{2C00C}; +var \u{2C00D}; +var \u{2C00E}; +var \u{2C00F}; +var \u{2C010}; +var \u{2C011}; +var \u{2C012}; +var \u{2C013}; +var \u{2C014}; +var \u{2C015}; +var \u{2C016}; +var \u{2C017}; +var \u{2C018}; +var \u{2C019}; +var \u{2C01A}; +var \u{2C01B}; +var \u{2C01C}; +var \u{2C01D}; +var \u{2C01E}; +var \u{2C01F}; +var \u{2C020}; +var \u{2C021}; +var \u{2C022}; +var \u{2C023}; +var \u{2C024}; +var \u{2C025}; +var \u{2C026}; +var \u{2C027}; +var \u{2C028}; +var \u{2C029}; +var \u{2C02A}; +var \u{2C02B}; +var \u{2C02C}; +var \u{2C02D}; +var \u{2C02E}; +var \u{2C02F}; +var \u{2C030}; +var \u{2C031}; +var \u{2C032}; +var \u{2C033}; +var \u{2C034}; +var \u{2C035}; +var \u{2C036}; +var \u{2C037}; +var \u{2C038}; +var \u{2C039}; +var \u{2C03A}; +var \u{2C03B}; +var \u{2C03C}; +var \u{2C03D}; +var \u{2C03E}; +var \u{2C03F}; +var \u{2C040}; +var \u{2C041}; +var \u{2C042}; +var \u{2C043}; +var \u{2C044}; +var \u{2C045}; +var \u{2C046}; +var \u{2C047}; +var \u{2C048}; +var \u{2C049}; +var \u{2C04A}; +var \u{2C04B}; +var \u{2C04C}; +var \u{2C04D}; +var \u{2C04E}; +var \u{2C04F}; +var \u{2C050}; +var \u{2C051}; +var \u{2C052}; +var \u{2C053}; +var \u{2C054}; +var \u{2C055}; +var \u{2C056}; +var \u{2C057}; +var \u{2C058}; +var \u{2C059}; +var \u{2C05A}; +var \u{2C05B}; +var \u{2C05C}; +var \u{2C05D}; +var \u{2C05E}; +var \u{2C05F}; +var \u{2C060}; +var \u{2C061}; +var \u{2C062}; +var \u{2C063}; +var \u{2C064}; +var \u{2C065}; +var \u{2C066}; +var \u{2C067}; +var \u{2C068}; +var \u{2C069}; +var \u{2C06A}; +var \u{2C06B}; +var \u{2C06C}; +var \u{2C06D}; +var \u{2C06E}; +var \u{2C06F}; +var \u{2C070}; +var \u{2C071}; +var \u{2C072}; +var \u{2C073}; +var \u{2C074}; +var \u{2C075}; +var \u{2C076}; +var \u{2C077}; +var \u{2C078}; +var \u{2C079}; +var \u{2C07A}; +var \u{2C07B}; +var \u{2C07C}; +var \u{2C07D}; +var \u{2C07E}; +var \u{2C07F}; +var \u{2C080}; +var \u{2C081}; +var \u{2C082}; +var \u{2C083}; +var \u{2C084}; +var \u{2C085}; +var \u{2C086}; +var \u{2C087}; +var \u{2C088}; +var \u{2C089}; +var \u{2C08A}; +var \u{2C08B}; +var \u{2C08C}; +var \u{2C08D}; +var \u{2C08E}; +var \u{2C08F}; +var \u{2C090}; +var \u{2C091}; +var \u{2C092}; +var \u{2C093}; +var \u{2C094}; +var \u{2C095}; +var \u{2C096}; +var \u{2C097}; +var \u{2C098}; +var \u{2C099}; +var \u{2C09A}; +var \u{2C09B}; +var \u{2C09C}; +var \u{2C09D}; +var \u{2C09E}; +var \u{2C09F}; +var \u{2C0A0}; +var \u{2C0A1}; +var \u{2C0A2}; +var \u{2C0A3}; +var \u{2C0A4}; +var \u{2C0A5}; +var \u{2C0A6}; +var \u{2C0A7}; +var \u{2C0A8}; +var \u{2C0A9}; +var \u{2C0AA}; +var \u{2C0AB}; +var \u{2C0AC}; +var \u{2C0AD}; +var \u{2C0AE}; +var \u{2C0AF}; +var \u{2C0B0}; +var \u{2C0B1}; +var \u{2C0B2}; +var \u{2C0B3}; +var \u{2C0B4}; +var \u{2C0B5}; +var \u{2C0B6}; +var \u{2C0B7}; +var \u{2C0B8}; +var \u{2C0B9}; +var \u{2C0BA}; +var \u{2C0BB}; +var \u{2C0BC}; +var \u{2C0BD}; +var \u{2C0BE}; +var \u{2C0BF}; +var \u{2C0C0}; +var \u{2C0C1}; +var \u{2C0C2}; +var \u{2C0C3}; +var \u{2C0C4}; +var \u{2C0C5}; +var \u{2C0C6}; +var \u{2C0C7}; +var \u{2C0C8}; +var \u{2C0C9}; +var \u{2C0CA}; +var \u{2C0CB}; +var \u{2C0CC}; +var \u{2C0CD}; +var \u{2C0CE}; +var \u{2C0CF}; +var \u{2C0D0}; +var \u{2C0D1}; +var \u{2C0D2}; +var \u{2C0D3}; +var \u{2C0D4}; +var \u{2C0D5}; +var \u{2C0D6}; +var \u{2C0D7}; +var \u{2C0D8}; +var \u{2C0D9}; +var \u{2C0DA}; +var \u{2C0DB}; +var \u{2C0DC}; +var \u{2C0DD}; +var \u{2C0DE}; +var \u{2C0DF}; +var \u{2C0E0}; +var \u{2C0E1}; +var \u{2C0E2}; +var \u{2C0E3}; +var \u{2C0E4}; +var \u{2C0E5}; +var \u{2C0E6}; +var \u{2C0E7}; +var \u{2C0E8}; +var \u{2C0E9}; +var \u{2C0EA}; +var \u{2C0EB}; +var \u{2C0EC}; +var \u{2C0ED}; +var \u{2C0EE}; +var \u{2C0EF}; +var \u{2C0F0}; +var \u{2C0F1}; +var \u{2C0F2}; +var \u{2C0F3}; +var \u{2C0F4}; +var \u{2C0F5}; +var \u{2C0F6}; +var \u{2C0F7}; +var \u{2C0F8}; +var \u{2C0F9}; +var \u{2C0FA}; +var \u{2C0FB}; +var \u{2C0FC}; +var \u{2C0FD}; +var \u{2C0FE}; +var \u{2C0FF}; +var \u{2C100}; +var \u{2C101}; +var \u{2C102}; +var \u{2C103}; +var \u{2C104}; +var \u{2C105}; +var \u{2C106}; +var \u{2C107}; +var \u{2C108}; +var \u{2C109}; +var \u{2C10A}; +var \u{2C10B}; +var \u{2C10C}; +var \u{2C10D}; +var \u{2C10E}; +var \u{2C10F}; +var \u{2C110}; +var \u{2C111}; +var \u{2C112}; +var \u{2C113}; +var \u{2C114}; +var \u{2C115}; +var \u{2C116}; +var \u{2C117}; +var \u{2C118}; +var \u{2C119}; +var \u{2C11A}; +var \u{2C11B}; +var \u{2C11C}; +var \u{2C11D}; +var \u{2C11E}; +var \u{2C11F}; +var \u{2C120}; +var \u{2C121}; +var \u{2C122}; +var \u{2C123}; +var \u{2C124}; +var \u{2C125}; +var \u{2C126}; +var \u{2C127}; +var \u{2C128}; +var \u{2C129}; +var \u{2C12A}; +var \u{2C12B}; +var \u{2C12C}; +var \u{2C12D}; +var \u{2C12E}; +var \u{2C12F}; +var \u{2C130}; +var \u{2C131}; +var \u{2C132}; +var \u{2C133}; +var \u{2C134}; +var \u{2C135}; +var \u{2C136}; +var \u{2C137}; +var \u{2C138}; +var \u{2C139}; +var \u{2C13A}; +var \u{2C13B}; +var \u{2C13C}; +var \u{2C13D}; +var \u{2C13E}; +var \u{2C13F}; +var \u{2C140}; +var \u{2C141}; +var \u{2C142}; +var \u{2C143}; +var \u{2C144}; +var \u{2C145}; +var \u{2C146}; +var \u{2C147}; +var \u{2C148}; +var \u{2C149}; +var \u{2C14A}; +var \u{2C14B}; +var \u{2C14C}; +var \u{2C14D}; +var \u{2C14E}; +var \u{2C14F}; +var \u{2C150}; +var \u{2C151}; +var \u{2C152}; +var \u{2C153}; +var \u{2C154}; +var \u{2C155}; +var \u{2C156}; +var \u{2C157}; +var \u{2C158}; +var \u{2C159}; +var \u{2C15A}; +var \u{2C15B}; +var \u{2C15C}; +var \u{2C15D}; +var \u{2C15E}; +var \u{2C15F}; +var \u{2C160}; +var \u{2C161}; +var \u{2C162}; +var \u{2C163}; +var \u{2C164}; +var \u{2C165}; +var \u{2C166}; +var \u{2C167}; +var \u{2C168}; +var \u{2C169}; +var \u{2C16A}; +var \u{2C16B}; +var \u{2C16C}; +var \u{2C16D}; +var \u{2C16E}; +var \u{2C16F}; +var \u{2C170}; +var \u{2C171}; +var \u{2C172}; +var \u{2C173}; +var \u{2C174}; +var \u{2C175}; +var \u{2C176}; +var \u{2C177}; +var \u{2C178}; +var \u{2C179}; +var \u{2C17A}; +var \u{2C17B}; +var \u{2C17C}; +var \u{2C17D}; +var \u{2C17E}; +var \u{2C17F}; +var \u{2C180}; +var \u{2C181}; +var \u{2C182}; +var \u{2C183}; +var \u{2C184}; +var \u{2C185}; +var \u{2C186}; +var \u{2C187}; +var \u{2C188}; +var \u{2C189}; +var \u{2C18A}; +var \u{2C18B}; +var \u{2C18C}; +var \u{2C18D}; +var \u{2C18E}; +var \u{2C18F}; +var \u{2C190}; +var \u{2C191}; +var \u{2C192}; +var \u{2C193}; +var \u{2C194}; +var \u{2C195}; +var \u{2C196}; +var \u{2C197}; +var \u{2C198}; +var \u{2C199}; +var \u{2C19A}; +var \u{2C19B}; +var \u{2C19C}; +var \u{2C19D}; +var \u{2C19E}; +var \u{2C19F}; +var \u{2C1A0}; +var \u{2C1A1}; +var \u{2C1A2}; +var \u{2C1A3}; +var \u{2C1A4}; +var \u{2C1A5}; +var \u{2C1A6}; +var \u{2C1A7}; +var \u{2C1A8}; +var \u{2C1A9}; +var \u{2C1AA}; +var \u{2C1AB}; +var \u{2C1AC}; +var \u{2C1AD}; +var \u{2C1AE}; +var \u{2C1AF}; +var \u{2C1B0}; +var \u{2C1B1}; +var \u{2C1B2}; +var \u{2C1B3}; +var \u{2C1B4}; +var \u{2C1B5}; +var \u{2C1B6}; +var \u{2C1B7}; +var \u{2C1B8}; +var \u{2C1B9}; +var \u{2C1BA}; +var \u{2C1BB}; +var \u{2C1BC}; +var \u{2C1BD}; +var \u{2C1BE}; +var \u{2C1BF}; +var \u{2C1C0}; +var \u{2C1C1}; +var \u{2C1C2}; +var \u{2C1C3}; +var \u{2C1C4}; +var \u{2C1C5}; +var \u{2C1C6}; +var \u{2C1C7}; +var \u{2C1C8}; +var \u{2C1C9}; +var \u{2C1CA}; +var \u{2C1CB}; +var \u{2C1CC}; +var \u{2C1CD}; +var \u{2C1CE}; +var \u{2C1CF}; +var \u{2C1D0}; +var \u{2C1D1}; +var \u{2C1D2}; +var \u{2C1D3}; +var \u{2C1D4}; +var \u{2C1D5}; +var \u{2C1D6}; +var \u{2C1D7}; +var \u{2C1D8}; +var \u{2C1D9}; +var \u{2C1DA}; +var \u{2C1DB}; +var \u{2C1DC}; +var \u{2C1DD}; +var \u{2C1DE}; +var \u{2C1DF}; +var \u{2C1E0}; +var \u{2C1E1}; +var \u{2C1E2}; +var \u{2C1E3}; +var \u{2C1E4}; +var \u{2C1E5}; +var \u{2C1E6}; +var \u{2C1E7}; +var \u{2C1E8}; +var \u{2C1E9}; +var \u{2C1EA}; +var \u{2C1EB}; +var \u{2C1EC}; +var \u{2C1ED}; +var \u{2C1EE}; +var \u{2C1EF}; +var \u{2C1F0}; +var \u{2C1F1}; +var \u{2C1F2}; +var \u{2C1F3}; +var \u{2C1F4}; +var \u{2C1F5}; +var \u{2C1F6}; +var \u{2C1F7}; +var \u{2C1F8}; +var \u{2C1F9}; +var \u{2C1FA}; +var \u{2C1FB}; +var \u{2C1FC}; +var \u{2C1FD}; +var \u{2C1FE}; +var \u{2C1FF}; +var \u{2C200}; +var \u{2C201}; +var \u{2C202}; +var \u{2C203}; +var \u{2C204}; +var \u{2C205}; +var \u{2C206}; +var \u{2C207}; +var \u{2C208}; +var \u{2C209}; +var \u{2C20A}; +var \u{2C20B}; +var \u{2C20C}; +var \u{2C20D}; +var \u{2C20E}; +var \u{2C20F}; +var \u{2C210}; +var \u{2C211}; +var \u{2C212}; +var \u{2C213}; +var \u{2C214}; +var \u{2C215}; +var \u{2C216}; +var \u{2C217}; +var \u{2C218}; +var \u{2C219}; +var \u{2C21A}; +var \u{2C21B}; +var \u{2C21C}; +var \u{2C21D}; +var \u{2C21E}; +var \u{2C21F}; +var \u{2C220}; +var \u{2C221}; +var \u{2C222}; +var \u{2C223}; +var \u{2C224}; +var \u{2C225}; +var \u{2C226}; +var \u{2C227}; +var \u{2C228}; +var \u{2C229}; +var \u{2C22A}; +var \u{2C22B}; +var \u{2C22C}; +var \u{2C22D}; +var \u{2C22E}; +var \u{2C22F}; +var \u{2C230}; +var \u{2C231}; +var \u{2C232}; +var \u{2C233}; +var \u{2C234}; +var \u{2C235}; +var \u{2C236}; +var \u{2C237}; +var \u{2C238}; +var \u{2C239}; +var \u{2C23A}; +var \u{2C23B}; +var \u{2C23C}; +var \u{2C23D}; +var \u{2C23E}; +var \u{2C23F}; +var \u{2C240}; +var \u{2C241}; +var \u{2C242}; +var \u{2C243}; +var \u{2C244}; +var \u{2C245}; +var \u{2C246}; +var \u{2C247}; +var \u{2C248}; +var \u{2C249}; +var \u{2C24A}; +var \u{2C24B}; +var \u{2C24C}; +var \u{2C24D}; +var \u{2C24E}; +var \u{2C24F}; +var \u{2C250}; +var \u{2C251}; +var \u{2C252}; +var \u{2C253}; +var \u{2C254}; +var \u{2C255}; +var \u{2C256}; +var \u{2C257}; +var \u{2C258}; +var \u{2C259}; +var \u{2C25A}; +var \u{2C25B}; +var \u{2C25C}; +var \u{2C25D}; +var \u{2C25E}; +var \u{2C25F}; +var \u{2C260}; +var \u{2C261}; +var \u{2C262}; +var \u{2C263}; +var \u{2C264}; +var \u{2C265}; +var \u{2C266}; +var \u{2C267}; +var \u{2C268}; +var \u{2C269}; +var \u{2C26A}; +var \u{2C26B}; +var \u{2C26C}; +var \u{2C26D}; +var \u{2C26E}; +var \u{2C26F}; +var \u{2C270}; +var \u{2C271}; +var \u{2C272}; +var \u{2C273}; +var \u{2C274}; +var \u{2C275}; +var \u{2C276}; +var \u{2C277}; +var \u{2C278}; +var \u{2C279}; +var \u{2C27A}; +var \u{2C27B}; +var \u{2C27C}; +var \u{2C27D}; +var \u{2C27E}; +var \u{2C27F}; +var \u{2C280}; +var \u{2C281}; +var \u{2C282}; +var \u{2C283}; +var \u{2C284}; +var \u{2C285}; +var \u{2C286}; +var \u{2C287}; +var \u{2C288}; +var \u{2C289}; +var \u{2C28A}; +var \u{2C28B}; +var \u{2C28C}; +var \u{2C28D}; +var \u{2C28E}; +var \u{2C28F}; +var \u{2C290}; +var \u{2C291}; +var \u{2C292}; +var \u{2C293}; +var \u{2C294}; +var \u{2C295}; +var \u{2C296}; +var \u{2C297}; +var \u{2C298}; +var \u{2C299}; +var \u{2C29A}; +var \u{2C29B}; +var \u{2C29C}; +var \u{2C29D}; +var \u{2C29E}; +var \u{2C29F}; +var \u{2C2A0}; +var \u{2C2A1}; +var \u{2C2A2}; +var \u{2C2A3}; +var \u{2C2A4}; +var \u{2C2A5}; +var \u{2C2A6}; +var \u{2C2A7}; +var \u{2C2A8}; +var \u{2C2A9}; +var \u{2C2AA}; +var \u{2C2AB}; +var \u{2C2AC}; +var \u{2C2AD}; +var \u{2C2AE}; +var \u{2C2AF}; +var \u{2C2B0}; +var \u{2C2B1}; +var \u{2C2B2}; +var \u{2C2B3}; +var \u{2C2B4}; +var \u{2C2B5}; +var \u{2C2B6}; +var \u{2C2B7}; +var \u{2C2B8}; +var \u{2C2B9}; +var \u{2C2BA}; +var \u{2C2BB}; +var \u{2C2BC}; +var \u{2C2BD}; +var \u{2C2BE}; +var \u{2C2BF}; +var \u{2C2C0}; +var \u{2C2C1}; +var \u{2C2C2}; +var \u{2C2C3}; +var \u{2C2C4}; +var \u{2C2C5}; +var \u{2C2C6}; +var \u{2C2C7}; +var \u{2C2C8}; +var \u{2C2C9}; +var \u{2C2CA}; +var \u{2C2CB}; +var \u{2C2CC}; +var \u{2C2CD}; +var \u{2C2CE}; +var \u{2C2CF}; +var \u{2C2D0}; +var \u{2C2D1}; +var \u{2C2D2}; +var \u{2C2D3}; +var \u{2C2D4}; +var \u{2C2D5}; +var \u{2C2D6}; +var \u{2C2D7}; +var \u{2C2D8}; +var \u{2C2D9}; +var \u{2C2DA}; +var \u{2C2DB}; +var \u{2C2DC}; +var \u{2C2DD}; +var \u{2C2DE}; +var \u{2C2DF}; +var \u{2C2E0}; +var \u{2C2E1}; +var \u{2C2E2}; +var \u{2C2E3}; +var \u{2C2E4}; +var \u{2C2E5}; +var \u{2C2E6}; +var \u{2C2E7}; +var \u{2C2E8}; +var \u{2C2E9}; +var \u{2C2EA}; +var \u{2C2EB}; +var \u{2C2EC}; +var \u{2C2ED}; +var \u{2C2EE}; +var \u{2C2EF}; +var \u{2C2F0}; +var \u{2C2F1}; +var \u{2C2F2}; +var \u{2C2F3}; +var \u{2C2F4}; +var \u{2C2F5}; +var \u{2C2F6}; +var \u{2C2F7}; +var \u{2C2F8}; +var \u{2C2F9}; +var \u{2C2FA}; +var \u{2C2FB}; +var \u{2C2FC}; +var \u{2C2FD}; +var \u{2C2FE}; +var \u{2C2FF}; +var \u{2C300}; +var \u{2C301}; +var \u{2C302}; +var \u{2C303}; +var \u{2C304}; +var \u{2C305}; +var \u{2C306}; +var \u{2C307}; +var \u{2C308}; +var \u{2C309}; +var \u{2C30A}; +var \u{2C30B}; +var \u{2C30C}; +var \u{2C30D}; +var \u{2C30E}; +var \u{2C30F}; +var \u{2C310}; +var \u{2C311}; +var \u{2C312}; +var \u{2C313}; +var \u{2C314}; +var \u{2C315}; +var \u{2C316}; +var \u{2C317}; +var \u{2C318}; +var \u{2C319}; +var \u{2C31A}; +var \u{2C31B}; +var \u{2C31C}; +var \u{2C31D}; +var \u{2C31E}; +var \u{2C31F}; +var \u{2C320}; +var \u{2C321}; +var \u{2C322}; +var \u{2C323}; +var \u{2C324}; +var \u{2C325}; +var \u{2C326}; +var \u{2C327}; +var \u{2C328}; +var \u{2C329}; +var \u{2C32A}; +var \u{2C32B}; +var \u{2C32C}; +var \u{2C32D}; +var \u{2C32E}; +var \u{2C32F}; +var \u{2C330}; +var \u{2C331}; +var \u{2C332}; +var \u{2C333}; +var \u{2C334}; +var \u{2C335}; +var \u{2C336}; +var \u{2C337}; +var \u{2C338}; +var \u{2C339}; +var \u{2C33A}; +var \u{2C33B}; +var \u{2C33C}; +var \u{2C33D}; +var \u{2C33E}; +var \u{2C33F}; +var \u{2C340}; +var \u{2C341}; +var \u{2C342}; +var \u{2C343}; +var \u{2C344}; +var \u{2C345}; +var \u{2C346}; +var \u{2C347}; +var \u{2C348}; +var \u{2C349}; +var \u{2C34A}; +var \u{2C34B}; +var \u{2C34C}; +var \u{2C34D}; +var \u{2C34E}; +var \u{2C34F}; +var \u{2C350}; +var \u{2C351}; +var \u{2C352}; +var \u{2C353}; +var \u{2C354}; +var \u{2C355}; +var \u{2C356}; +var \u{2C357}; +var \u{2C358}; +var \u{2C359}; +var \u{2C35A}; +var \u{2C35B}; +var \u{2C35C}; +var \u{2C35D}; +var \u{2C35E}; +var \u{2C35F}; +var \u{2C360}; +var \u{2C361}; +var \u{2C362}; +var \u{2C363}; +var \u{2C364}; +var \u{2C365}; +var \u{2C366}; +var \u{2C367}; +var \u{2C368}; +var \u{2C369}; +var \u{2C36A}; +var \u{2C36B}; +var \u{2C36C}; +var \u{2C36D}; +var \u{2C36E}; +var \u{2C36F}; +var \u{2C370}; +var \u{2C371}; +var \u{2C372}; +var \u{2C373}; +var \u{2C374}; +var \u{2C375}; +var \u{2C376}; +var \u{2C377}; +var \u{2C378}; +var \u{2C379}; +var \u{2C37A}; +var \u{2C37B}; +var \u{2C37C}; +var \u{2C37D}; +var \u{2C37E}; +var \u{2C37F}; +var \u{2C380}; +var \u{2C381}; +var \u{2C382}; +var \u{2C383}; +var \u{2C384}; +var \u{2C385}; +var \u{2C386}; +var \u{2C387}; +var \u{2C388}; +var \u{2C389}; +var \u{2C38A}; +var \u{2C38B}; +var \u{2C38C}; +var \u{2C38D}; +var \u{2C38E}; +var \u{2C38F}; +var \u{2C390}; +var \u{2C391}; +var \u{2C392}; +var \u{2C393}; +var \u{2C394}; +var \u{2C395}; +var \u{2C396}; +var \u{2C397}; +var \u{2C398}; +var \u{2C399}; +var \u{2C39A}; +var \u{2C39B}; +var \u{2C39C}; +var \u{2C39D}; +var \u{2C39E}; +var \u{2C39F}; +var \u{2C3A0}; +var \u{2C3A1}; +var \u{2C3A2}; +var \u{2C3A3}; +var \u{2C3A4}; +var \u{2C3A5}; +var \u{2C3A6}; +var \u{2C3A7}; +var \u{2C3A8}; +var \u{2C3A9}; +var \u{2C3AA}; +var \u{2C3AB}; +var \u{2C3AC}; +var \u{2C3AD}; +var \u{2C3AE}; +var \u{2C3AF}; +var \u{2C3B0}; +var \u{2C3B1}; +var \u{2C3B2}; +var \u{2C3B3}; +var \u{2C3B4}; +var \u{2C3B5}; +var \u{2C3B6}; +var \u{2C3B7}; +var \u{2C3B8}; +var \u{2C3B9}; +var \u{2C3BA}; +var \u{2C3BB}; +var \u{2C3BC}; +var \u{2C3BD}; +var \u{2C3BE}; +var \u{2C3BF}; +var \u{2C3C0}; +var \u{2C3C1}; +var \u{2C3C2}; +var \u{2C3C3}; +var \u{2C3C4}; +var \u{2C3C5}; +var \u{2C3C6}; +var \u{2C3C7}; +var \u{2C3C8}; +var \u{2C3C9}; +var \u{2C3CA}; +var \u{2C3CB}; +var \u{2C3CC}; +var \u{2C3CD}; +var \u{2C3CE}; +var \u{2C3CF}; +var \u{2C3D0}; +var \u{2C3D1}; +var \u{2C3D2}; +var \u{2C3D3}; +var \u{2C3D4}; +var \u{2C3D5}; +var \u{2C3D6}; +var \u{2C3D7}; +var \u{2C3D8}; +var \u{2C3D9}; +var \u{2C3DA}; +var \u{2C3DB}; +var \u{2C3DC}; +var \u{2C3DD}; +var \u{2C3DE}; +var \u{2C3DF}; +var \u{2C3E0}; +var \u{2C3E1}; +var \u{2C3E2}; +var \u{2C3E3}; +var \u{2C3E4}; +var \u{2C3E5}; +var \u{2C3E6}; +var \u{2C3E7}; +var \u{2C3E8}; +var \u{2C3E9}; +var \u{2C3EA}; +var \u{2C3EB}; +var \u{2C3EC}; +var \u{2C3ED}; +var \u{2C3EE}; +var \u{2C3EF}; +var \u{2C3F0}; +var \u{2C3F1}; +var \u{2C3F2}; +var \u{2C3F3}; +var \u{2C3F4}; +var \u{2C3F5}; +var \u{2C3F6}; +var \u{2C3F7}; +var \u{2C3F8}; +var \u{2C3F9}; +var \u{2C3FA}; +var \u{2C3FB}; +var \u{2C3FC}; +var \u{2C3FD}; +var \u{2C3FE}; +var \u{2C3FF}; +var \u{2C400}; +var \u{2C401}; +var \u{2C402}; +var \u{2C403}; +var \u{2C404}; +var \u{2C405}; +var \u{2C406}; +var \u{2C407}; +var \u{2C408}; +var \u{2C409}; +var \u{2C40A}; +var \u{2C40B}; +var \u{2C40C}; +var \u{2C40D}; +var \u{2C40E}; +var \u{2C40F}; +var \u{2C410}; +var \u{2C411}; +var \u{2C412}; +var \u{2C413}; +var \u{2C414}; +var \u{2C415}; +var \u{2C416}; +var \u{2C417}; +var \u{2C418}; +var \u{2C419}; +var \u{2C41A}; +var \u{2C41B}; +var \u{2C41C}; +var \u{2C41D}; +var \u{2C41E}; +var \u{2C41F}; +var \u{2C420}; +var \u{2C421}; +var \u{2C422}; +var \u{2C423}; +var \u{2C424}; +var \u{2C425}; +var \u{2C426}; +var \u{2C427}; +var \u{2C428}; +var \u{2C429}; +var \u{2C42A}; +var \u{2C42B}; +var \u{2C42C}; +var \u{2C42D}; +var \u{2C42E}; +var \u{2C42F}; +var \u{2C430}; +var \u{2C431}; +var \u{2C432}; +var \u{2C433}; +var \u{2C434}; +var \u{2C435}; +var \u{2C436}; +var \u{2C437}; +var \u{2C438}; +var \u{2C439}; +var \u{2C43A}; +var \u{2C43B}; +var \u{2C43C}; +var \u{2C43D}; +var \u{2C43E}; +var \u{2C43F}; +var \u{2C440}; +var \u{2C441}; +var \u{2C442}; +var \u{2C443}; +var \u{2C444}; +var \u{2C445}; +var \u{2C446}; +var \u{2C447}; +var \u{2C448}; +var \u{2C449}; +var \u{2C44A}; +var \u{2C44B}; +var \u{2C44C}; +var \u{2C44D}; +var \u{2C44E}; +var \u{2C44F}; +var \u{2C450}; +var \u{2C451}; +var \u{2C452}; +var \u{2C453}; +var \u{2C454}; +var \u{2C455}; +var \u{2C456}; +var \u{2C457}; +var \u{2C458}; +var \u{2C459}; +var \u{2C45A}; +var \u{2C45B}; +var \u{2C45C}; +var \u{2C45D}; +var \u{2C45E}; +var \u{2C45F}; +var \u{2C460}; +var \u{2C461}; +var \u{2C462}; +var \u{2C463}; +var \u{2C464}; +var \u{2C465}; +var \u{2C466}; +var \u{2C467}; +var \u{2C468}; +var \u{2C469}; +var \u{2C46A}; +var \u{2C46B}; +var \u{2C46C}; +var \u{2C46D}; +var \u{2C46E}; +var \u{2C46F}; +var \u{2C470}; +var \u{2C471}; +var \u{2C472}; +var \u{2C473}; +var \u{2C474}; +var \u{2C475}; +var \u{2C476}; +var \u{2C477}; +var \u{2C478}; +var \u{2C479}; +var \u{2C47A}; +var \u{2C47B}; +var \u{2C47C}; +var \u{2C47D}; +var \u{2C47E}; +var \u{2C47F}; +var \u{2C480}; +var \u{2C481}; +var \u{2C482}; +var \u{2C483}; +var \u{2C484}; +var \u{2C485}; +var \u{2C486}; +var \u{2C487}; +var \u{2C488}; +var \u{2C489}; +var \u{2C48A}; +var \u{2C48B}; +var \u{2C48C}; +var \u{2C48D}; +var \u{2C48E}; +var \u{2C48F}; +var \u{2C490}; +var \u{2C491}; +var \u{2C492}; +var \u{2C493}; +var \u{2C494}; +var \u{2C495}; +var \u{2C496}; +var \u{2C497}; +var \u{2C498}; +var \u{2C499}; +var \u{2C49A}; +var \u{2C49B}; +var \u{2C49C}; +var \u{2C49D}; +var \u{2C49E}; +var \u{2C49F}; +var \u{2C4A0}; +var \u{2C4A1}; +var \u{2C4A2}; +var \u{2C4A3}; +var \u{2C4A4}; +var \u{2C4A5}; +var \u{2C4A6}; +var \u{2C4A7}; +var \u{2C4A8}; +var \u{2C4A9}; +var \u{2C4AA}; +var \u{2C4AB}; +var \u{2C4AC}; +var \u{2C4AD}; +var \u{2C4AE}; +var \u{2C4AF}; +var \u{2C4B0}; +var \u{2C4B1}; +var \u{2C4B2}; +var \u{2C4B3}; +var \u{2C4B4}; +var \u{2C4B5}; +var \u{2C4B6}; +var \u{2C4B7}; +var \u{2C4B8}; +var \u{2C4B9}; +var \u{2C4BA}; +var \u{2C4BB}; +var \u{2C4BC}; +var \u{2C4BD}; +var \u{2C4BE}; +var \u{2C4BF}; +var \u{2C4C0}; +var \u{2C4C1}; +var \u{2C4C2}; +var \u{2C4C3}; +var \u{2C4C4}; +var \u{2C4C5}; +var \u{2C4C6}; +var \u{2C4C7}; +var \u{2C4C8}; +var \u{2C4C9}; +var \u{2C4CA}; +var \u{2C4CB}; +var \u{2C4CC}; +var \u{2C4CD}; +var \u{2C4CE}; +var \u{2C4CF}; +var \u{2C4D0}; +var \u{2C4D1}; +var \u{2C4D2}; +var \u{2C4D3}; +var \u{2C4D4}; +var \u{2C4D5}; +var \u{2C4D6}; +var \u{2C4D7}; +var \u{2C4D8}; +var \u{2C4D9}; +var \u{2C4DA}; +var \u{2C4DB}; +var \u{2C4DC}; +var \u{2C4DD}; +var \u{2C4DE}; +var \u{2C4DF}; +var \u{2C4E0}; +var \u{2C4E1}; +var \u{2C4E2}; +var \u{2C4E3}; +var \u{2C4E4}; +var \u{2C4E5}; +var \u{2C4E6}; +var \u{2C4E7}; +var \u{2C4E8}; +var \u{2C4E9}; +var \u{2C4EA}; +var \u{2C4EB}; +var \u{2C4EC}; +var \u{2C4ED}; +var \u{2C4EE}; +var \u{2C4EF}; +var \u{2C4F0}; +var \u{2C4F1}; +var \u{2C4F2}; +var \u{2C4F3}; +var \u{2C4F4}; +var \u{2C4F5}; +var \u{2C4F6}; +var \u{2C4F7}; +var \u{2C4F8}; +var \u{2C4F9}; +var \u{2C4FA}; +var \u{2C4FB}; +var \u{2C4FC}; +var \u{2C4FD}; +var \u{2C4FE}; +var \u{2C4FF}; +var \u{2C500}; +var \u{2C501}; +var \u{2C502}; +var \u{2C503}; +var \u{2C504}; +var \u{2C505}; +var \u{2C506}; +var \u{2C507}; +var \u{2C508}; +var \u{2C509}; +var \u{2C50A}; +var \u{2C50B}; +var \u{2C50C}; +var \u{2C50D}; +var \u{2C50E}; +var \u{2C50F}; +var \u{2C510}; +var \u{2C511}; +var \u{2C512}; +var \u{2C513}; +var \u{2C514}; +var \u{2C515}; +var \u{2C516}; +var \u{2C517}; +var \u{2C518}; +var \u{2C519}; +var \u{2C51A}; +var \u{2C51B}; +var \u{2C51C}; +var \u{2C51D}; +var \u{2C51E}; +var \u{2C51F}; +var \u{2C520}; +var \u{2C521}; +var \u{2C522}; +var \u{2C523}; +var \u{2C524}; +var \u{2C525}; +var \u{2C526}; +var \u{2C527}; +var \u{2C528}; +var \u{2C529}; +var \u{2C52A}; +var \u{2C52B}; +var \u{2C52C}; +var \u{2C52D}; +var \u{2C52E}; +var \u{2C52F}; +var \u{2C530}; +var \u{2C531}; +var \u{2C532}; +var \u{2C533}; +var \u{2C534}; +var \u{2C535}; +var \u{2C536}; +var \u{2C537}; +var \u{2C538}; +var \u{2C539}; +var \u{2C53A}; +var \u{2C53B}; +var \u{2C53C}; +var \u{2C53D}; +var \u{2C53E}; +var \u{2C53F}; +var \u{2C540}; +var \u{2C541}; +var \u{2C542}; +var \u{2C543}; +var \u{2C544}; +var \u{2C545}; +var \u{2C546}; +var \u{2C547}; +var \u{2C548}; +var \u{2C549}; +var \u{2C54A}; +var \u{2C54B}; +var \u{2C54C}; +var \u{2C54D}; +var \u{2C54E}; +var \u{2C54F}; +var \u{2C550}; +var \u{2C551}; +var \u{2C552}; +var \u{2C553}; +var \u{2C554}; +var \u{2C555}; +var \u{2C556}; +var \u{2C557}; +var \u{2C558}; +var \u{2C559}; +var \u{2C55A}; +var \u{2C55B}; +var \u{2C55C}; +var \u{2C55D}; +var \u{2C55E}; +var \u{2C55F}; +var \u{2C560}; +var \u{2C561}; +var \u{2C562}; +var \u{2C563}; +var \u{2C564}; +var \u{2C565}; +var \u{2C566}; +var \u{2C567}; +var \u{2C568}; +var \u{2C569}; +var \u{2C56A}; +var \u{2C56B}; +var \u{2C56C}; +var \u{2C56D}; +var \u{2C56E}; +var \u{2C56F}; +var \u{2C570}; +var \u{2C571}; +var \u{2C572}; +var \u{2C573}; +var \u{2C574}; +var \u{2C575}; +var \u{2C576}; +var \u{2C577}; +var \u{2C578}; +var \u{2C579}; +var \u{2C57A}; +var \u{2C57B}; +var \u{2C57C}; +var \u{2C57D}; +var \u{2C57E}; +var \u{2C57F}; +var \u{2C580}; +var \u{2C581}; +var \u{2C582}; +var \u{2C583}; +var \u{2C584}; +var \u{2C585}; +var \u{2C586}; +var \u{2C587}; +var \u{2C588}; +var \u{2C589}; +var \u{2C58A}; +var \u{2C58B}; +var \u{2C58C}; +var \u{2C58D}; +var \u{2C58E}; +var \u{2C58F}; +var \u{2C590}; +var \u{2C591}; +var \u{2C592}; +var \u{2C593}; +var \u{2C594}; +var \u{2C595}; +var \u{2C596}; +var \u{2C597}; +var \u{2C598}; +var \u{2C599}; +var \u{2C59A}; +var \u{2C59B}; +var \u{2C59C}; +var \u{2C59D}; +var \u{2C59E}; +var \u{2C59F}; +var \u{2C5A0}; +var \u{2C5A1}; +var \u{2C5A2}; +var \u{2C5A3}; +var \u{2C5A4}; +var \u{2C5A5}; +var \u{2C5A6}; +var \u{2C5A7}; +var \u{2C5A8}; +var \u{2C5A9}; +var \u{2C5AA}; +var \u{2C5AB}; +var \u{2C5AC}; +var \u{2C5AD}; +var \u{2C5AE}; +var \u{2C5AF}; +var \u{2C5B0}; +var \u{2C5B1}; +var \u{2C5B2}; +var \u{2C5B3}; +var \u{2C5B4}; +var \u{2C5B5}; +var \u{2C5B6}; +var \u{2C5B7}; +var \u{2C5B8}; +var \u{2C5B9}; +var \u{2C5BA}; +var \u{2C5BB}; +var \u{2C5BC}; +var \u{2C5BD}; +var \u{2C5BE}; +var \u{2C5BF}; +var \u{2C5C0}; +var \u{2C5C1}; +var \u{2C5C2}; +var \u{2C5C3}; +var \u{2C5C4}; +var \u{2C5C5}; +var \u{2C5C6}; +var \u{2C5C7}; +var \u{2C5C8}; +var \u{2C5C9}; +var \u{2C5CA}; +var \u{2C5CB}; +var \u{2C5CC}; +var \u{2C5CD}; +var \u{2C5CE}; +var \u{2C5CF}; +var \u{2C5D0}; +var \u{2C5D1}; +var \u{2C5D2}; +var \u{2C5D3}; +var \u{2C5D4}; +var \u{2C5D5}; +var \u{2C5D6}; +var \u{2C5D7}; +var \u{2C5D8}; +var \u{2C5D9}; +var \u{2C5DA}; +var \u{2C5DB}; +var \u{2C5DC}; +var \u{2C5DD}; +var \u{2C5DE}; +var \u{2C5DF}; +var \u{2C5E0}; +var \u{2C5E1}; +var \u{2C5E2}; +var \u{2C5E3}; +var \u{2C5E4}; +var \u{2C5E5}; +var \u{2C5E6}; +var \u{2C5E7}; +var \u{2C5E8}; +var \u{2C5E9}; +var \u{2C5EA}; +var \u{2C5EB}; +var \u{2C5EC}; +var \u{2C5ED}; +var \u{2C5EE}; +var \u{2C5EF}; +var \u{2C5F0}; +var \u{2C5F1}; +var \u{2C5F2}; +var \u{2C5F3}; +var \u{2C5F4}; +var \u{2C5F5}; +var \u{2C5F6}; +var \u{2C5F7}; +var \u{2C5F8}; +var \u{2C5F9}; +var \u{2C5FA}; +var \u{2C5FB}; +var \u{2C5FC}; +var \u{2C5FD}; +var \u{2C5FE}; +var \u{2C5FF}; +var \u{2C600}; +var \u{2C601}; +var \u{2C602}; +var \u{2C603}; +var \u{2C604}; +var \u{2C605}; +var \u{2C606}; +var \u{2C607}; +var \u{2C608}; +var \u{2C609}; +var \u{2C60A}; +var \u{2C60B}; +var \u{2C60C}; +var \u{2C60D}; +var \u{2C60E}; +var \u{2C60F}; +var \u{2C610}; +var \u{2C611}; +var \u{2C612}; +var \u{2C613}; +var \u{2C614}; +var \u{2C615}; +var \u{2C616}; +var \u{2C617}; +var \u{2C618}; +var \u{2C619}; +var \u{2C61A}; +var \u{2C61B}; +var \u{2C61C}; +var \u{2C61D}; +var \u{2C61E}; +var \u{2C61F}; +var \u{2C620}; +var \u{2C621}; +var \u{2C622}; +var \u{2C623}; +var \u{2C624}; +var \u{2C625}; +var \u{2C626}; +var \u{2C627}; +var \u{2C628}; +var \u{2C629}; +var \u{2C62A}; +var \u{2C62B}; +var \u{2C62C}; +var \u{2C62D}; +var \u{2C62E}; +var \u{2C62F}; +var \u{2C630}; +var \u{2C631}; +var \u{2C632}; +var \u{2C633}; +var \u{2C634}; +var \u{2C635}; +var \u{2C636}; +var \u{2C637}; +var \u{2C638}; +var \u{2C639}; +var \u{2C63A}; +var \u{2C63B}; +var \u{2C63C}; +var \u{2C63D}; +var \u{2C63E}; +var \u{2C63F}; +var \u{2C640}; +var \u{2C641}; +var \u{2C642}; +var \u{2C643}; +var \u{2C644}; +var \u{2C645}; +var \u{2C646}; +var \u{2C647}; +var \u{2C648}; +var \u{2C649}; +var \u{2C64A}; +var \u{2C64B}; +var \u{2C64C}; +var \u{2C64D}; +var \u{2C64E}; +var \u{2C64F}; +var \u{2C650}; +var \u{2C651}; +var \u{2C652}; +var \u{2C653}; +var \u{2C654}; +var \u{2C655}; +var \u{2C656}; +var \u{2C657}; +var \u{2C658}; +var \u{2C659}; +var \u{2C65A}; +var \u{2C65B}; +var \u{2C65C}; +var \u{2C65D}; +var \u{2C65E}; +var \u{2C65F}; +var \u{2C660}; +var \u{2C661}; +var \u{2C662}; +var \u{2C663}; +var \u{2C664}; +var \u{2C665}; +var \u{2C666}; +var \u{2C667}; +var \u{2C668}; +var \u{2C669}; +var \u{2C66A}; +var \u{2C66B}; +var \u{2C66C}; +var \u{2C66D}; +var \u{2C66E}; +var \u{2C66F}; +var \u{2C670}; +var \u{2C671}; +var \u{2C672}; +var \u{2C673}; +var \u{2C674}; +var \u{2C675}; +var \u{2C676}; +var \u{2C677}; +var \u{2C678}; +var \u{2C679}; +var \u{2C67A}; +var \u{2C67B}; +var \u{2C67C}; +var \u{2C67D}; +var \u{2C67E}; +var \u{2C67F}; +var \u{2C680}; +var \u{2C681}; +var \u{2C682}; +var \u{2C683}; +var \u{2C684}; +var \u{2C685}; +var \u{2C686}; +var \u{2C687}; +var \u{2C688}; +var \u{2C689}; +var \u{2C68A}; +var \u{2C68B}; +var \u{2C68C}; +var \u{2C68D}; +var \u{2C68E}; +var \u{2C68F}; +var \u{2C690}; +var \u{2C691}; +var \u{2C692}; +var \u{2C693}; +var \u{2C694}; +var \u{2C695}; +var \u{2C696}; +var \u{2C697}; +var \u{2C698}; +var \u{2C699}; +var \u{2C69A}; +var \u{2C69B}; +var \u{2C69C}; +var \u{2C69D}; +var \u{2C69E}; +var \u{2C69F}; +var \u{2C6A0}; +var \u{2C6A1}; +var \u{2C6A2}; +var \u{2C6A3}; +var \u{2C6A4}; +var \u{2C6A5}; +var \u{2C6A6}; +var \u{2C6A7}; +var \u{2C6A8}; +var \u{2C6A9}; +var \u{2C6AA}; +var \u{2C6AB}; +var \u{2C6AC}; +var \u{2C6AD}; +var \u{2C6AE}; +var \u{2C6AF}; +var \u{2C6B0}; +var \u{2C6B1}; +var \u{2C6B2}; +var \u{2C6B3}; +var \u{2C6B4}; +var \u{2C6B5}; +var \u{2C6B6}; +var \u{2C6B7}; +var \u{2C6B8}; +var \u{2C6B9}; +var \u{2C6BA}; +var \u{2C6BB}; +var \u{2C6BC}; +var \u{2C6BD}; +var \u{2C6BE}; +var \u{2C6BF}; +var \u{2C6C0}; +var \u{2C6C1}; +var \u{2C6C2}; +var \u{2C6C3}; +var \u{2C6C4}; +var \u{2C6C5}; +var \u{2C6C6}; +var \u{2C6C7}; +var \u{2C6C8}; +var \u{2C6C9}; +var \u{2C6CA}; +var \u{2C6CB}; +var \u{2C6CC}; +var \u{2C6CD}; +var \u{2C6CE}; +var \u{2C6CF}; +var \u{2C6D0}; +var \u{2C6D1}; +var \u{2C6D2}; +var \u{2C6D3}; +var \u{2C6D4}; +var \u{2C6D5}; +var \u{2C6D6}; +var \u{2C6D7}; +var \u{2C6D8}; +var \u{2C6D9}; +var \u{2C6DA}; +var \u{2C6DB}; +var \u{2C6DC}; +var \u{2C6DD}; +var \u{2C6DE}; +var \u{2C6DF}; +var \u{2C6E0}; +var \u{2C6E1}; +var \u{2C6E2}; +var \u{2C6E3}; +var \u{2C6E4}; +var \u{2C6E5}; +var \u{2C6E6}; +var \u{2C6E7}; +var \u{2C6E8}; +var \u{2C6E9}; +var \u{2C6EA}; +var \u{2C6EB}; +var \u{2C6EC}; +var \u{2C6ED}; +var \u{2C6EE}; +var \u{2C6EF}; +var \u{2C6F0}; +var \u{2C6F1}; +var \u{2C6F2}; +var \u{2C6F3}; +var \u{2C6F4}; +var \u{2C6F5}; +var \u{2C6F6}; +var \u{2C6F7}; +var \u{2C6F8}; +var \u{2C6F9}; +var \u{2C6FA}; +var \u{2C6FB}; +var \u{2C6FC}; +var \u{2C6FD}; +var \u{2C6FE}; +var \u{2C6FF}; +var \u{2C700}; +var \u{2C701}; +var \u{2C702}; +var \u{2C703}; +var \u{2C704}; +var \u{2C705}; +var \u{2C706}; +var \u{2C707}; +var \u{2C708}; +var \u{2C709}; +var \u{2C70A}; +var \u{2C70B}; +var \u{2C70C}; +var \u{2C70D}; +var \u{2C70E}; +var \u{2C70F}; +var \u{2C710}; +var \u{2C711}; +var \u{2C712}; +var \u{2C713}; +var \u{2C714}; +var \u{2C715}; +var \u{2C716}; +var \u{2C717}; +var \u{2C718}; +var \u{2C719}; +var \u{2C71A}; +var \u{2C71B}; +var \u{2C71C}; +var \u{2C71D}; +var \u{2C71E}; +var \u{2C71F}; +var \u{2C720}; +var \u{2C721}; +var \u{2C722}; +var \u{2C723}; +var \u{2C724}; +var \u{2C725}; +var \u{2C726}; +var \u{2C727}; +var \u{2C728}; +var \u{2C729}; +var \u{2C72A}; +var \u{2C72B}; +var \u{2C72C}; +var \u{2C72D}; +var \u{2C72E}; +var \u{2C72F}; +var \u{2C730}; +var \u{2C731}; +var \u{2C732}; +var \u{2C733}; +var \u{2C734}; +var \u{2C735}; +var \u{2C736}; +var \u{2C737}; +var \u{2C738}; +var \u{2C739}; +var \u{2C73A}; +var \u{2C73B}; +var \u{2C73C}; +var \u{2C73D}; +var \u{2C73E}; +var \u{2C73F}; +var \u{2C740}; +var \u{2C741}; +var \u{2C742}; +var \u{2C743}; +var \u{2C744}; +var \u{2C745}; +var \u{2C746}; +var \u{2C747}; +var \u{2C748}; +var \u{2C749}; +var \u{2C74A}; +var \u{2C74B}; +var \u{2C74C}; +var \u{2C74D}; +var \u{2C74E}; +var \u{2C74F}; +var \u{2C750}; +var \u{2C751}; +var \u{2C752}; +var \u{2C753}; +var \u{2C754}; +var \u{2C755}; +var \u{2C756}; +var \u{2C757}; +var \u{2C758}; +var \u{2C759}; +var \u{2C75A}; +var \u{2C75B}; +var \u{2C75C}; +var \u{2C75D}; +var \u{2C75E}; +var \u{2C75F}; +var \u{2C760}; +var \u{2C761}; +var \u{2C762}; +var \u{2C763}; +var \u{2C764}; +var \u{2C765}; +var \u{2C766}; +var \u{2C767}; +var \u{2C768}; +var \u{2C769}; +var \u{2C76A}; +var \u{2C76B}; +var \u{2C76C}; +var \u{2C76D}; +var \u{2C76E}; +var \u{2C76F}; +var \u{2C770}; +var \u{2C771}; +var \u{2C772}; +var \u{2C773}; +var \u{2C774}; +var \u{2C775}; +var \u{2C776}; +var \u{2C777}; +var \u{2C778}; +var \u{2C779}; +var \u{2C77A}; +var \u{2C77B}; +var \u{2C77C}; +var \u{2C77D}; +var \u{2C77E}; +var \u{2C77F}; +var \u{2C780}; +var \u{2C781}; +var \u{2C782}; +var \u{2C783}; +var \u{2C784}; +var \u{2C785}; +var \u{2C786}; +var \u{2C787}; +var \u{2C788}; +var \u{2C789}; +var \u{2C78A}; +var \u{2C78B}; +var \u{2C78C}; +var \u{2C78D}; +var \u{2C78E}; +var \u{2C78F}; +var \u{2C790}; +var \u{2C791}; +var \u{2C792}; +var \u{2C793}; +var \u{2C794}; +var \u{2C795}; +var \u{2C796}; +var \u{2C797}; +var \u{2C798}; +var \u{2C799}; +var \u{2C79A}; +var \u{2C79B}; +var \u{2C79C}; +var \u{2C79D}; +var \u{2C79E}; +var \u{2C79F}; +var \u{2C7A0}; +var \u{2C7A1}; +var \u{2C7A2}; +var \u{2C7A3}; +var \u{2C7A4}; +var \u{2C7A5}; +var \u{2C7A6}; +var \u{2C7A7}; +var \u{2C7A8}; +var \u{2C7A9}; +var \u{2C7AA}; +var \u{2C7AB}; +var \u{2C7AC}; +var \u{2C7AD}; +var \u{2C7AE}; +var \u{2C7AF}; +var \u{2C7B0}; +var \u{2C7B1}; +var \u{2C7B2}; +var \u{2C7B3}; +var \u{2C7B4}; +var \u{2C7B5}; +var \u{2C7B6}; +var \u{2C7B7}; +var \u{2C7B8}; +var \u{2C7B9}; +var \u{2C7BA}; +var \u{2C7BB}; +var \u{2C7BC}; +var \u{2C7BD}; +var \u{2C7BE}; +var \u{2C7BF}; +var \u{2C7C0}; +var \u{2C7C1}; +var \u{2C7C2}; +var \u{2C7C3}; +var \u{2C7C4}; +var \u{2C7C5}; +var \u{2C7C6}; +var \u{2C7C7}; +var \u{2C7C8}; +var \u{2C7C9}; +var \u{2C7CA}; +var \u{2C7CB}; +var \u{2C7CC}; +var \u{2C7CD}; +var \u{2C7CE}; +var \u{2C7CF}; +var \u{2C7D0}; +var \u{2C7D1}; +var \u{2C7D2}; +var \u{2C7D3}; +var \u{2C7D4}; +var \u{2C7D5}; +var \u{2C7D6}; +var \u{2C7D7}; +var \u{2C7D8}; +var \u{2C7D9}; +var \u{2C7DA}; +var \u{2C7DB}; +var \u{2C7DC}; +var \u{2C7DD}; +var \u{2C7DE}; +var \u{2C7DF}; +var \u{2C7E0}; +var \u{2C7E1}; +var \u{2C7E2}; +var \u{2C7E3}; +var \u{2C7E4}; +var \u{2C7E5}; +var \u{2C7E6}; +var \u{2C7E7}; +var \u{2C7E8}; +var \u{2C7E9}; +var \u{2C7EA}; +var \u{2C7EB}; +var \u{2C7EC}; +var \u{2C7ED}; +var \u{2C7EE}; +var \u{2C7EF}; +var \u{2C7F0}; +var \u{2C7F1}; +var \u{2C7F2}; +var \u{2C7F3}; +var \u{2C7F4}; +var \u{2C7F5}; +var \u{2C7F6}; +var \u{2C7F7}; +var \u{2C7F8}; +var \u{2C7F9}; +var \u{2C7FA}; +var \u{2C7FB}; +var \u{2C7FC}; +var \u{2C7FD}; +var \u{2C7FE}; +var \u{2C7FF}; +var \u{2C800}; +var \u{2C801}; +var \u{2C802}; +var \u{2C803}; +var \u{2C804}; +var \u{2C805}; +var \u{2C806}; +var \u{2C807}; +var \u{2C808}; +var \u{2C809}; +var \u{2C80A}; +var \u{2C80B}; +var \u{2C80C}; +var \u{2C80D}; +var \u{2C80E}; +var \u{2C80F}; +var \u{2C810}; +var \u{2C811}; +var \u{2C812}; +var \u{2C813}; +var \u{2C814}; +var \u{2C815}; +var \u{2C816}; +var \u{2C817}; +var \u{2C818}; +var \u{2C819}; +var \u{2C81A}; +var \u{2C81B}; +var \u{2C81C}; +var \u{2C81D}; +var \u{2C81E}; +var \u{2C81F}; +var \u{2C820}; +var \u{2C821}; +var \u{2C822}; +var \u{2C823}; +var \u{2C824}; +var \u{2C825}; +var \u{2C826}; +var \u{2C827}; +var \u{2C828}; +var \u{2C829}; +var \u{2C82A}; +var \u{2C82B}; +var \u{2C82C}; +var \u{2C82D}; +var \u{2C82E}; +var \u{2C82F}; +var \u{2C830}; +var \u{2C831}; +var \u{2C832}; +var \u{2C833}; +var \u{2C834}; +var \u{2C835}; +var \u{2C836}; +var \u{2C837}; +var \u{2C838}; +var \u{2C839}; +var \u{2C83A}; +var \u{2C83B}; +var \u{2C83C}; +var \u{2C83D}; +var \u{2C83E}; +var \u{2C83F}; +var \u{2C840}; +var \u{2C841}; +var \u{2C842}; +var \u{2C843}; +var \u{2C844}; +var \u{2C845}; +var \u{2C846}; +var \u{2C847}; +var \u{2C848}; +var \u{2C849}; +var \u{2C84A}; +var \u{2C84B}; +var \u{2C84C}; +var \u{2C84D}; +var \u{2C84E}; +var \u{2C84F}; +var \u{2C850}; +var \u{2C851}; +var \u{2C852}; +var \u{2C853}; +var \u{2C854}; +var \u{2C855}; +var \u{2C856}; +var \u{2C857}; +var \u{2C858}; +var \u{2C859}; +var \u{2C85A}; +var \u{2C85B}; +var \u{2C85C}; +var \u{2C85D}; +var \u{2C85E}; +var \u{2C85F}; +var \u{2C860}; +var \u{2C861}; +var \u{2C862}; +var \u{2C863}; +var \u{2C864}; +var \u{2C865}; +var \u{2C866}; +var \u{2C867}; +var \u{2C868}; +var \u{2C869}; +var \u{2C86A}; +var \u{2C86B}; +var \u{2C86C}; +var \u{2C86D}; +var \u{2C86E}; +var \u{2C86F}; +var \u{2C870}; +var \u{2C871}; +var \u{2C872}; +var \u{2C873}; +var \u{2C874}; +var \u{2C875}; +var \u{2C876}; +var \u{2C877}; +var \u{2C878}; +var \u{2C879}; +var \u{2C87A}; +var \u{2C87B}; +var \u{2C87C}; +var \u{2C87D}; +var \u{2C87E}; +var \u{2C87F}; +var \u{2C880}; +var \u{2C881}; +var \u{2C882}; +var \u{2C883}; +var \u{2C884}; +var \u{2C885}; +var \u{2C886}; +var \u{2C887}; +var \u{2C888}; +var \u{2C889}; +var \u{2C88A}; +var \u{2C88B}; +var \u{2C88C}; +var \u{2C88D}; +var \u{2C88E}; +var \u{2C88F}; +var \u{2C890}; +var \u{2C891}; +var \u{2C892}; +var \u{2C893}; +var \u{2C894}; +var \u{2C895}; +var \u{2C896}; +var \u{2C897}; +var \u{2C898}; +var \u{2C899}; +var \u{2C89A}; +var \u{2C89B}; +var \u{2C89C}; +var \u{2C89D}; +var \u{2C89E}; +var \u{2C89F}; +var \u{2C8A0}; +var \u{2C8A1}; +var \u{2C8A2}; +var \u{2C8A3}; +var \u{2C8A4}; +var \u{2C8A5}; +var \u{2C8A6}; +var \u{2C8A7}; +var \u{2C8A8}; +var \u{2C8A9}; +var \u{2C8AA}; +var \u{2C8AB}; +var \u{2C8AC}; +var \u{2C8AD}; +var \u{2C8AE}; +var \u{2C8AF}; +var \u{2C8B0}; +var \u{2C8B1}; +var \u{2C8B2}; +var \u{2C8B3}; +var \u{2C8B4}; +var \u{2C8B5}; +var \u{2C8B6}; +var \u{2C8B7}; +var \u{2C8B8}; +var \u{2C8B9}; +var \u{2C8BA}; +var \u{2C8BB}; +var \u{2C8BC}; +var \u{2C8BD}; +var \u{2C8BE}; +var \u{2C8BF}; +var \u{2C8C0}; +var \u{2C8C1}; +var \u{2C8C2}; +var \u{2C8C3}; +var \u{2C8C4}; +var \u{2C8C5}; +var \u{2C8C6}; +var \u{2C8C7}; +var \u{2C8C8}; +var \u{2C8C9}; +var \u{2C8CA}; +var \u{2C8CB}; +var \u{2C8CC}; +var \u{2C8CD}; +var \u{2C8CE}; +var \u{2C8CF}; +var \u{2C8D0}; +var \u{2C8D1}; +var \u{2C8D2}; +var \u{2C8D3}; +var \u{2C8D4}; +var \u{2C8D5}; +var \u{2C8D6}; +var \u{2C8D7}; +var \u{2C8D8}; +var \u{2C8D9}; +var \u{2C8DA}; +var \u{2C8DB}; +var \u{2C8DC}; +var \u{2C8DD}; +var \u{2C8DE}; +var \u{2C8DF}; +var \u{2C8E0}; +var \u{2C8E1}; +var \u{2C8E2}; +var \u{2C8E3}; +var \u{2C8E4}; +var \u{2C8E5}; +var \u{2C8E6}; +var \u{2C8E7}; +var \u{2C8E8}; +var \u{2C8E9}; +var \u{2C8EA}; +var \u{2C8EB}; +var \u{2C8EC}; +var \u{2C8ED}; +var \u{2C8EE}; +var \u{2C8EF}; +var \u{2C8F0}; +var \u{2C8F1}; +var \u{2C8F2}; +var \u{2C8F3}; +var \u{2C8F4}; +var \u{2C8F5}; +var \u{2C8F6}; +var \u{2C8F7}; +var \u{2C8F8}; +var \u{2C8F9}; +var \u{2C8FA}; +var \u{2C8FB}; +var \u{2C8FC}; +var \u{2C8FD}; +var \u{2C8FE}; +var \u{2C8FF}; +var \u{2C900}; +var \u{2C901}; +var \u{2C902}; +var \u{2C903}; +var \u{2C904}; +var \u{2C905}; +var \u{2C906}; +var \u{2C907}; +var \u{2C908}; +var \u{2C909}; +var \u{2C90A}; +var \u{2C90B}; +var \u{2C90C}; +var \u{2C90D}; +var \u{2C90E}; +var \u{2C90F}; +var \u{2C910}; +var \u{2C911}; +var \u{2C912}; +var \u{2C913}; +var \u{2C914}; +var \u{2C915}; +var \u{2C916}; +var \u{2C917}; +var \u{2C918}; +var \u{2C919}; +var \u{2C91A}; +var \u{2C91B}; +var \u{2C91C}; +var \u{2C91D}; +var \u{2C91E}; +var \u{2C91F}; +var \u{2C920}; +var \u{2C921}; +var \u{2C922}; +var \u{2C923}; +var \u{2C924}; +var \u{2C925}; +var \u{2C926}; +var \u{2C927}; +var \u{2C928}; +var \u{2C929}; +var \u{2C92A}; +var \u{2C92B}; +var \u{2C92C}; +var \u{2C92D}; +var \u{2C92E}; +var \u{2C92F}; +var \u{2C930}; +var \u{2C931}; +var \u{2C932}; +var \u{2C933}; +var \u{2C934}; +var \u{2C935}; +var \u{2C936}; +var \u{2C937}; +var \u{2C938}; +var \u{2C939}; +var \u{2C93A}; +var \u{2C93B}; +var \u{2C93C}; +var \u{2C93D}; +var \u{2C93E}; +var \u{2C93F}; +var \u{2C940}; +var \u{2C941}; +var \u{2C942}; +var \u{2C943}; +var \u{2C944}; +var \u{2C945}; +var \u{2C946}; +var \u{2C947}; +var \u{2C948}; +var \u{2C949}; +var \u{2C94A}; +var \u{2C94B}; +var \u{2C94C}; +var \u{2C94D}; +var \u{2C94E}; +var \u{2C94F}; +var \u{2C950}; +var \u{2C951}; +var \u{2C952}; +var \u{2C953}; +var \u{2C954}; +var \u{2C955}; +var \u{2C956}; +var \u{2C957}; +var \u{2C958}; +var \u{2C959}; +var \u{2C95A}; +var \u{2C95B}; +var \u{2C95C}; +var \u{2C95D}; +var \u{2C95E}; +var \u{2C95F}; +var \u{2C960}; +var \u{2C961}; +var \u{2C962}; +var \u{2C963}; +var \u{2C964}; +var \u{2C965}; +var \u{2C966}; +var \u{2C967}; +var \u{2C968}; +var \u{2C969}; +var \u{2C96A}; +var \u{2C96B}; +var \u{2C96C}; +var \u{2C96D}; +var \u{2C96E}; +var \u{2C96F}; +var \u{2C970}; +var \u{2C971}; +var \u{2C972}; +var \u{2C973}; +var \u{2C974}; +var \u{2C975}; +var \u{2C976}; +var \u{2C977}; +var \u{2C978}; +var \u{2C979}; +var \u{2C97A}; +var \u{2C97B}; +var \u{2C97C}; +var \u{2C97D}; +var \u{2C97E}; +var \u{2C97F}; +var \u{2C980}; +var \u{2C981}; +var \u{2C982}; +var \u{2C983}; +var \u{2C984}; +var \u{2C985}; +var \u{2C986}; +var \u{2C987}; +var \u{2C988}; +var \u{2C989}; +var \u{2C98A}; +var \u{2C98B}; +var \u{2C98C}; +var \u{2C98D}; +var \u{2C98E}; +var \u{2C98F}; +var \u{2C990}; +var \u{2C991}; +var \u{2C992}; +var \u{2C993}; +var \u{2C994}; +var \u{2C995}; +var \u{2C996}; +var \u{2C997}; +var \u{2C998}; +var \u{2C999}; +var \u{2C99A}; +var \u{2C99B}; +var \u{2C99C}; +var \u{2C99D}; +var \u{2C99E}; +var \u{2C99F}; +var \u{2C9A0}; +var \u{2C9A1}; +var \u{2C9A2}; +var \u{2C9A3}; +var \u{2C9A4}; +var \u{2C9A5}; +var \u{2C9A6}; +var \u{2C9A7}; +var \u{2C9A8}; +var \u{2C9A9}; +var \u{2C9AA}; +var \u{2C9AB}; +var \u{2C9AC}; +var \u{2C9AD}; +var \u{2C9AE}; +var \u{2C9AF}; +var \u{2C9B0}; +var \u{2C9B1}; +var \u{2C9B2}; +var \u{2C9B3}; +var \u{2C9B4}; +var \u{2C9B5}; +var \u{2C9B6}; +var \u{2C9B7}; +var \u{2C9B8}; +var \u{2C9B9}; +var \u{2C9BA}; +var \u{2C9BB}; +var \u{2C9BC}; +var \u{2C9BD}; +var \u{2C9BE}; +var \u{2C9BF}; +var \u{2C9C0}; +var \u{2C9C1}; +var \u{2C9C2}; +var \u{2C9C3}; +var \u{2C9C4}; +var \u{2C9C5}; +var \u{2C9C6}; +var \u{2C9C7}; +var \u{2C9C8}; +var \u{2C9C9}; +var \u{2C9CA}; +var \u{2C9CB}; +var \u{2C9CC}; +var \u{2C9CD}; +var \u{2C9CE}; +var \u{2C9CF}; +var \u{2C9D0}; +var \u{2C9D1}; +var \u{2C9D2}; +var \u{2C9D3}; +var \u{2C9D4}; +var \u{2C9D5}; +var \u{2C9D6}; +var \u{2C9D7}; +var \u{2C9D8}; +var \u{2C9D9}; +var \u{2C9DA}; +var \u{2C9DB}; +var \u{2C9DC}; +var \u{2C9DD}; +var \u{2C9DE}; +var \u{2C9DF}; +var \u{2C9E0}; +var \u{2C9E1}; +var \u{2C9E2}; +var \u{2C9E3}; +var \u{2C9E4}; +var \u{2C9E5}; +var \u{2C9E6}; +var \u{2C9E7}; +var \u{2C9E8}; +var \u{2C9E9}; +var \u{2C9EA}; +var \u{2C9EB}; +var \u{2C9EC}; +var \u{2C9ED}; +var \u{2C9EE}; +var \u{2C9EF}; +var \u{2C9F0}; +var \u{2C9F1}; +var \u{2C9F2}; +var \u{2C9F3}; +var \u{2C9F4}; +var \u{2C9F5}; +var \u{2C9F6}; +var \u{2C9F7}; +var \u{2C9F8}; +var \u{2C9F9}; +var \u{2C9FA}; +var \u{2C9FB}; +var \u{2C9FC}; +var \u{2C9FD}; +var \u{2C9FE}; +var \u{2C9FF}; +var \u{2CA00}; +var \u{2CA01}; +var \u{2CA02}; +var \u{2CA03}; +var \u{2CA04}; +var \u{2CA05}; +var \u{2CA06}; +var \u{2CA07}; +var \u{2CA08}; +var \u{2CA09}; +var \u{2CA0A}; +var \u{2CA0B}; +var \u{2CA0C}; +var \u{2CA0D}; +var \u{2CA0E}; +var \u{2CA0F}; +var \u{2CA10}; +var \u{2CA11}; +var \u{2CA12}; +var \u{2CA13}; +var \u{2CA14}; +var \u{2CA15}; +var \u{2CA16}; +var \u{2CA17}; +var \u{2CA18}; +var \u{2CA19}; +var \u{2CA1A}; +var \u{2CA1B}; +var \u{2CA1C}; +var \u{2CA1D}; +var \u{2CA1E}; +var \u{2CA1F}; +var \u{2CA20}; +var \u{2CA21}; +var \u{2CA22}; +var \u{2CA23}; +var \u{2CA24}; +var \u{2CA25}; +var \u{2CA26}; +var \u{2CA27}; +var \u{2CA28}; +var \u{2CA29}; +var \u{2CA2A}; +var \u{2CA2B}; +var \u{2CA2C}; +var \u{2CA2D}; +var \u{2CA2E}; +var \u{2CA2F}; +var \u{2CA30}; +var \u{2CA31}; +var \u{2CA32}; +var \u{2CA33}; +var \u{2CA34}; +var \u{2CA35}; +var \u{2CA36}; +var \u{2CA37}; +var \u{2CA38}; +var \u{2CA39}; +var \u{2CA3A}; +var \u{2CA3B}; +var \u{2CA3C}; +var \u{2CA3D}; +var \u{2CA3E}; +var \u{2CA3F}; +var \u{2CA40}; +var \u{2CA41}; +var \u{2CA42}; +var \u{2CA43}; +var \u{2CA44}; +var \u{2CA45}; +var \u{2CA46}; +var \u{2CA47}; +var \u{2CA48}; +var \u{2CA49}; +var \u{2CA4A}; +var \u{2CA4B}; +var \u{2CA4C}; +var \u{2CA4D}; +var \u{2CA4E}; +var \u{2CA4F}; +var \u{2CA50}; +var \u{2CA51}; +var \u{2CA52}; +var \u{2CA53}; +var \u{2CA54}; +var \u{2CA55}; +var \u{2CA56}; +var \u{2CA57}; +var \u{2CA58}; +var \u{2CA59}; +var \u{2CA5A}; +var \u{2CA5B}; +var \u{2CA5C}; +var \u{2CA5D}; +var \u{2CA5E}; +var \u{2CA5F}; +var \u{2CA60}; +var \u{2CA61}; +var \u{2CA62}; +var \u{2CA63}; +var \u{2CA64}; +var \u{2CA65}; +var \u{2CA66}; +var \u{2CA67}; +var \u{2CA68}; +var \u{2CA69}; +var \u{2CA6A}; +var \u{2CA6B}; +var \u{2CA6C}; +var \u{2CA6D}; +var \u{2CA6E}; +var \u{2CA6F}; +var \u{2CA70}; +var \u{2CA71}; +var \u{2CA72}; +var \u{2CA73}; +var \u{2CA74}; +var \u{2CA75}; +var \u{2CA76}; +var \u{2CA77}; +var \u{2CA78}; +var \u{2CA79}; +var \u{2CA7A}; +var \u{2CA7B}; +var \u{2CA7C}; +var \u{2CA7D}; +var \u{2CA7E}; +var \u{2CA7F}; +var \u{2CA80}; +var \u{2CA81}; +var \u{2CA82}; +var \u{2CA83}; +var \u{2CA84}; +var \u{2CA85}; +var \u{2CA86}; +var \u{2CA87}; +var \u{2CA88}; +var \u{2CA89}; +var \u{2CA8A}; +var \u{2CA8B}; +var \u{2CA8C}; +var \u{2CA8D}; +var \u{2CA8E}; +var \u{2CA8F}; +var \u{2CA90}; +var \u{2CA91}; +var \u{2CA92}; +var \u{2CA93}; +var \u{2CA94}; +var \u{2CA95}; +var \u{2CA96}; +var \u{2CA97}; +var \u{2CA98}; +var \u{2CA99}; +var \u{2CA9A}; +var \u{2CA9B}; +var \u{2CA9C}; +var \u{2CA9D}; +var \u{2CA9E}; +var \u{2CA9F}; +var \u{2CAA0}; +var \u{2CAA1}; +var \u{2CAA2}; +var \u{2CAA3}; +var \u{2CAA4}; +var \u{2CAA5}; +var \u{2CAA6}; +var \u{2CAA7}; +var \u{2CAA8}; +var \u{2CAA9}; +var \u{2CAAA}; +var \u{2CAAB}; +var \u{2CAAC}; +var \u{2CAAD}; +var \u{2CAAE}; +var \u{2CAAF}; +var \u{2CAB0}; +var \u{2CAB1}; +var \u{2CAB2}; +var \u{2CAB3}; +var \u{2CAB4}; +var \u{2CAB5}; +var \u{2CAB6}; +var \u{2CAB7}; +var \u{2CAB8}; +var \u{2CAB9}; +var \u{2CABA}; +var \u{2CABB}; +var \u{2CABC}; +var \u{2CABD}; +var \u{2CABE}; +var \u{2CABF}; +var \u{2CAC0}; +var \u{2CAC1}; +var \u{2CAC2}; +var \u{2CAC3}; +var \u{2CAC4}; +var \u{2CAC5}; +var \u{2CAC6}; +var \u{2CAC7}; +var \u{2CAC8}; +var \u{2CAC9}; +var \u{2CACA}; +var \u{2CACB}; +var \u{2CACC}; +var \u{2CACD}; +var \u{2CACE}; +var \u{2CACF}; +var \u{2CAD0}; +var \u{2CAD1}; +var \u{2CAD2}; +var \u{2CAD3}; +var \u{2CAD4}; +var \u{2CAD5}; +var \u{2CAD6}; +var \u{2CAD7}; +var \u{2CAD8}; +var \u{2CAD9}; +var \u{2CADA}; +var \u{2CADB}; +var \u{2CADC}; +var \u{2CADD}; +var \u{2CADE}; +var \u{2CADF}; +var \u{2CAE0}; +var \u{2CAE1}; +var \u{2CAE2}; +var \u{2CAE3}; +var \u{2CAE4}; +var \u{2CAE5}; +var \u{2CAE6}; +var \u{2CAE7}; +var \u{2CAE8}; +var \u{2CAE9}; +var \u{2CAEA}; +var \u{2CAEB}; +var \u{2CAEC}; +var \u{2CAED}; +var \u{2CAEE}; +var \u{2CAEF}; +var \u{2CAF0}; +var \u{2CAF1}; +var \u{2CAF2}; +var \u{2CAF3}; +var \u{2CAF4}; +var \u{2CAF5}; +var \u{2CAF6}; +var \u{2CAF7}; +var \u{2CAF8}; +var \u{2CAF9}; +var \u{2CAFA}; +var \u{2CAFB}; +var \u{2CAFC}; +var \u{2CAFD}; +var \u{2CAFE}; +var \u{2CAFF}; +var \u{2CB00}; +var \u{2CB01}; +var \u{2CB02}; +var \u{2CB03}; +var \u{2CB04}; +var \u{2CB05}; +var \u{2CB06}; +var \u{2CB07}; +var \u{2CB08}; +var \u{2CB09}; +var \u{2CB0A}; +var \u{2CB0B}; +var \u{2CB0C}; +var \u{2CB0D}; +var \u{2CB0E}; +var \u{2CB0F}; +var \u{2CB10}; +var \u{2CB11}; +var \u{2CB12}; +var \u{2CB13}; +var \u{2CB14}; +var \u{2CB15}; +var \u{2CB16}; +var \u{2CB17}; +var \u{2CB18}; +var \u{2CB19}; +var \u{2CB1A}; +var \u{2CB1B}; +var \u{2CB1C}; +var \u{2CB1D}; +var \u{2CB1E}; +var \u{2CB1F}; +var \u{2CB20}; +var \u{2CB21}; +var \u{2CB22}; +var \u{2CB23}; +var \u{2CB24}; +var \u{2CB25}; +var \u{2CB26}; +var \u{2CB27}; +var \u{2CB28}; +var \u{2CB29}; +var \u{2CB2A}; +var \u{2CB2B}; +var \u{2CB2C}; +var \u{2CB2D}; +var \u{2CB2E}; +var \u{2CB2F}; +var \u{2CB30}; +var \u{2CB31}; +var \u{2CB32}; +var \u{2CB33}; +var \u{2CB34}; +var \u{2CB35}; +var \u{2CB36}; +var \u{2CB37}; +var \u{2CB38}; +var \u{2CB39}; +var \u{2CB3A}; +var \u{2CB3B}; +var \u{2CB3C}; +var \u{2CB3D}; +var \u{2CB3E}; +var \u{2CB3F}; +var \u{2CB40}; +var \u{2CB41}; +var \u{2CB42}; +var \u{2CB43}; +var \u{2CB44}; +var \u{2CB45}; +var \u{2CB46}; +var \u{2CB47}; +var \u{2CB48}; +var \u{2CB49}; +var \u{2CB4A}; +var \u{2CB4B}; +var \u{2CB4C}; +var \u{2CB4D}; +var \u{2CB4E}; +var \u{2CB4F}; +var \u{2CB50}; +var \u{2CB51}; +var \u{2CB52}; +var \u{2CB53}; +var \u{2CB54}; +var \u{2CB55}; +var \u{2CB56}; +var \u{2CB57}; +var \u{2CB58}; +var \u{2CB59}; +var \u{2CB5A}; +var \u{2CB5B}; +var \u{2CB5C}; +var \u{2CB5D}; +var \u{2CB5E}; +var \u{2CB5F}; +var \u{2CB60}; +var \u{2CB61}; +var \u{2CB62}; +var \u{2CB63}; +var \u{2CB64}; +var \u{2CB65}; +var \u{2CB66}; +var \u{2CB67}; +var \u{2CB68}; +var \u{2CB69}; +var \u{2CB6A}; +var \u{2CB6B}; +var \u{2CB6C}; +var \u{2CB6D}; +var \u{2CB6E}; +var \u{2CB6F}; +var \u{2CB70}; +var \u{2CB71}; +var \u{2CB72}; +var \u{2CB73}; +var \u{2CB74}; +var \u{2CB75}; +var \u{2CB76}; +var \u{2CB77}; +var \u{2CB78}; +var \u{2CB79}; +var \u{2CB7A}; +var \u{2CB7B}; +var \u{2CB7C}; +var \u{2CB7D}; +var \u{2CB7E}; +var \u{2CB7F}; +var \u{2CB80}; +var \u{2CB81}; +var \u{2CB82}; +var \u{2CB83}; +var \u{2CB84}; +var \u{2CB85}; +var \u{2CB86}; +var \u{2CB87}; +var \u{2CB88}; +var \u{2CB89}; +var \u{2CB8A}; +var \u{2CB8B}; +var \u{2CB8C}; +var \u{2CB8D}; +var \u{2CB8E}; +var \u{2CB8F}; +var \u{2CB90}; +var \u{2CB91}; +var \u{2CB92}; +var \u{2CB93}; +var \u{2CB94}; +var \u{2CB95}; +var \u{2CB96}; +var \u{2CB97}; +var \u{2CB98}; +var \u{2CB99}; +var \u{2CB9A}; +var \u{2CB9B}; +var \u{2CB9C}; +var \u{2CB9D}; +var \u{2CB9E}; +var \u{2CB9F}; +var \u{2CBA0}; +var \u{2CBA1}; +var \u{2CBA2}; +var \u{2CBA3}; +var \u{2CBA4}; +var \u{2CBA5}; +var \u{2CBA6}; +var \u{2CBA7}; +var \u{2CBA8}; +var \u{2CBA9}; +var \u{2CBAA}; +var \u{2CBAB}; +var \u{2CBAC}; +var \u{2CBAD}; +var \u{2CBAE}; +var \u{2CBAF}; +var \u{2CBB0}; +var \u{2CBB1}; +var \u{2CBB2}; +var \u{2CBB3}; +var \u{2CBB4}; +var \u{2CBB5}; +var \u{2CBB6}; +var \u{2CBB7}; +var \u{2CBB8}; +var \u{2CBB9}; +var \u{2CBBA}; +var \u{2CBBB}; +var \u{2CBBC}; +var \u{2CBBD}; +var \u{2CBBE}; +var \u{2CBBF}; +var \u{2CBC0}; +var \u{2CBC1}; +var \u{2CBC2}; +var \u{2CBC3}; +var \u{2CBC4}; +var \u{2CBC5}; +var \u{2CBC6}; +var \u{2CBC7}; +var \u{2CBC8}; +var \u{2CBC9}; +var \u{2CBCA}; +var \u{2CBCB}; +var \u{2CBCC}; +var \u{2CBCD}; +var \u{2CBCE}; +var \u{2CBCF}; +var \u{2CBD0}; +var \u{2CBD1}; +var \u{2CBD2}; +var \u{2CBD3}; +var \u{2CBD4}; +var \u{2CBD5}; +var \u{2CBD6}; +var \u{2CBD7}; +var \u{2CBD8}; +var \u{2CBD9}; +var \u{2CBDA}; +var \u{2CBDB}; +var \u{2CBDC}; +var \u{2CBDD}; +var \u{2CBDE}; +var \u{2CBDF}; +var \u{2CBE0}; +var \u{2CBE1}; +var \u{2CBE2}; +var \u{2CBE3}; +var \u{2CBE4}; +var \u{2CBE5}; +var \u{2CBE6}; +var \u{2CBE7}; +var \u{2CBE8}; +var \u{2CBE9}; +var \u{2CBEA}; +var \u{2CBEB}; +var \u{2CBEC}; +var \u{2CBED}; +var \u{2CBEE}; +var \u{2CBEF}; +var \u{2CBF0}; +var \u{2CBF1}; +var \u{2CBF2}; +var \u{2CBF3}; +var \u{2CBF4}; +var \u{2CBF5}; +var \u{2CBF6}; +var \u{2CBF7}; +var \u{2CBF8}; +var \u{2CBF9}; +var \u{2CBFA}; +var \u{2CBFB}; +var \u{2CBFC}; +var \u{2CBFD}; +var \u{2CBFE}; +var \u{2CBFF}; +var \u{2CC00}; +var \u{2CC01}; +var \u{2CC02}; +var \u{2CC03}; +var \u{2CC04}; +var \u{2CC05}; +var \u{2CC06}; +var \u{2CC07}; +var \u{2CC08}; +var \u{2CC09}; +var \u{2CC0A}; +var \u{2CC0B}; +var \u{2CC0C}; +var \u{2CC0D}; +var \u{2CC0E}; +var \u{2CC0F}; +var \u{2CC10}; +var \u{2CC11}; +var \u{2CC12}; +var \u{2CC13}; +var \u{2CC14}; +var \u{2CC15}; +var \u{2CC16}; +var \u{2CC17}; +var \u{2CC18}; +var \u{2CC19}; +var \u{2CC1A}; +var \u{2CC1B}; +var \u{2CC1C}; +var \u{2CC1D}; +var \u{2CC1E}; +var \u{2CC1F}; +var \u{2CC20}; +var \u{2CC21}; +var \u{2CC22}; +var \u{2CC23}; +var \u{2CC24}; +var \u{2CC25}; +var \u{2CC26}; +var \u{2CC27}; +var \u{2CC28}; +var \u{2CC29}; +var \u{2CC2A}; +var \u{2CC2B}; +var \u{2CC2C}; +var \u{2CC2D}; +var \u{2CC2E}; +var \u{2CC2F}; +var \u{2CC30}; +var \u{2CC31}; +var \u{2CC32}; +var \u{2CC33}; +var \u{2CC34}; +var \u{2CC35}; +var \u{2CC36}; +var \u{2CC37}; +var \u{2CC38}; +var \u{2CC39}; +var \u{2CC3A}; +var \u{2CC3B}; +var \u{2CC3C}; +var \u{2CC3D}; +var \u{2CC3E}; +var \u{2CC3F}; +var \u{2CC40}; +var \u{2CC41}; +var \u{2CC42}; +var \u{2CC43}; +var \u{2CC44}; +var \u{2CC45}; +var \u{2CC46}; +var \u{2CC47}; +var \u{2CC48}; +var \u{2CC49}; +var \u{2CC4A}; +var \u{2CC4B}; +var \u{2CC4C}; +var \u{2CC4D}; +var \u{2CC4E}; +var \u{2CC4F}; +var \u{2CC50}; +var \u{2CC51}; +var \u{2CC52}; +var \u{2CC53}; +var \u{2CC54}; +var \u{2CC55}; +var \u{2CC56}; +var \u{2CC57}; +var \u{2CC58}; +var \u{2CC59}; +var \u{2CC5A}; +var \u{2CC5B}; +var \u{2CC5C}; +var \u{2CC5D}; +var \u{2CC5E}; +var \u{2CC5F}; +var \u{2CC60}; +var \u{2CC61}; +var \u{2CC62}; +var \u{2CC63}; +var \u{2CC64}; +var \u{2CC65}; +var \u{2CC66}; +var \u{2CC67}; +var \u{2CC68}; +var \u{2CC69}; +var \u{2CC6A}; +var \u{2CC6B}; +var \u{2CC6C}; +var \u{2CC6D}; +var \u{2CC6E}; +var \u{2CC6F}; +var \u{2CC70}; +var \u{2CC71}; +var \u{2CC72}; +var \u{2CC73}; +var \u{2CC74}; +var \u{2CC75}; +var \u{2CC76}; +var \u{2CC77}; +var \u{2CC78}; +var \u{2CC79}; +var \u{2CC7A}; +var \u{2CC7B}; +var \u{2CC7C}; +var \u{2CC7D}; +var \u{2CC7E}; +var \u{2CC7F}; +var \u{2CC80}; +var \u{2CC81}; +var \u{2CC82}; +var \u{2CC83}; +var \u{2CC84}; +var \u{2CC85}; +var \u{2CC86}; +var \u{2CC87}; +var \u{2CC88}; +var \u{2CC89}; +var \u{2CC8A}; +var \u{2CC8B}; +var \u{2CC8C}; +var \u{2CC8D}; +var \u{2CC8E}; +var \u{2CC8F}; +var \u{2CC90}; +var \u{2CC91}; +var \u{2CC92}; +var \u{2CC93}; +var \u{2CC94}; +var \u{2CC95}; +var \u{2CC96}; +var \u{2CC97}; +var \u{2CC98}; +var \u{2CC99}; +var \u{2CC9A}; +var \u{2CC9B}; +var \u{2CC9C}; +var \u{2CC9D}; +var \u{2CC9E}; +var \u{2CC9F}; +var \u{2CCA0}; +var \u{2CCA1}; +var \u{2CCA2}; +var \u{2CCA3}; +var \u{2CCA4}; +var \u{2CCA5}; +var \u{2CCA6}; +var \u{2CCA7}; +var \u{2CCA8}; +var \u{2CCA9}; +var \u{2CCAA}; +var \u{2CCAB}; +var \u{2CCAC}; +var \u{2CCAD}; +var \u{2CCAE}; +var \u{2CCAF}; +var \u{2CCB0}; +var \u{2CCB1}; +var \u{2CCB2}; +var \u{2CCB3}; +var \u{2CCB4}; +var \u{2CCB5}; +var \u{2CCB6}; +var \u{2CCB7}; +var \u{2CCB8}; +var \u{2CCB9}; +var \u{2CCBA}; +var \u{2CCBB}; +var \u{2CCBC}; +var \u{2CCBD}; +var \u{2CCBE}; +var \u{2CCBF}; +var \u{2CCC0}; +var \u{2CCC1}; +var \u{2CCC2}; +var \u{2CCC3}; +var \u{2CCC4}; +var \u{2CCC5}; +var \u{2CCC6}; +var \u{2CCC7}; +var \u{2CCC8}; +var \u{2CCC9}; +var \u{2CCCA}; +var \u{2CCCB}; +var \u{2CCCC}; +var \u{2CCCD}; +var \u{2CCCE}; +var \u{2CCCF}; +var \u{2CCD0}; +var \u{2CCD1}; +var \u{2CCD2}; +var \u{2CCD3}; +var \u{2CCD4}; +var \u{2CCD5}; +var \u{2CCD6}; +var \u{2CCD7}; +var \u{2CCD8}; +var \u{2CCD9}; +var \u{2CCDA}; +var \u{2CCDB}; +var \u{2CCDC}; +var \u{2CCDD}; +var \u{2CCDE}; +var \u{2CCDF}; +var \u{2CCE0}; +var \u{2CCE1}; +var \u{2CCE2}; +var \u{2CCE3}; +var \u{2CCE4}; +var \u{2CCE5}; +var \u{2CCE6}; +var \u{2CCE7}; +var \u{2CCE8}; +var \u{2CCE9}; +var \u{2CCEA}; +var \u{2CCEB}; +var \u{2CCEC}; +var \u{2CCED}; +var \u{2CCEE}; +var \u{2CCEF}; +var \u{2CCF0}; +var \u{2CCF1}; +var \u{2CCF2}; +var \u{2CCF3}; +var \u{2CCF4}; +var \u{2CCF5}; +var \u{2CCF6}; +var \u{2CCF7}; +var \u{2CCF8}; +var \u{2CCF9}; +var \u{2CCFA}; +var \u{2CCFB}; +var \u{2CCFC}; +var \u{2CCFD}; +var \u{2CCFE}; +var \u{2CCFF}; +var \u{2CD00}; +var \u{2CD01}; +var \u{2CD02}; +var \u{2CD03}; +var \u{2CD04}; +var \u{2CD05}; +var \u{2CD06}; +var \u{2CD07}; +var \u{2CD08}; +var \u{2CD09}; +var \u{2CD0A}; +var \u{2CD0B}; +var \u{2CD0C}; +var \u{2CD0D}; +var \u{2CD0E}; +var \u{2CD0F}; +var \u{2CD10}; +var \u{2CD11}; +var \u{2CD12}; +var \u{2CD13}; +var \u{2CD14}; +var \u{2CD15}; +var \u{2CD16}; +var \u{2CD17}; +var \u{2CD18}; +var \u{2CD19}; +var \u{2CD1A}; +var \u{2CD1B}; +var \u{2CD1C}; +var \u{2CD1D}; +var \u{2CD1E}; +var \u{2CD1F}; +var \u{2CD20}; +var \u{2CD21}; +var \u{2CD22}; +var \u{2CD23}; +var \u{2CD24}; +var \u{2CD25}; +var \u{2CD26}; +var \u{2CD27}; +var \u{2CD28}; +var \u{2CD29}; +var \u{2CD2A}; +var \u{2CD2B}; +var \u{2CD2C}; +var \u{2CD2D}; +var \u{2CD2E}; +var \u{2CD2F}; +var \u{2CD30}; +var \u{2CD31}; +var \u{2CD32}; +var \u{2CD33}; +var \u{2CD34}; +var \u{2CD35}; +var \u{2CD36}; +var \u{2CD37}; +var \u{2CD38}; +var \u{2CD39}; +var \u{2CD3A}; +var \u{2CD3B}; +var \u{2CD3C}; +var \u{2CD3D}; +var \u{2CD3E}; +var \u{2CD3F}; +var \u{2CD40}; +var \u{2CD41}; +var \u{2CD42}; +var \u{2CD43}; +var \u{2CD44}; +var \u{2CD45}; +var \u{2CD46}; +var \u{2CD47}; +var \u{2CD48}; +var \u{2CD49}; +var \u{2CD4A}; +var \u{2CD4B}; +var \u{2CD4C}; +var \u{2CD4D}; +var \u{2CD4E}; +var \u{2CD4F}; +var \u{2CD50}; +var \u{2CD51}; +var \u{2CD52}; +var \u{2CD53}; +var \u{2CD54}; +var \u{2CD55}; +var \u{2CD56}; +var \u{2CD57}; +var \u{2CD58}; +var \u{2CD59}; +var \u{2CD5A}; +var \u{2CD5B}; +var \u{2CD5C}; +var \u{2CD5D}; +var \u{2CD5E}; +var \u{2CD5F}; +var \u{2CD60}; +var \u{2CD61}; +var \u{2CD62}; +var \u{2CD63}; +var \u{2CD64}; +var \u{2CD65}; +var \u{2CD66}; +var \u{2CD67}; +var \u{2CD68}; +var \u{2CD69}; +var \u{2CD6A}; +var \u{2CD6B}; +var \u{2CD6C}; +var \u{2CD6D}; +var \u{2CD6E}; +var \u{2CD6F}; +var \u{2CD70}; +var \u{2CD71}; +var \u{2CD72}; +var \u{2CD73}; +var \u{2CD74}; +var \u{2CD75}; +var \u{2CD76}; +var \u{2CD77}; +var \u{2CD78}; +var \u{2CD79}; +var \u{2CD7A}; +var \u{2CD7B}; +var \u{2CD7C}; +var \u{2CD7D}; +var \u{2CD7E}; +var \u{2CD7F}; +var \u{2CD80}; +var \u{2CD81}; +var \u{2CD82}; +var \u{2CD83}; +var \u{2CD84}; +var \u{2CD85}; +var \u{2CD86}; +var \u{2CD87}; +var \u{2CD88}; +var \u{2CD89}; +var \u{2CD8A}; +var \u{2CD8B}; +var \u{2CD8C}; +var \u{2CD8D}; +var \u{2CD8E}; +var \u{2CD8F}; +var \u{2CD90}; +var \u{2CD91}; +var \u{2CD92}; +var \u{2CD93}; +var \u{2CD94}; +var \u{2CD95}; +var \u{2CD96}; +var \u{2CD97}; +var \u{2CD98}; +var \u{2CD99}; +var \u{2CD9A}; +var \u{2CD9B}; +var \u{2CD9C}; +var \u{2CD9D}; +var \u{2CD9E}; +var \u{2CD9F}; +var \u{2CDA0}; +var \u{2CDA1}; +var \u{2CDA2}; +var \u{2CDA3}; +var \u{2CDA4}; +var \u{2CDA5}; +var \u{2CDA6}; +var \u{2CDA7}; +var \u{2CDA8}; +var \u{2CDA9}; +var \u{2CDAA}; +var \u{2CDAB}; +var \u{2CDAC}; +var \u{2CDAD}; +var \u{2CDAE}; +var \u{2CDAF}; +var \u{2CDB0}; +var \u{2CDB1}; +var \u{2CDB2}; +var \u{2CDB3}; +var \u{2CDB4}; +var \u{2CDB5}; +var \u{2CDB6}; +var \u{2CDB7}; +var \u{2CDB8}; +var \u{2CDB9}; +var \u{2CDBA}; +var \u{2CDBB}; +var \u{2CDBC}; +var \u{2CDBD}; +var \u{2CDBE}; +var \u{2CDBF}; +var \u{2CDC0}; +var \u{2CDC1}; +var \u{2CDC2}; +var \u{2CDC3}; +var \u{2CDC4}; +var \u{2CDC5}; +var \u{2CDC6}; +var \u{2CDC7}; +var \u{2CDC8}; +var \u{2CDC9}; +var \u{2CDCA}; +var \u{2CDCB}; +var \u{2CDCC}; +var \u{2CDCD}; +var \u{2CDCE}; +var \u{2CDCF}; +var \u{2CDD0}; +var \u{2CDD1}; +var \u{2CDD2}; +var \u{2CDD3}; +var \u{2CDD4}; +var \u{2CDD5}; +var \u{2CDD6}; +var \u{2CDD7}; +var \u{2CDD8}; +var \u{2CDD9}; +var \u{2CDDA}; +var \u{2CDDB}; +var \u{2CDDC}; +var \u{2CDDD}; +var \u{2CDDE}; +var \u{2CDDF}; +var \u{2CDE0}; +var \u{2CDE1}; +var \u{2CDE2}; +var \u{2CDE3}; +var \u{2CDE4}; +var \u{2CDE5}; +var \u{2CDE6}; +var \u{2CDE7}; +var \u{2CDE8}; +var \u{2CDE9}; +var \u{2CDEA}; +var \u{2CDEB}; +var \u{2CDEC}; +var \u{2CDED}; +var \u{2CDEE}; +var \u{2CDEF}; +var \u{2CDF0}; +var \u{2CDF1}; +var \u{2CDF2}; +var \u{2CDF3}; +var \u{2CDF4}; +var \u{2CDF5}; +var \u{2CDF6}; +var \u{2CDF7}; +var \u{2CDF8}; +var \u{2CDF9}; +var \u{2CDFA}; +var \u{2CDFB}; +var \u{2CDFC}; +var \u{2CDFD}; +var \u{2CDFE}; +var \u{2CDFF}; +var \u{2CE00}; +var \u{2CE01}; +var \u{2CE02}; +var \u{2CE03}; +var \u{2CE04}; +var \u{2CE05}; +var \u{2CE06}; +var \u{2CE07}; +var \u{2CE08}; +var \u{2CE09}; +var \u{2CE0A}; +var \u{2CE0B}; +var \u{2CE0C}; +var \u{2CE0D}; +var \u{2CE0E}; +var \u{2CE0F}; +var \u{2CE10}; +var \u{2CE11}; +var \u{2CE12}; +var \u{2CE13}; +var \u{2CE14}; +var \u{2CE15}; +var \u{2CE16}; +var \u{2CE17}; +var \u{2CE18}; +var \u{2CE19}; +var \u{2CE1A}; +var \u{2CE1B}; +var \u{2CE1C}; +var \u{2CE1D}; +var \u{2CE1E}; +var \u{2CE1F}; +var \u{2CE20}; +var \u{2CE21}; +var \u{2CE22}; +var \u{2CE23}; +var \u{2CE24}; +var \u{2CE25}; +var \u{2CE26}; +var \u{2CE27}; +var \u{2CE28}; +var \u{2CE29}; +var \u{2CE2A}; +var \u{2CE2B}; +var \u{2CE2C}; +var \u{2CE2D}; +var \u{2CE2E}; +var \u{2CE2F}; +var \u{2CE30}; +var \u{2CE31}; +var \u{2CE32}; +var \u{2CE33}; +var \u{2CE34}; +var \u{2CE35}; +var \u{2CE36}; +var \u{2CE37}; +var \u{2CE38}; +var \u{2CE39}; +var \u{2CE3A}; +var \u{2CE3B}; +var \u{2CE3C}; +var \u{2CE3D}; +var \u{2CE3E}; +var \u{2CE3F}; +var \u{2CE40}; +var \u{2CE41}; +var \u{2CE42}; +var \u{2CE43}; +var \u{2CE44}; +var \u{2CE45}; +var \u{2CE46}; +var \u{2CE47}; +var \u{2CE48}; +var \u{2CE49}; +var \u{2CE4A}; +var \u{2CE4B}; +var \u{2CE4C}; +var \u{2CE4D}; +var \u{2CE4E}; +var \u{2CE4F}; +var \u{2CE50}; +var \u{2CE51}; +var \u{2CE52}; +var \u{2CE53}; +var \u{2CE54}; +var \u{2CE55}; +var \u{2CE56}; +var \u{2CE57}; +var \u{2CE58}; +var \u{2CE59}; +var \u{2CE5A}; +var \u{2CE5B}; +var \u{2CE5C}; +var \u{2CE5D}; +var \u{2CE5E}; +var \u{2CE5F}; +var \u{2CE60}; +var \u{2CE61}; +var \u{2CE62}; +var \u{2CE63}; +var \u{2CE64}; +var \u{2CE65}; +var \u{2CE66}; +var \u{2CE67}; +var \u{2CE68}; +var \u{2CE69}; +var \u{2CE6A}; +var \u{2CE6B}; +var \u{2CE6C}; +var \u{2CE6D}; +var \u{2CE6E}; +var \u{2CE6F}; +var \u{2CE70}; +var \u{2CE71}; +var \u{2CE72}; +var \u{2CE73}; +var \u{2CE74}; +var \u{2CE75}; +var \u{2CE76}; +var \u{2CE77}; +var \u{2CE78}; +var \u{2CE79}; +var \u{2CE7A}; +var \u{2CE7B}; +var \u{2CE7C}; +var \u{2CE7D}; +var \u{2CE7E}; +var \u{2CE7F}; +var \u{2CE80}; +var \u{2CE81}; +var \u{2CE82}; +var \u{2CE83}; +var \u{2CE84}; +var \u{2CE85}; +var \u{2CE86}; +var \u{2CE87}; +var \u{2CE88}; +var \u{2CE89}; +var \u{2CE8A}; +var \u{2CE8B}; +var \u{2CE8C}; +var \u{2CE8D}; +var \u{2CE8E}; +var \u{2CE8F}; +var \u{2CE90}; +var \u{2CE91}; +var \u{2CE92}; +var \u{2CE93}; +var \u{2CE94}; +var \u{2CE95}; +var \u{2CE96}; +var \u{2CE97}; +var \u{2CE98}; +var \u{2CE99}; +var \u{2CE9A}; +var \u{2CE9B}; +var \u{2CE9C}; +var \u{2CE9D}; +var \u{2CE9E}; +var \u{2CE9F}; +var \u{2CEA0}; +var \u{2CEA1}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0.js new file mode 100644 index 000000000..b97096d76 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-8.0.0.js @@ -0,0 +1,6879 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v8.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var ࢳ; +var ࢴ; +var ૹ; +var ౚ; +var ൟ; +var Ᏽ; +var ᏸ; +var ᏹ; +var ᏺ; +var ᏻ; +var ᏼ; +var ᏽ; +var ᦰ; +var ᦱ; +var ᦲ; +var ᦳ; +var ᦴ; +var ᦵ; +var ᦶ; +var ᦷ; +var ᦸ; +var ᦹ; +var ᦺ; +var ᦻ; +var ᦼ; +var ᦽ; +var ᦾ; +var ᦿ; +var ᧀ; +var ᧈ; +var ᧉ; +var 鿍; +var 鿎; +var 鿏; +var 鿐; +var 鿑; +var 鿒; +var 鿓; +var 鿔; +var 鿕; +var ꞏ; +var Ʝ; +var Ꭓ; +var Ꞵ; +var ꞵ; +var Ꞷ; +var ꞷ; +var ꣽ; +var ꭠ; +var ꭡ; +var ꭢ; +var ꭣ; +var ꭰ; +var ꭱ; +var ꭲ; +var ꭳ; +var ꭴ; +var ꭵ; +var ꭶ; +var ꭷ; +var ꭸ; +var ꭹ; +var ꭺ; +var ꭻ; +var ꭼ; +var ꭽ; +var ꭾ; +var ꭿ; +var ꮀ; +var ꮁ; +var ꮂ; +var ꮃ; +var ꮄ; +var ꮅ; +var ꮆ; +var ꮇ; +var ꮈ; +var ꮉ; +var ꮊ; +var ꮋ; +var ꮌ; +var ꮍ; +var ꮎ; +var ꮏ; +var ꮐ; +var ꮑ; +var ꮒ; +var ꮓ; +var ꮔ; +var ꮕ; +var ꮖ; +var ꮗ; +var ꮘ; +var ꮙ; +var ꮚ; +var ꮛ; +var ꮜ; +var ꮝ; +var ꮞ; +var ꮟ; +var ꮠ; +var ꮡ; +var ꮢ; +var ꮣ; +var ꮤ; +var ꮥ; +var ꮦ; +var ꮧ; +var ꮨ; +var ꮩ; +var ꮪ; +var ꮫ; +var ꮬ; +var ꮭ; +var ꮮ; +var ꮯ; +var ꮰ; +var ꮱ; +var ꮲ; +var ꮳ; +var ꮴ; +var ꮵ; +var ꮶ; +var ꮷ; +var ꮸ; +var ꮹ; +var ꮺ; +var ꮻ; +var ꮼ; +var ꮽ; +var ꮾ; +var ꮿ; +var 𐣠; +var 𐣡; +var 𐣢; +var 𐣣; +var 𐣤; +var 𐣥; +var 𐣦; +var 𐣧; +var 𐣨; +var 𐣩; +var 𐣪; +var 𐣫; +var 𐣬; +var 𐣭; +var 𐣮; +var 𐣯; +var 𐣰; +var 𐣱; +var 𐣲; +var 𐣴; +var 𐣵; +var 𐲀; +var 𐲁; +var 𐲂; +var 𐲃; +var 𐲄; +var 𐲅; +var 𐲆; +var 𐲇; +var 𐲈; +var 𐲉; +var 𐲊; +var 𐲋; +var 𐲌; +var 𐲍; +var 𐲎; +var 𐲏; +var 𐲐; +var 𐲑; +var 𐲒; +var 𐲓; +var 𐲔; +var 𐲕; +var 𐲖; +var 𐲗; +var 𐲘; +var 𐲙; +var 𐲚; +var 𐲛; +var 𐲜; +var 𐲝; +var 𐲞; +var 𐲟; +var 𐲠; +var 𐲡; +var 𐲢; +var 𐲣; +var 𐲤; +var 𐲥; +var 𐲦; +var 𐲧; +var 𐲨; +var 𐲩; +var 𐲪; +var 𐲫; +var 𐲬; +var 𐲭; +var 𐲮; +var 𐲯; +var 𐲰; +var 𐲱; +var 𐲲; +var 𐳀; +var 𐳁; +var 𐳂; +var 𐳃; +var 𐳄; +var 𐳅; +var 𐳆; +var 𐳇; +var 𐳈; +var 𐳉; +var 𐳊; +var 𐳋; +var 𐳌; +var 𐳍; +var 𐳎; +var 𐳏; +var 𐳐; +var 𐳑; +var 𐳒; +var 𐳓; +var 𐳔; +var 𐳕; +var 𐳖; +var 𐳗; +var 𐳘; +var 𐳙; +var 𐳚; +var 𐳛; +var 𐳜; +var 𐳝; +var 𐳞; +var 𐳟; +var 𐳠; +var 𐳡; +var 𐳢; +var 𐳣; +var 𐳤; +var 𐳥; +var 𐳦; +var 𐳧; +var 𐳨; +var 𐳩; +var 𐳪; +var 𐳫; +var 𐳬; +var 𐳭; +var 𐳮; +var 𐳯; +var 𐳰; +var 𐳱; +var 𐳲; +var 𑇜; +var 𑊀; +var 𑊁; +var 𑊂; +var 𑊃; +var 𑊄; +var 𑊅; +var 𑊆; +var 𑊈; +var 𑊊; +var 𑊋; +var 𑊌; +var 𑊍; +var 𑊏; +var 𑊐; +var 𑊑; +var 𑊒; +var 𑊓; +var 𑊔; +var 𑊕; +var 𑊖; +var 𑊗; +var 𑊘; +var 𑊙; +var 𑊚; +var 𑊛; +var 𑊜; +var 𑊝; +var 𑊟; +var 𑊠; +var 𑊡; +var 𑊢; +var 𑊣; +var 𑊤; +var 𑊥; +var 𑊦; +var 𑊧; +var 𑊨; +var 𑍐; +var 𑗘; +var 𑗙; +var 𑗚; +var 𑗛; +var 𑜀; +var 𑜁; +var 𑜂; +var 𑜃; +var 𑜄; +var 𑜅; +var 𑜆; +var 𑜇; +var 𑜈; +var 𑜉; +var 𑜊; +var 𑜋; +var 𑜌; +var 𑜍; +var 𑜎; +var 𑜏; +var 𑜐; +var 𑜑; +var 𑜒; +var 𑜓; +var 𑜔; +var 𑜕; +var 𑜖; +var 𑜗; +var 𑜘; +var 𑜙; +var 𒎙; +var 𒒀; +var 𒒁; +var 𒒂; +var 𒒃; +var 𒒄; +var 𒒅; +var 𒒆; +var 𒒇; +var 𒒈; +var 𒒉; +var 𒒊; +var 𒒋; +var 𒒌; +var 𒒍; +var 𒒎; +var 𒒏; +var 𒒐; +var 𒒑; +var 𒒒; +var 𒒓; +var 𒒔; +var 𒒕; +var 𒒖; +var 𒒗; +var 𒒘; +var 𒒙; +var 𒒚; +var 𒒛; +var 𒒜; +var 𒒝; +var 𒒞; +var 𒒟; +var 𒒠; +var 𒒡; +var 𒒢; +var 𒒣; +var 𒒤; +var 𒒥; +var 𒒦; +var 𒒧; +var 𒒨; +var 𒒩; +var 𒒪; +var 𒒫; +var 𒒬; +var 𒒭; +var 𒒮; +var 𒒯; +var 𒒰; +var 𒒱; +var 𒒲; +var 𒒳; +var 𒒴; +var 𒒵; +var 𒒶; +var 𒒷; +var 𒒸; +var 𒒹; +var 𒒺; +var 𒒻; +var 𒒼; +var 𒒽; +var 𒒾; +var 𒒿; +var 𒓀; +var 𒓁; +var 𒓂; +var 𒓃; +var 𒓄; +var 𒓅; +var 𒓆; +var 𒓇; +var 𒓈; +var 𒓉; +var 𒓊; +var 𒓋; +var 𒓌; +var 𒓍; +var 𒓎; +var 𒓏; +var 𒓐; +var 𒓑; +var 𒓒; +var 𒓓; +var 𒓔; +var 𒓕; +var 𒓖; +var 𒓗; +var 𒓘; +var 𒓙; +var 𒓚; +var 𒓛; +var 𒓜; +var 𒓝; +var 𒓞; +var 𒓟; +var 𒓠; +var 𒓡; +var 𒓢; +var 𒓣; +var 𒓤; +var 𒓥; +var 𒓦; +var 𒓧; +var 𒓨; +var 𒓩; +var 𒓪; +var 𒓫; +var 𒓬; +var 𒓭; +var 𒓮; +var 𒓯; +var 𒓰; +var 𒓱; +var 𒓲; +var 𒓳; +var 𒓴; +var 𒓵; +var 𒓶; +var 𒓷; +var 𒓸; +var 𒓹; +var 𒓺; +var 𒓻; +var 𒓼; +var 𒓽; +var 𒓾; +var 𒓿; +var 𒔀; +var 𒔁; +var 𒔂; +var 𒔃; +var 𒔄; +var 𒔅; +var 𒔆; +var 𒔇; +var 𒔈; +var 𒔉; +var 𒔊; +var 𒔋; +var 𒔌; +var 𒔍; +var 𒔎; +var 𒔏; +var 𒔐; +var 𒔑; +var 𒔒; +var 𒔓; +var 𒔔; +var 𒔕; +var 𒔖; +var 𒔗; +var 𒔘; +var 𒔙; +var 𒔚; +var 𒔛; +var 𒔜; +var 𒔝; +var 𒔞; +var 𒔟; +var 𒔠; +var 𒔡; +var 𒔢; +var 𒔣; +var 𒔤; +var 𒔥; +var 𒔦; +var 𒔧; +var 𒔨; +var 𒔩; +var 𒔪; +var 𒔫; +var 𒔬; +var 𒔭; +var 𒔮; +var 𒔯; +var 𒔰; +var 𒔱; +var 𒔲; +var 𒔳; +var 𒔴; +var 𒔵; +var 𒔶; +var 𒔷; +var 𒔸; +var 𒔹; +var 𒔺; +var 𒔻; +var 𒔼; +var 𒔽; +var 𒔾; +var 𒔿; +var 𒕀; +var 𒕁; +var 𒕂; +var 𒕃; +var 𔐀; +var 𔐁; +var 𔐂; +var 𔐃; +var 𔐄; +var 𔐅; +var 𔐆; +var 𔐇; +var 𔐈; +var 𔐉; +var 𔐊; +var 𔐋; +var 𔐌; +var 𔐍; +var 𔐎; +var 𔐏; +var 𔐐; +var 𔐑; +var 𔐒; +var 𔐓; +var 𔐔; +var 𔐕; +var 𔐖; +var 𔐗; +var 𔐘; +var 𔐙; +var 𔐚; +var 𔐛; +var 𔐜; +var 𔐝; +var 𔐞; +var 𔐟; +var 𔐠; +var 𔐡; +var 𔐢; +var 𔐣; +var 𔐤; +var 𔐥; +var 𔐦; +var 𔐧; +var 𔐨; +var 𔐩; +var 𔐪; +var 𔐫; +var 𔐬; +var 𔐭; +var 𔐮; +var 𔐯; +var 𔐰; +var 𔐱; +var 𔐲; +var 𔐳; +var 𔐴; +var 𔐵; +var 𔐶; +var 𔐷; +var 𔐸; +var 𔐹; +var 𔐺; +var 𔐻; +var 𔐼; +var 𔐽; +var 𔐾; +var 𔐿; +var 𔑀; +var 𔑁; +var 𔑂; +var 𔑃; +var 𔑄; +var 𔑅; +var 𔑆; +var 𔑇; +var 𔑈; +var 𔑉; +var 𔑊; +var 𔑋; +var 𔑌; +var 𔑍; +var 𔑎; +var 𔑏; +var 𔑐; +var 𔑑; +var 𔑒; +var 𔑓; +var 𔑔; +var 𔑕; +var 𔑖; +var 𔑗; +var 𔑘; +var 𔑙; +var 𔑚; +var 𔑛; +var 𔑜; +var 𔑝; +var 𔑞; +var 𔑟; +var 𔑠; +var 𔑡; +var 𔑢; +var 𔑣; +var 𔑤; +var 𔑥; +var 𔑦; +var 𔑧; +var 𔑨; +var 𔑩; +var 𔑪; +var 𔑫; +var 𔑬; +var 𔑭; +var 𔑮; +var 𔑯; +var 𔑰; +var 𔑱; +var 𔑲; +var 𔑳; +var 𔑴; +var 𔑵; +var 𔑶; +var 𔑷; +var 𔑸; +var 𔑹; +var 𔑺; +var 𔑻; +var 𔑼; +var 𔑽; +var 𔑾; +var 𔑿; +var 𔒀; +var 𔒁; +var 𔒂; +var 𔒃; +var 𔒄; +var 𔒅; +var 𔒆; +var 𔒇; +var 𔒈; +var 𔒉; +var 𔒊; +var 𔒋; +var 𔒌; +var 𔒍; +var 𔒎; +var 𔒏; +var 𔒐; +var 𔒑; +var 𔒒; +var 𔒓; +var 𔒔; +var 𔒕; +var 𔒖; +var 𔒗; +var 𔒘; +var 𔒙; +var 𔒚; +var 𔒛; +var 𔒜; +var 𔒝; +var 𔒞; +var 𔒟; +var 𔒠; +var 𔒡; +var 𔒢; +var 𔒣; +var 𔒤; +var 𔒥; +var 𔒦; +var 𔒧; +var 𔒨; +var 𔒩; +var 𔒪; +var 𔒫; +var 𔒬; +var 𔒭; +var 𔒮; +var 𔒯; +var 𔒰; +var 𔒱; +var 𔒲; +var 𔒳; +var 𔒴; +var 𔒵; +var 𔒶; +var 𔒷; +var 𔒸; +var 𔒹; +var 𔒺; +var 𔒻; +var 𔒼; +var 𔒽; +var 𔒾; +var 𔒿; +var 𔓀; +var 𔓁; +var 𔓂; +var 𔓃; +var 𔓄; +var 𔓅; +var 𔓆; +var 𔓇; +var 𔓈; +var 𔓉; +var 𔓊; +var 𔓋; +var 𔓌; +var 𔓍; +var 𔓎; +var 𔓏; +var 𔓐; +var 𔓑; +var 𔓒; +var 𔓓; +var 𔓔; +var 𔓕; +var 𔓖; +var 𔓗; +var 𔓘; +var 𔓙; +var 𔓚; +var 𔓛; +var 𔓜; +var 𔓝; +var 𔓞; +var 𔓟; +var 𔓠; +var 𔓡; +var 𔓢; +var 𔓣; +var 𔓤; +var 𔓥; +var 𔓦; +var 𔓧; +var 𔓨; +var 𔓩; +var 𔓪; +var 𔓫; +var 𔓬; +var 𔓭; +var 𔓮; +var 𔓯; +var 𔓰; +var 𔓱; +var 𔓲; +var 𔓳; +var 𔓴; +var 𔓵; +var 𔓶; +var 𔓷; +var 𔓸; +var 𔓹; +var 𔓺; +var 𔓻; +var 𔓼; +var 𔓽; +var 𔓾; +var 𔓿; +var 𔔀; +var 𔔁; +var 𔔂; +var 𔔃; +var 𔔄; +var 𔔅; +var 𔔆; +var 𔔇; +var 𔔈; +var 𔔉; +var 𔔊; +var 𔔋; +var 𔔌; +var 𔔍; +var 𔔎; +var 𔔏; +var 𔔐; +var 𔔑; +var 𔔒; +var 𔔓; +var 𔔔; +var 𔔕; +var 𔔖; +var 𔔗; +var 𔔘; +var 𔔙; +var 𔔚; +var 𔔛; +var 𔔜; +var 𔔝; +var 𔔞; +var 𔔟; +var 𔔠; +var 𔔡; +var 𔔢; +var 𔔣; +var 𔔤; +var 𔔥; +var 𔔦; +var 𔔧; +var 𔔨; +var 𔔩; +var 𔔪; +var 𔔫; +var 𔔬; +var 𔔭; +var 𔔮; +var 𔔯; +var 𔔰; +var 𔔱; +var 𔔲; +var 𔔳; +var 𔔴; +var 𔔵; +var 𔔶; +var 𔔷; +var 𔔸; +var 𔔹; +var 𔔺; +var 𔔻; +var 𔔼; +var 𔔽; +var 𔔾; +var 𔔿; +var 𔕀; +var 𔕁; +var 𔕂; +var 𔕃; +var 𔕄; +var 𔕅; +var 𔕆; +var 𔕇; +var 𔕈; +var 𔕉; +var 𔕊; +var 𔕋; +var 𔕌; +var 𔕍; +var 𔕎; +var 𔕏; +var 𔕐; +var 𔕑; +var 𔕒; +var 𔕓; +var 𔕔; +var 𔕕; +var 𔕖; +var 𔕗; +var 𔕘; +var 𔕙; +var 𔕚; +var 𔕛; +var 𔕜; +var 𔕝; +var 𔕞; +var 𔕟; +var 𔕠; +var 𔕡; +var 𔕢; +var 𔕣; +var 𔕤; +var 𔕥; +var 𔕦; +var 𔕧; +var 𔕨; +var 𔕩; +var 𔕪; +var 𔕫; +var 𔕬; +var 𔕭; +var 𔕮; +var 𔕯; +var 𔕰; +var 𔕱; +var 𔕲; +var 𔕳; +var 𔕴; +var 𔕵; +var 𔕶; +var 𔕷; +var 𔕸; +var 𔕹; +var 𔕺; +var 𔕻; +var 𔕼; +var 𔕽; +var 𔕾; +var 𔕿; +var 𔖀; +var 𔖁; +var 𔖂; +var 𔖃; +var 𔖄; +var 𔖅; +var 𔖆; +var 𔖇; +var 𔖈; +var 𔖉; +var 𔖊; +var 𔖋; +var 𔖌; +var 𔖍; +var 𔖎; +var 𔖏; +var 𔖐; +var 𔖑; +var 𔖒; +var 𔖓; +var 𔖔; +var 𔖕; +var 𔖖; +var 𔖗; +var 𔖘; +var 𔖙; +var 𔖚; +var 𔖛; +var 𔖜; +var 𔖝; +var 𔖞; +var 𔖟; +var 𔖠; +var 𔖡; +var 𔖢; +var 𔖣; +var 𔖤; +var 𔖥; +var 𔖦; +var 𔖧; +var 𔖨; +var 𔖩; +var 𔖪; +var 𔖫; +var 𔖬; +var 𔖭; +var 𔖮; +var 𔖯; +var 𔖰; +var 𔖱; +var 𔖲; +var 𔖳; +var 𔖴; +var 𔖵; +var 𔖶; +var 𔖷; +var 𔖸; +var 𔖹; +var 𔖺; +var 𔖻; +var 𔖼; +var 𔖽; +var 𔖾; +var 𔖿; +var 𔗀; +var 𔗁; +var 𔗂; +var 𔗃; +var 𔗄; +var 𔗅; +var 𔗆; +var 𔗇; +var 𔗈; +var 𔗉; +var 𔗊; +var 𔗋; +var 𔗌; +var 𔗍; +var 𔗎; +var 𔗏; +var 𔗐; +var 𔗑; +var 𔗒; +var 𔗓; +var 𔗔; +var 𔗕; +var 𔗖; +var 𔗗; +var 𔗘; +var 𔗙; +var 𔗚; +var 𔗛; +var 𔗜; +var 𔗝; +var 𔗞; +var 𔗟; +var 𔗠; +var 𔗡; +var 𔗢; +var 𔗣; +var 𔗤; +var 𔗥; +var 𔗦; +var 𔗧; +var 𔗨; +var 𔗩; +var 𔗪; +var 𔗫; +var 𔗬; +var 𔗭; +var 𔗮; +var 𔗯; +var 𔗰; +var 𔗱; +var 𔗲; +var 𔗳; +var 𔗴; +var 𔗵; +var 𔗶; +var 𔗷; +var 𔗸; +var 𔗹; +var 𔗺; +var 𔗻; +var 𔗼; +var 𔗽; +var 𔗾; +var 𔗿; +var 𔘀; +var 𔘁; +var 𔘂; +var 𔘃; +var 𔘄; +var 𔘅; +var 𔘆; +var 𔘇; +var 𔘈; +var 𔘉; +var 𔘊; +var 𔘋; +var 𔘌; +var 𔘍; +var 𔘎; +var 𔘏; +var 𔘐; +var 𔘑; +var 𔘒; +var 𔘓; +var 𔘔; +var 𔘕; +var 𔘖; +var 𔘗; +var 𔘘; +var 𔘙; +var 𔘚; +var 𔘛; +var 𔘜; +var 𔘝; +var 𔘞; +var 𔘟; +var 𔘠; +var 𔘡; +var 𔘢; +var 𔘣; +var 𔘤; +var 𔘥; +var 𔘦; +var 𔘧; +var 𔘨; +var 𔘩; +var 𔘪; +var 𔘫; +var 𔘬; +var 𔘭; +var 𔘮; +var 𔘯; +var 𔘰; +var 𔘱; +var 𔘲; +var 𔘳; +var 𔘴; +var 𔘵; +var 𔘶; +var 𔘷; +var 𔘸; +var 𔘹; +var 𔘺; +var 𔘻; +var 𔘼; +var 𔘽; +var 𔘾; +var 𔘿; +var 𔙀; +var 𔙁; +var 𔙂; +var 𔙃; +var 𔙄; +var 𔙅; +var 𔙆; +var 𫠠; +var 𫠡; +var 𫠢; +var 𫠣; +var 𫠤; +var 𫠥; +var 𫠦; +var 𫠧; +var 𫠨; +var 𫠩; +var 𫠪; +var 𫠫; +var 𫠬; +var 𫠭; +var 𫠮; +var 𫠯; +var 𫠰; +var 𫠱; +var 𫠲; +var 𫠳; +var 𫠴; +var 𫠵; +var 𫠶; +var 𫠷; +var 𫠸; +var 𫠹; +var 𫠺; +var 𫠻; +var 𫠼; +var 𫠽; +var 𫠾; +var 𫠿; +var 𫡀; +var 𫡁; +var 𫡂; +var 𫡃; +var 𫡄; +var 𫡅; +var 𫡆; +var 𫡇; +var 𫡈; +var 𫡉; +var 𫡊; +var 𫡋; +var 𫡌; +var 𫡍; +var 𫡎; +var 𫡏; +var 𫡐; +var 𫡑; +var 𫡒; +var 𫡓; +var 𫡔; +var 𫡕; +var 𫡖; +var 𫡗; +var 𫡘; +var 𫡙; +var 𫡚; +var 𫡛; +var 𫡜; +var 𫡝; +var 𫡞; +var 𫡟; +var 𫡠; +var 𫡡; +var 𫡢; +var 𫡣; +var 𫡤; +var 𫡥; +var 𫡦; +var 𫡧; +var 𫡨; +var 𫡩; +var 𫡪; +var 𫡫; +var 𫡬; +var 𫡭; +var 𫡮; +var 𫡯; +var 𫡰; +var 𫡱; +var 𫡲; +var 𫡳; +var 𫡴; +var 𫡵; +var 𫡶; +var 𫡷; +var 𫡸; +var 𫡹; +var 𫡺; +var 𫡻; +var 𫡼; +var 𫡽; +var 𫡾; +var 𫡿; +var 𫢀; +var 𫢁; +var 𫢂; +var 𫢃; +var 𫢄; +var 𫢅; +var 𫢆; +var 𫢇; +var 𫢈; +var 𫢉; +var 𫢊; +var 𫢋; +var 𫢌; +var 𫢍; +var 𫢎; +var 𫢏; +var 𫢐; +var 𫢑; +var 𫢒; +var 𫢓; +var 𫢔; +var 𫢕; +var 𫢖; +var 𫢗; +var 𫢘; +var 𫢙; +var 𫢚; +var 𫢛; +var 𫢜; +var 𫢝; +var 𫢞; +var 𫢟; +var 𫢠; +var 𫢡; +var 𫢢; +var 𫢣; +var 𫢤; +var 𫢥; +var 𫢦; +var 𫢧; +var 𫢨; +var 𫢩; +var 𫢪; +var 𫢫; +var 𫢬; +var 𫢭; +var 𫢮; +var 𫢯; +var 𫢰; +var 𫢱; +var 𫢲; +var 𫢳; +var 𫢴; +var 𫢵; +var 𫢶; +var 𫢷; +var 𫢸; +var 𫢹; +var 𫢺; +var 𫢻; +var 𫢼; +var 𫢽; +var 𫢾; +var 𫢿; +var 𫣀; +var 𫣁; +var 𫣂; +var 𫣃; +var 𫣄; +var 𫣅; +var 𫣆; +var 𫣇; +var 𫣈; +var 𫣉; +var 𫣊; +var 𫣋; +var 𫣌; +var 𫣍; +var 𫣎; +var 𫣏; +var 𫣐; +var 𫣑; +var 𫣒; +var 𫣓; +var 𫣔; +var 𫣕; +var 𫣖; +var 𫣗; +var 𫣘; +var 𫣙; +var 𫣚; +var 𫣛; +var 𫣜; +var 𫣝; +var 𫣞; +var 𫣟; +var 𫣠; +var 𫣡; +var 𫣢; +var 𫣣; +var 𫣤; +var 𫣥; +var 𫣦; +var 𫣧; +var 𫣨; +var 𫣩; +var 𫣪; +var 𫣫; +var 𫣬; +var 𫣭; +var 𫣮; +var 𫣯; +var 𫣰; +var 𫣱; +var 𫣲; +var 𫣳; +var 𫣴; +var 𫣵; +var 𫣶; +var 𫣷; +var 𫣸; +var 𫣹; +var 𫣺; +var 𫣻; +var 𫣼; +var 𫣽; +var 𫣾; +var 𫣿; +var 𫤀; +var 𫤁; +var 𫤂; +var 𫤃; +var 𫤄; +var 𫤅; +var 𫤆; +var 𫤇; +var 𫤈; +var 𫤉; +var 𫤊; +var 𫤋; +var 𫤌; +var 𫤍; +var 𫤎; +var 𫤏; +var 𫤐; +var 𫤑; +var 𫤒; +var 𫤓; +var 𫤔; +var 𫤕; +var 𫤖; +var 𫤗; +var 𫤘; +var 𫤙; +var 𫤚; +var 𫤛; +var 𫤜; +var 𫤝; +var 𫤞; +var 𫤟; +var 𫤠; +var 𫤡; +var 𫤢; +var 𫤣; +var 𫤤; +var 𫤥; +var 𫤦; +var 𫤧; +var 𫤨; +var 𫤩; +var 𫤪; +var 𫤫; +var 𫤬; +var 𫤭; +var 𫤮; +var 𫤯; +var 𫤰; +var 𫤱; +var 𫤲; +var 𫤳; +var 𫤴; +var 𫤵; +var 𫤶; +var 𫤷; +var 𫤸; +var 𫤹; +var 𫤺; +var 𫤻; +var 𫤼; +var 𫤽; +var 𫤾; +var 𫤿; +var 𫥀; +var 𫥁; +var 𫥂; +var 𫥃; +var 𫥄; +var 𫥅; +var 𫥆; +var 𫥇; +var 𫥈; +var 𫥉; +var 𫥊; +var 𫥋; +var 𫥌; +var 𫥍; +var 𫥎; +var 𫥏; +var 𫥐; +var 𫥑; +var 𫥒; +var 𫥓; +var 𫥔; +var 𫥕; +var 𫥖; +var 𫥗; +var 𫥘; +var 𫥙; +var 𫥚; +var 𫥛; +var 𫥜; +var 𫥝; +var 𫥞; +var 𫥟; +var 𫥠; +var 𫥡; +var 𫥢; +var 𫥣; +var 𫥤; +var 𫥥; +var 𫥦; +var 𫥧; +var 𫥨; +var 𫥩; +var 𫥪; +var 𫥫; +var 𫥬; +var 𫥭; +var 𫥮; +var 𫥯; +var 𫥰; +var 𫥱; +var 𫥲; +var 𫥳; +var 𫥴; +var 𫥵; +var 𫥶; +var 𫥷; +var 𫥸; +var 𫥹; +var 𫥺; +var 𫥻; +var 𫥼; +var 𫥽; +var 𫥾; +var 𫥿; +var 𫦀; +var 𫦁; +var 𫦂; +var 𫦃; +var 𫦄; +var 𫦅; +var 𫦆; +var 𫦇; +var 𫦈; +var 𫦉; +var 𫦊; +var 𫦋; +var 𫦌; +var 𫦍; +var 𫦎; +var 𫦏; +var 𫦐; +var 𫦑; +var 𫦒; +var 𫦓; +var 𫦔; +var 𫦕; +var 𫦖; +var 𫦗; +var 𫦘; +var 𫦙; +var 𫦚; +var 𫦛; +var 𫦜; +var 𫦝; +var 𫦞; +var 𫦟; +var 𫦠; +var 𫦡; +var 𫦢; +var 𫦣; +var 𫦤; +var 𫦥; +var 𫦦; +var 𫦧; +var 𫦨; +var 𫦩; +var 𫦪; +var 𫦫; +var 𫦬; +var 𫦭; +var 𫦮; +var 𫦯; +var 𫦰; +var 𫦱; +var 𫦲; +var 𫦳; +var 𫦴; +var 𫦵; +var 𫦶; +var 𫦷; +var 𫦸; +var 𫦹; +var 𫦺; +var 𫦻; +var 𫦼; +var 𫦽; +var 𫦾; +var 𫦿; +var 𫧀; +var 𫧁; +var 𫧂; +var 𫧃; +var 𫧄; +var 𫧅; +var 𫧆; +var 𫧇; +var 𫧈; +var 𫧉; +var 𫧊; +var 𫧋; +var 𫧌; +var 𫧍; +var 𫧎; +var 𫧏; +var 𫧐; +var 𫧑; +var 𫧒; +var 𫧓; +var 𫧔; +var 𫧕; +var 𫧖; +var 𫧗; +var 𫧘; +var 𫧙; +var 𫧚; +var 𫧛; +var 𫧜; +var 𫧝; +var 𫧞; +var 𫧟; +var 𫧠; +var 𫧡; +var 𫧢; +var 𫧣; +var 𫧤; +var 𫧥; +var 𫧦; +var 𫧧; +var 𫧨; +var 𫧩; +var 𫧪; +var 𫧫; +var 𫧬; +var 𫧭; +var 𫧮; +var 𫧯; +var 𫧰; +var 𫧱; +var 𫧲; +var 𫧳; +var 𫧴; +var 𫧵; +var 𫧶; +var 𫧷; +var 𫧸; +var 𫧹; +var 𫧺; +var 𫧻; +var 𫧼; +var 𫧽; +var 𫧾; +var 𫧿; +var 𫨀; +var 𫨁; +var 𫨂; +var 𫨃; +var 𫨄; +var 𫨅; +var 𫨆; +var 𫨇; +var 𫨈; +var 𫨉; +var 𫨊; +var 𫨋; +var 𫨌; +var 𫨍; +var 𫨎; +var 𫨏; +var 𫨐; +var 𫨑; +var 𫨒; +var 𫨓; +var 𫨔; +var 𫨕; +var 𫨖; +var 𫨗; +var 𫨘; +var 𫨙; +var 𫨚; +var 𫨛; +var 𫨜; +var 𫨝; +var 𫨞; +var 𫨟; +var 𫨠; +var 𫨡; +var 𫨢; +var 𫨣; +var 𫨤; +var 𫨥; +var 𫨦; +var 𫨧; +var 𫨨; +var 𫨩; +var 𫨪; +var 𫨫; +var 𫨬; +var 𫨭; +var 𫨮; +var 𫨯; +var 𫨰; +var 𫨱; +var 𫨲; +var 𫨳; +var 𫨴; +var 𫨵; +var 𫨶; +var 𫨷; +var 𫨸; +var 𫨹; +var 𫨺; +var 𫨻; +var 𫨼; +var 𫨽; +var 𫨾; +var 𫨿; +var 𫩀; +var 𫩁; +var 𫩂; +var 𫩃; +var 𫩄; +var 𫩅; +var 𫩆; +var 𫩇; +var 𫩈; +var 𫩉; +var 𫩊; +var 𫩋; +var 𫩌; +var 𫩍; +var 𫩎; +var 𫩏; +var 𫩐; +var 𫩑; +var 𫩒; +var 𫩓; +var 𫩔; +var 𫩕; +var 𫩖; +var 𫩗; +var 𫩘; +var 𫩙; +var 𫩚; +var 𫩛; +var 𫩜; +var 𫩝; +var 𫩞; +var 𫩟; +var 𫩠; +var 𫩡; +var 𫩢; +var 𫩣; +var 𫩤; +var 𫩥; +var 𫩦; +var 𫩧; +var 𫩨; +var 𫩩; +var 𫩪; +var 𫩫; +var 𫩬; +var 𫩭; +var 𫩮; +var 𫩯; +var 𫩰; +var 𫩱; +var 𫩲; +var 𫩳; +var 𫩴; +var 𫩵; +var 𫩶; +var 𫩷; +var 𫩸; +var 𫩹; +var 𫩺; +var 𫩻; +var 𫩼; +var 𫩽; +var 𫩾; +var 𫩿; +var 𫪀; +var 𫪁; +var 𫪂; +var 𫪃; +var 𫪄; +var 𫪅; +var 𫪆; +var 𫪇; +var 𫪈; +var 𫪉; +var 𫪊; +var 𫪋; +var 𫪌; +var 𫪍; +var 𫪎; +var 𫪏; +var 𫪐; +var 𫪑; +var 𫪒; +var 𫪓; +var 𫪔; +var 𫪕; +var 𫪖; +var 𫪗; +var 𫪘; +var 𫪙; +var 𫪚; +var 𫪛; +var 𫪜; +var 𫪝; +var 𫪞; +var 𫪟; +var 𫪠; +var 𫪡; +var 𫪢; +var 𫪣; +var 𫪤; +var 𫪥; +var 𫪦; +var 𫪧; +var 𫪨; +var 𫪩; +var 𫪪; +var 𫪫; +var 𫪬; +var 𫪭; +var 𫪮; +var 𫪯; +var 𫪰; +var 𫪱; +var 𫪲; +var 𫪳; +var 𫪴; +var 𫪵; +var 𫪶; +var 𫪷; +var 𫪸; +var 𫪹; +var 𫪺; +var 𫪻; +var 𫪼; +var 𫪽; +var 𫪾; +var 𫪿; +var 𫫀; +var 𫫁; +var 𫫂; +var 𫫃; +var 𫫄; +var 𫫅; +var 𫫆; +var 𫫇; +var 𫫈; +var 𫫉; +var 𫫊; +var 𫫋; +var 𫫌; +var 𫫍; +var 𫫎; +var 𫫏; +var 𫫐; +var 𫫑; +var 𫫒; +var 𫫓; +var 𫫔; +var 𫫕; +var 𫫖; +var 𫫗; +var 𫫘; +var 𫫙; +var 𫫚; +var 𫫛; +var 𫫜; +var 𫫝; +var 𫫞; +var 𫫟; +var 𫫠; +var 𫫡; +var 𫫢; +var 𫫣; +var 𫫤; +var 𫫥; +var 𫫦; +var 𫫧; +var 𫫨; +var 𫫩; +var 𫫪; +var 𫫫; +var 𫫬; +var 𫫭; +var 𫫮; +var 𫫯; +var 𫫰; +var 𫫱; +var 𫫲; +var 𫫳; +var 𫫴; +var 𫫵; +var 𫫶; +var 𫫷; +var 𫫸; +var 𫫹; +var 𫫺; +var 𫫻; +var 𫫼; +var 𫫽; +var 𫫾; +var 𫫿; +var 𫬀; +var 𫬁; +var 𫬂; +var 𫬃; +var 𫬄; +var 𫬅; +var 𫬆; +var 𫬇; +var 𫬈; +var 𫬉; +var 𫬊; +var 𫬋; +var 𫬌; +var 𫬍; +var 𫬎; +var 𫬏; +var 𫬐; +var 𫬑; +var 𫬒; +var 𫬓; +var 𫬔; +var 𫬕; +var 𫬖; +var 𫬗; +var 𫬘; +var 𫬙; +var 𫬚; +var 𫬛; +var 𫬜; +var 𫬝; +var 𫬞; +var 𫬟; +var 𫬠; +var 𫬡; +var 𫬢; +var 𫬣; +var 𫬤; +var 𫬥; +var 𫬦; +var 𫬧; +var 𫬨; +var 𫬩; +var 𫬪; +var 𫬫; +var 𫬬; +var 𫬭; +var 𫬮; +var 𫬯; +var 𫬰; +var 𫬱; +var 𫬲; +var 𫬳; +var 𫬴; +var 𫬵; +var 𫬶; +var 𫬷; +var 𫬸; +var 𫬹; +var 𫬺; +var 𫬻; +var 𫬼; +var 𫬽; +var 𫬾; +var 𫬿; +var 𫭀; +var 𫭁; +var 𫭂; +var 𫭃; +var 𫭄; +var 𫭅; +var 𫭆; +var 𫭇; +var 𫭈; +var 𫭉; +var 𫭊; +var 𫭋; +var 𫭌; +var 𫭍; +var 𫭎; +var 𫭏; +var 𫭐; +var 𫭑; +var 𫭒; +var 𫭓; +var 𫭔; +var 𫭕; +var 𫭖; +var 𫭗; +var 𫭘; +var 𫭙; +var 𫭚; +var 𫭛; +var 𫭜; +var 𫭝; +var 𫭞; +var 𫭟; +var 𫭠; +var 𫭡; +var 𫭢; +var 𫭣; +var 𫭤; +var 𫭥; +var 𫭦; +var 𫭧; +var 𫭨; +var 𫭩; +var 𫭪; +var 𫭫; +var 𫭬; +var 𫭭; +var 𫭮; +var 𫭯; +var 𫭰; +var 𫭱; +var 𫭲; +var 𫭳; +var 𫭴; +var 𫭵; +var 𫭶; +var 𫭷; +var 𫭸; +var 𫭹; +var 𫭺; +var 𫭻; +var 𫭼; +var 𫭽; +var 𫭾; +var 𫭿; +var 𫮀; +var 𫮁; +var 𫮂; +var 𫮃; +var 𫮄; +var 𫮅; +var 𫮆; +var 𫮇; +var 𫮈; +var 𫮉; +var 𫮊; +var 𫮋; +var 𫮌; +var 𫮍; +var 𫮎; +var 𫮏; +var 𫮐; +var 𫮑; +var 𫮒; +var 𫮓; +var 𫮔; +var 𫮕; +var 𫮖; +var 𫮗; +var 𫮘; +var 𫮙; +var 𫮚; +var 𫮛; +var 𫮜; +var 𫮝; +var 𫮞; +var 𫮟; +var 𫮠; +var 𫮡; +var 𫮢; +var 𫮣; +var 𫮤; +var 𫮥; +var 𫮦; +var 𫮧; +var 𫮨; +var 𫮩; +var 𫮪; +var 𫮫; +var 𫮬; +var 𫮭; +var 𫮮; +var 𫮯; +var 𫮰; +var 𫮱; +var 𫮲; +var 𫮳; +var 𫮴; +var 𫮵; +var 𫮶; +var 𫮷; +var 𫮸; +var 𫮹; +var 𫮺; +var 𫮻; +var 𫮼; +var 𫮽; +var 𫮾; +var 𫮿; +var 𫯀; +var 𫯁; +var 𫯂; +var 𫯃; +var 𫯄; +var 𫯅; +var 𫯆; +var 𫯇; +var 𫯈; +var 𫯉; +var 𫯊; +var 𫯋; +var 𫯌; +var 𫯍; +var 𫯎; +var 𫯏; +var 𫯐; +var 𫯑; +var 𫯒; +var 𫯓; +var 𫯔; +var 𫯕; +var 𫯖; +var 𫯗; +var 𫯘; +var 𫯙; +var 𫯚; +var 𫯛; +var 𫯜; +var 𫯝; +var 𫯞; +var 𫯟; +var 𫯠; +var 𫯡; +var 𫯢; +var 𫯣; +var 𫯤; +var 𫯥; +var 𫯦; +var 𫯧; +var 𫯨; +var 𫯩; +var 𫯪; +var 𫯫; +var 𫯬; +var 𫯭; +var 𫯮; +var 𫯯; +var 𫯰; +var 𫯱; +var 𫯲; +var 𫯳; +var 𫯴; +var 𫯵; +var 𫯶; +var 𫯷; +var 𫯸; +var 𫯹; +var 𫯺; +var 𫯻; +var 𫯼; +var 𫯽; +var 𫯾; +var 𫯿; +var 𫰀; +var 𫰁; +var 𫰂; +var 𫰃; +var 𫰄; +var 𫰅; +var 𫰆; +var 𫰇; +var 𫰈; +var 𫰉; +var 𫰊; +var 𫰋; +var 𫰌; +var 𫰍; +var 𫰎; +var 𫰏; +var 𫰐; +var 𫰑; +var 𫰒; +var 𫰓; +var 𫰔; +var 𫰕; +var 𫰖; +var 𫰗; +var 𫰘; +var 𫰙; +var 𫰚; +var 𫰛; +var 𫰜; +var 𫰝; +var 𫰞; +var 𫰟; +var 𫰠; +var 𫰡; +var 𫰢; +var 𫰣; +var 𫰤; +var 𫰥; +var 𫰦; +var 𫰧; +var 𫰨; +var 𫰩; +var 𫰪; +var 𫰫; +var 𫰬; +var 𫰭; +var 𫰮; +var 𫰯; +var 𫰰; +var 𫰱; +var 𫰲; +var 𫰳; +var 𫰴; +var 𫰵; +var 𫰶; +var 𫰷; +var 𫰸; +var 𫰹; +var 𫰺; +var 𫰻; +var 𫰼; +var 𫰽; +var 𫰾; +var 𫰿; +var 𫱀; +var 𫱁; +var 𫱂; +var 𫱃; +var 𫱄; +var 𫱅; +var 𫱆; +var 𫱇; +var 𫱈; +var 𫱉; +var 𫱊; +var 𫱋; +var 𫱌; +var 𫱍; +var 𫱎; +var 𫱏; +var 𫱐; +var 𫱑; +var 𫱒; +var 𫱓; +var 𫱔; +var 𫱕; +var 𫱖; +var 𫱗; +var 𫱘; +var 𫱙; +var 𫱚; +var 𫱛; +var 𫱜; +var 𫱝; +var 𫱞; +var 𫱟; +var 𫱠; +var 𫱡; +var 𫱢; +var 𫱣; +var 𫱤; +var 𫱥; +var 𫱦; +var 𫱧; +var 𫱨; +var 𫱩; +var 𫱪; +var 𫱫; +var 𫱬; +var 𫱭; +var 𫱮; +var 𫱯; +var 𫱰; +var 𫱱; +var 𫱲; +var 𫱳; +var 𫱴; +var 𫱵; +var 𫱶; +var 𫱷; +var 𫱸; +var 𫱹; +var 𫱺; +var 𫱻; +var 𫱼; +var 𫱽; +var 𫱾; +var 𫱿; +var 𫲀; +var 𫲁; +var 𫲂; +var 𫲃; +var 𫲄; +var 𫲅; +var 𫲆; +var 𫲇; +var 𫲈; +var 𫲉; +var 𫲊; +var 𫲋; +var 𫲌; +var 𫲍; +var 𫲎; +var 𫲏; +var 𫲐; +var 𫲑; +var 𫲒; +var 𫲓; +var 𫲔; +var 𫲕; +var 𫲖; +var 𫲗; +var 𫲘; +var 𫲙; +var 𫲚; +var 𫲛; +var 𫲜; +var 𫲝; +var 𫲞; +var 𫲟; +var 𫲠; +var 𫲡; +var 𫲢; +var 𫲣; +var 𫲤; +var 𫲥; +var 𫲦; +var 𫲧; +var 𫲨; +var 𫲩; +var 𫲪; +var 𫲫; +var 𫲬; +var 𫲭; +var 𫲮; +var 𫲯; +var 𫲰; +var 𫲱; +var 𫲲; +var 𫲳; +var 𫲴; +var 𫲵; +var 𫲶; +var 𫲷; +var 𫲸; +var 𫲹; +var 𫲺; +var 𫲻; +var 𫲼; +var 𫲽; +var 𫲾; +var 𫲿; +var 𫳀; +var 𫳁; +var 𫳂; +var 𫳃; +var 𫳄; +var 𫳅; +var 𫳆; +var 𫳇; +var 𫳈; +var 𫳉; +var 𫳊; +var 𫳋; +var 𫳌; +var 𫳍; +var 𫳎; +var 𫳏; +var 𫳐; +var 𫳑; +var 𫳒; +var 𫳓; +var 𫳔; +var 𫳕; +var 𫳖; +var 𫳗; +var 𫳘; +var 𫳙; +var 𫳚; +var 𫳛; +var 𫳜; +var 𫳝; +var 𫳞; +var 𫳟; +var 𫳠; +var 𫳡; +var 𫳢; +var 𫳣; +var 𫳤; +var 𫳥; +var 𫳦; +var 𫳧; +var 𫳨; +var 𫳩; +var 𫳪; +var 𫳫; +var 𫳬; +var 𫳭; +var 𫳮; +var 𫳯; +var 𫳰; +var 𫳱; +var 𫳲; +var 𫳳; +var 𫳴; +var 𫳵; +var 𫳶; +var 𫳷; +var 𫳸; +var 𫳹; +var 𫳺; +var 𫳻; +var 𫳼; +var 𫳽; +var 𫳾; +var 𫳿; +var 𫴀; +var 𫴁; +var 𫴂; +var 𫴃; +var 𫴄; +var 𫴅; +var 𫴆; +var 𫴇; +var 𫴈; +var 𫴉; +var 𫴊; +var 𫴋; +var 𫴌; +var 𫴍; +var 𫴎; +var 𫴏; +var 𫴐; +var 𫴑; +var 𫴒; +var 𫴓; +var 𫴔; +var 𫴕; +var 𫴖; +var 𫴗; +var 𫴘; +var 𫴙; +var 𫴚; +var 𫴛; +var 𫴜; +var 𫴝; +var 𫴞; +var 𫴟; +var 𫴠; +var 𫴡; +var 𫴢; +var 𫴣; +var 𫴤; +var 𫴥; +var 𫴦; +var 𫴧; +var 𫴨; +var 𫴩; +var 𫴪; +var 𫴫; +var 𫴬; +var 𫴭; +var 𫴮; +var 𫴯; +var 𫴰; +var 𫴱; +var 𫴲; +var 𫴳; +var 𫴴; +var 𫴵; +var 𫴶; +var 𫴷; +var 𫴸; +var 𫴹; +var 𫴺; +var 𫴻; +var 𫴼; +var 𫴽; +var 𫴾; +var 𫴿; +var 𫵀; +var 𫵁; +var 𫵂; +var 𫵃; +var 𫵄; +var 𫵅; +var 𫵆; +var 𫵇; +var 𫵈; +var 𫵉; +var 𫵊; +var 𫵋; +var 𫵌; +var 𫵍; +var 𫵎; +var 𫵏; +var 𫵐; +var 𫵑; +var 𫵒; +var 𫵓; +var 𫵔; +var 𫵕; +var 𫵖; +var 𫵗; +var 𫵘; +var 𫵙; +var 𫵚; +var 𫵛; +var 𫵜; +var 𫵝; +var 𫵞; +var 𫵟; +var 𫵠; +var 𫵡; +var 𫵢; +var 𫵣; +var 𫵤; +var 𫵥; +var 𫵦; +var 𫵧; +var 𫵨; +var 𫵩; +var 𫵪; +var 𫵫; +var 𫵬; +var 𫵭; +var 𫵮; +var 𫵯; +var 𫵰; +var 𫵱; +var 𫵲; +var 𫵳; +var 𫵴; +var 𫵵; +var 𫵶; +var 𫵷; +var 𫵸; +var 𫵹; +var 𫵺; +var 𫵻; +var 𫵼; +var 𫵽; +var 𫵾; +var 𫵿; +var 𫶀; +var 𫶁; +var 𫶂; +var 𫶃; +var 𫶄; +var 𫶅; +var 𫶆; +var 𫶇; +var 𫶈; +var 𫶉; +var 𫶊; +var 𫶋; +var 𫶌; +var 𫶍; +var 𫶎; +var 𫶏; +var 𫶐; +var 𫶑; +var 𫶒; +var 𫶓; +var 𫶔; +var 𫶕; +var 𫶖; +var 𫶗; +var 𫶘; +var 𫶙; +var 𫶚; +var 𫶛; +var 𫶜; +var 𫶝; +var 𫶞; +var 𫶟; +var 𫶠; +var 𫶡; +var 𫶢; +var 𫶣; +var 𫶤; +var 𫶥; +var 𫶦; +var 𫶧; +var 𫶨; +var 𫶩; +var 𫶪; +var 𫶫; +var 𫶬; +var 𫶭; +var 𫶮; +var 𫶯; +var 𫶰; +var 𫶱; +var 𫶲; +var 𫶳; +var 𫶴; +var 𫶵; +var 𫶶; +var 𫶷; +var 𫶸; +var 𫶹; +var 𫶺; +var 𫶻; +var 𫶼; +var 𫶽; +var 𫶾; +var 𫶿; +var 𫷀; +var 𫷁; +var 𫷂; +var 𫷃; +var 𫷄; +var 𫷅; +var 𫷆; +var 𫷇; +var 𫷈; +var 𫷉; +var 𫷊; +var 𫷋; +var 𫷌; +var 𫷍; +var 𫷎; +var 𫷏; +var 𫷐; +var 𫷑; +var 𫷒; +var 𫷓; +var 𫷔; +var 𫷕; +var 𫷖; +var 𫷗; +var 𫷘; +var 𫷙; +var 𫷚; +var 𫷛; +var 𫷜; +var 𫷝; +var 𫷞; +var 𫷟; +var 𫷠; +var 𫷡; +var 𫷢; +var 𫷣; +var 𫷤; +var 𫷥; +var 𫷦; +var 𫷧; +var 𫷨; +var 𫷩; +var 𫷪; +var 𫷫; +var 𫷬; +var 𫷭; +var 𫷮; +var 𫷯; +var 𫷰; +var 𫷱; +var 𫷲; +var 𫷳; +var 𫷴; +var 𫷵; +var 𫷶; +var 𫷷; +var 𫷸; +var 𫷹; +var 𫷺; +var 𫷻; +var 𫷼; +var 𫷽; +var 𫷾; +var 𫷿; +var 𫸀; +var 𫸁; +var 𫸂; +var 𫸃; +var 𫸄; +var 𫸅; +var 𫸆; +var 𫸇; +var 𫸈; +var 𫸉; +var 𫸊; +var 𫸋; +var 𫸌; +var 𫸍; +var 𫸎; +var 𫸏; +var 𫸐; +var 𫸑; +var 𫸒; +var 𫸓; +var 𫸔; +var 𫸕; +var 𫸖; +var 𫸗; +var 𫸘; +var 𫸙; +var 𫸚; +var 𫸛; +var 𫸜; +var 𫸝; +var 𫸞; +var 𫸟; +var 𫸠; +var 𫸡; +var 𫸢; +var 𫸣; +var 𫸤; +var 𫸥; +var 𫸦; +var 𫸧; +var 𫸨; +var 𫸩; +var 𫸪; +var 𫸫; +var 𫸬; +var 𫸭; +var 𫸮; +var 𫸯; +var 𫸰; +var 𫸱; +var 𫸲; +var 𫸳; +var 𫸴; +var 𫸵; +var 𫸶; +var 𫸷; +var 𫸸; +var 𫸹; +var 𫸺; +var 𫸻; +var 𫸼; +var 𫸽; +var 𫸾; +var 𫸿; +var 𫹀; +var 𫹁; +var 𫹂; +var 𫹃; +var 𫹄; +var 𫹅; +var 𫹆; +var 𫹇; +var 𫹈; +var 𫹉; +var 𫹊; +var 𫹋; +var 𫹌; +var 𫹍; +var 𫹎; +var 𫹏; +var 𫹐; +var 𫹑; +var 𫹒; +var 𫹓; +var 𫹔; +var 𫹕; +var 𫹖; +var 𫹗; +var 𫹘; +var 𫹙; +var 𫹚; +var 𫹛; +var 𫹜; +var 𫹝; +var 𫹞; +var 𫹟; +var 𫹠; +var 𫹡; +var 𫹢; +var 𫹣; +var 𫹤; +var 𫹥; +var 𫹦; +var 𫹧; +var 𫹨; +var 𫹩; +var 𫹪; +var 𫹫; +var 𫹬; +var 𫹭; +var 𫹮; +var 𫹯; +var 𫹰; +var 𫹱; +var 𫹲; +var 𫹳; +var 𫹴; +var 𫹵; +var 𫹶; +var 𫹷; +var 𫹸; +var 𫹹; +var 𫹺; +var 𫹻; +var 𫹼; +var 𫹽; +var 𫹾; +var 𫹿; +var 𫺀; +var 𫺁; +var 𫺂; +var 𫺃; +var 𫺄; +var 𫺅; +var 𫺆; +var 𫺇; +var 𫺈; +var 𫺉; +var 𫺊; +var 𫺋; +var 𫺌; +var 𫺍; +var 𫺎; +var 𫺏; +var 𫺐; +var 𫺑; +var 𫺒; +var 𫺓; +var 𫺔; +var 𫺕; +var 𫺖; +var 𫺗; +var 𫺘; +var 𫺙; +var 𫺚; +var 𫺛; +var 𫺜; +var 𫺝; +var 𫺞; +var 𫺟; +var 𫺠; +var 𫺡; +var 𫺢; +var 𫺣; +var 𫺤; +var 𫺥; +var 𫺦; +var 𫺧; +var 𫺨; +var 𫺩; +var 𫺪; +var 𫺫; +var 𫺬; +var 𫺭; +var 𫺮; +var 𫺯; +var 𫺰; +var 𫺱; +var 𫺲; +var 𫺳; +var 𫺴; +var 𫺵; +var 𫺶; +var 𫺷; +var 𫺸; +var 𫺹; +var 𫺺; +var 𫺻; +var 𫺼; +var 𫺽; +var 𫺾; +var 𫺿; +var 𫻀; +var 𫻁; +var 𫻂; +var 𫻃; +var 𫻄; +var 𫻅; +var 𫻆; +var 𫻇; +var 𫻈; +var 𫻉; +var 𫻊; +var 𫻋; +var 𫻌; +var 𫻍; +var 𫻎; +var 𫻏; +var 𫻐; +var 𫻑; +var 𫻒; +var 𫻓; +var 𫻔; +var 𫻕; +var 𫻖; +var 𫻗; +var 𫻘; +var 𫻙; +var 𫻚; +var 𫻛; +var 𫻜; +var 𫻝; +var 𫻞; +var 𫻟; +var 𫻠; +var 𫻡; +var 𫻢; +var 𫻣; +var 𫻤; +var 𫻥; +var 𫻦; +var 𫻧; +var 𫻨; +var 𫻩; +var 𫻪; +var 𫻫; +var 𫻬; +var 𫻭; +var 𫻮; +var 𫻯; +var 𫻰; +var 𫻱; +var 𫻲; +var 𫻳; +var 𫻴; +var 𫻵; +var 𫻶; +var 𫻷; +var 𫻸; +var 𫻹; +var 𫻺; +var 𫻻; +var 𫻼; +var 𫻽; +var 𫻾; +var 𫻿; +var 𫼀; +var 𫼁; +var 𫼂; +var 𫼃; +var 𫼄; +var 𫼅; +var 𫼆; +var 𫼇; +var 𫼈; +var 𫼉; +var 𫼊; +var 𫼋; +var 𫼌; +var 𫼍; +var 𫼎; +var 𫼏; +var 𫼐; +var 𫼑; +var 𫼒; +var 𫼓; +var 𫼔; +var 𫼕; +var 𫼖; +var 𫼗; +var 𫼘; +var 𫼙; +var 𫼚; +var 𫼛; +var 𫼜; +var 𫼝; +var 𫼞; +var 𫼟; +var 𫼠; +var 𫼡; +var 𫼢; +var 𫼣; +var 𫼤; +var 𫼥; +var 𫼦; +var 𫼧; +var 𫼨; +var 𫼩; +var 𫼪; +var 𫼫; +var 𫼬; +var 𫼭; +var 𫼮; +var 𫼯; +var 𫼰; +var 𫼱; +var 𫼲; +var 𫼳; +var 𫼴; +var 𫼵; +var 𫼶; +var 𫼷; +var 𫼸; +var 𫼹; +var 𫼺; +var 𫼻; +var 𫼼; +var 𫼽; +var 𫼾; +var 𫼿; +var 𫽀; +var 𫽁; +var 𫽂; +var 𫽃; +var 𫽄; +var 𫽅; +var 𫽆; +var 𫽇; +var 𫽈; +var 𫽉; +var 𫽊; +var 𫽋; +var 𫽌; +var 𫽍; +var 𫽎; +var 𫽏; +var 𫽐; +var 𫽑; +var 𫽒; +var 𫽓; +var 𫽔; +var 𫽕; +var 𫽖; +var 𫽗; +var 𫽘; +var 𫽙; +var 𫽚; +var 𫽛; +var 𫽜; +var 𫽝; +var 𫽞; +var 𫽟; +var 𫽠; +var 𫽡; +var 𫽢; +var 𫽣; +var 𫽤; +var 𫽥; +var 𫽦; +var 𫽧; +var 𫽨; +var 𫽩; +var 𫽪; +var 𫽫; +var 𫽬; +var 𫽭; +var 𫽮; +var 𫽯; +var 𫽰; +var 𫽱; +var 𫽲; +var 𫽳; +var 𫽴; +var 𫽵; +var 𫽶; +var 𫽷; +var 𫽸; +var 𫽹; +var 𫽺; +var 𫽻; +var 𫽼; +var 𫽽; +var 𫽾; +var 𫽿; +var 𫾀; +var 𫾁; +var 𫾂; +var 𫾃; +var 𫾄; +var 𫾅; +var 𫾆; +var 𫾇; +var 𫾈; +var 𫾉; +var 𫾊; +var 𫾋; +var 𫾌; +var 𫾍; +var 𫾎; +var 𫾏; +var 𫾐; +var 𫾑; +var 𫾒; +var 𫾓; +var 𫾔; +var 𫾕; +var 𫾖; +var 𫾗; +var 𫾘; +var 𫾙; +var 𫾚; +var 𫾛; +var 𫾜; +var 𫾝; +var 𫾞; +var 𫾟; +var 𫾠; +var 𫾡; +var 𫾢; +var 𫾣; +var 𫾤; +var 𫾥; +var 𫾦; +var 𫾧; +var 𫾨; +var 𫾩; +var 𫾪; +var 𫾫; +var 𫾬; +var 𫾭; +var 𫾮; +var 𫾯; +var 𫾰; +var 𫾱; +var 𫾲; +var 𫾳; +var 𫾴; +var 𫾵; +var 𫾶; +var 𫾷; +var 𫾸; +var 𫾹; +var 𫾺; +var 𫾻; +var 𫾼; +var 𫾽; +var 𫾾; +var 𫾿; +var 𫿀; +var 𫿁; +var 𫿂; +var 𫿃; +var 𫿄; +var 𫿅; +var 𫿆; +var 𫿇; +var 𫿈; +var 𫿉; +var 𫿊; +var 𫿋; +var 𫿌; +var 𫿍; +var 𫿎; +var 𫿏; +var 𫿐; +var 𫿑; +var 𫿒; +var 𫿓; +var 𫿔; +var 𫿕; +var 𫿖; +var 𫿗; +var 𫿘; +var 𫿙; +var 𫿚; +var 𫿛; +var 𫿜; +var 𫿝; +var 𫿞; +var 𫿟; +var 𫿠; +var 𫿡; +var 𫿢; +var 𫿣; +var 𫿤; +var 𫿥; +var 𫿦; +var 𫿧; +var 𫿨; +var 𫿩; +var 𫿪; +var 𫿫; +var 𫿬; +var 𫿭; +var 𫿮; +var 𫿯; +var 𫿰; +var 𫿱; +var 𫿲; +var 𫿳; +var 𫿴; +var 𫿵; +var 𫿶; +var 𫿷; +var 𫿸; +var 𫿹; +var 𫿺; +var 𫿻; +var 𫿼; +var 𫿽; +var 𫿾; +var 𫿿; +var 𬀀; +var 𬀁; +var 𬀂; +var 𬀃; +var 𬀄; +var 𬀅; +var 𬀆; +var 𬀇; +var 𬀈; +var 𬀉; +var 𬀊; +var 𬀋; +var 𬀌; +var 𬀍; +var 𬀎; +var 𬀏; +var 𬀐; +var 𬀑; +var 𬀒; +var 𬀓; +var 𬀔; +var 𬀕; +var 𬀖; +var 𬀗; +var 𬀘; +var 𬀙; +var 𬀚; +var 𬀛; +var 𬀜; +var 𬀝; +var 𬀞; +var 𬀟; +var 𬀠; +var 𬀡; +var 𬀢; +var 𬀣; +var 𬀤; +var 𬀥; +var 𬀦; +var 𬀧; +var 𬀨; +var 𬀩; +var 𬀪; +var 𬀫; +var 𬀬; +var 𬀭; +var 𬀮; +var 𬀯; +var 𬀰; +var 𬀱; +var 𬀲; +var 𬀳; +var 𬀴; +var 𬀵; +var 𬀶; +var 𬀷; +var 𬀸; +var 𬀹; +var 𬀺; +var 𬀻; +var 𬀼; +var 𬀽; +var 𬀾; +var 𬀿; +var 𬁀; +var 𬁁; +var 𬁂; +var 𬁃; +var 𬁄; +var 𬁅; +var 𬁆; +var 𬁇; +var 𬁈; +var 𬁉; +var 𬁊; +var 𬁋; +var 𬁌; +var 𬁍; +var 𬁎; +var 𬁏; +var 𬁐; +var 𬁑; +var 𬁒; +var 𬁓; +var 𬁔; +var 𬁕; +var 𬁖; +var 𬁗; +var 𬁘; +var 𬁙; +var 𬁚; +var 𬁛; +var 𬁜; +var 𬁝; +var 𬁞; +var 𬁟; +var 𬁠; +var 𬁡; +var 𬁢; +var 𬁣; +var 𬁤; +var 𬁥; +var 𬁦; +var 𬁧; +var 𬁨; +var 𬁩; +var 𬁪; +var 𬁫; +var 𬁬; +var 𬁭; +var 𬁮; +var 𬁯; +var 𬁰; +var 𬁱; +var 𬁲; +var 𬁳; +var 𬁴; +var 𬁵; +var 𬁶; +var 𬁷; +var 𬁸; +var 𬁹; +var 𬁺; +var 𬁻; +var 𬁼; +var 𬁽; +var 𬁾; +var 𬁿; +var 𬂀; +var 𬂁; +var 𬂂; +var 𬂃; +var 𬂄; +var 𬂅; +var 𬂆; +var 𬂇; +var 𬂈; +var 𬂉; +var 𬂊; +var 𬂋; +var 𬂌; +var 𬂍; +var 𬂎; +var 𬂏; +var 𬂐; +var 𬂑; +var 𬂒; +var 𬂓; +var 𬂔; +var 𬂕; +var 𬂖; +var 𬂗; +var 𬂘; +var 𬂙; +var 𬂚; +var 𬂛; +var 𬂜; +var 𬂝; +var 𬂞; +var 𬂟; +var 𬂠; +var 𬂡; +var 𬂢; +var 𬂣; +var 𬂤; +var 𬂥; +var 𬂦; +var 𬂧; +var 𬂨; +var 𬂩; +var 𬂪; +var 𬂫; +var 𬂬; +var 𬂭; +var 𬂮; +var 𬂯; +var 𬂰; +var 𬂱; +var 𬂲; +var 𬂳; +var 𬂴; +var 𬂵; +var 𬂶; +var 𬂷; +var 𬂸; +var 𬂹; +var 𬂺; +var 𬂻; +var 𬂼; +var 𬂽; +var 𬂾; +var 𬂿; +var 𬃀; +var 𬃁; +var 𬃂; +var 𬃃; +var 𬃄; +var 𬃅; +var 𬃆; +var 𬃇; +var 𬃈; +var 𬃉; +var 𬃊; +var 𬃋; +var 𬃌; +var 𬃍; +var 𬃎; +var 𬃏; +var 𬃐; +var 𬃑; +var 𬃒; +var 𬃓; +var 𬃔; +var 𬃕; +var 𬃖; +var 𬃗; +var 𬃘; +var 𬃙; +var 𬃚; +var 𬃛; +var 𬃜; +var 𬃝; +var 𬃞; +var 𬃟; +var 𬃠; +var 𬃡; +var 𬃢; +var 𬃣; +var 𬃤; +var 𬃥; +var 𬃦; +var 𬃧; +var 𬃨; +var 𬃩; +var 𬃪; +var 𬃫; +var 𬃬; +var 𬃭; +var 𬃮; +var 𬃯; +var 𬃰; +var 𬃱; +var 𬃲; +var 𬃳; +var 𬃴; +var 𬃵; +var 𬃶; +var 𬃷; +var 𬃸; +var 𬃹; +var 𬃺; +var 𬃻; +var 𬃼; +var 𬃽; +var 𬃾; +var 𬃿; +var 𬄀; +var 𬄁; +var 𬄂; +var 𬄃; +var 𬄄; +var 𬄅; +var 𬄆; +var 𬄇; +var 𬄈; +var 𬄉; +var 𬄊; +var 𬄋; +var 𬄌; +var 𬄍; +var 𬄎; +var 𬄏; +var 𬄐; +var 𬄑; +var 𬄒; +var 𬄓; +var 𬄔; +var 𬄕; +var 𬄖; +var 𬄗; +var 𬄘; +var 𬄙; +var 𬄚; +var 𬄛; +var 𬄜; +var 𬄝; +var 𬄞; +var 𬄟; +var 𬄠; +var 𬄡; +var 𬄢; +var 𬄣; +var 𬄤; +var 𬄥; +var 𬄦; +var 𬄧; +var 𬄨; +var 𬄩; +var 𬄪; +var 𬄫; +var 𬄬; +var 𬄭; +var 𬄮; +var 𬄯; +var 𬄰; +var 𬄱; +var 𬄲; +var 𬄳; +var 𬄴; +var 𬄵; +var 𬄶; +var 𬄷; +var 𬄸; +var 𬄹; +var 𬄺; +var 𬄻; +var 𬄼; +var 𬄽; +var 𬄾; +var 𬄿; +var 𬅀; +var 𬅁; +var 𬅂; +var 𬅃; +var 𬅄; +var 𬅅; +var 𬅆; +var 𬅇; +var 𬅈; +var 𬅉; +var 𬅊; +var 𬅋; +var 𬅌; +var 𬅍; +var 𬅎; +var 𬅏; +var 𬅐; +var 𬅑; +var 𬅒; +var 𬅓; +var 𬅔; +var 𬅕; +var 𬅖; +var 𬅗; +var 𬅘; +var 𬅙; +var 𬅚; +var 𬅛; +var 𬅜; +var 𬅝; +var 𬅞; +var 𬅟; +var 𬅠; +var 𬅡; +var 𬅢; +var 𬅣; +var 𬅤; +var 𬅥; +var 𬅦; +var 𬅧; +var 𬅨; +var 𬅩; +var 𬅪; +var 𬅫; +var 𬅬; +var 𬅭; +var 𬅮; +var 𬅯; +var 𬅰; +var 𬅱; +var 𬅲; +var 𬅳; +var 𬅴; +var 𬅵; +var 𬅶; +var 𬅷; +var 𬅸; +var 𬅹; +var 𬅺; +var 𬅻; +var 𬅼; +var 𬅽; +var 𬅾; +var 𬅿; +var 𬆀; +var 𬆁; +var 𬆂; +var 𬆃; +var 𬆄; +var 𬆅; +var 𬆆; +var 𬆇; +var 𬆈; +var 𬆉; +var 𬆊; +var 𬆋; +var 𬆌; +var 𬆍; +var 𬆎; +var 𬆏; +var 𬆐; +var 𬆑; +var 𬆒; +var 𬆓; +var 𬆔; +var 𬆕; +var 𬆖; +var 𬆗; +var 𬆘; +var 𬆙; +var 𬆚; +var 𬆛; +var 𬆜; +var 𬆝; +var 𬆞; +var 𬆟; +var 𬆠; +var 𬆡; +var 𬆢; +var 𬆣; +var 𬆤; +var 𬆥; +var 𬆦; +var 𬆧; +var 𬆨; +var 𬆩; +var 𬆪; +var 𬆫; +var 𬆬; +var 𬆭; +var 𬆮; +var 𬆯; +var 𬆰; +var 𬆱; +var 𬆲; +var 𬆳; +var 𬆴; +var 𬆵; +var 𬆶; +var 𬆷; +var 𬆸; +var 𬆹; +var 𬆺; +var 𬆻; +var 𬆼; +var 𬆽; +var 𬆾; +var 𬆿; +var 𬇀; +var 𬇁; +var 𬇂; +var 𬇃; +var 𬇄; +var 𬇅; +var 𬇆; +var 𬇇; +var 𬇈; +var 𬇉; +var 𬇊; +var 𬇋; +var 𬇌; +var 𬇍; +var 𬇎; +var 𬇏; +var 𬇐; +var 𬇑; +var 𬇒; +var 𬇓; +var 𬇔; +var 𬇕; +var 𬇖; +var 𬇗; +var 𬇘; +var 𬇙; +var 𬇚; +var 𬇛; +var 𬇜; +var 𬇝; +var 𬇞; +var 𬇟; +var 𬇠; +var 𬇡; +var 𬇢; +var 𬇣; +var 𬇤; +var 𬇥; +var 𬇦; +var 𬇧; +var 𬇨; +var 𬇩; +var 𬇪; +var 𬇫; +var 𬇬; +var 𬇭; +var 𬇮; +var 𬇯; +var 𬇰; +var 𬇱; +var 𬇲; +var 𬇳; +var 𬇴; +var 𬇵; +var 𬇶; +var 𬇷; +var 𬇸; +var 𬇹; +var 𬇺; +var 𬇻; +var 𬇼; +var 𬇽; +var 𬇾; +var 𬇿; +var 𬈀; +var 𬈁; +var 𬈂; +var 𬈃; +var 𬈄; +var 𬈅; +var 𬈆; +var 𬈇; +var 𬈈; +var 𬈉; +var 𬈊; +var 𬈋; +var 𬈌; +var 𬈍; +var 𬈎; +var 𬈏; +var 𬈐; +var 𬈑; +var 𬈒; +var 𬈓; +var 𬈔; +var 𬈕; +var 𬈖; +var 𬈗; +var 𬈘; +var 𬈙; +var 𬈚; +var 𬈛; +var 𬈜; +var 𬈝; +var 𬈞; +var 𬈟; +var 𬈠; +var 𬈡; +var 𬈢; +var 𬈣; +var 𬈤; +var 𬈥; +var 𬈦; +var 𬈧; +var 𬈨; +var 𬈩; +var 𬈪; +var 𬈫; +var 𬈬; +var 𬈭; +var 𬈮; +var 𬈯; +var 𬈰; +var 𬈱; +var 𬈲; +var 𬈳; +var 𬈴; +var 𬈵; +var 𬈶; +var 𬈷; +var 𬈸; +var 𬈹; +var 𬈺; +var 𬈻; +var 𬈼; +var 𬈽; +var 𬈾; +var 𬈿; +var 𬉀; +var 𬉁; +var 𬉂; +var 𬉃; +var 𬉄; +var 𬉅; +var 𬉆; +var 𬉇; +var 𬉈; +var 𬉉; +var 𬉊; +var 𬉋; +var 𬉌; +var 𬉍; +var 𬉎; +var 𬉏; +var 𬉐; +var 𬉑; +var 𬉒; +var 𬉓; +var 𬉔; +var 𬉕; +var 𬉖; +var 𬉗; +var 𬉘; +var 𬉙; +var 𬉚; +var 𬉛; +var 𬉜; +var 𬉝; +var 𬉞; +var 𬉟; +var 𬉠; +var 𬉡; +var 𬉢; +var 𬉣; +var 𬉤; +var 𬉥; +var 𬉦; +var 𬉧; +var 𬉨; +var 𬉩; +var 𬉪; +var 𬉫; +var 𬉬; +var 𬉭; +var 𬉮; +var 𬉯; +var 𬉰; +var 𬉱; +var 𬉲; +var 𬉳; +var 𬉴; +var 𬉵; +var 𬉶; +var 𬉷; +var 𬉸; +var 𬉹; +var 𬉺; +var 𬉻; +var 𬉼; +var 𬉽; +var 𬉾; +var 𬉿; +var 𬊀; +var 𬊁; +var 𬊂; +var 𬊃; +var 𬊄; +var 𬊅; +var 𬊆; +var 𬊇; +var 𬊈; +var 𬊉; +var 𬊊; +var 𬊋; +var 𬊌; +var 𬊍; +var 𬊎; +var 𬊏; +var 𬊐; +var 𬊑; +var 𬊒; +var 𬊓; +var 𬊔; +var 𬊕; +var 𬊖; +var 𬊗; +var 𬊘; +var 𬊙; +var 𬊚; +var 𬊛; +var 𬊜; +var 𬊝; +var 𬊞; +var 𬊟; +var 𬊠; +var 𬊡; +var 𬊢; +var 𬊣; +var 𬊤; +var 𬊥; +var 𬊦; +var 𬊧; +var 𬊨; +var 𬊩; +var 𬊪; +var 𬊫; +var 𬊬; +var 𬊭; +var 𬊮; +var 𬊯; +var 𬊰; +var 𬊱; +var 𬊲; +var 𬊳; +var 𬊴; +var 𬊵; +var 𬊶; +var 𬊷; +var 𬊸; +var 𬊹; +var 𬊺; +var 𬊻; +var 𬊼; +var 𬊽; +var 𬊾; +var 𬊿; +var 𬋀; +var 𬋁; +var 𬋂; +var 𬋃; +var 𬋄; +var 𬋅; +var 𬋆; +var 𬋇; +var 𬋈; +var 𬋉; +var 𬋊; +var 𬋋; +var 𬋌; +var 𬋍; +var 𬋎; +var 𬋏; +var 𬋐; +var 𬋑; +var 𬋒; +var 𬋓; +var 𬋔; +var 𬋕; +var 𬋖; +var 𬋗; +var 𬋘; +var 𬋙; +var 𬋚; +var 𬋛; +var 𬋜; +var 𬋝; +var 𬋞; +var 𬋟; +var 𬋠; +var 𬋡; +var 𬋢; +var 𬋣; +var 𬋤; +var 𬋥; +var 𬋦; +var 𬋧; +var 𬋨; +var 𬋩; +var 𬋪; +var 𬋫; +var 𬋬; +var 𬋭; +var 𬋮; +var 𬋯; +var 𬋰; +var 𬋱; +var 𬋲; +var 𬋳; +var 𬋴; +var 𬋵; +var 𬋶; +var 𬋷; +var 𬋸; +var 𬋹; +var 𬋺; +var 𬋻; +var 𬋼; +var 𬋽; +var 𬋾; +var 𬋿; +var 𬌀; +var 𬌁; +var 𬌂; +var 𬌃; +var 𬌄; +var 𬌅; +var 𬌆; +var 𬌇; +var 𬌈; +var 𬌉; +var 𬌊; +var 𬌋; +var 𬌌; +var 𬌍; +var 𬌎; +var 𬌏; +var 𬌐; +var 𬌑; +var 𬌒; +var 𬌓; +var 𬌔; +var 𬌕; +var 𬌖; +var 𬌗; +var 𬌘; +var 𬌙; +var 𬌚; +var 𬌛; +var 𬌜; +var 𬌝; +var 𬌞; +var 𬌟; +var 𬌠; +var 𬌡; +var 𬌢; +var 𬌣; +var 𬌤; +var 𬌥; +var 𬌦; +var 𬌧; +var 𬌨; +var 𬌩; +var 𬌪; +var 𬌫; +var 𬌬; +var 𬌭; +var 𬌮; +var 𬌯; +var 𬌰; +var 𬌱; +var 𬌲; +var 𬌳; +var 𬌴; +var 𬌵; +var 𬌶; +var 𬌷; +var 𬌸; +var 𬌹; +var 𬌺; +var 𬌻; +var 𬌼; +var 𬌽; +var 𬌾; +var 𬌿; +var 𬍀; +var 𬍁; +var 𬍂; +var 𬍃; +var 𬍄; +var 𬍅; +var 𬍆; +var 𬍇; +var 𬍈; +var 𬍉; +var 𬍊; +var 𬍋; +var 𬍌; +var 𬍍; +var 𬍎; +var 𬍏; +var 𬍐; +var 𬍑; +var 𬍒; +var 𬍓; +var 𬍔; +var 𬍕; +var 𬍖; +var 𬍗; +var 𬍘; +var 𬍙; +var 𬍚; +var 𬍛; +var 𬍜; +var 𬍝; +var 𬍞; +var 𬍟; +var 𬍠; +var 𬍡; +var 𬍢; +var 𬍣; +var 𬍤; +var 𬍥; +var 𬍦; +var 𬍧; +var 𬍨; +var 𬍩; +var 𬍪; +var 𬍫; +var 𬍬; +var 𬍭; +var 𬍮; +var 𬍯; +var 𬍰; +var 𬍱; +var 𬍲; +var 𬍳; +var 𬍴; +var 𬍵; +var 𬍶; +var 𬍷; +var 𬍸; +var 𬍹; +var 𬍺; +var 𬍻; +var 𬍼; +var 𬍽; +var 𬍾; +var 𬍿; +var 𬎀; +var 𬎁; +var 𬎂; +var 𬎃; +var 𬎄; +var 𬎅; +var 𬎆; +var 𬎇; +var 𬎈; +var 𬎉; +var 𬎊; +var 𬎋; +var 𬎌; +var 𬎍; +var 𬎎; +var 𬎏; +var 𬎐; +var 𬎑; +var 𬎒; +var 𬎓; +var 𬎔; +var 𬎕; +var 𬎖; +var 𬎗; +var 𬎘; +var 𬎙; +var 𬎚; +var 𬎛; +var 𬎜; +var 𬎝; +var 𬎞; +var 𬎟; +var 𬎠; +var 𬎡; +var 𬎢; +var 𬎣; +var 𬎤; +var 𬎥; +var 𬎦; +var 𬎧; +var 𬎨; +var 𬎩; +var 𬎪; +var 𬎫; +var 𬎬; +var 𬎭; +var 𬎮; +var 𬎯; +var 𬎰; +var 𬎱; +var 𬎲; +var 𬎳; +var 𬎴; +var 𬎵; +var 𬎶; +var 𬎷; +var 𬎸; +var 𬎹; +var 𬎺; +var 𬎻; +var 𬎼; +var 𬎽; +var 𬎾; +var 𬎿; +var 𬏀; +var 𬏁; +var 𬏂; +var 𬏃; +var 𬏄; +var 𬏅; +var 𬏆; +var 𬏇; +var 𬏈; +var 𬏉; +var 𬏊; +var 𬏋; +var 𬏌; +var 𬏍; +var 𬏎; +var 𬏏; +var 𬏐; +var 𬏑; +var 𬏒; +var 𬏓; +var 𬏔; +var 𬏕; +var 𬏖; +var 𬏗; +var 𬏘; +var 𬏙; +var 𬏚; +var 𬏛; +var 𬏜; +var 𬏝; +var 𬏞; +var 𬏟; +var 𬏠; +var 𬏡; +var 𬏢; +var 𬏣; +var 𬏤; +var 𬏥; +var 𬏦; +var 𬏧; +var 𬏨; +var 𬏩; +var 𬏪; +var 𬏫; +var 𬏬; +var 𬏭; +var 𬏮; +var 𬏯; +var 𬏰; +var 𬏱; +var 𬏲; +var 𬏳; +var 𬏴; +var 𬏵; +var 𬏶; +var 𬏷; +var 𬏸; +var 𬏹; +var 𬏺; +var 𬏻; +var 𬏼; +var 𬏽; +var 𬏾; +var 𬏿; +var 𬐀; +var 𬐁; +var 𬐂; +var 𬐃; +var 𬐄; +var 𬐅; +var 𬐆; +var 𬐇; +var 𬐈; +var 𬐉; +var 𬐊; +var 𬐋; +var 𬐌; +var 𬐍; +var 𬐎; +var 𬐏; +var 𬐐; +var 𬐑; +var 𬐒; +var 𬐓; +var 𬐔; +var 𬐕; +var 𬐖; +var 𬐗; +var 𬐘; +var 𬐙; +var 𬐚; +var 𬐛; +var 𬐜; +var 𬐝; +var 𬐞; +var 𬐟; +var 𬐠; +var 𬐡; +var 𬐢; +var 𬐣; +var 𬐤; +var 𬐥; +var 𬐦; +var 𬐧; +var 𬐨; +var 𬐩; +var 𬐪; +var 𬐫; +var 𬐬; +var 𬐭; +var 𬐮; +var 𬐯; +var 𬐰; +var 𬐱; +var 𬐲; +var 𬐳; +var 𬐴; +var 𬐵; +var 𬐶; +var 𬐷; +var 𬐸; +var 𬐹; +var 𬐺; +var 𬐻; +var 𬐼; +var 𬐽; +var 𬐾; +var 𬐿; +var 𬑀; +var 𬑁; +var 𬑂; +var 𬑃; +var 𬑄; +var 𬑅; +var 𬑆; +var 𬑇; +var 𬑈; +var 𬑉; +var 𬑊; +var 𬑋; +var 𬑌; +var 𬑍; +var 𬑎; +var 𬑏; +var 𬑐; +var 𬑑; +var 𬑒; +var 𬑓; +var 𬑔; +var 𬑕; +var 𬑖; +var 𬑗; +var 𬑘; +var 𬑙; +var 𬑚; +var 𬑛; +var 𬑜; +var 𬑝; +var 𬑞; +var 𬑟; +var 𬑠; +var 𬑡; +var 𬑢; +var 𬑣; +var 𬑤; +var 𬑥; +var 𬑦; +var 𬑧; +var 𬑨; +var 𬑩; +var 𬑪; +var 𬑫; +var 𬑬; +var 𬑭; +var 𬑮; +var 𬑯; +var 𬑰; +var 𬑱; +var 𬑲; +var 𬑳; +var 𬑴; +var 𬑵; +var 𬑶; +var 𬑷; +var 𬑸; +var 𬑹; +var 𬑺; +var 𬑻; +var 𬑼; +var 𬑽; +var 𬑾; +var 𬑿; +var 𬒀; +var 𬒁; +var 𬒂; +var 𬒃; +var 𬒄; +var 𬒅; +var 𬒆; +var 𬒇; +var 𬒈; +var 𬒉; +var 𬒊; +var 𬒋; +var 𬒌; +var 𬒍; +var 𬒎; +var 𬒏; +var 𬒐; +var 𬒑; +var 𬒒; +var 𬒓; +var 𬒔; +var 𬒕; +var 𬒖; +var 𬒗; +var 𬒘; +var 𬒙; +var 𬒚; +var 𬒛; +var 𬒜; +var 𬒝; +var 𬒞; +var 𬒟; +var 𬒠; +var 𬒡; +var 𬒢; +var 𬒣; +var 𬒤; +var 𬒥; +var 𬒦; +var 𬒧; +var 𬒨; +var 𬒩; +var 𬒪; +var 𬒫; +var 𬒬; +var 𬒭; +var 𬒮; +var 𬒯; +var 𬒰; +var 𬒱; +var 𬒲; +var 𬒳; +var 𬒴; +var 𬒵; +var 𬒶; +var 𬒷; +var 𬒸; +var 𬒹; +var 𬒺; +var 𬒻; +var 𬒼; +var 𬒽; +var 𬒾; +var 𬒿; +var 𬓀; +var 𬓁; +var 𬓂; +var 𬓃; +var 𬓄; +var 𬓅; +var 𬓆; +var 𬓇; +var 𬓈; +var 𬓉; +var 𬓊; +var 𬓋; +var 𬓌; +var 𬓍; +var 𬓎; +var 𬓏; +var 𬓐; +var 𬓑; +var 𬓒; +var 𬓓; +var 𬓔; +var 𬓕; +var 𬓖; +var 𬓗; +var 𬓘; +var 𬓙; +var 𬓚; +var 𬓛; +var 𬓜; +var 𬓝; +var 𬓞; +var 𬓟; +var 𬓠; +var 𬓡; +var 𬓢; +var 𬓣; +var 𬓤; +var 𬓥; +var 𬓦; +var 𬓧; +var 𬓨; +var 𬓩; +var 𬓪; +var 𬓫; +var 𬓬; +var 𬓭; +var 𬓮; +var 𬓯; +var 𬓰; +var 𬓱; +var 𬓲; +var 𬓳; +var 𬓴; +var 𬓵; +var 𬓶; +var 𬓷; +var 𬓸; +var 𬓹; +var 𬓺; +var 𬓻; +var 𬓼; +var 𬓽; +var 𬓾; +var 𬓿; +var 𬔀; +var 𬔁; +var 𬔂; +var 𬔃; +var 𬔄; +var 𬔅; +var 𬔆; +var 𬔇; +var 𬔈; +var 𬔉; +var 𬔊; +var 𬔋; +var 𬔌; +var 𬔍; +var 𬔎; +var 𬔏; +var 𬔐; +var 𬔑; +var 𬔒; +var 𬔓; +var 𬔔; +var 𬔕; +var 𬔖; +var 𬔗; +var 𬔘; +var 𬔙; +var 𬔚; +var 𬔛; +var 𬔜; +var 𬔝; +var 𬔞; +var 𬔟; +var 𬔠; +var 𬔡; +var 𬔢; +var 𬔣; +var 𬔤; +var 𬔥; +var 𬔦; +var 𬔧; +var 𬔨; +var 𬔩; +var 𬔪; +var 𬔫; +var 𬔬; +var 𬔭; +var 𬔮; +var 𬔯; +var 𬔰; +var 𬔱; +var 𬔲; +var 𬔳; +var 𬔴; +var 𬔵; +var 𬔶; +var 𬔷; +var 𬔸; +var 𬔹; +var 𬔺; +var 𬔻; +var 𬔼; +var 𬔽; +var 𬔾; +var 𬔿; +var 𬕀; +var 𬕁; +var 𬕂; +var 𬕃; +var 𬕄; +var 𬕅; +var 𬕆; +var 𬕇; +var 𬕈; +var 𬕉; +var 𬕊; +var 𬕋; +var 𬕌; +var 𬕍; +var 𬕎; +var 𬕏; +var 𬕐; +var 𬕑; +var 𬕒; +var 𬕓; +var 𬕔; +var 𬕕; +var 𬕖; +var 𬕗; +var 𬕘; +var 𬕙; +var 𬕚; +var 𬕛; +var 𬕜; +var 𬕝; +var 𬕞; +var 𬕟; +var 𬕠; +var 𬕡; +var 𬕢; +var 𬕣; +var 𬕤; +var 𬕥; +var 𬕦; +var 𬕧; +var 𬕨; +var 𬕩; +var 𬕪; +var 𬕫; +var 𬕬; +var 𬕭; +var 𬕮; +var 𬕯; +var 𬕰; +var 𬕱; +var 𬕲; +var 𬕳; +var 𬕴; +var 𬕵; +var 𬕶; +var 𬕷; +var 𬕸; +var 𬕹; +var 𬕺; +var 𬕻; +var 𬕼; +var 𬕽; +var 𬕾; +var 𬕿; +var 𬖀; +var 𬖁; +var 𬖂; +var 𬖃; +var 𬖄; +var 𬖅; +var 𬖆; +var 𬖇; +var 𬖈; +var 𬖉; +var 𬖊; +var 𬖋; +var 𬖌; +var 𬖍; +var 𬖎; +var 𬖏; +var 𬖐; +var 𬖑; +var 𬖒; +var 𬖓; +var 𬖔; +var 𬖕; +var 𬖖; +var 𬖗; +var 𬖘; +var 𬖙; +var 𬖚; +var 𬖛; +var 𬖜; +var 𬖝; +var 𬖞; +var 𬖟; +var 𬖠; +var 𬖡; +var 𬖢; +var 𬖣; +var 𬖤; +var 𬖥; +var 𬖦; +var 𬖧; +var 𬖨; +var 𬖩; +var 𬖪; +var 𬖫; +var 𬖬; +var 𬖭; +var 𬖮; +var 𬖯; +var 𬖰; +var 𬖱; +var 𬖲; +var 𬖳; +var 𬖴; +var 𬖵; +var 𬖶; +var 𬖷; +var 𬖸; +var 𬖹; +var 𬖺; +var 𬖻; +var 𬖼; +var 𬖽; +var 𬖾; +var 𬖿; +var 𬗀; +var 𬗁; +var 𬗂; +var 𬗃; +var 𬗄; +var 𬗅; +var 𬗆; +var 𬗇; +var 𬗈; +var 𬗉; +var 𬗊; +var 𬗋; +var 𬗌; +var 𬗍; +var 𬗎; +var 𬗏; +var 𬗐; +var 𬗑; +var 𬗒; +var 𬗓; +var 𬗔; +var 𬗕; +var 𬗖; +var 𬗗; +var 𬗘; +var 𬗙; +var 𬗚; +var 𬗛; +var 𬗜; +var 𬗝; +var 𬗞; +var 𬗟; +var 𬗠; +var 𬗡; +var 𬗢; +var 𬗣; +var 𬗤; +var 𬗥; +var 𬗦; +var 𬗧; +var 𬗨; +var 𬗩; +var 𬗪; +var 𬗫; +var 𬗬; +var 𬗭; +var 𬗮; +var 𬗯; +var 𬗰; +var 𬗱; +var 𬗲; +var 𬗳; +var 𬗴; +var 𬗵; +var 𬗶; +var 𬗷; +var 𬗸; +var 𬗹; +var 𬗺; +var 𬗻; +var 𬗼; +var 𬗽; +var 𬗾; +var 𬗿; +var 𬘀; +var 𬘁; +var 𬘂; +var 𬘃; +var 𬘄; +var 𬘅; +var 𬘆; +var 𬘇; +var 𬘈; +var 𬘉; +var 𬘊; +var 𬘋; +var 𬘌; +var 𬘍; +var 𬘎; +var 𬘏; +var 𬘐; +var 𬘑; +var 𬘒; +var 𬘓; +var 𬘔; +var 𬘕; +var 𬘖; +var 𬘗; +var 𬘘; +var 𬘙; +var 𬘚; +var 𬘛; +var 𬘜; +var 𬘝; +var 𬘞; +var 𬘟; +var 𬘠; +var 𬘡; +var 𬘢; +var 𬘣; +var 𬘤; +var 𬘥; +var 𬘦; +var 𬘧; +var 𬘨; +var 𬘩; +var 𬘪; +var 𬘫; +var 𬘬; +var 𬘭; +var 𬘮; +var 𬘯; +var 𬘰; +var 𬘱; +var 𬘲; +var 𬘳; +var 𬘴; +var 𬘵; +var 𬘶; +var 𬘷; +var 𬘸; +var 𬘹; +var 𬘺; +var 𬘻; +var 𬘼; +var 𬘽; +var 𬘾; +var 𬘿; +var 𬙀; +var 𬙁; +var 𬙂; +var 𬙃; +var 𬙄; +var 𬙅; +var 𬙆; +var 𬙇; +var 𬙈; +var 𬙉; +var 𬙊; +var 𬙋; +var 𬙌; +var 𬙍; +var 𬙎; +var 𬙏; +var 𬙐; +var 𬙑; +var 𬙒; +var 𬙓; +var 𬙔; +var 𬙕; +var 𬙖; +var 𬙗; +var 𬙘; +var 𬙙; +var 𬙚; +var 𬙛; +var 𬙜; +var 𬙝; +var 𬙞; +var 𬙟; +var 𬙠; +var 𬙡; +var 𬙢; +var 𬙣; +var 𬙤; +var 𬙥; +var 𬙦; +var 𬙧; +var 𬙨; +var 𬙩; +var 𬙪; +var 𬙫; +var 𬙬; +var 𬙭; +var 𬙮; +var 𬙯; +var 𬙰; +var 𬙱; +var 𬙲; +var 𬙳; +var 𬙴; +var 𬙵; +var 𬙶; +var 𬙷; +var 𬙸; +var 𬙹; +var 𬙺; +var 𬙻; +var 𬙼; +var 𬙽; +var 𬙾; +var 𬙿; +var 𬚀; +var 𬚁; +var 𬚂; +var 𬚃; +var 𬚄; +var 𬚅; +var 𬚆; +var 𬚇; +var 𬚈; +var 𬚉; +var 𬚊; +var 𬚋; +var 𬚌; +var 𬚍; +var 𬚎; +var 𬚏; +var 𬚐; +var 𬚑; +var 𬚒; +var 𬚓; +var 𬚔; +var 𬚕; +var 𬚖; +var 𬚗; +var 𬚘; +var 𬚙; +var 𬚚; +var 𬚛; +var 𬚜; +var 𬚝; +var 𬚞; +var 𬚟; +var 𬚠; +var 𬚡; +var 𬚢; +var 𬚣; +var 𬚤; +var 𬚥; +var 𬚦; +var 𬚧; +var 𬚨; +var 𬚩; +var 𬚪; +var 𬚫; +var 𬚬; +var 𬚭; +var 𬚮; +var 𬚯; +var 𬚰; +var 𬚱; +var 𬚲; +var 𬚳; +var 𬚴; +var 𬚵; +var 𬚶; +var 𬚷; +var 𬚸; +var 𬚹; +var 𬚺; +var 𬚻; +var 𬚼; +var 𬚽; +var 𬚾; +var 𬚿; +var 𬛀; +var 𬛁; +var 𬛂; +var 𬛃; +var 𬛄; +var 𬛅; +var 𬛆; +var 𬛇; +var 𬛈; +var 𬛉; +var 𬛊; +var 𬛋; +var 𬛌; +var 𬛍; +var 𬛎; +var 𬛏; +var 𬛐; +var 𬛑; +var 𬛒; +var 𬛓; +var 𬛔; +var 𬛕; +var 𬛖; +var 𬛗; +var 𬛘; +var 𬛙; +var 𬛚; +var 𬛛; +var 𬛜; +var 𬛝; +var 𬛞; +var 𬛟; +var 𬛠; +var 𬛡; +var 𬛢; +var 𬛣; +var 𬛤; +var 𬛥; +var 𬛦; +var 𬛧; +var 𬛨; +var 𬛩; +var 𬛪; +var 𬛫; +var 𬛬; +var 𬛭; +var 𬛮; +var 𬛯; +var 𬛰; +var 𬛱; +var 𬛲; +var 𬛳; +var 𬛴; +var 𬛵; +var 𬛶; +var 𬛷; +var 𬛸; +var 𬛹; +var 𬛺; +var 𬛻; +var 𬛼; +var 𬛽; +var 𬛾; +var 𬛿; +var 𬜀; +var 𬜁; +var 𬜂; +var 𬜃; +var 𬜄; +var 𬜅; +var 𬜆; +var 𬜇; +var 𬜈; +var 𬜉; +var 𬜊; +var 𬜋; +var 𬜌; +var 𬜍; +var 𬜎; +var 𬜏; +var 𬜐; +var 𬜑; +var 𬜒; +var 𬜓; +var 𬜔; +var 𬜕; +var 𬜖; +var 𬜗; +var 𬜘; +var 𬜙; +var 𬜚; +var 𬜛; +var 𬜜; +var 𬜝; +var 𬜞; +var 𬜟; +var 𬜠; +var 𬜡; +var 𬜢; +var 𬜣; +var 𬜤; +var 𬜥; +var 𬜦; +var 𬜧; +var 𬜨; +var 𬜩; +var 𬜪; +var 𬜫; +var 𬜬; +var 𬜭; +var 𬜮; +var 𬜯; +var 𬜰; +var 𬜱; +var 𬜲; +var 𬜳; +var 𬜴; +var 𬜵; +var 𬜶; +var 𬜷; +var 𬜸; +var 𬜹; +var 𬜺; +var 𬜻; +var 𬜼; +var 𬜽; +var 𬜾; +var 𬜿; +var 𬝀; +var 𬝁; +var 𬝂; +var 𬝃; +var 𬝄; +var 𬝅; +var 𬝆; +var 𬝇; +var 𬝈; +var 𬝉; +var 𬝊; +var 𬝋; +var 𬝌; +var 𬝍; +var 𬝎; +var 𬝏; +var 𬝐; +var 𬝑; +var 𬝒; +var 𬝓; +var 𬝔; +var 𬝕; +var 𬝖; +var 𬝗; +var 𬝘; +var 𬝙; +var 𬝚; +var 𬝛; +var 𬝜; +var 𬝝; +var 𬝞; +var 𬝟; +var 𬝠; +var 𬝡; +var 𬝢; +var 𬝣; +var 𬝤; +var 𬝥; +var 𬝦; +var 𬝧; +var 𬝨; +var 𬝩; +var 𬝪; +var 𬝫; +var 𬝬; +var 𬝭; +var 𬝮; +var 𬝯; +var 𬝰; +var 𬝱; +var 𬝲; +var 𬝳; +var 𬝴; +var 𬝵; +var 𬝶; +var 𬝷; +var 𬝸; +var 𬝹; +var 𬝺; +var 𬝻; +var 𬝼; +var 𬝽; +var 𬝾; +var 𬝿; +var 𬞀; +var 𬞁; +var 𬞂; +var 𬞃; +var 𬞄; +var 𬞅; +var 𬞆; +var 𬞇; +var 𬞈; +var 𬞉; +var 𬞊; +var 𬞋; +var 𬞌; +var 𬞍; +var 𬞎; +var 𬞏; +var 𬞐; +var 𬞑; +var 𬞒; +var 𬞓; +var 𬞔; +var 𬞕; +var 𬞖; +var 𬞗; +var 𬞘; +var 𬞙; +var 𬞚; +var 𬞛; +var 𬞜; +var 𬞝; +var 𬞞; +var 𬞟; +var 𬞠; +var 𬞡; +var 𬞢; +var 𬞣; +var 𬞤; +var 𬞥; +var 𬞦; +var 𬞧; +var 𬞨; +var 𬞩; +var 𬞪; +var 𬞫; +var 𬞬; +var 𬞭; +var 𬞮; +var 𬞯; +var 𬞰; +var 𬞱; +var 𬞲; +var 𬞳; +var 𬞴; +var 𬞵; +var 𬞶; +var 𬞷; +var 𬞸; +var 𬞹; +var 𬞺; +var 𬞻; +var 𬞼; +var 𬞽; +var 𬞾; +var 𬞿; +var 𬟀; +var 𬟁; +var 𬟂; +var 𬟃; +var 𬟄; +var 𬟅; +var 𬟆; +var 𬟇; +var 𬟈; +var 𬟉; +var 𬟊; +var 𬟋; +var 𬟌; +var 𬟍; +var 𬟎; +var 𬟏; +var 𬟐; +var 𬟑; +var 𬟒; +var 𬟓; +var 𬟔; +var 𬟕; +var 𬟖; +var 𬟗; +var 𬟘; +var 𬟙; +var 𬟚; +var 𬟛; +var 𬟜; +var 𬟝; +var 𬟞; +var 𬟟; +var 𬟠; +var 𬟡; +var 𬟢; +var 𬟣; +var 𬟤; +var 𬟥; +var 𬟦; +var 𬟧; +var 𬟨; +var 𬟩; +var 𬟪; +var 𬟫; +var 𬟬; +var 𬟭; +var 𬟮; +var 𬟯; +var 𬟰; +var 𬟱; +var 𬟲; +var 𬟳; +var 𬟴; +var 𬟵; +var 𬟶; +var 𬟷; +var 𬟸; +var 𬟹; +var 𬟺; +var 𬟻; +var 𬟼; +var 𬟽; +var 𬟾; +var 𬟿; +var 𬠀; +var 𬠁; +var 𬠂; +var 𬠃; +var 𬠄; +var 𬠅; +var 𬠆; +var 𬠇; +var 𬠈; +var 𬠉; +var 𬠊; +var 𬠋; +var 𬠌; +var 𬠍; +var 𬠎; +var 𬠏; +var 𬠐; +var 𬠑; +var 𬠒; +var 𬠓; +var 𬠔; +var 𬠕; +var 𬠖; +var 𬠗; +var 𬠘; +var 𬠙; +var 𬠚; +var 𬠛; +var 𬠜; +var 𬠝; +var 𬠞; +var 𬠟; +var 𬠠; +var 𬠡; +var 𬠢; +var 𬠣; +var 𬠤; +var 𬠥; +var 𬠦; +var 𬠧; +var 𬠨; +var 𬠩; +var 𬠪; +var 𬠫; +var 𬠬; +var 𬠭; +var 𬠮; +var 𬠯; +var 𬠰; +var 𬠱; +var 𬠲; +var 𬠳; +var 𬠴; +var 𬠵; +var 𬠶; +var 𬠷; +var 𬠸; +var 𬠹; +var 𬠺; +var 𬠻; +var 𬠼; +var 𬠽; +var 𬠾; +var 𬠿; +var 𬡀; +var 𬡁; +var 𬡂; +var 𬡃; +var 𬡄; +var 𬡅; +var 𬡆; +var 𬡇; +var 𬡈; +var 𬡉; +var 𬡊; +var 𬡋; +var 𬡌; +var 𬡍; +var 𬡎; +var 𬡏; +var 𬡐; +var 𬡑; +var 𬡒; +var 𬡓; +var 𬡔; +var 𬡕; +var 𬡖; +var 𬡗; +var 𬡘; +var 𬡙; +var 𬡚; +var 𬡛; +var 𬡜; +var 𬡝; +var 𬡞; +var 𬡟; +var 𬡠; +var 𬡡; +var 𬡢; +var 𬡣; +var 𬡤; +var 𬡥; +var 𬡦; +var 𬡧; +var 𬡨; +var 𬡩; +var 𬡪; +var 𬡫; +var 𬡬; +var 𬡭; +var 𬡮; +var 𬡯; +var 𬡰; +var 𬡱; +var 𬡲; +var 𬡳; +var 𬡴; +var 𬡵; +var 𬡶; +var 𬡷; +var 𬡸; +var 𬡹; +var 𬡺; +var 𬡻; +var 𬡼; +var 𬡽; +var 𬡾; +var 𬡿; +var 𬢀; +var 𬢁; +var 𬢂; +var 𬢃; +var 𬢄; +var 𬢅; +var 𬢆; +var 𬢇; +var 𬢈; +var 𬢉; +var 𬢊; +var 𬢋; +var 𬢌; +var 𬢍; +var 𬢎; +var 𬢏; +var 𬢐; +var 𬢑; +var 𬢒; +var 𬢓; +var 𬢔; +var 𬢕; +var 𬢖; +var 𬢗; +var 𬢘; +var 𬢙; +var 𬢚; +var 𬢛; +var 𬢜; +var 𬢝; +var 𬢞; +var 𬢟; +var 𬢠; +var 𬢡; +var 𬢢; +var 𬢣; +var 𬢤; +var 𬢥; +var 𬢦; +var 𬢧; +var 𬢨; +var 𬢩; +var 𬢪; +var 𬢫; +var 𬢬; +var 𬢭; +var 𬢮; +var 𬢯; +var 𬢰; +var 𬢱; +var 𬢲; +var 𬢳; +var 𬢴; +var 𬢵; +var 𬢶; +var 𬢷; +var 𬢸; +var 𬢹; +var 𬢺; +var 𬢻; +var 𬢼; +var 𬢽; +var 𬢾; +var 𬢿; +var 𬣀; +var 𬣁; +var 𬣂; +var 𬣃; +var 𬣄; +var 𬣅; +var 𬣆; +var 𬣇; +var 𬣈; +var 𬣉; +var 𬣊; +var 𬣋; +var 𬣌; +var 𬣍; +var 𬣎; +var 𬣏; +var 𬣐; +var 𬣑; +var 𬣒; +var 𬣓; +var 𬣔; +var 𬣕; +var 𬣖; +var 𬣗; +var 𬣘; +var 𬣙; +var 𬣚; +var 𬣛; +var 𬣜; +var 𬣝; +var 𬣞; +var 𬣟; +var 𬣠; +var 𬣡; +var 𬣢; +var 𬣣; +var 𬣤; +var 𬣥; +var 𬣦; +var 𬣧; +var 𬣨; +var 𬣩; +var 𬣪; +var 𬣫; +var 𬣬; +var 𬣭; +var 𬣮; +var 𬣯; +var 𬣰; +var 𬣱; +var 𬣲; +var 𬣳; +var 𬣴; +var 𬣵; +var 𬣶; +var 𬣷; +var 𬣸; +var 𬣹; +var 𬣺; +var 𬣻; +var 𬣼; +var 𬣽; +var 𬣾; +var 𬣿; +var 𬤀; +var 𬤁; +var 𬤂; +var 𬤃; +var 𬤄; +var 𬤅; +var 𬤆; +var 𬤇; +var 𬤈; +var 𬤉; +var 𬤊; +var 𬤋; +var 𬤌; +var 𬤍; +var 𬤎; +var 𬤏; +var 𬤐; +var 𬤑; +var 𬤒; +var 𬤓; +var 𬤔; +var 𬤕; +var 𬤖; +var 𬤗; +var 𬤘; +var 𬤙; +var 𬤚; +var 𬤛; +var 𬤜; +var 𬤝; +var 𬤞; +var 𬤟; +var 𬤠; +var 𬤡; +var 𬤢; +var 𬤣; +var 𬤤; +var 𬤥; +var 𬤦; +var 𬤧; +var 𬤨; +var 𬤩; +var 𬤪; +var 𬤫; +var 𬤬; +var 𬤭; +var 𬤮; +var 𬤯; +var 𬤰; +var 𬤱; +var 𬤲; +var 𬤳; +var 𬤴; +var 𬤵; +var 𬤶; +var 𬤷; +var 𬤸; +var 𬤹; +var 𬤺; +var 𬤻; +var 𬤼; +var 𬤽; +var 𬤾; +var 𬤿; +var 𬥀; +var 𬥁; +var 𬥂; +var 𬥃; +var 𬥄; +var 𬥅; +var 𬥆; +var 𬥇; +var 𬥈; +var 𬥉; +var 𬥊; +var 𬥋; +var 𬥌; +var 𬥍; +var 𬥎; +var 𬥏; +var 𬥐; +var 𬥑; +var 𬥒; +var 𬥓; +var 𬥔; +var 𬥕; +var 𬥖; +var 𬥗; +var 𬥘; +var 𬥙; +var 𬥚; +var 𬥛; +var 𬥜; +var 𬥝; +var 𬥞; +var 𬥟; +var 𬥠; +var 𬥡; +var 𬥢; +var 𬥣; +var 𬥤; +var 𬥥; +var 𬥦; +var 𬥧; +var 𬥨; +var 𬥩; +var 𬥪; +var 𬥫; +var 𬥬; +var 𬥭; +var 𬥮; +var 𬥯; +var 𬥰; +var 𬥱; +var 𬥲; +var 𬥳; +var 𬥴; +var 𬥵; +var 𬥶; +var 𬥷; +var 𬥸; +var 𬥹; +var 𬥺; +var 𬥻; +var 𬥼; +var 𬥽; +var 𬥾; +var 𬥿; +var 𬦀; +var 𬦁; +var 𬦂; +var 𬦃; +var 𬦄; +var 𬦅; +var 𬦆; +var 𬦇; +var 𬦈; +var 𬦉; +var 𬦊; +var 𬦋; +var 𬦌; +var 𬦍; +var 𬦎; +var 𬦏; +var 𬦐; +var 𬦑; +var 𬦒; +var 𬦓; +var 𬦔; +var 𬦕; +var 𬦖; +var 𬦗; +var 𬦘; +var 𬦙; +var 𬦚; +var 𬦛; +var 𬦜; +var 𬦝; +var 𬦞; +var 𬦟; +var 𬦠; +var 𬦡; +var 𬦢; +var 𬦣; +var 𬦤; +var 𬦥; +var 𬦦; +var 𬦧; +var 𬦨; +var 𬦩; +var 𬦪; +var 𬦫; +var 𬦬; +var 𬦭; +var 𬦮; +var 𬦯; +var 𬦰; +var 𬦱; +var 𬦲; +var 𬦳; +var 𬦴; +var 𬦵; +var 𬦶; +var 𬦷; +var 𬦸; +var 𬦹; +var 𬦺; +var 𬦻; +var 𬦼; +var 𬦽; +var 𬦾; +var 𬦿; +var 𬧀; +var 𬧁; +var 𬧂; +var 𬧃; +var 𬧄; +var 𬧅; +var 𬧆; +var 𬧇; +var 𬧈; +var 𬧉; +var 𬧊; +var 𬧋; +var 𬧌; +var 𬧍; +var 𬧎; +var 𬧏; +var 𬧐; +var 𬧑; +var 𬧒; +var 𬧓; +var 𬧔; +var 𬧕; +var 𬧖; +var 𬧗; +var 𬧘; +var 𬧙; +var 𬧚; +var 𬧛; +var 𬧜; +var 𬧝; +var 𬧞; +var 𬧟; +var 𬧠; +var 𬧡; +var 𬧢; +var 𬧣; +var 𬧤; +var 𬧥; +var 𬧦; +var 𬧧; +var 𬧨; +var 𬧩; +var 𬧪; +var 𬧫; +var 𬧬; +var 𬧭; +var 𬧮; +var 𬧯; +var 𬧰; +var 𬧱; +var 𬧲; +var 𬧳; +var 𬧴; +var 𬧵; +var 𬧶; +var 𬧷; +var 𬧸; +var 𬧹; +var 𬧺; +var 𬧻; +var 𬧼; +var 𬧽; +var 𬧾; +var 𬧿; +var 𬨀; +var 𬨁; +var 𬨂; +var 𬨃; +var 𬨄; +var 𬨅; +var 𬨆; +var 𬨇; +var 𬨈; +var 𬨉; +var 𬨊; +var 𬨋; +var 𬨌; +var 𬨍; +var 𬨎; +var 𬨏; +var 𬨐; +var 𬨑; +var 𬨒; +var 𬨓; +var 𬨔; +var 𬨕; +var 𬨖; +var 𬨗; +var 𬨘; +var 𬨙; +var 𬨚; +var 𬨛; +var 𬨜; +var 𬨝; +var 𬨞; +var 𬨟; +var 𬨠; +var 𬨡; +var 𬨢; +var 𬨣; +var 𬨤; +var 𬨥; +var 𬨦; +var 𬨧; +var 𬨨; +var 𬨩; +var 𬨪; +var 𬨫; +var 𬨬; +var 𬨭; +var 𬨮; +var 𬨯; +var 𬨰; +var 𬨱; +var 𬨲; +var 𬨳; +var 𬨴; +var 𬨵; +var 𬨶; +var 𬨷; +var 𬨸; +var 𬨹; +var 𬨺; +var 𬨻; +var 𬨼; +var 𬨽; +var 𬨾; +var 𬨿; +var 𬩀; +var 𬩁; +var 𬩂; +var 𬩃; +var 𬩄; +var 𬩅; +var 𬩆; +var 𬩇; +var 𬩈; +var 𬩉; +var 𬩊; +var 𬩋; +var 𬩌; +var 𬩍; +var 𬩎; +var 𬩏; +var 𬩐; +var 𬩑; +var 𬩒; +var 𬩓; +var 𬩔; +var 𬩕; +var 𬩖; +var 𬩗; +var 𬩘; +var 𬩙; +var 𬩚; +var 𬩛; +var 𬩜; +var 𬩝; +var 𬩞; +var 𬩟; +var 𬩠; +var 𬩡; +var 𬩢; +var 𬩣; +var 𬩤; +var 𬩥; +var 𬩦; +var 𬩧; +var 𬩨; +var 𬩩; +var 𬩪; +var 𬩫; +var 𬩬; +var 𬩭; +var 𬩮; +var 𬩯; +var 𬩰; +var 𬩱; +var 𬩲; +var 𬩳; +var 𬩴; +var 𬩵; +var 𬩶; +var 𬩷; +var 𬩸; +var 𬩹; +var 𬩺; +var 𬩻; +var 𬩼; +var 𬩽; +var 𬩾; +var 𬩿; +var 𬪀; +var 𬪁; +var 𬪂; +var 𬪃; +var 𬪄; +var 𬪅; +var 𬪆; +var 𬪇; +var 𬪈; +var 𬪉; +var 𬪊; +var 𬪋; +var 𬪌; +var 𬪍; +var 𬪎; +var 𬪏; +var 𬪐; +var 𬪑; +var 𬪒; +var 𬪓; +var 𬪔; +var 𬪕; +var 𬪖; +var 𬪗; +var 𬪘; +var 𬪙; +var 𬪚; +var 𬪛; +var 𬪜; +var 𬪝; +var 𬪞; +var 𬪟; +var 𬪠; +var 𬪡; +var 𬪢; +var 𬪣; +var 𬪤; +var 𬪥; +var 𬪦; +var 𬪧; +var 𬪨; +var 𬪩; +var 𬪪; +var 𬪫; +var 𬪬; +var 𬪭; +var 𬪮; +var 𬪯; +var 𬪰; +var 𬪱; +var 𬪲; +var 𬪳; +var 𬪴; +var 𬪵; +var 𬪶; +var 𬪷; +var 𬪸; +var 𬪹; +var 𬪺; +var 𬪻; +var 𬪼; +var 𬪽; +var 𬪾; +var 𬪿; +var 𬫀; +var 𬫁; +var 𬫂; +var 𬫃; +var 𬫄; +var 𬫅; +var 𬫆; +var 𬫇; +var 𬫈; +var 𬫉; +var 𬫊; +var 𬫋; +var 𬫌; +var 𬫍; +var 𬫎; +var 𬫏; +var 𬫐; +var 𬫑; +var 𬫒; +var 𬫓; +var 𬫔; +var 𬫕; +var 𬫖; +var 𬫗; +var 𬫘; +var 𬫙; +var 𬫚; +var 𬫛; +var 𬫜; +var 𬫝; +var 𬫞; +var 𬫟; +var 𬫠; +var 𬫡; +var 𬫢; +var 𬫣; +var 𬫤; +var 𬫥; +var 𬫦; +var 𬫧; +var 𬫨; +var 𬫩; +var 𬫪; +var 𬫫; +var 𬫬; +var 𬫭; +var 𬫮; +var 𬫯; +var 𬫰; +var 𬫱; +var 𬫲; +var 𬫳; +var 𬫴; +var 𬫵; +var 𬫶; +var 𬫷; +var 𬫸; +var 𬫹; +var 𬫺; +var 𬫻; +var 𬫼; +var 𬫽; +var 𬫾; +var 𬫿; +var 𬬀; +var 𬬁; +var 𬬂; +var 𬬃; +var 𬬄; +var 𬬅; +var 𬬆; +var 𬬇; +var 𬬈; +var 𬬉; +var 𬬊; +var 𬬋; +var 𬬌; +var 𬬍; +var 𬬎; +var 𬬏; +var 𬬐; +var 𬬑; +var 𬬒; +var 𬬓; +var 𬬔; +var 𬬕; +var 𬬖; +var 𬬗; +var 𬬘; +var 𬬙; +var 𬬚; +var 𬬛; +var 𬬜; +var 𬬝; +var 𬬞; +var 𬬟; +var 𬬠; +var 𬬡; +var 𬬢; +var 𬬣; +var 𬬤; +var 𬬥; +var 𬬦; +var 𬬧; +var 𬬨; +var 𬬩; +var 𬬪; +var 𬬫; +var 𬬬; +var 𬬭; +var 𬬮; +var 𬬯; +var 𬬰; +var 𬬱; +var 𬬲; +var 𬬳; +var 𬬴; +var 𬬵; +var 𬬶; +var 𬬷; +var 𬬸; +var 𬬹; +var 𬬺; +var 𬬻; +var 𬬼; +var 𬬽; +var 𬬾; +var 𬬿; +var 𬭀; +var 𬭁; +var 𬭂; +var 𬭃; +var 𬭄; +var 𬭅; +var 𬭆; +var 𬭇; +var 𬭈; +var 𬭉; +var 𬭊; +var 𬭋; +var 𬭌; +var 𬭍; +var 𬭎; +var 𬭏; +var 𬭐; +var 𬭑; +var 𬭒; +var 𬭓; +var 𬭔; +var 𬭕; +var 𬭖; +var 𬭗; +var 𬭘; +var 𬭙; +var 𬭚; +var 𬭛; +var 𬭜; +var 𬭝; +var 𬭞; +var 𬭟; +var 𬭠; +var 𬭡; +var 𬭢; +var 𬭣; +var 𬭤; +var 𬭥; +var 𬭦; +var 𬭧; +var 𬭨; +var 𬭩; +var 𬭪; +var 𬭫; +var 𬭬; +var 𬭭; +var 𬭮; +var 𬭯; +var 𬭰; +var 𬭱; +var 𬭲; +var 𬭳; +var 𬭴; +var 𬭵; +var 𬭶; +var 𬭷; +var 𬭸; +var 𬭹; +var 𬭺; +var 𬭻; +var 𬭼; +var 𬭽; +var 𬭾; +var 𬭿; +var 𬮀; +var 𬮁; +var 𬮂; +var 𬮃; +var 𬮄; +var 𬮅; +var 𬮆; +var 𬮇; +var 𬮈; +var 𬮉; +var 𬮊; +var 𬮋; +var 𬮌; +var 𬮍; +var 𬮎; +var 𬮏; +var 𬮐; +var 𬮑; +var 𬮒; +var 𬮓; +var 𬮔; +var 𬮕; +var 𬮖; +var 𬮗; +var 𬮘; +var 𬮙; +var 𬮚; +var 𬮛; +var 𬮜; +var 𬮝; +var 𬮞; +var 𬮟; +var 𬮠; +var 𬮡; +var 𬮢; +var 𬮣; +var 𬮤; +var 𬮥; +var 𬮦; +var 𬮧; +var 𬮨; +var 𬮩; +var 𬮪; +var 𬮫; +var 𬮬; +var 𬮭; +var 𬮮; +var 𬮯; +var 𬮰; +var 𬮱; +var 𬮲; +var 𬮳; +var 𬮴; +var 𬮵; +var 𬮶; +var 𬮷; +var 𬮸; +var 𬮹; +var 𬮺; +var 𬮻; +var 𬮼; +var 𬮽; +var 𬮾; +var 𬮿; +var 𬯀; +var 𬯁; +var 𬯂; +var 𬯃; +var 𬯄; +var 𬯅; +var 𬯆; +var 𬯇; +var 𬯈; +var 𬯉; +var 𬯊; +var 𬯋; +var 𬯌; +var 𬯍; +var 𬯎; +var 𬯏; +var 𬯐; +var 𬯑; +var 𬯒; +var 𬯓; +var 𬯔; +var 𬯕; +var 𬯖; +var 𬯗; +var 𬯘; +var 𬯙; +var 𬯚; +var 𬯛; +var 𬯜; +var 𬯝; +var 𬯞; +var 𬯟; +var 𬯠; +var 𬯡; +var 𬯢; +var 𬯣; +var 𬯤; +var 𬯥; +var 𬯦; +var 𬯧; +var 𬯨; +var 𬯩; +var 𬯪; +var 𬯫; +var 𬯬; +var 𬯭; +var 𬯮; +var 𬯯; +var 𬯰; +var 𬯱; +var 𬯲; +var 𬯳; +var 𬯴; +var 𬯵; +var 𬯶; +var 𬯷; +var 𬯸; +var 𬯹; +var 𬯺; +var 𬯻; +var 𬯼; +var 𬯽; +var 𬯾; +var 𬯿; +var 𬰀; +var 𬰁; +var 𬰂; +var 𬰃; +var 𬰄; +var 𬰅; +var 𬰆; +var 𬰇; +var 𬰈; +var 𬰉; +var 𬰊; +var 𬰋; +var 𬰌; +var 𬰍; +var 𬰎; +var 𬰏; +var 𬰐; +var 𬰑; +var 𬰒; +var 𬰓; +var 𬰔; +var 𬰕; +var 𬰖; +var 𬰗; +var 𬰘; +var 𬰙; +var 𬰚; +var 𬰛; +var 𬰜; +var 𬰝; +var 𬰞; +var 𬰟; +var 𬰠; +var 𬰡; +var 𬰢; +var 𬰣; +var 𬰤; +var 𬰥; +var 𬰦; +var 𬰧; +var 𬰨; +var 𬰩; +var 𬰪; +var 𬰫; +var 𬰬; +var 𬰭; +var 𬰮; +var 𬰯; +var 𬰰; +var 𬰱; +var 𬰲; +var 𬰳; +var 𬰴; +var 𬰵; +var 𬰶; +var 𬰷; +var 𬰸; +var 𬰹; +var 𬰺; +var 𬰻; +var 𬰼; +var 𬰽; +var 𬰾; +var 𬰿; +var 𬱀; +var 𬱁; +var 𬱂; +var 𬱃; +var 𬱄; +var 𬱅; +var 𬱆; +var 𬱇; +var 𬱈; +var 𬱉; +var 𬱊; +var 𬱋; +var 𬱌; +var 𬱍; +var 𬱎; +var 𬱏; +var 𬱐; +var 𬱑; +var 𬱒; +var 𬱓; +var 𬱔; +var 𬱕; +var 𬱖; +var 𬱗; +var 𬱘; +var 𬱙; +var 𬱚; +var 𬱛; +var 𬱜; +var 𬱝; +var 𬱞; +var 𬱟; +var 𬱠; +var 𬱡; +var 𬱢; +var 𬱣; +var 𬱤; +var 𬱥; +var 𬱦; +var 𬱧; +var 𬱨; +var 𬱩; +var 𬱪; +var 𬱫; +var 𬱬; +var 𬱭; +var 𬱮; +var 𬱯; +var 𬱰; +var 𬱱; +var 𬱲; +var 𬱳; +var 𬱴; +var 𬱵; +var 𬱶; +var 𬱷; +var 𬱸; +var 𬱹; +var 𬱺; +var 𬱻; +var 𬱼; +var 𬱽; +var 𬱾; +var 𬱿; +var 𬲀; +var 𬲁; +var 𬲂; +var 𬲃; +var 𬲄; +var 𬲅; +var 𬲆; +var 𬲇; +var 𬲈; +var 𬲉; +var 𬲊; +var 𬲋; +var 𬲌; +var 𬲍; +var 𬲎; +var 𬲏; +var 𬲐; +var 𬲑; +var 𬲒; +var 𬲓; +var 𬲔; +var 𬲕; +var 𬲖; +var 𬲗; +var 𬲘; +var 𬲙; +var 𬲚; +var 𬲛; +var 𬲜; +var 𬲝; +var 𬲞; +var 𬲟; +var 𬲠; +var 𬲡; +var 𬲢; +var 𬲣; +var 𬲤; +var 𬲥; +var 𬲦; +var 𬲧; +var 𬲨; +var 𬲩; +var 𬲪; +var 𬲫; +var 𬲬; +var 𬲭; +var 𬲮; +var 𬲯; +var 𬲰; +var 𬲱; +var 𬲲; +var 𬲳; +var 𬲴; +var 𬲵; +var 𬲶; +var 𬲷; +var 𬲸; +var 𬲹; +var 𬲺; +var 𬲻; +var 𬲼; +var 𬲽; +var 𬲾; +var 𬲿; +var 𬳀; +var 𬳁; +var 𬳂; +var 𬳃; +var 𬳄; +var 𬳅; +var 𬳆; +var 𬳇; +var 𬳈; +var 𬳉; +var 𬳊; +var 𬳋; +var 𬳌; +var 𬳍; +var 𬳎; +var 𬳏; +var 𬳐; +var 𬳑; +var 𬳒; +var 𬳓; +var 𬳔; +var 𬳕; +var 𬳖; +var 𬳗; +var 𬳘; +var 𬳙; +var 𬳚; +var 𬳛; +var 𬳜; +var 𬳝; +var 𬳞; +var 𬳟; +var 𬳠; +var 𬳡; +var 𬳢; +var 𬳣; +var 𬳤; +var 𬳥; +var 𬳦; +var 𬳧; +var 𬳨; +var 𬳩; +var 𬳪; +var 𬳫; +var 𬳬; +var 𬳭; +var 𬳮; +var 𬳯; +var 𬳰; +var 𬳱; +var 𬳲; +var 𬳳; +var 𬳴; +var 𬳵; +var 𬳶; +var 𬳷; +var 𬳸; +var 𬳹; +var 𬳺; +var 𬳻; +var 𬳼; +var 𬳽; +var 𬳾; +var 𬳿; +var 𬴀; +var 𬴁; +var 𬴂; +var 𬴃; +var 𬴄; +var 𬴅; +var 𬴆; +var 𬴇; +var 𬴈; +var 𬴉; +var 𬴊; +var 𬴋; +var 𬴌; +var 𬴍; +var 𬴎; +var 𬴏; +var 𬴐; +var 𬴑; +var 𬴒; +var 𬴓; +var 𬴔; +var 𬴕; +var 𬴖; +var 𬴗; +var 𬴘; +var 𬴙; +var 𬴚; +var 𬴛; +var 𬴜; +var 𬴝; +var 𬴞; +var 𬴟; +var 𬴠; +var 𬴡; +var 𬴢; +var 𬴣; +var 𬴤; +var 𬴥; +var 𬴦; +var 𬴧; +var 𬴨; +var 𬴩; +var 𬴪; +var 𬴫; +var 𬴬; +var 𬴭; +var 𬴮; +var 𬴯; +var 𬴰; +var 𬴱; +var 𬴲; +var 𬴳; +var 𬴴; +var 𬴵; +var 𬴶; +var 𬴷; +var 𬴸; +var 𬴹; +var 𬴺; +var 𬴻; +var 𬴼; +var 𬴽; +var 𬴾; +var 𬴿; +var 𬵀; +var 𬵁; +var 𬵂; +var 𬵃; +var 𬵄; +var 𬵅; +var 𬵆; +var 𬵇; +var 𬵈; +var 𬵉; +var 𬵊; +var 𬵋; +var 𬵌; +var 𬵍; +var 𬵎; +var 𬵏; +var 𬵐; +var 𬵑; +var 𬵒; +var 𬵓; +var 𬵔; +var 𬵕; +var 𬵖; +var 𬵗; +var 𬵘; +var 𬵙; +var 𬵚; +var 𬵛; +var 𬵜; +var 𬵝; +var 𬵞; +var 𬵟; +var 𬵠; +var 𬵡; +var 𬵢; +var 𬵣; +var 𬵤; +var 𬵥; +var 𬵦; +var 𬵧; +var 𬵨; +var 𬵩; +var 𬵪; +var 𬵫; +var 𬵬; +var 𬵭; +var 𬵮; +var 𬵯; +var 𬵰; +var 𬵱; +var 𬵲; +var 𬵳; +var 𬵴; +var 𬵵; +var 𬵶; +var 𬵷; +var 𬵸; +var 𬵹; +var 𬵺; +var 𬵻; +var 𬵼; +var 𬵽; +var 𬵾; +var 𬵿; +var 𬶀; +var 𬶁; +var 𬶂; +var 𬶃; +var 𬶄; +var 𬶅; +var 𬶆; +var 𬶇; +var 𬶈; +var 𬶉; +var 𬶊; +var 𬶋; +var 𬶌; +var 𬶍; +var 𬶎; +var 𬶏; +var 𬶐; +var 𬶑; +var 𬶒; +var 𬶓; +var 𬶔; +var 𬶕; +var 𬶖; +var 𬶗; +var 𬶘; +var 𬶙; +var 𬶚; +var 𬶛; +var 𬶜; +var 𬶝; +var 𬶞; +var 𬶟; +var 𬶠; +var 𬶡; +var 𬶢; +var 𬶣; +var 𬶤; +var 𬶥; +var 𬶦; +var 𬶧; +var 𬶨; +var 𬶩; +var 𬶪; +var 𬶫; +var 𬶬; +var 𬶭; +var 𬶮; +var 𬶯; +var 𬶰; +var 𬶱; +var 𬶲; +var 𬶳; +var 𬶴; +var 𬶵; +var 𬶶; +var 𬶷; +var 𬶸; +var 𬶹; +var 𬶺; +var 𬶻; +var 𬶼; +var 𬶽; +var 𬶾; +var 𬶿; +var 𬷀; +var 𬷁; +var 𬷂; +var 𬷃; +var 𬷄; +var 𬷅; +var 𬷆; +var 𬷇; +var 𬷈; +var 𬷉; +var 𬷊; +var 𬷋; +var 𬷌; +var 𬷍; +var 𬷎; +var 𬷏; +var 𬷐; +var 𬷑; +var 𬷒; +var 𬷓; +var 𬷔; +var 𬷕; +var 𬷖; +var 𬷗; +var 𬷘; +var 𬷙; +var 𬷚; +var 𬷛; +var 𬷜; +var 𬷝; +var 𬷞; +var 𬷟; +var 𬷠; +var 𬷡; +var 𬷢; +var 𬷣; +var 𬷤; +var 𬷥; +var 𬷦; +var 𬷧; +var 𬷨; +var 𬷩; +var 𬷪; +var 𬷫; +var 𬷬; +var 𬷭; +var 𬷮; +var 𬷯; +var 𬷰; +var 𬷱; +var 𬷲; +var 𬷳; +var 𬷴; +var 𬷵; +var 𬷶; +var 𬷷; +var 𬷸; +var 𬷹; +var 𬷺; +var 𬷻; +var 𬷼; +var 𬷽; +var 𬷾; +var 𬷿; +var 𬸀; +var 𬸁; +var 𬸂; +var 𬸃; +var 𬸄; +var 𬸅; +var 𬸆; +var 𬸇; +var 𬸈; +var 𬸉; +var 𬸊; +var 𬸋; +var 𬸌; +var 𬸍; +var 𬸎; +var 𬸏; +var 𬸐; +var 𬸑; +var 𬸒; +var 𬸓; +var 𬸔; +var 𬸕; +var 𬸖; +var 𬸗; +var 𬸘; +var 𬸙; +var 𬸚; +var 𬸛; +var 𬸜; +var 𬸝; +var 𬸞; +var 𬸟; +var 𬸠; +var 𬸡; +var 𬸢; +var 𬸣; +var 𬸤; +var 𬸥; +var 𬸦; +var 𬸧; +var 𬸨; +var 𬸩; +var 𬸪; +var 𬸫; +var 𬸬; +var 𬸭; +var 𬸮; +var 𬸯; +var 𬸰; +var 𬸱; +var 𬸲; +var 𬸳; +var 𬸴; +var 𬸵; +var 𬸶; +var 𬸷; +var 𬸸; +var 𬸹; +var 𬸺; +var 𬸻; +var 𬸼; +var 𬸽; +var 𬸾; +var 𬸿; +var 𬹀; +var 𬹁; +var 𬹂; +var 𬹃; +var 𬹄; +var 𬹅; +var 𬹆; +var 𬹇; +var 𬹈; +var 𬹉; +var 𬹊; +var 𬹋; +var 𬹌; +var 𬹍; +var 𬹎; +var 𬹏; +var 𬹐; +var 𬹑; +var 𬹒; +var 𬹓; +var 𬹔; +var 𬹕; +var 𬹖; +var 𬹗; +var 𬹘; +var 𬹙; +var 𬹚; +var 𬹛; +var 𬹜; +var 𬹝; +var 𬹞; +var 𬹟; +var 𬹠; +var 𬹡; +var 𬹢; +var 𬹣; +var 𬹤; +var 𬹥; +var 𬹦; +var 𬹧; +var 𬹨; +var 𬹩; +var 𬹪; +var 𬹫; +var 𬹬; +var 𬹭; +var 𬹮; +var 𬹯; +var 𬹰; +var 𬹱; +var 𬹲; +var 𬹳; +var 𬹴; +var 𬹵; +var 𬹶; +var 𬹷; +var 𬹸; +var 𬹹; +var 𬹺; +var 𬹻; +var 𬹼; +var 𬹽; +var 𬹾; +var 𬹿; +var 𬺀; +var 𬺁; +var 𬺂; +var 𬺃; +var 𬺄; +var 𬺅; +var 𬺆; +var 𬺇; +var 𬺈; +var 𬺉; +var 𬺊; +var 𬺋; +var 𬺌; +var 𬺍; +var 𬺎; +var 𬺏; +var 𬺐; +var 𬺑; +var 𬺒; +var 𬺓; +var 𬺔; +var 𬺕; +var 𬺖; +var 𬺗; +var 𬺘; +var 𬺙; +var 𬺚; +var 𬺛; +var 𬺜; +var 𬺝; +var 𬺞; +var 𬺟; +var 𬺠; +var 𬺡; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0-class-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0-class-escaped.js new file mode 100644 index 000000000..a249fbcf4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0-class-escaped.js @@ -0,0 +1,7196 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v9.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols + in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #\u08B6; + #\u08B7; + #\u08B8; + #\u08B9; + #\u08BA; + #\u08BB; + #\u08BC; + #\u08BD; + #\u0C80; + #\u0D54; + #\u0D55; + #\u0D56; + #\u1C80; + #\u1C81; + #\u1C82; + #\u1C83; + #\u1C84; + #\u1C85; + #\u1C86; + #\u1C87; + #\u1C88; + #\uA7AE; + #\u{104B0}; + #\u{104B1}; + #\u{104B2}; + #\u{104B3}; + #\u{104B4}; + #\u{104B5}; + #\u{104B6}; + #\u{104B7}; + #\u{104B8}; + #\u{104B9}; + #\u{104BA}; + #\u{104BB}; + #\u{104BC}; + #\u{104BD}; + #\u{104BE}; + #\u{104BF}; + #\u{104C0}; + #\u{104C1}; + #\u{104C2}; + #\u{104C3}; + #\u{104C4}; + #\u{104C5}; + #\u{104C6}; + #\u{104C7}; + #\u{104C8}; + #\u{104C9}; + #\u{104CA}; + #\u{104CB}; + #\u{104CC}; + #\u{104CD}; + #\u{104CE}; + #\u{104CF}; + #\u{104D0}; + #\u{104D1}; + #\u{104D2}; + #\u{104D3}; + #\u{104D8}; + #\u{104D9}; + #\u{104DA}; + #\u{104DB}; + #\u{104DC}; + #\u{104DD}; + #\u{104DE}; + #\u{104DF}; + #\u{104E0}; + #\u{104E1}; + #\u{104E2}; + #\u{104E3}; + #\u{104E4}; + #\u{104E5}; + #\u{104E6}; + #\u{104E7}; + #\u{104E8}; + #\u{104E9}; + #\u{104EA}; + #\u{104EB}; + #\u{104EC}; + #\u{104ED}; + #\u{104EE}; + #\u{104EF}; + #\u{104F0}; + #\u{104F1}; + #\u{104F2}; + #\u{104F3}; + #\u{104F4}; + #\u{104F5}; + #\u{104F6}; + #\u{104F7}; + #\u{104F8}; + #\u{104F9}; + #\u{104FA}; + #\u{104FB}; + #\u{11400}; + #\u{11401}; + #\u{11402}; + #\u{11403}; + #\u{11404}; + #\u{11405}; + #\u{11406}; + #\u{11407}; + #\u{11408}; + #\u{11409}; + #\u{1140A}; + #\u{1140B}; + #\u{1140C}; + #\u{1140D}; + #\u{1140E}; + #\u{1140F}; + #\u{11410}; + #\u{11411}; + #\u{11412}; + #\u{11413}; + #\u{11414}; + #\u{11415}; + #\u{11416}; + #\u{11417}; + #\u{11418}; + #\u{11419}; + #\u{1141A}; + #\u{1141B}; + #\u{1141C}; + #\u{1141D}; + #\u{1141E}; + #\u{1141F}; + #\u{11420}; + #\u{11421}; + #\u{11422}; + #\u{11423}; + #\u{11424}; + #\u{11425}; + #\u{11426}; + #\u{11427}; + #\u{11428}; + #\u{11429}; + #\u{1142A}; + #\u{1142B}; + #\u{1142C}; + #\u{1142D}; + #\u{1142E}; + #\u{1142F}; + #\u{11430}; + #\u{11431}; + #\u{11432}; + #\u{11433}; + #\u{11434}; + #\u{11447}; + #\u{11448}; + #\u{11449}; + #\u{1144A}; + #\u{11C00}; + #\u{11C01}; + #\u{11C02}; + #\u{11C03}; + #\u{11C04}; + #\u{11C05}; + #\u{11C06}; + #\u{11C07}; + #\u{11C08}; + #\u{11C0A}; + #\u{11C0B}; + #\u{11C0C}; + #\u{11C0D}; + #\u{11C0E}; + #\u{11C0F}; + #\u{11C10}; + #\u{11C11}; + #\u{11C12}; + #\u{11C13}; + #\u{11C14}; + #\u{11C15}; + #\u{11C16}; + #\u{11C17}; + #\u{11C18}; + #\u{11C19}; + #\u{11C1A}; + #\u{11C1B}; + #\u{11C1C}; + #\u{11C1D}; + #\u{11C1E}; + #\u{11C1F}; + #\u{11C20}; + #\u{11C21}; + #\u{11C22}; + #\u{11C23}; + #\u{11C24}; + #\u{11C25}; + #\u{11C26}; + #\u{11C27}; + #\u{11C28}; + #\u{11C29}; + #\u{11C2A}; + #\u{11C2B}; + #\u{11C2C}; + #\u{11C2D}; + #\u{11C2E}; + #\u{11C40}; + #\u{11C72}; + #\u{11C73}; + #\u{11C74}; + #\u{11C75}; + #\u{11C76}; + #\u{11C77}; + #\u{11C78}; + #\u{11C79}; + #\u{11C7A}; + #\u{11C7B}; + #\u{11C7C}; + #\u{11C7D}; + #\u{11C7E}; + #\u{11C7F}; + #\u{11C80}; + #\u{11C81}; + #\u{11C82}; + #\u{11C83}; + #\u{11C84}; + #\u{11C85}; + #\u{11C86}; + #\u{11C87}; + #\u{11C88}; + #\u{11C89}; + #\u{11C8A}; + #\u{11C8B}; + #\u{11C8C}; + #\u{11C8D}; + #\u{11C8E}; + #\u{11C8F}; + #\u{16FE0}; + #\u{17000}; + #\u{17001}; + #\u{17002}; + #\u{17003}; + #\u{17004}; + #\u{17005}; + #\u{17006}; + #\u{17007}; + #\u{17008}; + #\u{17009}; + #\u{1700A}; + #\u{1700B}; + #\u{1700C}; + #\u{1700D}; + #\u{1700E}; + #\u{1700F}; + #\u{17010}; + #\u{17011}; + #\u{17012}; + #\u{17013}; + #\u{17014}; + #\u{17015}; + #\u{17016}; + #\u{17017}; + #\u{17018}; + #\u{17019}; + #\u{1701A}; + #\u{1701B}; + #\u{1701C}; + #\u{1701D}; + #\u{1701E}; + #\u{1701F}; + #\u{17020}; + #\u{17021}; + #\u{17022}; + #\u{17023}; + #\u{17024}; + #\u{17025}; + #\u{17026}; + #\u{17027}; + #\u{17028}; + #\u{17029}; + #\u{1702A}; + #\u{1702B}; + #\u{1702C}; + #\u{1702D}; + #\u{1702E}; + #\u{1702F}; + #\u{17030}; + #\u{17031}; + #\u{17032}; + #\u{17033}; + #\u{17034}; + #\u{17035}; + #\u{17036}; + #\u{17037}; + #\u{17038}; + #\u{17039}; + #\u{1703A}; + #\u{1703B}; + #\u{1703C}; + #\u{1703D}; + #\u{1703E}; + #\u{1703F}; + #\u{17040}; + #\u{17041}; + #\u{17042}; + #\u{17043}; + #\u{17044}; + #\u{17045}; + #\u{17046}; + #\u{17047}; + #\u{17048}; + #\u{17049}; + #\u{1704A}; + #\u{1704B}; + #\u{1704C}; + #\u{1704D}; + #\u{1704E}; + #\u{1704F}; + #\u{17050}; + #\u{17051}; + #\u{17052}; + #\u{17053}; + #\u{17054}; + #\u{17055}; + #\u{17056}; + #\u{17057}; + #\u{17058}; + #\u{17059}; + #\u{1705A}; + #\u{1705B}; + #\u{1705C}; + #\u{1705D}; + #\u{1705E}; + #\u{1705F}; + #\u{17060}; + #\u{17061}; + #\u{17062}; + #\u{17063}; + #\u{17064}; + #\u{17065}; + #\u{17066}; + #\u{17067}; + #\u{17068}; + #\u{17069}; + #\u{1706A}; + #\u{1706B}; + #\u{1706C}; + #\u{1706D}; + #\u{1706E}; + #\u{1706F}; + #\u{17070}; + #\u{17071}; + #\u{17072}; + #\u{17073}; + #\u{17074}; + #\u{17075}; + #\u{17076}; + #\u{17077}; + #\u{17078}; + #\u{17079}; + #\u{1707A}; + #\u{1707B}; + #\u{1707C}; + #\u{1707D}; + #\u{1707E}; + #\u{1707F}; + #\u{17080}; + #\u{17081}; + #\u{17082}; + #\u{17083}; + #\u{17084}; + #\u{17085}; + #\u{17086}; + #\u{17087}; + #\u{17088}; + #\u{17089}; + #\u{1708A}; + #\u{1708B}; + #\u{1708C}; + #\u{1708D}; + #\u{1708E}; + #\u{1708F}; + #\u{17090}; + #\u{17091}; + #\u{17092}; + #\u{17093}; + #\u{17094}; + #\u{17095}; + #\u{17096}; + #\u{17097}; + #\u{17098}; + #\u{17099}; + #\u{1709A}; + #\u{1709B}; + #\u{1709C}; + #\u{1709D}; + #\u{1709E}; + #\u{1709F}; + #\u{170A0}; + #\u{170A1}; + #\u{170A2}; + #\u{170A3}; + #\u{170A4}; + #\u{170A5}; + #\u{170A6}; + #\u{170A7}; + #\u{170A8}; + #\u{170A9}; + #\u{170AA}; + #\u{170AB}; + #\u{170AC}; + #\u{170AD}; + #\u{170AE}; + #\u{170AF}; + #\u{170B0}; + #\u{170B1}; + #\u{170B2}; + #\u{170B3}; + #\u{170B4}; + #\u{170B5}; + #\u{170B6}; + #\u{170B7}; + #\u{170B8}; + #\u{170B9}; + #\u{170BA}; + #\u{170BB}; + #\u{170BC}; + #\u{170BD}; + #\u{170BE}; + #\u{170BF}; + #\u{170C0}; + #\u{170C1}; + #\u{170C2}; + #\u{170C3}; + #\u{170C4}; + #\u{170C5}; + #\u{170C6}; + #\u{170C7}; + #\u{170C8}; + #\u{170C9}; + #\u{170CA}; + #\u{170CB}; + #\u{170CC}; + #\u{170CD}; + #\u{170CE}; + #\u{170CF}; + #\u{170D0}; + #\u{170D1}; + #\u{170D2}; + #\u{170D3}; + #\u{170D4}; + #\u{170D5}; + #\u{170D6}; + #\u{170D7}; + #\u{170D8}; + #\u{170D9}; + #\u{170DA}; + #\u{170DB}; + #\u{170DC}; + #\u{170DD}; + #\u{170DE}; + #\u{170DF}; + #\u{170E0}; + #\u{170E1}; + #\u{170E2}; + #\u{170E3}; + #\u{170E4}; + #\u{170E5}; + #\u{170E6}; + #\u{170E7}; + #\u{170E8}; + #\u{170E9}; + #\u{170EA}; + #\u{170EB}; + #\u{170EC}; + #\u{170ED}; + #\u{170EE}; + #\u{170EF}; + #\u{170F0}; + #\u{170F1}; + #\u{170F2}; + #\u{170F3}; + #\u{170F4}; + #\u{170F5}; + #\u{170F6}; + #\u{170F7}; + #\u{170F8}; + #\u{170F9}; + #\u{170FA}; + #\u{170FB}; + #\u{170FC}; + #\u{170FD}; + #\u{170FE}; + #\u{170FF}; + #\u{17100}; + #\u{17101}; + #\u{17102}; + #\u{17103}; + #\u{17104}; + #\u{17105}; + #\u{17106}; + #\u{17107}; + #\u{17108}; + #\u{17109}; + #\u{1710A}; + #\u{1710B}; + #\u{1710C}; + #\u{1710D}; + #\u{1710E}; + #\u{1710F}; + #\u{17110}; + #\u{17111}; + #\u{17112}; + #\u{17113}; + #\u{17114}; + #\u{17115}; + #\u{17116}; + #\u{17117}; + #\u{17118}; + #\u{17119}; + #\u{1711A}; + #\u{1711B}; + #\u{1711C}; + #\u{1711D}; + #\u{1711E}; + #\u{1711F}; + #\u{17120}; + #\u{17121}; + #\u{17122}; + #\u{17123}; + #\u{17124}; + #\u{17125}; + #\u{17126}; + #\u{17127}; + #\u{17128}; + #\u{17129}; + #\u{1712A}; + #\u{1712B}; + #\u{1712C}; + #\u{1712D}; + #\u{1712E}; + #\u{1712F}; + #\u{17130}; + #\u{17131}; + #\u{17132}; + #\u{17133}; + #\u{17134}; + #\u{17135}; + #\u{17136}; + #\u{17137}; + #\u{17138}; + #\u{17139}; + #\u{1713A}; + #\u{1713B}; + #\u{1713C}; + #\u{1713D}; + #\u{1713E}; + #\u{1713F}; + #\u{17140}; + #\u{17141}; + #\u{17142}; + #\u{17143}; + #\u{17144}; + #\u{17145}; + #\u{17146}; + #\u{17147}; + #\u{17148}; + #\u{17149}; + #\u{1714A}; + #\u{1714B}; + #\u{1714C}; + #\u{1714D}; + #\u{1714E}; + #\u{1714F}; + #\u{17150}; + #\u{17151}; + #\u{17152}; + #\u{17153}; + #\u{17154}; + #\u{17155}; + #\u{17156}; + #\u{17157}; + #\u{17158}; + #\u{17159}; + #\u{1715A}; + #\u{1715B}; + #\u{1715C}; + #\u{1715D}; + #\u{1715E}; + #\u{1715F}; + #\u{17160}; + #\u{17161}; + #\u{17162}; + #\u{17163}; + #\u{17164}; + #\u{17165}; + #\u{17166}; + #\u{17167}; + #\u{17168}; + #\u{17169}; + #\u{1716A}; + #\u{1716B}; + #\u{1716C}; + #\u{1716D}; + #\u{1716E}; + #\u{1716F}; + #\u{17170}; + #\u{17171}; + #\u{17172}; + #\u{17173}; + #\u{17174}; + #\u{17175}; + #\u{17176}; + #\u{17177}; + #\u{17178}; + #\u{17179}; + #\u{1717A}; + #\u{1717B}; + #\u{1717C}; + #\u{1717D}; + #\u{1717E}; + #\u{1717F}; + #\u{17180}; + #\u{17181}; + #\u{17182}; + #\u{17183}; + #\u{17184}; + #\u{17185}; + #\u{17186}; + #\u{17187}; + #\u{17188}; + #\u{17189}; + #\u{1718A}; + #\u{1718B}; + #\u{1718C}; + #\u{1718D}; + #\u{1718E}; + #\u{1718F}; + #\u{17190}; + #\u{17191}; + #\u{17192}; + #\u{17193}; + #\u{17194}; + #\u{17195}; + #\u{17196}; + #\u{17197}; + #\u{17198}; + #\u{17199}; + #\u{1719A}; + #\u{1719B}; + #\u{1719C}; + #\u{1719D}; + #\u{1719E}; + #\u{1719F}; + #\u{171A0}; + #\u{171A1}; + #\u{171A2}; + #\u{171A3}; + #\u{171A4}; + #\u{171A5}; + #\u{171A6}; + #\u{171A7}; + #\u{171A8}; + #\u{171A9}; + #\u{171AA}; + #\u{171AB}; + #\u{171AC}; + #\u{171AD}; + #\u{171AE}; + #\u{171AF}; + #\u{171B0}; + #\u{171B1}; + #\u{171B2}; + #\u{171B3}; + #\u{171B4}; + #\u{171B5}; + #\u{171B6}; + #\u{171B7}; + #\u{171B8}; + #\u{171B9}; + #\u{171BA}; + #\u{171BB}; + #\u{171BC}; + #\u{171BD}; + #\u{171BE}; + #\u{171BF}; + #\u{171C0}; + #\u{171C1}; + #\u{171C2}; + #\u{171C3}; + #\u{171C4}; + #\u{171C5}; + #\u{171C6}; + #\u{171C7}; + #\u{171C8}; + #\u{171C9}; + #\u{171CA}; + #\u{171CB}; + #\u{171CC}; + #\u{171CD}; + #\u{171CE}; + #\u{171CF}; + #\u{171D0}; + #\u{171D1}; + #\u{171D2}; + #\u{171D3}; + #\u{171D4}; + #\u{171D5}; + #\u{171D6}; + #\u{171D7}; + #\u{171D8}; + #\u{171D9}; + #\u{171DA}; + #\u{171DB}; + #\u{171DC}; + #\u{171DD}; + #\u{171DE}; + #\u{171DF}; + #\u{171E0}; + #\u{171E1}; + #\u{171E2}; + #\u{171E3}; + #\u{171E4}; + #\u{171E5}; + #\u{171E6}; + #\u{171E7}; + #\u{171E8}; + #\u{171E9}; + #\u{171EA}; + #\u{171EB}; + #\u{171EC}; + #\u{171ED}; + #\u{171EE}; + #\u{171EF}; + #\u{171F0}; + #\u{171F1}; + #\u{171F2}; + #\u{171F3}; + #\u{171F4}; + #\u{171F5}; + #\u{171F6}; + #\u{171F7}; + #\u{171F8}; + #\u{171F9}; + #\u{171FA}; + #\u{171FB}; + #\u{171FC}; + #\u{171FD}; + #\u{171FE}; + #\u{171FF}; + #\u{17200}; + #\u{17201}; + #\u{17202}; + #\u{17203}; + #\u{17204}; + #\u{17205}; + #\u{17206}; + #\u{17207}; + #\u{17208}; + #\u{17209}; + #\u{1720A}; + #\u{1720B}; + #\u{1720C}; + #\u{1720D}; + #\u{1720E}; + #\u{1720F}; + #\u{17210}; + #\u{17211}; + #\u{17212}; + #\u{17213}; + #\u{17214}; + #\u{17215}; + #\u{17216}; + #\u{17217}; + #\u{17218}; + #\u{17219}; + #\u{1721A}; + #\u{1721B}; + #\u{1721C}; + #\u{1721D}; + #\u{1721E}; + #\u{1721F}; + #\u{17220}; + #\u{17221}; + #\u{17222}; + #\u{17223}; + #\u{17224}; + #\u{17225}; + #\u{17226}; + #\u{17227}; + #\u{17228}; + #\u{17229}; + #\u{1722A}; + #\u{1722B}; + #\u{1722C}; + #\u{1722D}; + #\u{1722E}; + #\u{1722F}; + #\u{17230}; + #\u{17231}; + #\u{17232}; + #\u{17233}; + #\u{17234}; + #\u{17235}; + #\u{17236}; + #\u{17237}; + #\u{17238}; + #\u{17239}; + #\u{1723A}; + #\u{1723B}; + #\u{1723C}; + #\u{1723D}; + #\u{1723E}; + #\u{1723F}; + #\u{17240}; + #\u{17241}; + #\u{17242}; + #\u{17243}; + #\u{17244}; + #\u{17245}; + #\u{17246}; + #\u{17247}; + #\u{17248}; + #\u{17249}; + #\u{1724A}; + #\u{1724B}; + #\u{1724C}; + #\u{1724D}; + #\u{1724E}; + #\u{1724F}; + #\u{17250}; + #\u{17251}; + #\u{17252}; + #\u{17253}; + #\u{17254}; + #\u{17255}; + #\u{17256}; + #\u{17257}; + #\u{17258}; + #\u{17259}; + #\u{1725A}; + #\u{1725B}; + #\u{1725C}; + #\u{1725D}; + #\u{1725E}; + #\u{1725F}; + #\u{17260}; + #\u{17261}; + #\u{17262}; + #\u{17263}; + #\u{17264}; + #\u{17265}; + #\u{17266}; + #\u{17267}; + #\u{17268}; + #\u{17269}; + #\u{1726A}; + #\u{1726B}; + #\u{1726C}; + #\u{1726D}; + #\u{1726E}; + #\u{1726F}; + #\u{17270}; + #\u{17271}; + #\u{17272}; + #\u{17273}; + #\u{17274}; + #\u{17275}; + #\u{17276}; + #\u{17277}; + #\u{17278}; + #\u{17279}; + #\u{1727A}; + #\u{1727B}; + #\u{1727C}; + #\u{1727D}; + #\u{1727E}; + #\u{1727F}; + #\u{17280}; + #\u{17281}; + #\u{17282}; + #\u{17283}; + #\u{17284}; + #\u{17285}; + #\u{17286}; + #\u{17287}; + #\u{17288}; + #\u{17289}; + #\u{1728A}; + #\u{1728B}; + #\u{1728C}; + #\u{1728D}; + #\u{1728E}; + #\u{1728F}; + #\u{17290}; + #\u{17291}; + #\u{17292}; + #\u{17293}; + #\u{17294}; + #\u{17295}; + #\u{17296}; + #\u{17297}; + #\u{17298}; + #\u{17299}; + #\u{1729A}; + #\u{1729B}; + #\u{1729C}; + #\u{1729D}; + #\u{1729E}; + #\u{1729F}; + #\u{172A0}; + #\u{172A1}; + #\u{172A2}; + #\u{172A3}; + #\u{172A4}; + #\u{172A5}; + #\u{172A6}; + #\u{172A7}; + #\u{172A8}; + #\u{172A9}; + #\u{172AA}; + #\u{172AB}; + #\u{172AC}; + #\u{172AD}; + #\u{172AE}; + #\u{172AF}; + #\u{172B0}; + #\u{172B1}; + #\u{172B2}; + #\u{172B3}; + #\u{172B4}; + #\u{172B5}; + #\u{172B6}; + #\u{172B7}; + #\u{172B8}; + #\u{172B9}; + #\u{172BA}; + #\u{172BB}; + #\u{172BC}; + #\u{172BD}; + #\u{172BE}; + #\u{172BF}; + #\u{172C0}; + #\u{172C1}; + #\u{172C2}; + #\u{172C3}; + #\u{172C4}; + #\u{172C5}; + #\u{172C6}; + #\u{172C7}; + #\u{172C8}; + #\u{172C9}; + #\u{172CA}; + #\u{172CB}; + #\u{172CC}; + #\u{172CD}; + #\u{172CE}; + #\u{172CF}; + #\u{172D0}; + #\u{172D1}; + #\u{172D2}; + #\u{172D3}; + #\u{172D4}; + #\u{172D5}; + #\u{172D6}; + #\u{172D7}; + #\u{172D8}; + #\u{172D9}; + #\u{172DA}; + #\u{172DB}; + #\u{172DC}; + #\u{172DD}; + #\u{172DE}; + #\u{172DF}; + #\u{172E0}; + #\u{172E1}; + #\u{172E2}; + #\u{172E3}; + #\u{172E4}; + #\u{172E5}; + #\u{172E6}; + #\u{172E7}; + #\u{172E8}; + #\u{172E9}; + #\u{172EA}; + #\u{172EB}; + #\u{172EC}; + #\u{172ED}; + #\u{172EE}; + #\u{172EF}; + #\u{172F0}; + #\u{172F1}; + #\u{172F2}; + #\u{172F3}; + #\u{172F4}; + #\u{172F5}; + #\u{172F6}; + #\u{172F7}; + #\u{172F8}; + #\u{172F9}; + #\u{172FA}; + #\u{172FB}; + #\u{172FC}; + #\u{172FD}; + #\u{172FE}; + #\u{172FF}; + #\u{17300}; + #\u{17301}; + #\u{17302}; + #\u{17303}; + #\u{17304}; + #\u{17305}; + #\u{17306}; + #\u{17307}; + #\u{17308}; + #\u{17309}; + #\u{1730A}; + #\u{1730B}; + #\u{1730C}; + #\u{1730D}; + #\u{1730E}; + #\u{1730F}; + #\u{17310}; + #\u{17311}; + #\u{17312}; + #\u{17313}; + #\u{17314}; + #\u{17315}; + #\u{17316}; + #\u{17317}; + #\u{17318}; + #\u{17319}; + #\u{1731A}; + #\u{1731B}; + #\u{1731C}; + #\u{1731D}; + #\u{1731E}; + #\u{1731F}; + #\u{17320}; + #\u{17321}; + #\u{17322}; + #\u{17323}; + #\u{17324}; + #\u{17325}; + #\u{17326}; + #\u{17327}; + #\u{17328}; + #\u{17329}; + #\u{1732A}; + #\u{1732B}; + #\u{1732C}; + #\u{1732D}; + #\u{1732E}; + #\u{1732F}; + #\u{17330}; + #\u{17331}; + #\u{17332}; + #\u{17333}; + #\u{17334}; + #\u{17335}; + #\u{17336}; + #\u{17337}; + #\u{17338}; + #\u{17339}; + #\u{1733A}; + #\u{1733B}; + #\u{1733C}; + #\u{1733D}; + #\u{1733E}; + #\u{1733F}; + #\u{17340}; + #\u{17341}; + #\u{17342}; + #\u{17343}; + #\u{17344}; + #\u{17345}; + #\u{17346}; + #\u{17347}; + #\u{17348}; + #\u{17349}; + #\u{1734A}; + #\u{1734B}; + #\u{1734C}; + #\u{1734D}; + #\u{1734E}; + #\u{1734F}; + #\u{17350}; + #\u{17351}; + #\u{17352}; + #\u{17353}; + #\u{17354}; + #\u{17355}; + #\u{17356}; + #\u{17357}; + #\u{17358}; + #\u{17359}; + #\u{1735A}; + #\u{1735B}; + #\u{1735C}; + #\u{1735D}; + #\u{1735E}; + #\u{1735F}; + #\u{17360}; + #\u{17361}; + #\u{17362}; + #\u{17363}; + #\u{17364}; + #\u{17365}; + #\u{17366}; + #\u{17367}; + #\u{17368}; + #\u{17369}; + #\u{1736A}; + #\u{1736B}; + #\u{1736C}; + #\u{1736D}; + #\u{1736E}; + #\u{1736F}; + #\u{17370}; + #\u{17371}; + #\u{17372}; + #\u{17373}; + #\u{17374}; + #\u{17375}; + #\u{17376}; + #\u{17377}; + #\u{17378}; + #\u{17379}; + #\u{1737A}; + #\u{1737B}; + #\u{1737C}; + #\u{1737D}; + #\u{1737E}; + #\u{1737F}; + #\u{17380}; + #\u{17381}; + #\u{17382}; + #\u{17383}; + #\u{17384}; + #\u{17385}; + #\u{17386}; + #\u{17387}; + #\u{17388}; + #\u{17389}; + #\u{1738A}; + #\u{1738B}; + #\u{1738C}; + #\u{1738D}; + #\u{1738E}; + #\u{1738F}; + #\u{17390}; + #\u{17391}; + #\u{17392}; + #\u{17393}; + #\u{17394}; + #\u{17395}; + #\u{17396}; + #\u{17397}; + #\u{17398}; + #\u{17399}; + #\u{1739A}; + #\u{1739B}; + #\u{1739C}; + #\u{1739D}; + #\u{1739E}; + #\u{1739F}; + #\u{173A0}; + #\u{173A1}; + #\u{173A2}; + #\u{173A3}; + #\u{173A4}; + #\u{173A5}; + #\u{173A6}; + #\u{173A7}; + #\u{173A8}; + #\u{173A9}; + #\u{173AA}; + #\u{173AB}; + #\u{173AC}; + #\u{173AD}; + #\u{173AE}; + #\u{173AF}; + #\u{173B0}; + #\u{173B1}; + #\u{173B2}; + #\u{173B3}; + #\u{173B4}; + #\u{173B5}; + #\u{173B6}; + #\u{173B7}; + #\u{173B8}; + #\u{173B9}; + #\u{173BA}; + #\u{173BB}; + #\u{173BC}; + #\u{173BD}; + #\u{173BE}; + #\u{173BF}; + #\u{173C0}; + #\u{173C1}; + #\u{173C2}; + #\u{173C3}; + #\u{173C4}; + #\u{173C5}; + #\u{173C6}; + #\u{173C7}; + #\u{173C8}; + #\u{173C9}; + #\u{173CA}; + #\u{173CB}; + #\u{173CC}; + #\u{173CD}; + #\u{173CE}; + #\u{173CF}; + #\u{173D0}; + #\u{173D1}; + #\u{173D2}; + #\u{173D3}; + #\u{173D4}; + #\u{173D5}; + #\u{173D6}; + #\u{173D7}; + #\u{173D8}; + #\u{173D9}; + #\u{173DA}; + #\u{173DB}; + #\u{173DC}; + #\u{173DD}; + #\u{173DE}; + #\u{173DF}; + #\u{173E0}; + #\u{173E1}; + #\u{173E2}; + #\u{173E3}; + #\u{173E4}; + #\u{173E5}; + #\u{173E6}; + #\u{173E7}; + #\u{173E8}; + #\u{173E9}; + #\u{173EA}; + #\u{173EB}; + #\u{173EC}; + #\u{173ED}; + #\u{173EE}; + #\u{173EF}; + #\u{173F0}; + #\u{173F1}; + #\u{173F2}; + #\u{173F3}; + #\u{173F4}; + #\u{173F5}; + #\u{173F6}; + #\u{173F7}; + #\u{173F8}; + #\u{173F9}; + #\u{173FA}; + #\u{173FB}; + #\u{173FC}; + #\u{173FD}; + #\u{173FE}; + #\u{173FF}; + #\u{17400}; + #\u{17401}; + #\u{17402}; + #\u{17403}; + #\u{17404}; + #\u{17405}; + #\u{17406}; + #\u{17407}; + #\u{17408}; + #\u{17409}; + #\u{1740A}; + #\u{1740B}; + #\u{1740C}; + #\u{1740D}; + #\u{1740E}; + #\u{1740F}; + #\u{17410}; + #\u{17411}; + #\u{17412}; + #\u{17413}; + #\u{17414}; + #\u{17415}; + #\u{17416}; + #\u{17417}; + #\u{17418}; + #\u{17419}; + #\u{1741A}; + #\u{1741B}; + #\u{1741C}; + #\u{1741D}; + #\u{1741E}; + #\u{1741F}; + #\u{17420}; + #\u{17421}; + #\u{17422}; + #\u{17423}; + #\u{17424}; + #\u{17425}; + #\u{17426}; + #\u{17427}; + #\u{17428}; + #\u{17429}; + #\u{1742A}; + #\u{1742B}; + #\u{1742C}; + #\u{1742D}; + #\u{1742E}; + #\u{1742F}; + #\u{17430}; + #\u{17431}; + #\u{17432}; + #\u{17433}; + #\u{17434}; + #\u{17435}; + #\u{17436}; + #\u{17437}; + #\u{17438}; + #\u{17439}; + #\u{1743A}; + #\u{1743B}; + #\u{1743C}; + #\u{1743D}; + #\u{1743E}; + #\u{1743F}; + #\u{17440}; + #\u{17441}; + #\u{17442}; + #\u{17443}; + #\u{17444}; + #\u{17445}; + #\u{17446}; + #\u{17447}; + #\u{17448}; + #\u{17449}; + #\u{1744A}; + #\u{1744B}; + #\u{1744C}; + #\u{1744D}; + #\u{1744E}; + #\u{1744F}; + #\u{17450}; + #\u{17451}; + #\u{17452}; + #\u{17453}; + #\u{17454}; + #\u{17455}; + #\u{17456}; + #\u{17457}; + #\u{17458}; + #\u{17459}; + #\u{1745A}; + #\u{1745B}; + #\u{1745C}; + #\u{1745D}; + #\u{1745E}; + #\u{1745F}; + #\u{17460}; + #\u{17461}; + #\u{17462}; + #\u{17463}; + #\u{17464}; + #\u{17465}; + #\u{17466}; + #\u{17467}; + #\u{17468}; + #\u{17469}; + #\u{1746A}; + #\u{1746B}; + #\u{1746C}; + #\u{1746D}; + #\u{1746E}; + #\u{1746F}; + #\u{17470}; + #\u{17471}; + #\u{17472}; + #\u{17473}; + #\u{17474}; + #\u{17475}; + #\u{17476}; + #\u{17477}; + #\u{17478}; + #\u{17479}; + #\u{1747A}; + #\u{1747B}; + #\u{1747C}; + #\u{1747D}; + #\u{1747E}; + #\u{1747F}; + #\u{17480}; + #\u{17481}; + #\u{17482}; + #\u{17483}; + #\u{17484}; + #\u{17485}; + #\u{17486}; + #\u{17487}; + #\u{17488}; + #\u{17489}; + #\u{1748A}; + #\u{1748B}; + #\u{1748C}; + #\u{1748D}; + #\u{1748E}; + #\u{1748F}; + #\u{17490}; + #\u{17491}; + #\u{17492}; + #\u{17493}; + #\u{17494}; + #\u{17495}; + #\u{17496}; + #\u{17497}; + #\u{17498}; + #\u{17499}; + #\u{1749A}; + #\u{1749B}; + #\u{1749C}; + #\u{1749D}; + #\u{1749E}; + #\u{1749F}; + #\u{174A0}; + #\u{174A1}; + #\u{174A2}; + #\u{174A3}; + #\u{174A4}; + #\u{174A5}; + #\u{174A6}; + #\u{174A7}; + #\u{174A8}; + #\u{174A9}; + #\u{174AA}; + #\u{174AB}; + #\u{174AC}; + #\u{174AD}; + #\u{174AE}; + #\u{174AF}; + #\u{174B0}; + #\u{174B1}; + #\u{174B2}; + #\u{174B3}; + #\u{174B4}; + #\u{174B5}; + #\u{174B6}; + #\u{174B7}; + #\u{174B8}; + #\u{174B9}; + #\u{174BA}; + #\u{174BB}; + #\u{174BC}; + #\u{174BD}; + #\u{174BE}; + #\u{174BF}; + #\u{174C0}; + #\u{174C1}; + #\u{174C2}; + #\u{174C3}; + #\u{174C4}; + #\u{174C5}; + #\u{174C6}; + #\u{174C7}; + #\u{174C8}; + #\u{174C9}; + #\u{174CA}; + #\u{174CB}; + #\u{174CC}; + #\u{174CD}; + #\u{174CE}; + #\u{174CF}; + #\u{174D0}; + #\u{174D1}; + #\u{174D2}; + #\u{174D3}; + #\u{174D4}; + #\u{174D5}; + #\u{174D6}; + #\u{174D7}; + #\u{174D8}; + #\u{174D9}; + #\u{174DA}; + #\u{174DB}; + #\u{174DC}; + #\u{174DD}; + #\u{174DE}; + #\u{174DF}; + #\u{174E0}; + #\u{174E1}; + #\u{174E2}; + #\u{174E3}; + #\u{174E4}; + #\u{174E5}; + #\u{174E6}; + #\u{174E7}; + #\u{174E8}; + #\u{174E9}; + #\u{174EA}; + #\u{174EB}; + #\u{174EC}; + #\u{174ED}; + #\u{174EE}; + #\u{174EF}; + #\u{174F0}; + #\u{174F1}; + #\u{174F2}; + #\u{174F3}; + #\u{174F4}; + #\u{174F5}; + #\u{174F6}; + #\u{174F7}; + #\u{174F8}; + #\u{174F9}; + #\u{174FA}; + #\u{174FB}; + #\u{174FC}; + #\u{174FD}; + #\u{174FE}; + #\u{174FF}; + #\u{17500}; + #\u{17501}; + #\u{17502}; + #\u{17503}; + #\u{17504}; + #\u{17505}; + #\u{17506}; + #\u{17507}; + #\u{17508}; + #\u{17509}; + #\u{1750A}; + #\u{1750B}; + #\u{1750C}; + #\u{1750D}; + #\u{1750E}; + #\u{1750F}; + #\u{17510}; + #\u{17511}; + #\u{17512}; + #\u{17513}; + #\u{17514}; + #\u{17515}; + #\u{17516}; + #\u{17517}; + #\u{17518}; + #\u{17519}; + #\u{1751A}; + #\u{1751B}; + #\u{1751C}; + #\u{1751D}; + #\u{1751E}; + #\u{1751F}; + #\u{17520}; + #\u{17521}; + #\u{17522}; + #\u{17523}; + #\u{17524}; + #\u{17525}; + #\u{17526}; + #\u{17527}; + #\u{17528}; + #\u{17529}; + #\u{1752A}; + #\u{1752B}; + #\u{1752C}; + #\u{1752D}; + #\u{1752E}; + #\u{1752F}; + #\u{17530}; + #\u{17531}; + #\u{17532}; + #\u{17533}; + #\u{17534}; + #\u{17535}; + #\u{17536}; + #\u{17537}; + #\u{17538}; + #\u{17539}; + #\u{1753A}; + #\u{1753B}; + #\u{1753C}; + #\u{1753D}; + #\u{1753E}; + #\u{1753F}; + #\u{17540}; + #\u{17541}; + #\u{17542}; + #\u{17543}; + #\u{17544}; + #\u{17545}; + #\u{17546}; + #\u{17547}; + #\u{17548}; + #\u{17549}; + #\u{1754A}; + #\u{1754B}; + #\u{1754C}; + #\u{1754D}; + #\u{1754E}; + #\u{1754F}; + #\u{17550}; + #\u{17551}; + #\u{17552}; + #\u{17553}; + #\u{17554}; + #\u{17555}; + #\u{17556}; + #\u{17557}; + #\u{17558}; + #\u{17559}; + #\u{1755A}; + #\u{1755B}; + #\u{1755C}; + #\u{1755D}; + #\u{1755E}; + #\u{1755F}; + #\u{17560}; + #\u{17561}; + #\u{17562}; + #\u{17563}; + #\u{17564}; + #\u{17565}; + #\u{17566}; + #\u{17567}; + #\u{17568}; + #\u{17569}; + #\u{1756A}; + #\u{1756B}; + #\u{1756C}; + #\u{1756D}; + #\u{1756E}; + #\u{1756F}; + #\u{17570}; + #\u{17571}; + #\u{17572}; + #\u{17573}; + #\u{17574}; + #\u{17575}; + #\u{17576}; + #\u{17577}; + #\u{17578}; + #\u{17579}; + #\u{1757A}; + #\u{1757B}; + #\u{1757C}; + #\u{1757D}; + #\u{1757E}; + #\u{1757F}; + #\u{17580}; + #\u{17581}; + #\u{17582}; + #\u{17583}; + #\u{17584}; + #\u{17585}; + #\u{17586}; + #\u{17587}; + #\u{17588}; + #\u{17589}; + #\u{1758A}; + #\u{1758B}; + #\u{1758C}; + #\u{1758D}; + #\u{1758E}; + #\u{1758F}; + #\u{17590}; + #\u{17591}; + #\u{17592}; + #\u{17593}; + #\u{17594}; + #\u{17595}; + #\u{17596}; + #\u{17597}; + #\u{17598}; + #\u{17599}; + #\u{1759A}; + #\u{1759B}; + #\u{1759C}; + #\u{1759D}; + #\u{1759E}; + #\u{1759F}; + #\u{175A0}; + #\u{175A1}; + #\u{175A2}; + #\u{175A3}; + #\u{175A4}; + #\u{175A5}; + #\u{175A6}; + #\u{175A7}; + #\u{175A8}; + #\u{175A9}; + #\u{175AA}; + #\u{175AB}; + #\u{175AC}; + #\u{175AD}; + #\u{175AE}; + #\u{175AF}; + #\u{175B0}; + #\u{175B1}; + #\u{175B2}; + #\u{175B3}; + #\u{175B4}; + #\u{175B5}; + #\u{175B6}; + #\u{175B7}; + #\u{175B8}; + #\u{175B9}; + #\u{175BA}; + #\u{175BB}; + #\u{175BC}; + #\u{175BD}; + #\u{175BE}; + #\u{175BF}; + #\u{175C0}; + #\u{175C1}; + #\u{175C2}; + #\u{175C3}; + #\u{175C4}; + #\u{175C5}; + #\u{175C6}; + #\u{175C7}; + #\u{175C8}; + #\u{175C9}; + #\u{175CA}; + #\u{175CB}; + #\u{175CC}; + #\u{175CD}; + #\u{175CE}; + #\u{175CF}; + #\u{175D0}; + #\u{175D1}; + #\u{175D2}; + #\u{175D3}; + #\u{175D4}; + #\u{175D5}; + #\u{175D6}; + #\u{175D7}; + #\u{175D8}; + #\u{175D9}; + #\u{175DA}; + #\u{175DB}; + #\u{175DC}; + #\u{175DD}; + #\u{175DE}; + #\u{175DF}; + #\u{175E0}; + #\u{175E1}; + #\u{175E2}; + #\u{175E3}; + #\u{175E4}; + #\u{175E5}; + #\u{175E6}; + #\u{175E7}; + #\u{175E8}; + #\u{175E9}; + #\u{175EA}; + #\u{175EB}; + #\u{175EC}; + #\u{175ED}; + #\u{175EE}; + #\u{175EF}; + #\u{175F0}; + #\u{175F1}; + #\u{175F2}; + #\u{175F3}; + #\u{175F4}; + #\u{175F5}; + #\u{175F6}; + #\u{175F7}; + #\u{175F8}; + #\u{175F9}; + #\u{175FA}; + #\u{175FB}; + #\u{175FC}; + #\u{175FD}; + #\u{175FE}; + #\u{175FF}; + #\u{17600}; + #\u{17601}; + #\u{17602}; + #\u{17603}; + #\u{17604}; + #\u{17605}; + #\u{17606}; + #\u{17607}; + #\u{17608}; + #\u{17609}; + #\u{1760A}; + #\u{1760B}; + #\u{1760C}; + #\u{1760D}; + #\u{1760E}; + #\u{1760F}; + #\u{17610}; + #\u{17611}; + #\u{17612}; + #\u{17613}; + #\u{17614}; + #\u{17615}; + #\u{17616}; + #\u{17617}; + #\u{17618}; + #\u{17619}; + #\u{1761A}; + #\u{1761B}; + #\u{1761C}; + #\u{1761D}; + #\u{1761E}; + #\u{1761F}; + #\u{17620}; + #\u{17621}; + #\u{17622}; + #\u{17623}; + #\u{17624}; + #\u{17625}; + #\u{17626}; + #\u{17627}; + #\u{17628}; + #\u{17629}; + #\u{1762A}; + #\u{1762B}; + #\u{1762C}; + #\u{1762D}; + #\u{1762E}; + #\u{1762F}; + #\u{17630}; + #\u{17631}; + #\u{17632}; + #\u{17633}; + #\u{17634}; + #\u{17635}; + #\u{17636}; + #\u{17637}; + #\u{17638}; + #\u{17639}; + #\u{1763A}; + #\u{1763B}; + #\u{1763C}; + #\u{1763D}; + #\u{1763E}; + #\u{1763F}; + #\u{17640}; + #\u{17641}; + #\u{17642}; + #\u{17643}; + #\u{17644}; + #\u{17645}; + #\u{17646}; + #\u{17647}; + #\u{17648}; + #\u{17649}; + #\u{1764A}; + #\u{1764B}; + #\u{1764C}; + #\u{1764D}; + #\u{1764E}; + #\u{1764F}; + #\u{17650}; + #\u{17651}; + #\u{17652}; + #\u{17653}; + #\u{17654}; + #\u{17655}; + #\u{17656}; + #\u{17657}; + #\u{17658}; + #\u{17659}; + #\u{1765A}; + #\u{1765B}; + #\u{1765C}; + #\u{1765D}; + #\u{1765E}; + #\u{1765F}; + #\u{17660}; + #\u{17661}; + #\u{17662}; + #\u{17663}; + #\u{17664}; + #\u{17665}; + #\u{17666}; + #\u{17667}; + #\u{17668}; + #\u{17669}; + #\u{1766A}; + #\u{1766B}; + #\u{1766C}; + #\u{1766D}; + #\u{1766E}; + #\u{1766F}; + #\u{17670}; + #\u{17671}; + #\u{17672}; + #\u{17673}; + #\u{17674}; + #\u{17675}; + #\u{17676}; + #\u{17677}; + #\u{17678}; + #\u{17679}; + #\u{1767A}; + #\u{1767B}; + #\u{1767C}; + #\u{1767D}; + #\u{1767E}; + #\u{1767F}; + #\u{17680}; + #\u{17681}; + #\u{17682}; + #\u{17683}; + #\u{17684}; + #\u{17685}; + #\u{17686}; + #\u{17687}; + #\u{17688}; + #\u{17689}; + #\u{1768A}; + #\u{1768B}; + #\u{1768C}; + #\u{1768D}; + #\u{1768E}; + #\u{1768F}; + #\u{17690}; + #\u{17691}; + #\u{17692}; + #\u{17693}; + #\u{17694}; + #\u{17695}; + #\u{17696}; + #\u{17697}; + #\u{17698}; + #\u{17699}; + #\u{1769A}; + #\u{1769B}; + #\u{1769C}; + #\u{1769D}; + #\u{1769E}; + #\u{1769F}; + #\u{176A0}; + #\u{176A1}; + #\u{176A2}; + #\u{176A3}; + #\u{176A4}; + #\u{176A5}; + #\u{176A6}; + #\u{176A7}; + #\u{176A8}; + #\u{176A9}; + #\u{176AA}; + #\u{176AB}; + #\u{176AC}; + #\u{176AD}; + #\u{176AE}; + #\u{176AF}; + #\u{176B0}; + #\u{176B1}; + #\u{176B2}; + #\u{176B3}; + #\u{176B4}; + #\u{176B5}; + #\u{176B6}; + #\u{176B7}; + #\u{176B8}; + #\u{176B9}; + #\u{176BA}; + #\u{176BB}; + #\u{176BC}; + #\u{176BD}; + #\u{176BE}; + #\u{176BF}; + #\u{176C0}; + #\u{176C1}; + #\u{176C2}; + #\u{176C3}; + #\u{176C4}; + #\u{176C5}; + #\u{176C6}; + #\u{176C7}; + #\u{176C8}; + #\u{176C9}; + #\u{176CA}; + #\u{176CB}; + #\u{176CC}; + #\u{176CD}; + #\u{176CE}; + #\u{176CF}; + #\u{176D0}; + #\u{176D1}; + #\u{176D2}; + #\u{176D3}; + #\u{176D4}; + #\u{176D5}; + #\u{176D6}; + #\u{176D7}; + #\u{176D8}; + #\u{176D9}; + #\u{176DA}; + #\u{176DB}; + #\u{176DC}; + #\u{176DD}; + #\u{176DE}; + #\u{176DF}; + #\u{176E0}; + #\u{176E1}; + #\u{176E2}; + #\u{176E3}; + #\u{176E4}; + #\u{176E5}; + #\u{176E6}; + #\u{176E7}; + #\u{176E8}; + #\u{176E9}; + #\u{176EA}; + #\u{176EB}; + #\u{176EC}; + #\u{176ED}; + #\u{176EE}; + #\u{176EF}; + #\u{176F0}; + #\u{176F1}; + #\u{176F2}; + #\u{176F3}; + #\u{176F4}; + #\u{176F5}; + #\u{176F6}; + #\u{176F7}; + #\u{176F8}; + #\u{176F9}; + #\u{176FA}; + #\u{176FB}; + #\u{176FC}; + #\u{176FD}; + #\u{176FE}; + #\u{176FF}; + #\u{17700}; + #\u{17701}; + #\u{17702}; + #\u{17703}; + #\u{17704}; + #\u{17705}; + #\u{17706}; + #\u{17707}; + #\u{17708}; + #\u{17709}; + #\u{1770A}; + #\u{1770B}; + #\u{1770C}; + #\u{1770D}; + #\u{1770E}; + #\u{1770F}; + #\u{17710}; + #\u{17711}; + #\u{17712}; + #\u{17713}; + #\u{17714}; + #\u{17715}; + #\u{17716}; + #\u{17717}; + #\u{17718}; + #\u{17719}; + #\u{1771A}; + #\u{1771B}; + #\u{1771C}; + #\u{1771D}; + #\u{1771E}; + #\u{1771F}; + #\u{17720}; + #\u{17721}; + #\u{17722}; + #\u{17723}; + #\u{17724}; + #\u{17725}; + #\u{17726}; + #\u{17727}; + #\u{17728}; + #\u{17729}; + #\u{1772A}; + #\u{1772B}; + #\u{1772C}; + #\u{1772D}; + #\u{1772E}; + #\u{1772F}; + #\u{17730}; + #\u{17731}; + #\u{17732}; + #\u{17733}; + #\u{17734}; + #\u{17735}; + #\u{17736}; + #\u{17737}; + #\u{17738}; + #\u{17739}; + #\u{1773A}; + #\u{1773B}; + #\u{1773C}; + #\u{1773D}; + #\u{1773E}; + #\u{1773F}; + #\u{17740}; + #\u{17741}; + #\u{17742}; + #\u{17743}; + #\u{17744}; + #\u{17745}; + #\u{17746}; + #\u{17747}; + #\u{17748}; + #\u{17749}; + #\u{1774A}; + #\u{1774B}; + #\u{1774C}; + #\u{1774D}; + #\u{1774E}; + #\u{1774F}; + #\u{17750}; + #\u{17751}; + #\u{17752}; + #\u{17753}; + #\u{17754}; + #\u{17755}; + #\u{17756}; + #\u{17757}; + #\u{17758}; + #\u{17759}; + #\u{1775A}; + #\u{1775B}; + #\u{1775C}; + #\u{1775D}; + #\u{1775E}; + #\u{1775F}; + #\u{17760}; + #\u{17761}; + #\u{17762}; + #\u{17763}; + #\u{17764}; + #\u{17765}; + #\u{17766}; + #\u{17767}; + #\u{17768}; + #\u{17769}; + #\u{1776A}; + #\u{1776B}; + #\u{1776C}; + #\u{1776D}; + #\u{1776E}; + #\u{1776F}; + #\u{17770}; + #\u{17771}; + #\u{17772}; + #\u{17773}; + #\u{17774}; + #\u{17775}; + #\u{17776}; + #\u{17777}; + #\u{17778}; + #\u{17779}; + #\u{1777A}; + #\u{1777B}; + #\u{1777C}; + #\u{1777D}; + #\u{1777E}; + #\u{1777F}; + #\u{17780}; + #\u{17781}; + #\u{17782}; + #\u{17783}; + #\u{17784}; + #\u{17785}; + #\u{17786}; + #\u{17787}; + #\u{17788}; + #\u{17789}; + #\u{1778A}; + #\u{1778B}; + #\u{1778C}; + #\u{1778D}; + #\u{1778E}; + #\u{1778F}; + #\u{17790}; + #\u{17791}; + #\u{17792}; + #\u{17793}; + #\u{17794}; + #\u{17795}; + #\u{17796}; + #\u{17797}; + #\u{17798}; + #\u{17799}; + #\u{1779A}; + #\u{1779B}; + #\u{1779C}; + #\u{1779D}; + #\u{1779E}; + #\u{1779F}; + #\u{177A0}; + #\u{177A1}; + #\u{177A2}; + #\u{177A3}; + #\u{177A4}; + #\u{177A5}; + #\u{177A6}; + #\u{177A7}; + #\u{177A8}; + #\u{177A9}; + #\u{177AA}; + #\u{177AB}; + #\u{177AC}; + #\u{177AD}; + #\u{177AE}; + #\u{177AF}; + #\u{177B0}; + #\u{177B1}; + #\u{177B2}; + #\u{177B3}; + #\u{177B4}; + #\u{177B5}; + #\u{177B6}; + #\u{177B7}; + #\u{177B8}; + #\u{177B9}; + #\u{177BA}; + #\u{177BB}; + #\u{177BC}; + #\u{177BD}; + #\u{177BE}; + #\u{177BF}; + #\u{177C0}; + #\u{177C1}; + #\u{177C2}; + #\u{177C3}; + #\u{177C4}; + #\u{177C5}; + #\u{177C6}; + #\u{177C7}; + #\u{177C8}; + #\u{177C9}; + #\u{177CA}; + #\u{177CB}; + #\u{177CC}; + #\u{177CD}; + #\u{177CE}; + #\u{177CF}; + #\u{177D0}; + #\u{177D1}; + #\u{177D2}; + #\u{177D3}; + #\u{177D4}; + #\u{177D5}; + #\u{177D6}; + #\u{177D7}; + #\u{177D8}; + #\u{177D9}; + #\u{177DA}; + #\u{177DB}; + #\u{177DC}; + #\u{177DD}; + #\u{177DE}; + #\u{177DF}; + #\u{177E0}; + #\u{177E1}; + #\u{177E2}; + #\u{177E3}; + #\u{177E4}; + #\u{177E5}; + #\u{177E6}; + #\u{177E7}; + #\u{177E8}; + #\u{177E9}; + #\u{177EA}; + #\u{177EB}; + #\u{177EC}; + #\u{177ED}; + #\u{177EE}; + #\u{177EF}; + #\u{177F0}; + #\u{177F1}; + #\u{177F2}; + #\u{177F3}; + #\u{177F4}; + #\u{177F5}; + #\u{177F6}; + #\u{177F7}; + #\u{177F8}; + #\u{177F9}; + #\u{177FA}; + #\u{177FB}; + #\u{177FC}; + #\u{177FD}; + #\u{177FE}; + #\u{177FF}; + #\u{17800}; + #\u{17801}; + #\u{17802}; + #\u{17803}; + #\u{17804}; + #\u{17805}; + #\u{17806}; + #\u{17807}; + #\u{17808}; + #\u{17809}; + #\u{1780A}; + #\u{1780B}; + #\u{1780C}; + #\u{1780D}; + #\u{1780E}; + #\u{1780F}; + #\u{17810}; + #\u{17811}; + #\u{17812}; + #\u{17813}; + #\u{17814}; + #\u{17815}; + #\u{17816}; + #\u{17817}; + #\u{17818}; + #\u{17819}; + #\u{1781A}; + #\u{1781B}; + #\u{1781C}; + #\u{1781D}; + #\u{1781E}; + #\u{1781F}; + #\u{17820}; + #\u{17821}; + #\u{17822}; + #\u{17823}; + #\u{17824}; + #\u{17825}; + #\u{17826}; + #\u{17827}; + #\u{17828}; + #\u{17829}; + #\u{1782A}; + #\u{1782B}; + #\u{1782C}; + #\u{1782D}; + #\u{1782E}; + #\u{1782F}; + #\u{17830}; + #\u{17831}; + #\u{17832}; + #\u{17833}; + #\u{17834}; + #\u{17835}; + #\u{17836}; + #\u{17837}; + #\u{17838}; + #\u{17839}; + #\u{1783A}; + #\u{1783B}; + #\u{1783C}; + #\u{1783D}; + #\u{1783E}; + #\u{1783F}; + #\u{17840}; + #\u{17841}; + #\u{17842}; + #\u{17843}; + #\u{17844}; + #\u{17845}; + #\u{17846}; + #\u{17847}; + #\u{17848}; + #\u{17849}; + #\u{1784A}; + #\u{1784B}; + #\u{1784C}; + #\u{1784D}; + #\u{1784E}; + #\u{1784F}; + #\u{17850}; + #\u{17851}; + #\u{17852}; + #\u{17853}; + #\u{17854}; + #\u{17855}; + #\u{17856}; + #\u{17857}; + #\u{17858}; + #\u{17859}; + #\u{1785A}; + #\u{1785B}; + #\u{1785C}; + #\u{1785D}; + #\u{1785E}; + #\u{1785F}; + #\u{17860}; + #\u{17861}; + #\u{17862}; + #\u{17863}; + #\u{17864}; + #\u{17865}; + #\u{17866}; + #\u{17867}; + #\u{17868}; + #\u{17869}; + #\u{1786A}; + #\u{1786B}; + #\u{1786C}; + #\u{1786D}; + #\u{1786E}; + #\u{1786F}; + #\u{17870}; + #\u{17871}; + #\u{17872}; + #\u{17873}; + #\u{17874}; + #\u{17875}; + #\u{17876}; + #\u{17877}; + #\u{17878}; + #\u{17879}; + #\u{1787A}; + #\u{1787B}; + #\u{1787C}; + #\u{1787D}; + #\u{1787E}; + #\u{1787F}; + #\u{17880}; + #\u{17881}; + #\u{17882}; + #\u{17883}; + #\u{17884}; + #\u{17885}; + #\u{17886}; + #\u{17887}; + #\u{17888}; + #\u{17889}; + #\u{1788A}; + #\u{1788B}; + #\u{1788C}; + #\u{1788D}; + #\u{1788E}; + #\u{1788F}; + #\u{17890}; + #\u{17891}; + #\u{17892}; + #\u{17893}; + #\u{17894}; + #\u{17895}; + #\u{17896}; + #\u{17897}; + #\u{17898}; + #\u{17899}; + #\u{1789A}; + #\u{1789B}; + #\u{1789C}; + #\u{1789D}; + #\u{1789E}; + #\u{1789F}; + #\u{178A0}; + #\u{178A1}; + #\u{178A2}; + #\u{178A3}; + #\u{178A4}; + #\u{178A5}; + #\u{178A6}; + #\u{178A7}; + #\u{178A8}; + #\u{178A9}; + #\u{178AA}; + #\u{178AB}; + #\u{178AC}; + #\u{178AD}; + #\u{178AE}; + #\u{178AF}; + #\u{178B0}; + #\u{178B1}; + #\u{178B2}; + #\u{178B3}; + #\u{178B4}; + #\u{178B5}; + #\u{178B6}; + #\u{178B7}; + #\u{178B8}; + #\u{178B9}; + #\u{178BA}; + #\u{178BB}; + #\u{178BC}; + #\u{178BD}; + #\u{178BE}; + #\u{178BF}; + #\u{178C0}; + #\u{178C1}; + #\u{178C2}; + #\u{178C3}; + #\u{178C4}; + #\u{178C5}; + #\u{178C6}; + #\u{178C7}; + #\u{178C8}; + #\u{178C9}; + #\u{178CA}; + #\u{178CB}; + #\u{178CC}; + #\u{178CD}; + #\u{178CE}; + #\u{178CF}; + #\u{178D0}; + #\u{178D1}; + #\u{178D2}; + #\u{178D3}; + #\u{178D4}; + #\u{178D5}; + #\u{178D6}; + #\u{178D7}; + #\u{178D8}; + #\u{178D9}; + #\u{178DA}; + #\u{178DB}; + #\u{178DC}; + #\u{178DD}; + #\u{178DE}; + #\u{178DF}; + #\u{178E0}; + #\u{178E1}; + #\u{178E2}; + #\u{178E3}; + #\u{178E4}; + #\u{178E5}; + #\u{178E6}; + #\u{178E7}; + #\u{178E8}; + #\u{178E9}; + #\u{178EA}; + #\u{178EB}; + #\u{178EC}; + #\u{178ED}; + #\u{178EE}; + #\u{178EF}; + #\u{178F0}; + #\u{178F1}; + #\u{178F2}; + #\u{178F3}; + #\u{178F4}; + #\u{178F5}; + #\u{178F6}; + #\u{178F7}; + #\u{178F8}; + #\u{178F9}; + #\u{178FA}; + #\u{178FB}; + #\u{178FC}; + #\u{178FD}; + #\u{178FE}; + #\u{178FF}; + #\u{17900}; + #\u{17901}; + #\u{17902}; + #\u{17903}; + #\u{17904}; + #\u{17905}; + #\u{17906}; + #\u{17907}; + #\u{17908}; + #\u{17909}; + #\u{1790A}; + #\u{1790B}; + #\u{1790C}; + #\u{1790D}; + #\u{1790E}; + #\u{1790F}; + #\u{17910}; + #\u{17911}; + #\u{17912}; + #\u{17913}; + #\u{17914}; + #\u{17915}; + #\u{17916}; + #\u{17917}; + #\u{17918}; + #\u{17919}; + #\u{1791A}; + #\u{1791B}; + #\u{1791C}; + #\u{1791D}; + #\u{1791E}; + #\u{1791F}; + #\u{17920}; + #\u{17921}; + #\u{17922}; + #\u{17923}; + #\u{17924}; + #\u{17925}; + #\u{17926}; + #\u{17927}; + #\u{17928}; + #\u{17929}; + #\u{1792A}; + #\u{1792B}; + #\u{1792C}; + #\u{1792D}; + #\u{1792E}; + #\u{1792F}; + #\u{17930}; + #\u{17931}; + #\u{17932}; + #\u{17933}; + #\u{17934}; + #\u{17935}; + #\u{17936}; + #\u{17937}; + #\u{17938}; + #\u{17939}; + #\u{1793A}; + #\u{1793B}; + #\u{1793C}; + #\u{1793D}; + #\u{1793E}; + #\u{1793F}; + #\u{17940}; + #\u{17941}; + #\u{17942}; + #\u{17943}; + #\u{17944}; + #\u{17945}; + #\u{17946}; + #\u{17947}; + #\u{17948}; + #\u{17949}; + #\u{1794A}; + #\u{1794B}; + #\u{1794C}; + #\u{1794D}; + #\u{1794E}; + #\u{1794F}; + #\u{17950}; + #\u{17951}; + #\u{17952}; + #\u{17953}; + #\u{17954}; + #\u{17955}; + #\u{17956}; + #\u{17957}; + #\u{17958}; + #\u{17959}; + #\u{1795A}; + #\u{1795B}; + #\u{1795C}; + #\u{1795D}; + #\u{1795E}; + #\u{1795F}; + #\u{17960}; + #\u{17961}; + #\u{17962}; + #\u{17963}; + #\u{17964}; + #\u{17965}; + #\u{17966}; + #\u{17967}; + #\u{17968}; + #\u{17969}; + #\u{1796A}; + #\u{1796B}; + #\u{1796C}; + #\u{1796D}; + #\u{1796E}; + #\u{1796F}; + #\u{17970}; + #\u{17971}; + #\u{17972}; + #\u{17973}; + #\u{17974}; + #\u{17975}; + #\u{17976}; + #\u{17977}; + #\u{17978}; + #\u{17979}; + #\u{1797A}; + #\u{1797B}; + #\u{1797C}; + #\u{1797D}; + #\u{1797E}; + #\u{1797F}; + #\u{17980}; + #\u{17981}; + #\u{17982}; + #\u{17983}; + #\u{17984}; + #\u{17985}; + #\u{17986}; + #\u{17987}; + #\u{17988}; + #\u{17989}; + #\u{1798A}; + #\u{1798B}; + #\u{1798C}; + #\u{1798D}; + #\u{1798E}; + #\u{1798F}; + #\u{17990}; + #\u{17991}; + #\u{17992}; + #\u{17993}; + #\u{17994}; + #\u{17995}; + #\u{17996}; + #\u{17997}; + #\u{17998}; + #\u{17999}; + #\u{1799A}; + #\u{1799B}; + #\u{1799C}; + #\u{1799D}; + #\u{1799E}; + #\u{1799F}; + #\u{179A0}; + #\u{179A1}; + #\u{179A2}; + #\u{179A3}; + #\u{179A4}; + #\u{179A5}; + #\u{179A6}; + #\u{179A7}; + #\u{179A8}; + #\u{179A9}; + #\u{179AA}; + #\u{179AB}; + #\u{179AC}; + #\u{179AD}; + #\u{179AE}; + #\u{179AF}; + #\u{179B0}; + #\u{179B1}; + #\u{179B2}; + #\u{179B3}; + #\u{179B4}; + #\u{179B5}; + #\u{179B6}; + #\u{179B7}; + #\u{179B8}; + #\u{179B9}; + #\u{179BA}; + #\u{179BB}; + #\u{179BC}; + #\u{179BD}; + #\u{179BE}; + #\u{179BF}; + #\u{179C0}; + #\u{179C1}; + #\u{179C2}; + #\u{179C3}; + #\u{179C4}; + #\u{179C5}; + #\u{179C6}; + #\u{179C7}; + #\u{179C8}; + #\u{179C9}; + #\u{179CA}; + #\u{179CB}; + #\u{179CC}; + #\u{179CD}; + #\u{179CE}; + #\u{179CF}; + #\u{179D0}; + #\u{179D1}; + #\u{179D2}; + #\u{179D3}; + #\u{179D4}; + #\u{179D5}; + #\u{179D6}; + #\u{179D7}; + #\u{179D8}; + #\u{179D9}; + #\u{179DA}; + #\u{179DB}; + #\u{179DC}; + #\u{179DD}; + #\u{179DE}; + #\u{179DF}; + #\u{179E0}; + #\u{179E1}; + #\u{179E2}; + #\u{179E3}; + #\u{179E4}; + #\u{179E5}; + #\u{179E6}; + #\u{179E7}; + #\u{179E8}; + #\u{179E9}; + #\u{179EA}; + #\u{179EB}; + #\u{179EC}; + #\u{179ED}; + #\u{179EE}; + #\u{179EF}; + #\u{179F0}; + #\u{179F1}; + #\u{179F2}; + #\u{179F3}; + #\u{179F4}; + #\u{179F5}; + #\u{179F6}; + #\u{179F7}; + #\u{179F8}; + #\u{179F9}; + #\u{179FA}; + #\u{179FB}; + #\u{179FC}; + #\u{179FD}; + #\u{179FE}; + #\u{179FF}; + #\u{17A00}; + #\u{17A01}; + #\u{17A02}; + #\u{17A03}; + #\u{17A04}; + #\u{17A05}; + #\u{17A06}; + #\u{17A07}; + #\u{17A08}; + #\u{17A09}; + #\u{17A0A}; + #\u{17A0B}; + #\u{17A0C}; + #\u{17A0D}; + #\u{17A0E}; + #\u{17A0F}; + #\u{17A10}; + #\u{17A11}; + #\u{17A12}; + #\u{17A13}; + #\u{17A14}; + #\u{17A15}; + #\u{17A16}; + #\u{17A17}; + #\u{17A18}; + #\u{17A19}; + #\u{17A1A}; + #\u{17A1B}; + #\u{17A1C}; + #\u{17A1D}; + #\u{17A1E}; + #\u{17A1F}; + #\u{17A20}; + #\u{17A21}; + #\u{17A22}; + #\u{17A23}; + #\u{17A24}; + #\u{17A25}; + #\u{17A26}; + #\u{17A27}; + #\u{17A28}; + #\u{17A29}; + #\u{17A2A}; + #\u{17A2B}; + #\u{17A2C}; + #\u{17A2D}; + #\u{17A2E}; + #\u{17A2F}; + #\u{17A30}; + #\u{17A31}; + #\u{17A32}; + #\u{17A33}; + #\u{17A34}; + #\u{17A35}; + #\u{17A36}; + #\u{17A37}; + #\u{17A38}; + #\u{17A39}; + #\u{17A3A}; + #\u{17A3B}; + #\u{17A3C}; + #\u{17A3D}; + #\u{17A3E}; + #\u{17A3F}; + #\u{17A40}; + #\u{17A41}; + #\u{17A42}; + #\u{17A43}; + #\u{17A44}; + #\u{17A45}; + #\u{17A46}; + #\u{17A47}; + #\u{17A48}; + #\u{17A49}; + #\u{17A4A}; + #\u{17A4B}; + #\u{17A4C}; + #\u{17A4D}; + #\u{17A4E}; + #\u{17A4F}; + #\u{17A50}; + #\u{17A51}; + #\u{17A52}; + #\u{17A53}; + #\u{17A54}; + #\u{17A55}; + #\u{17A56}; + #\u{17A57}; + #\u{17A58}; + #\u{17A59}; + #\u{17A5A}; + #\u{17A5B}; + #\u{17A5C}; + #\u{17A5D}; + #\u{17A5E}; + #\u{17A5F}; + #\u{17A60}; + #\u{17A61}; + #\u{17A62}; + #\u{17A63}; + #\u{17A64}; + #\u{17A65}; + #\u{17A66}; + #\u{17A67}; + #\u{17A68}; + #\u{17A69}; + #\u{17A6A}; + #\u{17A6B}; + #\u{17A6C}; + #\u{17A6D}; + #\u{17A6E}; + #\u{17A6F}; + #\u{17A70}; + #\u{17A71}; + #\u{17A72}; + #\u{17A73}; + #\u{17A74}; + #\u{17A75}; + #\u{17A76}; + #\u{17A77}; + #\u{17A78}; + #\u{17A79}; + #\u{17A7A}; + #\u{17A7B}; + #\u{17A7C}; + #\u{17A7D}; + #\u{17A7E}; + #\u{17A7F}; + #\u{17A80}; + #\u{17A81}; + #\u{17A82}; + #\u{17A83}; + #\u{17A84}; + #\u{17A85}; + #\u{17A86}; + #\u{17A87}; + #\u{17A88}; + #\u{17A89}; + #\u{17A8A}; + #\u{17A8B}; + #\u{17A8C}; + #\u{17A8D}; + #\u{17A8E}; + #\u{17A8F}; + #\u{17A90}; + #\u{17A91}; + #\u{17A92}; + #\u{17A93}; + #\u{17A94}; + #\u{17A95}; + #\u{17A96}; + #\u{17A97}; + #\u{17A98}; + #\u{17A99}; + #\u{17A9A}; + #\u{17A9B}; + #\u{17A9C}; + #\u{17A9D}; + #\u{17A9E}; + #\u{17A9F}; + #\u{17AA0}; + #\u{17AA1}; + #\u{17AA2}; + #\u{17AA3}; + #\u{17AA4}; + #\u{17AA5}; + #\u{17AA6}; + #\u{17AA7}; + #\u{17AA8}; + #\u{17AA9}; + #\u{17AAA}; + #\u{17AAB}; + #\u{17AAC}; + #\u{17AAD}; + #\u{17AAE}; + #\u{17AAF}; + #\u{17AB0}; + #\u{17AB1}; + #\u{17AB2}; + #\u{17AB3}; + #\u{17AB4}; + #\u{17AB5}; + #\u{17AB6}; + #\u{17AB7}; + #\u{17AB8}; + #\u{17AB9}; + #\u{17ABA}; + #\u{17ABB}; + #\u{17ABC}; + #\u{17ABD}; + #\u{17ABE}; + #\u{17ABF}; + #\u{17AC0}; + #\u{17AC1}; + #\u{17AC2}; + #\u{17AC3}; + #\u{17AC4}; + #\u{17AC5}; + #\u{17AC6}; + #\u{17AC7}; + #\u{17AC8}; + #\u{17AC9}; + #\u{17ACA}; + #\u{17ACB}; + #\u{17ACC}; + #\u{17ACD}; + #\u{17ACE}; + #\u{17ACF}; + #\u{17AD0}; + #\u{17AD1}; + #\u{17AD2}; + #\u{17AD3}; + #\u{17AD4}; + #\u{17AD5}; + #\u{17AD6}; + #\u{17AD7}; + #\u{17AD8}; + #\u{17AD9}; + #\u{17ADA}; + #\u{17ADB}; + #\u{17ADC}; + #\u{17ADD}; + #\u{17ADE}; + #\u{17ADF}; + #\u{17AE0}; + #\u{17AE1}; + #\u{17AE2}; + #\u{17AE3}; + #\u{17AE4}; + #\u{17AE5}; + #\u{17AE6}; + #\u{17AE7}; + #\u{17AE8}; + #\u{17AE9}; + #\u{17AEA}; + #\u{17AEB}; + #\u{17AEC}; + #\u{17AED}; + #\u{17AEE}; + #\u{17AEF}; + #\u{17AF0}; + #\u{17AF1}; + #\u{17AF2}; + #\u{17AF3}; + #\u{17AF4}; + #\u{17AF5}; + #\u{17AF6}; + #\u{17AF7}; + #\u{17AF8}; + #\u{17AF9}; + #\u{17AFA}; + #\u{17AFB}; + #\u{17AFC}; + #\u{17AFD}; + #\u{17AFE}; + #\u{17AFF}; + #\u{17B00}; + #\u{17B01}; + #\u{17B02}; + #\u{17B03}; + #\u{17B04}; + #\u{17B05}; + #\u{17B06}; + #\u{17B07}; + #\u{17B08}; + #\u{17B09}; + #\u{17B0A}; + #\u{17B0B}; + #\u{17B0C}; + #\u{17B0D}; + #\u{17B0E}; + #\u{17B0F}; + #\u{17B10}; + #\u{17B11}; + #\u{17B12}; + #\u{17B13}; + #\u{17B14}; + #\u{17B15}; + #\u{17B16}; + #\u{17B17}; + #\u{17B18}; + #\u{17B19}; + #\u{17B1A}; + #\u{17B1B}; + #\u{17B1C}; + #\u{17B1D}; + #\u{17B1E}; + #\u{17B1F}; + #\u{17B20}; + #\u{17B21}; + #\u{17B22}; + #\u{17B23}; + #\u{17B24}; + #\u{17B25}; + #\u{17B26}; + #\u{17B27}; + #\u{17B28}; + #\u{17B29}; + #\u{17B2A}; + #\u{17B2B}; + #\u{17B2C}; + #\u{17B2D}; + #\u{17B2E}; + #\u{17B2F}; + #\u{17B30}; + #\u{17B31}; + #\u{17B32}; + #\u{17B33}; + #\u{17B34}; + #\u{17B35}; + #\u{17B36}; + #\u{17B37}; + #\u{17B38}; + #\u{17B39}; + #\u{17B3A}; + #\u{17B3B}; + #\u{17B3C}; + #\u{17B3D}; + #\u{17B3E}; + #\u{17B3F}; + #\u{17B40}; + #\u{17B41}; + #\u{17B42}; + #\u{17B43}; + #\u{17B44}; + #\u{17B45}; + #\u{17B46}; + #\u{17B47}; + #\u{17B48}; + #\u{17B49}; + #\u{17B4A}; + #\u{17B4B}; + #\u{17B4C}; + #\u{17B4D}; + #\u{17B4E}; + #\u{17B4F}; + #\u{17B50}; + #\u{17B51}; + #\u{17B52}; + #\u{17B53}; + #\u{17B54}; + #\u{17B55}; + #\u{17B56}; + #\u{17B57}; + #\u{17B58}; + #\u{17B59}; + #\u{17B5A}; + #\u{17B5B}; + #\u{17B5C}; + #\u{17B5D}; + #\u{17B5E}; + #\u{17B5F}; + #\u{17B60}; + #\u{17B61}; + #\u{17B62}; + #\u{17B63}; + #\u{17B64}; + #\u{17B65}; + #\u{17B66}; + #\u{17B67}; + #\u{17B68}; + #\u{17B69}; + #\u{17B6A}; + #\u{17B6B}; + #\u{17B6C}; + #\u{17B6D}; + #\u{17B6E}; + #\u{17B6F}; + #\u{17B70}; + #\u{17B71}; + #\u{17B72}; + #\u{17B73}; + #\u{17B74}; + #\u{17B75}; + #\u{17B76}; + #\u{17B77}; + #\u{17B78}; + #\u{17B79}; + #\u{17B7A}; + #\u{17B7B}; + #\u{17B7C}; + #\u{17B7D}; + #\u{17B7E}; + #\u{17B7F}; + #\u{17B80}; + #\u{17B81}; + #\u{17B82}; + #\u{17B83}; + #\u{17B84}; + #\u{17B85}; + #\u{17B86}; + #\u{17B87}; + #\u{17B88}; + #\u{17B89}; + #\u{17B8A}; + #\u{17B8B}; + #\u{17B8C}; + #\u{17B8D}; + #\u{17B8E}; + #\u{17B8F}; + #\u{17B90}; + #\u{17B91}; + #\u{17B92}; + #\u{17B93}; + #\u{17B94}; + #\u{17B95}; + #\u{17B96}; + #\u{17B97}; + #\u{17B98}; + #\u{17B99}; + #\u{17B9A}; + #\u{17B9B}; + #\u{17B9C}; + #\u{17B9D}; + #\u{17B9E}; + #\u{17B9F}; + #\u{17BA0}; + #\u{17BA1}; + #\u{17BA2}; + #\u{17BA3}; + #\u{17BA4}; + #\u{17BA5}; + #\u{17BA6}; + #\u{17BA7}; + #\u{17BA8}; + #\u{17BA9}; + #\u{17BAA}; + #\u{17BAB}; + #\u{17BAC}; + #\u{17BAD}; + #\u{17BAE}; + #\u{17BAF}; + #\u{17BB0}; + #\u{17BB1}; + #\u{17BB2}; + #\u{17BB3}; + #\u{17BB4}; + #\u{17BB5}; + #\u{17BB6}; + #\u{17BB7}; + #\u{17BB8}; + #\u{17BB9}; + #\u{17BBA}; + #\u{17BBB}; + #\u{17BBC}; + #\u{17BBD}; + #\u{17BBE}; + #\u{17BBF}; + #\u{17BC0}; + #\u{17BC1}; + #\u{17BC2}; + #\u{17BC3}; + #\u{17BC4}; + #\u{17BC5}; + #\u{17BC6}; + #\u{17BC7}; + #\u{17BC8}; + #\u{17BC9}; + #\u{17BCA}; + #\u{17BCB}; + #\u{17BCC}; + #\u{17BCD}; + #\u{17BCE}; + #\u{17BCF}; + #\u{17BD0}; + #\u{17BD1}; + #\u{17BD2}; + #\u{17BD3}; + #\u{17BD4}; + #\u{17BD5}; + #\u{17BD6}; + #\u{17BD7}; + #\u{17BD8}; + #\u{17BD9}; + #\u{17BDA}; + #\u{17BDB}; + #\u{17BDC}; + #\u{17BDD}; + #\u{17BDE}; + #\u{17BDF}; + #\u{17BE0}; + #\u{17BE1}; + #\u{17BE2}; + #\u{17BE3}; + #\u{17BE4}; + #\u{17BE5}; + #\u{17BE6}; + #\u{17BE7}; + #\u{17BE8}; + #\u{17BE9}; + #\u{17BEA}; + #\u{17BEB}; + #\u{17BEC}; + #\u{17BED}; + #\u{17BEE}; + #\u{17BEF}; + #\u{17BF0}; + #\u{17BF1}; + #\u{17BF2}; + #\u{17BF3}; + #\u{17BF4}; + #\u{17BF5}; + #\u{17BF6}; + #\u{17BF7}; + #\u{17BF8}; + #\u{17BF9}; + #\u{17BFA}; + #\u{17BFB}; + #\u{17BFC}; + #\u{17BFD}; + #\u{17BFE}; + #\u{17BFF}; + #\u{17C00}; + #\u{17C01}; + #\u{17C02}; + #\u{17C03}; + #\u{17C04}; + #\u{17C05}; + #\u{17C06}; + #\u{17C07}; + #\u{17C08}; + #\u{17C09}; + #\u{17C0A}; + #\u{17C0B}; + #\u{17C0C}; + #\u{17C0D}; + #\u{17C0E}; + #\u{17C0F}; + #\u{17C10}; + #\u{17C11}; + #\u{17C12}; + #\u{17C13}; + #\u{17C14}; + #\u{17C15}; + #\u{17C16}; + #\u{17C17}; + #\u{17C18}; + #\u{17C19}; + #\u{17C1A}; + #\u{17C1B}; + #\u{17C1C}; + #\u{17C1D}; + #\u{17C1E}; + #\u{17C1F}; + #\u{17C20}; + #\u{17C21}; + #\u{17C22}; + #\u{17C23}; + #\u{17C24}; + #\u{17C25}; + #\u{17C26}; + #\u{17C27}; + #\u{17C28}; + #\u{17C29}; + #\u{17C2A}; + #\u{17C2B}; + #\u{17C2C}; + #\u{17C2D}; + #\u{17C2E}; + #\u{17C2F}; + #\u{17C30}; + #\u{17C31}; + #\u{17C32}; + #\u{17C33}; + #\u{17C34}; + #\u{17C35}; + #\u{17C36}; + #\u{17C37}; + #\u{17C38}; + #\u{17C39}; + #\u{17C3A}; + #\u{17C3B}; + #\u{17C3C}; + #\u{17C3D}; + #\u{17C3E}; + #\u{17C3F}; + #\u{17C40}; + #\u{17C41}; + #\u{17C42}; + #\u{17C43}; + #\u{17C44}; + #\u{17C45}; + #\u{17C46}; + #\u{17C47}; + #\u{17C48}; + #\u{17C49}; + #\u{17C4A}; + #\u{17C4B}; + #\u{17C4C}; + #\u{17C4D}; + #\u{17C4E}; + #\u{17C4F}; + #\u{17C50}; + #\u{17C51}; + #\u{17C52}; + #\u{17C53}; + #\u{17C54}; + #\u{17C55}; + #\u{17C56}; + #\u{17C57}; + #\u{17C58}; + #\u{17C59}; + #\u{17C5A}; + #\u{17C5B}; + #\u{17C5C}; + #\u{17C5D}; + #\u{17C5E}; + #\u{17C5F}; + #\u{17C60}; + #\u{17C61}; + #\u{17C62}; + #\u{17C63}; + #\u{17C64}; + #\u{17C65}; + #\u{17C66}; + #\u{17C67}; + #\u{17C68}; + #\u{17C69}; + #\u{17C6A}; + #\u{17C6B}; + #\u{17C6C}; + #\u{17C6D}; + #\u{17C6E}; + #\u{17C6F}; + #\u{17C70}; + #\u{17C71}; + #\u{17C72}; + #\u{17C73}; + #\u{17C74}; + #\u{17C75}; + #\u{17C76}; + #\u{17C77}; + #\u{17C78}; + #\u{17C79}; + #\u{17C7A}; + #\u{17C7B}; + #\u{17C7C}; + #\u{17C7D}; + #\u{17C7E}; + #\u{17C7F}; + #\u{17C80}; + #\u{17C81}; + #\u{17C82}; + #\u{17C83}; + #\u{17C84}; + #\u{17C85}; + #\u{17C86}; + #\u{17C87}; + #\u{17C88}; + #\u{17C89}; + #\u{17C8A}; + #\u{17C8B}; + #\u{17C8C}; + #\u{17C8D}; + #\u{17C8E}; + #\u{17C8F}; + #\u{17C90}; + #\u{17C91}; + #\u{17C92}; + #\u{17C93}; + #\u{17C94}; + #\u{17C95}; + #\u{17C96}; + #\u{17C97}; + #\u{17C98}; + #\u{17C99}; + #\u{17C9A}; + #\u{17C9B}; + #\u{17C9C}; + #\u{17C9D}; + #\u{17C9E}; + #\u{17C9F}; + #\u{17CA0}; + #\u{17CA1}; + #\u{17CA2}; + #\u{17CA3}; + #\u{17CA4}; + #\u{17CA5}; + #\u{17CA6}; + #\u{17CA7}; + #\u{17CA8}; + #\u{17CA9}; + #\u{17CAA}; + #\u{17CAB}; + #\u{17CAC}; + #\u{17CAD}; + #\u{17CAE}; + #\u{17CAF}; + #\u{17CB0}; + #\u{17CB1}; + #\u{17CB2}; + #\u{17CB3}; + #\u{17CB4}; + #\u{17CB5}; + #\u{17CB6}; + #\u{17CB7}; + #\u{17CB8}; + #\u{17CB9}; + #\u{17CBA}; + #\u{17CBB}; + #\u{17CBC}; + #\u{17CBD}; + #\u{17CBE}; + #\u{17CBF}; + #\u{17CC0}; + #\u{17CC1}; + #\u{17CC2}; + #\u{17CC3}; + #\u{17CC4}; + #\u{17CC5}; + #\u{17CC6}; + #\u{17CC7}; + #\u{17CC8}; + #\u{17CC9}; + #\u{17CCA}; + #\u{17CCB}; + #\u{17CCC}; + #\u{17CCD}; + #\u{17CCE}; + #\u{17CCF}; + #\u{17CD0}; + #\u{17CD1}; + #\u{17CD2}; + #\u{17CD3}; + #\u{17CD4}; + #\u{17CD5}; + #\u{17CD6}; + #\u{17CD7}; + #\u{17CD8}; + #\u{17CD9}; + #\u{17CDA}; + #\u{17CDB}; + #\u{17CDC}; + #\u{17CDD}; + #\u{17CDE}; + #\u{17CDF}; + #\u{17CE0}; + #\u{17CE1}; + #\u{17CE2}; + #\u{17CE3}; + #\u{17CE4}; + #\u{17CE5}; + #\u{17CE6}; + #\u{17CE7}; + #\u{17CE8}; + #\u{17CE9}; + #\u{17CEA}; + #\u{17CEB}; + #\u{17CEC}; + #\u{17CED}; + #\u{17CEE}; + #\u{17CEF}; + #\u{17CF0}; + #\u{17CF1}; + #\u{17CF2}; + #\u{17CF3}; + #\u{17CF4}; + #\u{17CF5}; + #\u{17CF6}; + #\u{17CF7}; + #\u{17CF8}; + #\u{17CF9}; + #\u{17CFA}; + #\u{17CFB}; + #\u{17CFC}; + #\u{17CFD}; + #\u{17CFE}; + #\u{17CFF}; + #\u{17D00}; + #\u{17D01}; + #\u{17D02}; + #\u{17D03}; + #\u{17D04}; + #\u{17D05}; + #\u{17D06}; + #\u{17D07}; + #\u{17D08}; + #\u{17D09}; + #\u{17D0A}; + #\u{17D0B}; + #\u{17D0C}; + #\u{17D0D}; + #\u{17D0E}; + #\u{17D0F}; + #\u{17D10}; + #\u{17D11}; + #\u{17D12}; + #\u{17D13}; + #\u{17D14}; + #\u{17D15}; + #\u{17D16}; + #\u{17D17}; + #\u{17D18}; + #\u{17D19}; + #\u{17D1A}; + #\u{17D1B}; + #\u{17D1C}; + #\u{17D1D}; + #\u{17D1E}; + #\u{17D1F}; + #\u{17D20}; + #\u{17D21}; + #\u{17D22}; + #\u{17D23}; + #\u{17D24}; + #\u{17D25}; + #\u{17D26}; + #\u{17D27}; + #\u{17D28}; + #\u{17D29}; + #\u{17D2A}; + #\u{17D2B}; + #\u{17D2C}; + #\u{17D2D}; + #\u{17D2E}; + #\u{17D2F}; + #\u{17D30}; + #\u{17D31}; + #\u{17D32}; + #\u{17D33}; + #\u{17D34}; + #\u{17D35}; + #\u{17D36}; + #\u{17D37}; + #\u{17D38}; + #\u{17D39}; + #\u{17D3A}; + #\u{17D3B}; + #\u{17D3C}; + #\u{17D3D}; + #\u{17D3E}; + #\u{17D3F}; + #\u{17D40}; + #\u{17D41}; + #\u{17D42}; + #\u{17D43}; + #\u{17D44}; + #\u{17D45}; + #\u{17D46}; + #\u{17D47}; + #\u{17D48}; + #\u{17D49}; + #\u{17D4A}; + #\u{17D4B}; + #\u{17D4C}; + #\u{17D4D}; + #\u{17D4E}; + #\u{17D4F}; + #\u{17D50}; + #\u{17D51}; + #\u{17D52}; + #\u{17D53}; + #\u{17D54}; + #\u{17D55}; + #\u{17D56}; + #\u{17D57}; + #\u{17D58}; + #\u{17D59}; + #\u{17D5A}; + #\u{17D5B}; + #\u{17D5C}; + #\u{17D5D}; + #\u{17D5E}; + #\u{17D5F}; + #\u{17D60}; + #\u{17D61}; + #\u{17D62}; + #\u{17D63}; + #\u{17D64}; + #\u{17D65}; + #\u{17D66}; + #\u{17D67}; + #\u{17D68}; + #\u{17D69}; + #\u{17D6A}; + #\u{17D6B}; + #\u{17D6C}; + #\u{17D6D}; + #\u{17D6E}; + #\u{17D6F}; + #\u{17D70}; + #\u{17D71}; + #\u{17D72}; + #\u{17D73}; + #\u{17D74}; + #\u{17D75}; + #\u{17D76}; + #\u{17D77}; + #\u{17D78}; + #\u{17D79}; + #\u{17D7A}; + #\u{17D7B}; + #\u{17D7C}; + #\u{17D7D}; + #\u{17D7E}; + #\u{17D7F}; + #\u{17D80}; + #\u{17D81}; + #\u{17D82}; + #\u{17D83}; + #\u{17D84}; + #\u{17D85}; + #\u{17D86}; + #\u{17D87}; + #\u{17D88}; + #\u{17D89}; + #\u{17D8A}; + #\u{17D8B}; + #\u{17D8C}; + #\u{17D8D}; + #\u{17D8E}; + #\u{17D8F}; + #\u{17D90}; + #\u{17D91}; + #\u{17D92}; + #\u{17D93}; + #\u{17D94}; + #\u{17D95}; + #\u{17D96}; + #\u{17D97}; + #\u{17D98}; + #\u{17D99}; + #\u{17D9A}; + #\u{17D9B}; + #\u{17D9C}; + #\u{17D9D}; + #\u{17D9E}; + #\u{17D9F}; + #\u{17DA0}; + #\u{17DA1}; + #\u{17DA2}; + #\u{17DA3}; + #\u{17DA4}; + #\u{17DA5}; + #\u{17DA6}; + #\u{17DA7}; + #\u{17DA8}; + #\u{17DA9}; + #\u{17DAA}; + #\u{17DAB}; + #\u{17DAC}; + #\u{17DAD}; + #\u{17DAE}; + #\u{17DAF}; + #\u{17DB0}; + #\u{17DB1}; + #\u{17DB2}; + #\u{17DB3}; + #\u{17DB4}; + #\u{17DB5}; + #\u{17DB6}; + #\u{17DB7}; + #\u{17DB8}; + #\u{17DB9}; + #\u{17DBA}; + #\u{17DBB}; + #\u{17DBC}; + #\u{17DBD}; + #\u{17DBE}; + #\u{17DBF}; + #\u{17DC0}; + #\u{17DC1}; + #\u{17DC2}; + #\u{17DC3}; + #\u{17DC4}; + #\u{17DC5}; + #\u{17DC6}; + #\u{17DC7}; + #\u{17DC8}; + #\u{17DC9}; + #\u{17DCA}; + #\u{17DCB}; + #\u{17DCC}; + #\u{17DCD}; + #\u{17DCE}; + #\u{17DCF}; + #\u{17DD0}; + #\u{17DD1}; + #\u{17DD2}; + #\u{17DD3}; + #\u{17DD4}; + #\u{17DD5}; + #\u{17DD6}; + #\u{17DD7}; + #\u{17DD8}; + #\u{17DD9}; + #\u{17DDA}; + #\u{17DDB}; + #\u{17DDC}; + #\u{17DDD}; + #\u{17DDE}; + #\u{17DDF}; + #\u{17DE0}; + #\u{17DE1}; + #\u{17DE2}; + #\u{17DE3}; + #\u{17DE4}; + #\u{17DE5}; + #\u{17DE6}; + #\u{17DE7}; + #\u{17DE8}; + #\u{17DE9}; + #\u{17DEA}; + #\u{17DEB}; + #\u{17DEC}; + #\u{17DED}; + #\u{17DEE}; + #\u{17DEF}; + #\u{17DF0}; + #\u{17DF1}; + #\u{17DF2}; + #\u{17DF3}; + #\u{17DF4}; + #\u{17DF5}; + #\u{17DF6}; + #\u{17DF7}; + #\u{17DF8}; + #\u{17DF9}; + #\u{17DFA}; + #\u{17DFB}; + #\u{17DFC}; + #\u{17DFD}; + #\u{17DFE}; + #\u{17DFF}; + #\u{17E00}; + #\u{17E01}; + #\u{17E02}; + #\u{17E03}; + #\u{17E04}; + #\u{17E05}; + #\u{17E06}; + #\u{17E07}; + #\u{17E08}; + #\u{17E09}; + #\u{17E0A}; + #\u{17E0B}; + #\u{17E0C}; + #\u{17E0D}; + #\u{17E0E}; + #\u{17E0F}; + #\u{17E10}; + #\u{17E11}; + #\u{17E12}; + #\u{17E13}; + #\u{17E14}; + #\u{17E15}; + #\u{17E16}; + #\u{17E17}; + #\u{17E18}; + #\u{17E19}; + #\u{17E1A}; + #\u{17E1B}; + #\u{17E1C}; + #\u{17E1D}; + #\u{17E1E}; + #\u{17E1F}; + #\u{17E20}; + #\u{17E21}; + #\u{17E22}; + #\u{17E23}; + #\u{17E24}; + #\u{17E25}; + #\u{17E26}; + #\u{17E27}; + #\u{17E28}; + #\u{17E29}; + #\u{17E2A}; + #\u{17E2B}; + #\u{17E2C}; + #\u{17E2D}; + #\u{17E2E}; + #\u{17E2F}; + #\u{17E30}; + #\u{17E31}; + #\u{17E32}; + #\u{17E33}; + #\u{17E34}; + #\u{17E35}; + #\u{17E36}; + #\u{17E37}; + #\u{17E38}; + #\u{17E39}; + #\u{17E3A}; + #\u{17E3B}; + #\u{17E3C}; + #\u{17E3D}; + #\u{17E3E}; + #\u{17E3F}; + #\u{17E40}; + #\u{17E41}; + #\u{17E42}; + #\u{17E43}; + #\u{17E44}; + #\u{17E45}; + #\u{17E46}; + #\u{17E47}; + #\u{17E48}; + #\u{17E49}; + #\u{17E4A}; + #\u{17E4B}; + #\u{17E4C}; + #\u{17E4D}; + #\u{17E4E}; + #\u{17E4F}; + #\u{17E50}; + #\u{17E51}; + #\u{17E52}; + #\u{17E53}; + #\u{17E54}; + #\u{17E55}; + #\u{17E56}; + #\u{17E57}; + #\u{17E58}; + #\u{17E59}; + #\u{17E5A}; + #\u{17E5B}; + #\u{17E5C}; + #\u{17E5D}; + #\u{17E5E}; + #\u{17E5F}; + #\u{17E60}; + #\u{17E61}; + #\u{17E62}; + #\u{17E63}; + #\u{17E64}; + #\u{17E65}; + #\u{17E66}; + #\u{17E67}; + #\u{17E68}; + #\u{17E69}; + #\u{17E6A}; + #\u{17E6B}; + #\u{17E6C}; + #\u{17E6D}; + #\u{17E6E}; + #\u{17E6F}; + #\u{17E70}; + #\u{17E71}; + #\u{17E72}; + #\u{17E73}; + #\u{17E74}; + #\u{17E75}; + #\u{17E76}; + #\u{17E77}; + #\u{17E78}; + #\u{17E79}; + #\u{17E7A}; + #\u{17E7B}; + #\u{17E7C}; + #\u{17E7D}; + #\u{17E7E}; + #\u{17E7F}; + #\u{17E80}; + #\u{17E81}; + #\u{17E82}; + #\u{17E83}; + #\u{17E84}; + #\u{17E85}; + #\u{17E86}; + #\u{17E87}; + #\u{17E88}; + #\u{17E89}; + #\u{17E8A}; + #\u{17E8B}; + #\u{17E8C}; + #\u{17E8D}; + #\u{17E8E}; + #\u{17E8F}; + #\u{17E90}; + #\u{17E91}; + #\u{17E92}; + #\u{17E93}; + #\u{17E94}; + #\u{17E95}; + #\u{17E96}; + #\u{17E97}; + #\u{17E98}; + #\u{17E99}; + #\u{17E9A}; + #\u{17E9B}; + #\u{17E9C}; + #\u{17E9D}; + #\u{17E9E}; + #\u{17E9F}; + #\u{17EA0}; + #\u{17EA1}; + #\u{17EA2}; + #\u{17EA3}; + #\u{17EA4}; + #\u{17EA5}; + #\u{17EA6}; + #\u{17EA7}; + #\u{17EA8}; + #\u{17EA9}; + #\u{17EAA}; + #\u{17EAB}; + #\u{17EAC}; + #\u{17EAD}; + #\u{17EAE}; + #\u{17EAF}; + #\u{17EB0}; + #\u{17EB1}; + #\u{17EB2}; + #\u{17EB3}; + #\u{17EB4}; + #\u{17EB5}; + #\u{17EB6}; + #\u{17EB7}; + #\u{17EB8}; + #\u{17EB9}; + #\u{17EBA}; + #\u{17EBB}; + #\u{17EBC}; + #\u{17EBD}; + #\u{17EBE}; + #\u{17EBF}; + #\u{17EC0}; + #\u{17EC1}; + #\u{17EC2}; + #\u{17EC3}; + #\u{17EC4}; + #\u{17EC5}; + #\u{17EC6}; + #\u{17EC7}; + #\u{17EC8}; + #\u{17EC9}; + #\u{17ECA}; + #\u{17ECB}; + #\u{17ECC}; + #\u{17ECD}; + #\u{17ECE}; + #\u{17ECF}; + #\u{17ED0}; + #\u{17ED1}; + #\u{17ED2}; + #\u{17ED3}; + #\u{17ED4}; + #\u{17ED5}; + #\u{17ED6}; + #\u{17ED7}; + #\u{17ED8}; + #\u{17ED9}; + #\u{17EDA}; + #\u{17EDB}; + #\u{17EDC}; + #\u{17EDD}; + #\u{17EDE}; + #\u{17EDF}; + #\u{17EE0}; + #\u{17EE1}; + #\u{17EE2}; + #\u{17EE3}; + #\u{17EE4}; + #\u{17EE5}; + #\u{17EE6}; + #\u{17EE7}; + #\u{17EE8}; + #\u{17EE9}; + #\u{17EEA}; + #\u{17EEB}; + #\u{17EEC}; + #\u{17EED}; + #\u{17EEE}; + #\u{17EEF}; + #\u{17EF0}; + #\u{17EF1}; + #\u{17EF2}; + #\u{17EF3}; + #\u{17EF4}; + #\u{17EF5}; + #\u{17EF6}; + #\u{17EF7}; + #\u{17EF8}; + #\u{17EF9}; + #\u{17EFA}; + #\u{17EFB}; + #\u{17EFC}; + #\u{17EFD}; + #\u{17EFE}; + #\u{17EFF}; + #\u{17F00}; + #\u{17F01}; + #\u{17F02}; + #\u{17F03}; + #\u{17F04}; + #\u{17F05}; + #\u{17F06}; + #\u{17F07}; + #\u{17F08}; + #\u{17F09}; + #\u{17F0A}; + #\u{17F0B}; + #\u{17F0C}; + #\u{17F0D}; + #\u{17F0E}; + #\u{17F0F}; + #\u{17F10}; + #\u{17F11}; + #\u{17F12}; + #\u{17F13}; + #\u{17F14}; + #\u{17F15}; + #\u{17F16}; + #\u{17F17}; + #\u{17F18}; + #\u{17F19}; + #\u{17F1A}; + #\u{17F1B}; + #\u{17F1C}; + #\u{17F1D}; + #\u{17F1E}; + #\u{17F1F}; + #\u{17F20}; + #\u{17F21}; + #\u{17F22}; + #\u{17F23}; + #\u{17F24}; + #\u{17F25}; + #\u{17F26}; + #\u{17F27}; + #\u{17F28}; + #\u{17F29}; + #\u{17F2A}; + #\u{17F2B}; + #\u{17F2C}; + #\u{17F2D}; + #\u{17F2E}; + #\u{17F2F}; + #\u{17F30}; + #\u{17F31}; + #\u{17F32}; + #\u{17F33}; + #\u{17F34}; + #\u{17F35}; + #\u{17F36}; + #\u{17F37}; + #\u{17F38}; + #\u{17F39}; + #\u{17F3A}; + #\u{17F3B}; + #\u{17F3C}; + #\u{17F3D}; + #\u{17F3E}; + #\u{17F3F}; + #\u{17F40}; + #\u{17F41}; + #\u{17F42}; + #\u{17F43}; + #\u{17F44}; + #\u{17F45}; + #\u{17F46}; + #\u{17F47}; + #\u{17F48}; + #\u{17F49}; + #\u{17F4A}; + #\u{17F4B}; + #\u{17F4C}; + #\u{17F4D}; + #\u{17F4E}; + #\u{17F4F}; + #\u{17F50}; + #\u{17F51}; + #\u{17F52}; + #\u{17F53}; + #\u{17F54}; + #\u{17F55}; + #\u{17F56}; + #\u{17F57}; + #\u{17F58}; + #\u{17F59}; + #\u{17F5A}; + #\u{17F5B}; + #\u{17F5C}; + #\u{17F5D}; + #\u{17F5E}; + #\u{17F5F}; + #\u{17F60}; + #\u{17F61}; + #\u{17F62}; + #\u{17F63}; + #\u{17F64}; + #\u{17F65}; + #\u{17F66}; + #\u{17F67}; + #\u{17F68}; + #\u{17F69}; + #\u{17F6A}; + #\u{17F6B}; + #\u{17F6C}; + #\u{17F6D}; + #\u{17F6E}; + #\u{17F6F}; + #\u{17F70}; + #\u{17F71}; + #\u{17F72}; + #\u{17F73}; + #\u{17F74}; + #\u{17F75}; + #\u{17F76}; + #\u{17F77}; + #\u{17F78}; + #\u{17F79}; + #\u{17F7A}; + #\u{17F7B}; + #\u{17F7C}; + #\u{17F7D}; + #\u{17F7E}; + #\u{17F7F}; + #\u{17F80}; + #\u{17F81}; + #\u{17F82}; + #\u{17F83}; + #\u{17F84}; + #\u{17F85}; + #\u{17F86}; + #\u{17F87}; + #\u{17F88}; + #\u{17F89}; + #\u{17F8A}; + #\u{17F8B}; + #\u{17F8C}; + #\u{17F8D}; + #\u{17F8E}; + #\u{17F8F}; + #\u{17F90}; + #\u{17F91}; + #\u{17F92}; + #\u{17F93}; + #\u{17F94}; + #\u{17F95}; + #\u{17F96}; + #\u{17F97}; + #\u{17F98}; + #\u{17F99}; + #\u{17F9A}; + #\u{17F9B}; + #\u{17F9C}; + #\u{17F9D}; + #\u{17F9E}; + #\u{17F9F}; + #\u{17FA0}; + #\u{17FA1}; + #\u{17FA2}; + #\u{17FA3}; + #\u{17FA4}; + #\u{17FA5}; + #\u{17FA6}; + #\u{17FA7}; + #\u{17FA8}; + #\u{17FA9}; + #\u{17FAA}; + #\u{17FAB}; + #\u{17FAC}; + #\u{17FAD}; + #\u{17FAE}; + #\u{17FAF}; + #\u{17FB0}; + #\u{17FB1}; + #\u{17FB2}; + #\u{17FB3}; + #\u{17FB4}; + #\u{17FB5}; + #\u{17FB6}; + #\u{17FB7}; + #\u{17FB8}; + #\u{17FB9}; + #\u{17FBA}; + #\u{17FBB}; + #\u{17FBC}; + #\u{17FBD}; + #\u{17FBE}; + #\u{17FBF}; + #\u{17FC0}; + #\u{17FC1}; + #\u{17FC2}; + #\u{17FC3}; + #\u{17FC4}; + #\u{17FC5}; + #\u{17FC6}; + #\u{17FC7}; + #\u{17FC8}; + #\u{17FC9}; + #\u{17FCA}; + #\u{17FCB}; + #\u{17FCC}; + #\u{17FCD}; + #\u{17FCE}; + #\u{17FCF}; + #\u{17FD0}; + #\u{17FD1}; + #\u{17FD2}; + #\u{17FD3}; + #\u{17FD4}; + #\u{17FD5}; + #\u{17FD6}; + #\u{17FD7}; + #\u{17FD8}; + #\u{17FD9}; + #\u{17FDA}; + #\u{17FDB}; + #\u{17FDC}; + #\u{17FDD}; + #\u{17FDE}; + #\u{17FDF}; + #\u{17FE0}; + #\u{17FE1}; + #\u{17FE2}; + #\u{17FE3}; + #\u{17FE4}; + #\u{17FE5}; + #\u{17FE6}; + #\u{17FE7}; + #\u{17FE8}; + #\u{17FE9}; + #\u{17FEA}; + #\u{17FEB}; + #\u{17FEC}; + #\u{17FED}; + #\u{17FEE}; + #\u{17FEF}; + #\u{17FF0}; + #\u{17FF1}; + #\u{17FF2}; + #\u{17FF3}; + #\u{17FF4}; + #\u{17FF5}; + #\u{17FF6}; + #\u{17FF7}; + #\u{17FF8}; + #\u{17FF9}; + #\u{17FFA}; + #\u{17FFB}; + #\u{17FFC}; + #\u{17FFD}; + #\u{17FFE}; + #\u{17FFF}; + #\u{18000}; + #\u{18001}; + #\u{18002}; + #\u{18003}; + #\u{18004}; + #\u{18005}; + #\u{18006}; + #\u{18007}; + #\u{18008}; + #\u{18009}; + #\u{1800A}; + #\u{1800B}; + #\u{1800C}; + #\u{1800D}; + #\u{1800E}; + #\u{1800F}; + #\u{18010}; + #\u{18011}; + #\u{18012}; + #\u{18013}; + #\u{18014}; + #\u{18015}; + #\u{18016}; + #\u{18017}; + #\u{18018}; + #\u{18019}; + #\u{1801A}; + #\u{1801B}; + #\u{1801C}; + #\u{1801D}; + #\u{1801E}; + #\u{1801F}; + #\u{18020}; + #\u{18021}; + #\u{18022}; + #\u{18023}; + #\u{18024}; + #\u{18025}; + #\u{18026}; + #\u{18027}; + #\u{18028}; + #\u{18029}; + #\u{1802A}; + #\u{1802B}; + #\u{1802C}; + #\u{1802D}; + #\u{1802E}; + #\u{1802F}; + #\u{18030}; + #\u{18031}; + #\u{18032}; + #\u{18033}; + #\u{18034}; + #\u{18035}; + #\u{18036}; + #\u{18037}; + #\u{18038}; + #\u{18039}; + #\u{1803A}; + #\u{1803B}; + #\u{1803C}; + #\u{1803D}; + #\u{1803E}; + #\u{1803F}; + #\u{18040}; + #\u{18041}; + #\u{18042}; + #\u{18043}; + #\u{18044}; + #\u{18045}; + #\u{18046}; + #\u{18047}; + #\u{18048}; + #\u{18049}; + #\u{1804A}; + #\u{1804B}; + #\u{1804C}; + #\u{1804D}; + #\u{1804E}; + #\u{1804F}; + #\u{18050}; + #\u{18051}; + #\u{18052}; + #\u{18053}; + #\u{18054}; + #\u{18055}; + #\u{18056}; + #\u{18057}; + #\u{18058}; + #\u{18059}; + #\u{1805A}; + #\u{1805B}; + #\u{1805C}; + #\u{1805D}; + #\u{1805E}; + #\u{1805F}; + #\u{18060}; + #\u{18061}; + #\u{18062}; + #\u{18063}; + #\u{18064}; + #\u{18065}; + #\u{18066}; + #\u{18067}; + #\u{18068}; + #\u{18069}; + #\u{1806A}; + #\u{1806B}; + #\u{1806C}; + #\u{1806D}; + #\u{1806E}; + #\u{1806F}; + #\u{18070}; + #\u{18071}; + #\u{18072}; + #\u{18073}; + #\u{18074}; + #\u{18075}; + #\u{18076}; + #\u{18077}; + #\u{18078}; + #\u{18079}; + #\u{1807A}; + #\u{1807B}; + #\u{1807C}; + #\u{1807D}; + #\u{1807E}; + #\u{1807F}; + #\u{18080}; + #\u{18081}; + #\u{18082}; + #\u{18083}; + #\u{18084}; + #\u{18085}; + #\u{18086}; + #\u{18087}; + #\u{18088}; + #\u{18089}; + #\u{1808A}; + #\u{1808B}; + #\u{1808C}; + #\u{1808D}; + #\u{1808E}; + #\u{1808F}; + #\u{18090}; + #\u{18091}; + #\u{18092}; + #\u{18093}; + #\u{18094}; + #\u{18095}; + #\u{18096}; + #\u{18097}; + #\u{18098}; + #\u{18099}; + #\u{1809A}; + #\u{1809B}; + #\u{1809C}; + #\u{1809D}; + #\u{1809E}; + #\u{1809F}; + #\u{180A0}; + #\u{180A1}; + #\u{180A2}; + #\u{180A3}; + #\u{180A4}; + #\u{180A5}; + #\u{180A6}; + #\u{180A7}; + #\u{180A8}; + #\u{180A9}; + #\u{180AA}; + #\u{180AB}; + #\u{180AC}; + #\u{180AD}; + #\u{180AE}; + #\u{180AF}; + #\u{180B0}; + #\u{180B1}; + #\u{180B2}; + #\u{180B3}; + #\u{180B4}; + #\u{180B5}; + #\u{180B6}; + #\u{180B7}; + #\u{180B8}; + #\u{180B9}; + #\u{180BA}; + #\u{180BB}; + #\u{180BC}; + #\u{180BD}; + #\u{180BE}; + #\u{180BF}; + #\u{180C0}; + #\u{180C1}; + #\u{180C2}; + #\u{180C3}; + #\u{180C4}; + #\u{180C5}; + #\u{180C6}; + #\u{180C7}; + #\u{180C8}; + #\u{180C9}; + #\u{180CA}; + #\u{180CB}; + #\u{180CC}; + #\u{180CD}; + #\u{180CE}; + #\u{180CF}; + #\u{180D0}; + #\u{180D1}; + #\u{180D2}; + #\u{180D3}; + #\u{180D4}; + #\u{180D5}; + #\u{180D6}; + #\u{180D7}; + #\u{180D8}; + #\u{180D9}; + #\u{180DA}; + #\u{180DB}; + #\u{180DC}; + #\u{180DD}; + #\u{180DE}; + #\u{180DF}; + #\u{180E0}; + #\u{180E1}; + #\u{180E2}; + #\u{180E3}; + #\u{180E4}; + #\u{180E5}; + #\u{180E6}; + #\u{180E7}; + #\u{180E8}; + #\u{180E9}; + #\u{180EA}; + #\u{180EB}; + #\u{180EC}; + #\u{180ED}; + #\u{180EE}; + #\u{180EF}; + #\u{180F0}; + #\u{180F1}; + #\u{180F2}; + #\u{180F3}; + #\u{180F4}; + #\u{180F5}; + #\u{180F6}; + #\u{180F7}; + #\u{180F8}; + #\u{180F9}; + #\u{180FA}; + #\u{180FB}; + #\u{180FC}; + #\u{180FD}; + #\u{180FE}; + #\u{180FF}; + #\u{18100}; + #\u{18101}; + #\u{18102}; + #\u{18103}; + #\u{18104}; + #\u{18105}; + #\u{18106}; + #\u{18107}; + #\u{18108}; + #\u{18109}; + #\u{1810A}; + #\u{1810B}; + #\u{1810C}; + #\u{1810D}; + #\u{1810E}; + #\u{1810F}; + #\u{18110}; + #\u{18111}; + #\u{18112}; + #\u{18113}; + #\u{18114}; + #\u{18115}; + #\u{18116}; + #\u{18117}; + #\u{18118}; + #\u{18119}; + #\u{1811A}; + #\u{1811B}; + #\u{1811C}; + #\u{1811D}; + #\u{1811E}; + #\u{1811F}; + #\u{18120}; + #\u{18121}; + #\u{18122}; + #\u{18123}; + #\u{18124}; + #\u{18125}; + #\u{18126}; + #\u{18127}; + #\u{18128}; + #\u{18129}; + #\u{1812A}; + #\u{1812B}; + #\u{1812C}; + #\u{1812D}; + #\u{1812E}; + #\u{1812F}; + #\u{18130}; + #\u{18131}; + #\u{18132}; + #\u{18133}; + #\u{18134}; + #\u{18135}; + #\u{18136}; + #\u{18137}; + #\u{18138}; + #\u{18139}; + #\u{1813A}; + #\u{1813B}; + #\u{1813C}; + #\u{1813D}; + #\u{1813E}; + #\u{1813F}; + #\u{18140}; + #\u{18141}; + #\u{18142}; + #\u{18143}; + #\u{18144}; + #\u{18145}; + #\u{18146}; + #\u{18147}; + #\u{18148}; + #\u{18149}; + #\u{1814A}; + #\u{1814B}; + #\u{1814C}; + #\u{1814D}; + #\u{1814E}; + #\u{1814F}; + #\u{18150}; + #\u{18151}; + #\u{18152}; + #\u{18153}; + #\u{18154}; + #\u{18155}; + #\u{18156}; + #\u{18157}; + #\u{18158}; + #\u{18159}; + #\u{1815A}; + #\u{1815B}; + #\u{1815C}; + #\u{1815D}; + #\u{1815E}; + #\u{1815F}; + #\u{18160}; + #\u{18161}; + #\u{18162}; + #\u{18163}; + #\u{18164}; + #\u{18165}; + #\u{18166}; + #\u{18167}; + #\u{18168}; + #\u{18169}; + #\u{1816A}; + #\u{1816B}; + #\u{1816C}; + #\u{1816D}; + #\u{1816E}; + #\u{1816F}; + #\u{18170}; + #\u{18171}; + #\u{18172}; + #\u{18173}; + #\u{18174}; + #\u{18175}; + #\u{18176}; + #\u{18177}; + #\u{18178}; + #\u{18179}; + #\u{1817A}; + #\u{1817B}; + #\u{1817C}; + #\u{1817D}; + #\u{1817E}; + #\u{1817F}; + #\u{18180}; + #\u{18181}; + #\u{18182}; + #\u{18183}; + #\u{18184}; + #\u{18185}; + #\u{18186}; + #\u{18187}; + #\u{18188}; + #\u{18189}; + #\u{1818A}; + #\u{1818B}; + #\u{1818C}; + #\u{1818D}; + #\u{1818E}; + #\u{1818F}; + #\u{18190}; + #\u{18191}; + #\u{18192}; + #\u{18193}; + #\u{18194}; + #\u{18195}; + #\u{18196}; + #\u{18197}; + #\u{18198}; + #\u{18199}; + #\u{1819A}; + #\u{1819B}; + #\u{1819C}; + #\u{1819D}; + #\u{1819E}; + #\u{1819F}; + #\u{181A0}; + #\u{181A1}; + #\u{181A2}; + #\u{181A3}; + #\u{181A4}; + #\u{181A5}; + #\u{181A6}; + #\u{181A7}; + #\u{181A8}; + #\u{181A9}; + #\u{181AA}; + #\u{181AB}; + #\u{181AC}; + #\u{181AD}; + #\u{181AE}; + #\u{181AF}; + #\u{181B0}; + #\u{181B1}; + #\u{181B2}; + #\u{181B3}; + #\u{181B4}; + #\u{181B5}; + #\u{181B6}; + #\u{181B7}; + #\u{181B8}; + #\u{181B9}; + #\u{181BA}; + #\u{181BB}; + #\u{181BC}; + #\u{181BD}; + #\u{181BE}; + #\u{181BF}; + #\u{181C0}; + #\u{181C1}; + #\u{181C2}; + #\u{181C3}; + #\u{181C4}; + #\u{181C5}; + #\u{181C6}; + #\u{181C7}; + #\u{181C8}; + #\u{181C9}; + #\u{181CA}; + #\u{181CB}; + #\u{181CC}; + #\u{181CD}; + #\u{181CE}; + #\u{181CF}; + #\u{181D0}; + #\u{181D1}; + #\u{181D2}; + #\u{181D3}; + #\u{181D4}; + #\u{181D5}; + #\u{181D6}; + #\u{181D7}; + #\u{181D8}; + #\u{181D9}; + #\u{181DA}; + #\u{181DB}; + #\u{181DC}; + #\u{181DD}; + #\u{181DE}; + #\u{181DF}; + #\u{181E0}; + #\u{181E1}; + #\u{181E2}; + #\u{181E3}; + #\u{181E4}; + #\u{181E5}; + #\u{181E6}; + #\u{181E7}; + #\u{181E8}; + #\u{181E9}; + #\u{181EA}; + #\u{181EB}; + #\u{181EC}; + #\u{181ED}; + #\u{181EE}; + #\u{181EF}; + #\u{181F0}; + #\u{181F1}; + #\u{181F2}; + #\u{181F3}; + #\u{181F4}; + #\u{181F5}; + #\u{181F6}; + #\u{181F7}; + #\u{181F8}; + #\u{181F9}; + #\u{181FA}; + #\u{181FB}; + #\u{181FC}; + #\u{181FD}; + #\u{181FE}; + #\u{181FF}; + #\u{18200}; + #\u{18201}; + #\u{18202}; + #\u{18203}; + #\u{18204}; + #\u{18205}; + #\u{18206}; + #\u{18207}; + #\u{18208}; + #\u{18209}; + #\u{1820A}; + #\u{1820B}; + #\u{1820C}; + #\u{1820D}; + #\u{1820E}; + #\u{1820F}; + #\u{18210}; + #\u{18211}; + #\u{18212}; + #\u{18213}; + #\u{18214}; + #\u{18215}; + #\u{18216}; + #\u{18217}; + #\u{18218}; + #\u{18219}; + #\u{1821A}; + #\u{1821B}; + #\u{1821C}; + #\u{1821D}; + #\u{1821E}; + #\u{1821F}; + #\u{18220}; + #\u{18221}; + #\u{18222}; + #\u{18223}; + #\u{18224}; + #\u{18225}; + #\u{18226}; + #\u{18227}; + #\u{18228}; + #\u{18229}; + #\u{1822A}; + #\u{1822B}; + #\u{1822C}; + #\u{1822D}; + #\u{1822E}; + #\u{1822F}; + #\u{18230}; + #\u{18231}; + #\u{18232}; + #\u{18233}; + #\u{18234}; + #\u{18235}; + #\u{18236}; + #\u{18237}; + #\u{18238}; + #\u{18239}; + #\u{1823A}; + #\u{1823B}; + #\u{1823C}; + #\u{1823D}; + #\u{1823E}; + #\u{1823F}; + #\u{18240}; + #\u{18241}; + #\u{18242}; + #\u{18243}; + #\u{18244}; + #\u{18245}; + #\u{18246}; + #\u{18247}; + #\u{18248}; + #\u{18249}; + #\u{1824A}; + #\u{1824B}; + #\u{1824C}; + #\u{1824D}; + #\u{1824E}; + #\u{1824F}; + #\u{18250}; + #\u{18251}; + #\u{18252}; + #\u{18253}; + #\u{18254}; + #\u{18255}; + #\u{18256}; + #\u{18257}; + #\u{18258}; + #\u{18259}; + #\u{1825A}; + #\u{1825B}; + #\u{1825C}; + #\u{1825D}; + #\u{1825E}; + #\u{1825F}; + #\u{18260}; + #\u{18261}; + #\u{18262}; + #\u{18263}; + #\u{18264}; + #\u{18265}; + #\u{18266}; + #\u{18267}; + #\u{18268}; + #\u{18269}; + #\u{1826A}; + #\u{1826B}; + #\u{1826C}; + #\u{1826D}; + #\u{1826E}; + #\u{1826F}; + #\u{18270}; + #\u{18271}; + #\u{18272}; + #\u{18273}; + #\u{18274}; + #\u{18275}; + #\u{18276}; + #\u{18277}; + #\u{18278}; + #\u{18279}; + #\u{1827A}; + #\u{1827B}; + #\u{1827C}; + #\u{1827D}; + #\u{1827E}; + #\u{1827F}; + #\u{18280}; + #\u{18281}; + #\u{18282}; + #\u{18283}; + #\u{18284}; + #\u{18285}; + #\u{18286}; + #\u{18287}; + #\u{18288}; + #\u{18289}; + #\u{1828A}; + #\u{1828B}; + #\u{1828C}; + #\u{1828D}; + #\u{1828E}; + #\u{1828F}; + #\u{18290}; + #\u{18291}; + #\u{18292}; + #\u{18293}; + #\u{18294}; + #\u{18295}; + #\u{18296}; + #\u{18297}; + #\u{18298}; + #\u{18299}; + #\u{1829A}; + #\u{1829B}; + #\u{1829C}; + #\u{1829D}; + #\u{1829E}; + #\u{1829F}; + #\u{182A0}; + #\u{182A1}; + #\u{182A2}; + #\u{182A3}; + #\u{182A4}; + #\u{182A5}; + #\u{182A6}; + #\u{182A7}; + #\u{182A8}; + #\u{182A9}; + #\u{182AA}; + #\u{182AB}; + #\u{182AC}; + #\u{182AD}; + #\u{182AE}; + #\u{182AF}; + #\u{182B0}; + #\u{182B1}; + #\u{182B2}; + #\u{182B3}; + #\u{182B4}; + #\u{182B5}; + #\u{182B6}; + #\u{182B7}; + #\u{182B8}; + #\u{182B9}; + #\u{182BA}; + #\u{182BB}; + #\u{182BC}; + #\u{182BD}; + #\u{182BE}; + #\u{182BF}; + #\u{182C0}; + #\u{182C1}; + #\u{182C2}; + #\u{182C3}; + #\u{182C4}; + #\u{182C5}; + #\u{182C6}; + #\u{182C7}; + #\u{182C8}; + #\u{182C9}; + #\u{182CA}; + #\u{182CB}; + #\u{182CC}; + #\u{182CD}; + #\u{182CE}; + #\u{182CF}; + #\u{182D0}; + #\u{182D1}; + #\u{182D2}; + #\u{182D3}; + #\u{182D4}; + #\u{182D5}; + #\u{182D6}; + #\u{182D7}; + #\u{182D8}; + #\u{182D9}; + #\u{182DA}; + #\u{182DB}; + #\u{182DC}; + #\u{182DD}; + #\u{182DE}; + #\u{182DF}; + #\u{182E0}; + #\u{182E1}; + #\u{182E2}; + #\u{182E3}; + #\u{182E4}; + #\u{182E5}; + #\u{182E6}; + #\u{182E7}; + #\u{182E8}; + #\u{182E9}; + #\u{182EA}; + #\u{182EB}; + #\u{182EC}; + #\u{182ED}; + #\u{182EE}; + #\u{182EF}; + #\u{182F0}; + #\u{182F1}; + #\u{182F2}; + #\u{182F3}; + #\u{182F4}; + #\u{182F5}; + #\u{182F6}; + #\u{182F7}; + #\u{182F8}; + #\u{182F9}; + #\u{182FA}; + #\u{182FB}; + #\u{182FC}; + #\u{182FD}; + #\u{182FE}; + #\u{182FF}; + #\u{18300}; + #\u{18301}; + #\u{18302}; + #\u{18303}; + #\u{18304}; + #\u{18305}; + #\u{18306}; + #\u{18307}; + #\u{18308}; + #\u{18309}; + #\u{1830A}; + #\u{1830B}; + #\u{1830C}; + #\u{1830D}; + #\u{1830E}; + #\u{1830F}; + #\u{18310}; + #\u{18311}; + #\u{18312}; + #\u{18313}; + #\u{18314}; + #\u{18315}; + #\u{18316}; + #\u{18317}; + #\u{18318}; + #\u{18319}; + #\u{1831A}; + #\u{1831B}; + #\u{1831C}; + #\u{1831D}; + #\u{1831E}; + #\u{1831F}; + #\u{18320}; + #\u{18321}; + #\u{18322}; + #\u{18323}; + #\u{18324}; + #\u{18325}; + #\u{18326}; + #\u{18327}; + #\u{18328}; + #\u{18329}; + #\u{1832A}; + #\u{1832B}; + #\u{1832C}; + #\u{1832D}; + #\u{1832E}; + #\u{1832F}; + #\u{18330}; + #\u{18331}; + #\u{18332}; + #\u{18333}; + #\u{18334}; + #\u{18335}; + #\u{18336}; + #\u{18337}; + #\u{18338}; + #\u{18339}; + #\u{1833A}; + #\u{1833B}; + #\u{1833C}; + #\u{1833D}; + #\u{1833E}; + #\u{1833F}; + #\u{18340}; + #\u{18341}; + #\u{18342}; + #\u{18343}; + #\u{18344}; + #\u{18345}; + #\u{18346}; + #\u{18347}; + #\u{18348}; + #\u{18349}; + #\u{1834A}; + #\u{1834B}; + #\u{1834C}; + #\u{1834D}; + #\u{1834E}; + #\u{1834F}; + #\u{18350}; + #\u{18351}; + #\u{18352}; + #\u{18353}; + #\u{18354}; + #\u{18355}; + #\u{18356}; + #\u{18357}; + #\u{18358}; + #\u{18359}; + #\u{1835A}; + #\u{1835B}; + #\u{1835C}; + #\u{1835D}; + #\u{1835E}; + #\u{1835F}; + #\u{18360}; + #\u{18361}; + #\u{18362}; + #\u{18363}; + #\u{18364}; + #\u{18365}; + #\u{18366}; + #\u{18367}; + #\u{18368}; + #\u{18369}; + #\u{1836A}; + #\u{1836B}; + #\u{1836C}; + #\u{1836D}; + #\u{1836E}; + #\u{1836F}; + #\u{18370}; + #\u{18371}; + #\u{18372}; + #\u{18373}; + #\u{18374}; + #\u{18375}; + #\u{18376}; + #\u{18377}; + #\u{18378}; + #\u{18379}; + #\u{1837A}; + #\u{1837B}; + #\u{1837C}; + #\u{1837D}; + #\u{1837E}; + #\u{1837F}; + #\u{18380}; + #\u{18381}; + #\u{18382}; + #\u{18383}; + #\u{18384}; + #\u{18385}; + #\u{18386}; + #\u{18387}; + #\u{18388}; + #\u{18389}; + #\u{1838A}; + #\u{1838B}; + #\u{1838C}; + #\u{1838D}; + #\u{1838E}; + #\u{1838F}; + #\u{18390}; + #\u{18391}; + #\u{18392}; + #\u{18393}; + #\u{18394}; + #\u{18395}; + #\u{18396}; + #\u{18397}; + #\u{18398}; + #\u{18399}; + #\u{1839A}; + #\u{1839B}; + #\u{1839C}; + #\u{1839D}; + #\u{1839E}; + #\u{1839F}; + #\u{183A0}; + #\u{183A1}; + #\u{183A2}; + #\u{183A3}; + #\u{183A4}; + #\u{183A5}; + #\u{183A6}; + #\u{183A7}; + #\u{183A8}; + #\u{183A9}; + #\u{183AA}; + #\u{183AB}; + #\u{183AC}; + #\u{183AD}; + #\u{183AE}; + #\u{183AF}; + #\u{183B0}; + #\u{183B1}; + #\u{183B2}; + #\u{183B3}; + #\u{183B4}; + #\u{183B5}; + #\u{183B6}; + #\u{183B7}; + #\u{183B8}; + #\u{183B9}; + #\u{183BA}; + #\u{183BB}; + #\u{183BC}; + #\u{183BD}; + #\u{183BE}; + #\u{183BF}; + #\u{183C0}; + #\u{183C1}; + #\u{183C2}; + #\u{183C3}; + #\u{183C4}; + #\u{183C5}; + #\u{183C6}; + #\u{183C7}; + #\u{183C8}; + #\u{183C9}; + #\u{183CA}; + #\u{183CB}; + #\u{183CC}; + #\u{183CD}; + #\u{183CE}; + #\u{183CF}; + #\u{183D0}; + #\u{183D1}; + #\u{183D2}; + #\u{183D3}; + #\u{183D4}; + #\u{183D5}; + #\u{183D6}; + #\u{183D7}; + #\u{183D8}; + #\u{183D9}; + #\u{183DA}; + #\u{183DB}; + #\u{183DC}; + #\u{183DD}; + #\u{183DE}; + #\u{183DF}; + #\u{183E0}; + #\u{183E1}; + #\u{183E2}; + #\u{183E3}; + #\u{183E4}; + #\u{183E5}; + #\u{183E6}; + #\u{183E7}; + #\u{183E8}; + #\u{183E9}; + #\u{183EA}; + #\u{183EB}; + #\u{183EC}; + #\u{183ED}; + #\u{183EE}; + #\u{183EF}; + #\u{183F0}; + #\u{183F1}; + #\u{183F2}; + #\u{183F3}; + #\u{183F4}; + #\u{183F5}; + #\u{183F6}; + #\u{183F7}; + #\u{183F8}; + #\u{183F9}; + #\u{183FA}; + #\u{183FB}; + #\u{183FC}; + #\u{183FD}; + #\u{183FE}; + #\u{183FF}; + #\u{18400}; + #\u{18401}; + #\u{18402}; + #\u{18403}; + #\u{18404}; + #\u{18405}; + #\u{18406}; + #\u{18407}; + #\u{18408}; + #\u{18409}; + #\u{1840A}; + #\u{1840B}; + #\u{1840C}; + #\u{1840D}; + #\u{1840E}; + #\u{1840F}; + #\u{18410}; + #\u{18411}; + #\u{18412}; + #\u{18413}; + #\u{18414}; + #\u{18415}; + #\u{18416}; + #\u{18417}; + #\u{18418}; + #\u{18419}; + #\u{1841A}; + #\u{1841B}; + #\u{1841C}; + #\u{1841D}; + #\u{1841E}; + #\u{1841F}; + #\u{18420}; + #\u{18421}; + #\u{18422}; + #\u{18423}; + #\u{18424}; + #\u{18425}; + #\u{18426}; + #\u{18427}; + #\u{18428}; + #\u{18429}; + #\u{1842A}; + #\u{1842B}; + #\u{1842C}; + #\u{1842D}; + #\u{1842E}; + #\u{1842F}; + #\u{18430}; + #\u{18431}; + #\u{18432}; + #\u{18433}; + #\u{18434}; + #\u{18435}; + #\u{18436}; + #\u{18437}; + #\u{18438}; + #\u{18439}; + #\u{1843A}; + #\u{1843B}; + #\u{1843C}; + #\u{1843D}; + #\u{1843E}; + #\u{1843F}; + #\u{18440}; + #\u{18441}; + #\u{18442}; + #\u{18443}; + #\u{18444}; + #\u{18445}; + #\u{18446}; + #\u{18447}; + #\u{18448}; + #\u{18449}; + #\u{1844A}; + #\u{1844B}; + #\u{1844C}; + #\u{1844D}; + #\u{1844E}; + #\u{1844F}; + #\u{18450}; + #\u{18451}; + #\u{18452}; + #\u{18453}; + #\u{18454}; + #\u{18455}; + #\u{18456}; + #\u{18457}; + #\u{18458}; + #\u{18459}; + #\u{1845A}; + #\u{1845B}; + #\u{1845C}; + #\u{1845D}; + #\u{1845E}; + #\u{1845F}; + #\u{18460}; + #\u{18461}; + #\u{18462}; + #\u{18463}; + #\u{18464}; + #\u{18465}; + #\u{18466}; + #\u{18467}; + #\u{18468}; + #\u{18469}; + #\u{1846A}; + #\u{1846B}; + #\u{1846C}; + #\u{1846D}; + #\u{1846E}; + #\u{1846F}; + #\u{18470}; + #\u{18471}; + #\u{18472}; + #\u{18473}; + #\u{18474}; + #\u{18475}; + #\u{18476}; + #\u{18477}; + #\u{18478}; + #\u{18479}; + #\u{1847A}; + #\u{1847B}; + #\u{1847C}; + #\u{1847D}; + #\u{1847E}; + #\u{1847F}; + #\u{18480}; + #\u{18481}; + #\u{18482}; + #\u{18483}; + #\u{18484}; + #\u{18485}; + #\u{18486}; + #\u{18487}; + #\u{18488}; + #\u{18489}; + #\u{1848A}; + #\u{1848B}; + #\u{1848C}; + #\u{1848D}; + #\u{1848E}; + #\u{1848F}; + #\u{18490}; + #\u{18491}; + #\u{18492}; + #\u{18493}; + #\u{18494}; + #\u{18495}; + #\u{18496}; + #\u{18497}; + #\u{18498}; + #\u{18499}; + #\u{1849A}; + #\u{1849B}; + #\u{1849C}; + #\u{1849D}; + #\u{1849E}; + #\u{1849F}; + #\u{184A0}; + #\u{184A1}; + #\u{184A2}; + #\u{184A3}; + #\u{184A4}; + #\u{184A5}; + #\u{184A6}; + #\u{184A7}; + #\u{184A8}; + #\u{184A9}; + #\u{184AA}; + #\u{184AB}; + #\u{184AC}; + #\u{184AD}; + #\u{184AE}; + #\u{184AF}; + #\u{184B0}; + #\u{184B1}; + #\u{184B2}; + #\u{184B3}; + #\u{184B4}; + #\u{184B5}; + #\u{184B6}; + #\u{184B7}; + #\u{184B8}; + #\u{184B9}; + #\u{184BA}; + #\u{184BB}; + #\u{184BC}; + #\u{184BD}; + #\u{184BE}; + #\u{184BF}; + #\u{184C0}; + #\u{184C1}; + #\u{184C2}; + #\u{184C3}; + #\u{184C4}; + #\u{184C5}; + #\u{184C6}; + #\u{184C7}; + #\u{184C8}; + #\u{184C9}; + #\u{184CA}; + #\u{184CB}; + #\u{184CC}; + #\u{184CD}; + #\u{184CE}; + #\u{184CF}; + #\u{184D0}; + #\u{184D1}; + #\u{184D2}; + #\u{184D3}; + #\u{184D4}; + #\u{184D5}; + #\u{184D6}; + #\u{184D7}; + #\u{184D8}; + #\u{184D9}; + #\u{184DA}; + #\u{184DB}; + #\u{184DC}; + #\u{184DD}; + #\u{184DE}; + #\u{184DF}; + #\u{184E0}; + #\u{184E1}; + #\u{184E2}; + #\u{184E3}; + #\u{184E4}; + #\u{184E5}; + #\u{184E6}; + #\u{184E7}; + #\u{184E8}; + #\u{184E9}; + #\u{184EA}; + #\u{184EB}; + #\u{184EC}; + #\u{184ED}; + #\u{184EE}; + #\u{184EF}; + #\u{184F0}; + #\u{184F1}; + #\u{184F2}; + #\u{184F3}; + #\u{184F4}; + #\u{184F5}; + #\u{184F6}; + #\u{184F7}; + #\u{184F8}; + #\u{184F9}; + #\u{184FA}; + #\u{184FB}; + #\u{184FC}; + #\u{184FD}; + #\u{184FE}; + #\u{184FF}; + #\u{18500}; + #\u{18501}; + #\u{18502}; + #\u{18503}; + #\u{18504}; + #\u{18505}; + #\u{18506}; + #\u{18507}; + #\u{18508}; + #\u{18509}; + #\u{1850A}; + #\u{1850B}; + #\u{1850C}; + #\u{1850D}; + #\u{1850E}; + #\u{1850F}; + #\u{18510}; + #\u{18511}; + #\u{18512}; + #\u{18513}; + #\u{18514}; + #\u{18515}; + #\u{18516}; + #\u{18517}; + #\u{18518}; + #\u{18519}; + #\u{1851A}; + #\u{1851B}; + #\u{1851C}; + #\u{1851D}; + #\u{1851E}; + #\u{1851F}; + #\u{18520}; + #\u{18521}; + #\u{18522}; + #\u{18523}; + #\u{18524}; + #\u{18525}; + #\u{18526}; + #\u{18527}; + #\u{18528}; + #\u{18529}; + #\u{1852A}; + #\u{1852B}; + #\u{1852C}; + #\u{1852D}; + #\u{1852E}; + #\u{1852F}; + #\u{18530}; + #\u{18531}; + #\u{18532}; + #\u{18533}; + #\u{18534}; + #\u{18535}; + #\u{18536}; + #\u{18537}; + #\u{18538}; + #\u{18539}; + #\u{1853A}; + #\u{1853B}; + #\u{1853C}; + #\u{1853D}; + #\u{1853E}; + #\u{1853F}; + #\u{18540}; + #\u{18541}; + #\u{18542}; + #\u{18543}; + #\u{18544}; + #\u{18545}; + #\u{18546}; + #\u{18547}; + #\u{18548}; + #\u{18549}; + #\u{1854A}; + #\u{1854B}; + #\u{1854C}; + #\u{1854D}; + #\u{1854E}; + #\u{1854F}; + #\u{18550}; + #\u{18551}; + #\u{18552}; + #\u{18553}; + #\u{18554}; + #\u{18555}; + #\u{18556}; + #\u{18557}; + #\u{18558}; + #\u{18559}; + #\u{1855A}; + #\u{1855B}; + #\u{1855C}; + #\u{1855D}; + #\u{1855E}; + #\u{1855F}; + #\u{18560}; + #\u{18561}; + #\u{18562}; + #\u{18563}; + #\u{18564}; + #\u{18565}; + #\u{18566}; + #\u{18567}; + #\u{18568}; + #\u{18569}; + #\u{1856A}; + #\u{1856B}; + #\u{1856C}; + #\u{1856D}; + #\u{1856E}; + #\u{1856F}; + #\u{18570}; + #\u{18571}; + #\u{18572}; + #\u{18573}; + #\u{18574}; + #\u{18575}; + #\u{18576}; + #\u{18577}; + #\u{18578}; + #\u{18579}; + #\u{1857A}; + #\u{1857B}; + #\u{1857C}; + #\u{1857D}; + #\u{1857E}; + #\u{1857F}; + #\u{18580}; + #\u{18581}; + #\u{18582}; + #\u{18583}; + #\u{18584}; + #\u{18585}; + #\u{18586}; + #\u{18587}; + #\u{18588}; + #\u{18589}; + #\u{1858A}; + #\u{1858B}; + #\u{1858C}; + #\u{1858D}; + #\u{1858E}; + #\u{1858F}; + #\u{18590}; + #\u{18591}; + #\u{18592}; + #\u{18593}; + #\u{18594}; + #\u{18595}; + #\u{18596}; + #\u{18597}; + #\u{18598}; + #\u{18599}; + #\u{1859A}; + #\u{1859B}; + #\u{1859C}; + #\u{1859D}; + #\u{1859E}; + #\u{1859F}; + #\u{185A0}; + #\u{185A1}; + #\u{185A2}; + #\u{185A3}; + #\u{185A4}; + #\u{185A5}; + #\u{185A6}; + #\u{185A7}; + #\u{185A8}; + #\u{185A9}; + #\u{185AA}; + #\u{185AB}; + #\u{185AC}; + #\u{185AD}; + #\u{185AE}; + #\u{185AF}; + #\u{185B0}; + #\u{185B1}; + #\u{185B2}; + #\u{185B3}; + #\u{185B4}; + #\u{185B5}; + #\u{185B6}; + #\u{185B7}; + #\u{185B8}; + #\u{185B9}; + #\u{185BA}; + #\u{185BB}; + #\u{185BC}; + #\u{185BD}; + #\u{185BE}; + #\u{185BF}; + #\u{185C0}; + #\u{185C1}; + #\u{185C2}; + #\u{185C3}; + #\u{185C4}; + #\u{185C5}; + #\u{185C6}; + #\u{185C7}; + #\u{185C8}; + #\u{185C9}; + #\u{185CA}; + #\u{185CB}; + #\u{185CC}; + #\u{185CD}; + #\u{185CE}; + #\u{185CF}; + #\u{185D0}; + #\u{185D1}; + #\u{185D2}; + #\u{185D3}; + #\u{185D4}; + #\u{185D5}; + #\u{185D6}; + #\u{185D7}; + #\u{185D8}; + #\u{185D9}; + #\u{185DA}; + #\u{185DB}; + #\u{185DC}; + #\u{185DD}; + #\u{185DE}; + #\u{185DF}; + #\u{185E0}; + #\u{185E1}; + #\u{185E2}; + #\u{185E3}; + #\u{185E4}; + #\u{185E5}; + #\u{185E6}; + #\u{185E7}; + #\u{185E8}; + #\u{185E9}; + #\u{185EA}; + #\u{185EB}; + #\u{185EC}; + #\u{185ED}; + #\u{185EE}; + #\u{185EF}; + #\u{185F0}; + #\u{185F1}; + #\u{185F2}; + #\u{185F3}; + #\u{185F4}; + #\u{185F5}; + #\u{185F6}; + #\u{185F7}; + #\u{185F8}; + #\u{185F9}; + #\u{185FA}; + #\u{185FB}; + #\u{185FC}; + #\u{185FD}; + #\u{185FE}; + #\u{185FF}; + #\u{18600}; + #\u{18601}; + #\u{18602}; + #\u{18603}; + #\u{18604}; + #\u{18605}; + #\u{18606}; + #\u{18607}; + #\u{18608}; + #\u{18609}; + #\u{1860A}; + #\u{1860B}; + #\u{1860C}; + #\u{1860D}; + #\u{1860E}; + #\u{1860F}; + #\u{18610}; + #\u{18611}; + #\u{18612}; + #\u{18613}; + #\u{18614}; + #\u{18615}; + #\u{18616}; + #\u{18617}; + #\u{18618}; + #\u{18619}; + #\u{1861A}; + #\u{1861B}; + #\u{1861C}; + #\u{1861D}; + #\u{1861E}; + #\u{1861F}; + #\u{18620}; + #\u{18621}; + #\u{18622}; + #\u{18623}; + #\u{18624}; + #\u{18625}; + #\u{18626}; + #\u{18627}; + #\u{18628}; + #\u{18629}; + #\u{1862A}; + #\u{1862B}; + #\u{1862C}; + #\u{1862D}; + #\u{1862E}; + #\u{1862F}; + #\u{18630}; + #\u{18631}; + #\u{18632}; + #\u{18633}; + #\u{18634}; + #\u{18635}; + #\u{18636}; + #\u{18637}; + #\u{18638}; + #\u{18639}; + #\u{1863A}; + #\u{1863B}; + #\u{1863C}; + #\u{1863D}; + #\u{1863E}; + #\u{1863F}; + #\u{18640}; + #\u{18641}; + #\u{18642}; + #\u{18643}; + #\u{18644}; + #\u{18645}; + #\u{18646}; + #\u{18647}; + #\u{18648}; + #\u{18649}; + #\u{1864A}; + #\u{1864B}; + #\u{1864C}; + #\u{1864D}; + #\u{1864E}; + #\u{1864F}; + #\u{18650}; + #\u{18651}; + #\u{18652}; + #\u{18653}; + #\u{18654}; + #\u{18655}; + #\u{18656}; + #\u{18657}; + #\u{18658}; + #\u{18659}; + #\u{1865A}; + #\u{1865B}; + #\u{1865C}; + #\u{1865D}; + #\u{1865E}; + #\u{1865F}; + #\u{18660}; + #\u{18661}; + #\u{18662}; + #\u{18663}; + #\u{18664}; + #\u{18665}; + #\u{18666}; + #\u{18667}; + #\u{18668}; + #\u{18669}; + #\u{1866A}; + #\u{1866B}; + #\u{1866C}; + #\u{1866D}; + #\u{1866E}; + #\u{1866F}; + #\u{18670}; + #\u{18671}; + #\u{18672}; + #\u{18673}; + #\u{18674}; + #\u{18675}; + #\u{18676}; + #\u{18677}; + #\u{18678}; + #\u{18679}; + #\u{1867A}; + #\u{1867B}; + #\u{1867C}; + #\u{1867D}; + #\u{1867E}; + #\u{1867F}; + #\u{18680}; + #\u{18681}; + #\u{18682}; + #\u{18683}; + #\u{18684}; + #\u{18685}; + #\u{18686}; + #\u{18687}; + #\u{18688}; + #\u{18689}; + #\u{1868A}; + #\u{1868B}; + #\u{1868C}; + #\u{1868D}; + #\u{1868E}; + #\u{1868F}; + #\u{18690}; + #\u{18691}; + #\u{18692}; + #\u{18693}; + #\u{18694}; + #\u{18695}; + #\u{18696}; + #\u{18697}; + #\u{18698}; + #\u{18699}; + #\u{1869A}; + #\u{1869B}; + #\u{1869C}; + #\u{1869D}; + #\u{1869E}; + #\u{1869F}; + #\u{186A0}; + #\u{186A1}; + #\u{186A2}; + #\u{186A3}; + #\u{186A4}; + #\u{186A5}; + #\u{186A6}; + #\u{186A7}; + #\u{186A8}; + #\u{186A9}; + #\u{186AA}; + #\u{186AB}; + #\u{186AC}; + #\u{186AD}; + #\u{186AE}; + #\u{186AF}; + #\u{186B0}; + #\u{186B1}; + #\u{186B2}; + #\u{186B3}; + #\u{186B4}; + #\u{186B5}; + #\u{186B6}; + #\u{186B7}; + #\u{186B8}; + #\u{186B9}; + #\u{186BA}; + #\u{186BB}; + #\u{186BC}; + #\u{186BD}; + #\u{186BE}; + #\u{186BF}; + #\u{186C0}; + #\u{186C1}; + #\u{186C2}; + #\u{186C3}; + #\u{186C4}; + #\u{186C5}; + #\u{186C6}; + #\u{186C7}; + #\u{186C8}; + #\u{186C9}; + #\u{186CA}; + #\u{186CB}; + #\u{186CC}; + #\u{186CD}; + #\u{186CE}; + #\u{186CF}; + #\u{186D0}; + #\u{186D1}; + #\u{186D2}; + #\u{186D3}; + #\u{186D4}; + #\u{186D5}; + #\u{186D6}; + #\u{186D7}; + #\u{186D8}; + #\u{186D9}; + #\u{186DA}; + #\u{186DB}; + #\u{186DC}; + #\u{186DD}; + #\u{186DE}; + #\u{186DF}; + #\u{186E0}; + #\u{186E1}; + #\u{186E2}; + #\u{186E3}; + #\u{186E4}; + #\u{186E5}; + #\u{186E6}; + #\u{186E7}; + #\u{186E8}; + #\u{186E9}; + #\u{186EA}; + #\u{186EB}; + #\u{186EC}; + #\u{186ED}; + #\u{186EE}; + #\u{186EF}; + #\u{186F0}; + #\u{186F1}; + #\u{186F2}; + #\u{186F3}; + #\u{186F4}; + #\u{186F5}; + #\u{186F6}; + #\u{186F7}; + #\u{186F8}; + #\u{186F9}; + #\u{186FA}; + #\u{186FB}; + #\u{186FC}; + #\u{186FD}; + #\u{186FE}; + #\u{186FF}; + #\u{18700}; + #\u{18701}; + #\u{18702}; + #\u{18703}; + #\u{18704}; + #\u{18705}; + #\u{18706}; + #\u{18707}; + #\u{18708}; + #\u{18709}; + #\u{1870A}; + #\u{1870B}; + #\u{1870C}; + #\u{1870D}; + #\u{1870E}; + #\u{1870F}; + #\u{18710}; + #\u{18711}; + #\u{18712}; + #\u{18713}; + #\u{18714}; + #\u{18715}; + #\u{18716}; + #\u{18717}; + #\u{18718}; + #\u{18719}; + #\u{1871A}; + #\u{1871B}; + #\u{1871C}; + #\u{1871D}; + #\u{1871E}; + #\u{1871F}; + #\u{18720}; + #\u{18721}; + #\u{18722}; + #\u{18723}; + #\u{18724}; + #\u{18725}; + #\u{18726}; + #\u{18727}; + #\u{18728}; + #\u{18729}; + #\u{1872A}; + #\u{1872B}; + #\u{1872C}; + #\u{1872D}; + #\u{1872E}; + #\u{1872F}; + #\u{18730}; + #\u{18731}; + #\u{18732}; + #\u{18733}; + #\u{18734}; + #\u{18735}; + #\u{18736}; + #\u{18737}; + #\u{18738}; + #\u{18739}; + #\u{1873A}; + #\u{1873B}; + #\u{1873C}; + #\u{1873D}; + #\u{1873E}; + #\u{1873F}; + #\u{18740}; + #\u{18741}; + #\u{18742}; + #\u{18743}; + #\u{18744}; + #\u{18745}; + #\u{18746}; + #\u{18747}; + #\u{18748}; + #\u{18749}; + #\u{1874A}; + #\u{1874B}; + #\u{1874C}; + #\u{1874D}; + #\u{1874E}; + #\u{1874F}; + #\u{18750}; + #\u{18751}; + #\u{18752}; + #\u{18753}; + #\u{18754}; + #\u{18755}; + #\u{18756}; + #\u{18757}; + #\u{18758}; + #\u{18759}; + #\u{1875A}; + #\u{1875B}; + #\u{1875C}; + #\u{1875D}; + #\u{1875E}; + #\u{1875F}; + #\u{18760}; + #\u{18761}; + #\u{18762}; + #\u{18763}; + #\u{18764}; + #\u{18765}; + #\u{18766}; + #\u{18767}; + #\u{18768}; + #\u{18769}; + #\u{1876A}; + #\u{1876B}; + #\u{1876C}; + #\u{1876D}; + #\u{1876E}; + #\u{1876F}; + #\u{18770}; + #\u{18771}; + #\u{18772}; + #\u{18773}; + #\u{18774}; + #\u{18775}; + #\u{18776}; + #\u{18777}; + #\u{18778}; + #\u{18779}; + #\u{1877A}; + #\u{1877B}; + #\u{1877C}; + #\u{1877D}; + #\u{1877E}; + #\u{1877F}; + #\u{18780}; + #\u{18781}; + #\u{18782}; + #\u{18783}; + #\u{18784}; + #\u{18785}; + #\u{18786}; + #\u{18787}; + #\u{18788}; + #\u{18789}; + #\u{1878A}; + #\u{1878B}; + #\u{1878C}; + #\u{1878D}; + #\u{1878E}; + #\u{1878F}; + #\u{18790}; + #\u{18791}; + #\u{18792}; + #\u{18793}; + #\u{18794}; + #\u{18795}; + #\u{18796}; + #\u{18797}; + #\u{18798}; + #\u{18799}; + #\u{1879A}; + #\u{1879B}; + #\u{1879C}; + #\u{1879D}; + #\u{1879E}; + #\u{1879F}; + #\u{187A0}; + #\u{187A1}; + #\u{187A2}; + #\u{187A3}; + #\u{187A4}; + #\u{187A5}; + #\u{187A6}; + #\u{187A7}; + #\u{187A8}; + #\u{187A9}; + #\u{187AA}; + #\u{187AB}; + #\u{187AC}; + #\u{187AD}; + #\u{187AE}; + #\u{187AF}; + #\u{187B0}; + #\u{187B1}; + #\u{187B2}; + #\u{187B3}; + #\u{187B4}; + #\u{187B5}; + #\u{187B6}; + #\u{187B7}; + #\u{187B8}; + #\u{187B9}; + #\u{187BA}; + #\u{187BB}; + #\u{187BC}; + #\u{187BD}; + #\u{187BE}; + #\u{187BF}; + #\u{187C0}; + #\u{187C1}; + #\u{187C2}; + #\u{187C3}; + #\u{187C4}; + #\u{187C5}; + #\u{187C6}; + #\u{187C7}; + #\u{187C8}; + #\u{187C9}; + #\u{187CA}; + #\u{187CB}; + #\u{187CC}; + #\u{187CD}; + #\u{187CE}; + #\u{187CF}; + #\u{187D0}; + #\u{187D1}; + #\u{187D2}; + #\u{187D3}; + #\u{187D4}; + #\u{187D5}; + #\u{187D6}; + #\u{187D7}; + #\u{187D8}; + #\u{187D9}; + #\u{187DA}; + #\u{187DB}; + #\u{187DC}; + #\u{187DD}; + #\u{187DE}; + #\u{187DF}; + #\u{187E0}; + #\u{187E1}; + #\u{187E2}; + #\u{187E3}; + #\u{187E4}; + #\u{187E5}; + #\u{187E6}; + #\u{187E7}; + #\u{187E8}; + #\u{187E9}; + #\u{187EA}; + #\u{187EB}; + #\u{187EC}; + #\u{18800}; + #\u{18801}; + #\u{18802}; + #\u{18803}; + #\u{18804}; + #\u{18805}; + #\u{18806}; + #\u{18807}; + #\u{18808}; + #\u{18809}; + #\u{1880A}; + #\u{1880B}; + #\u{1880C}; + #\u{1880D}; + #\u{1880E}; + #\u{1880F}; + #\u{18810}; + #\u{18811}; + #\u{18812}; + #\u{18813}; + #\u{18814}; + #\u{18815}; + #\u{18816}; + #\u{18817}; + #\u{18818}; + #\u{18819}; + #\u{1881A}; + #\u{1881B}; + #\u{1881C}; + #\u{1881D}; + #\u{1881E}; + #\u{1881F}; + #\u{18820}; + #\u{18821}; + #\u{18822}; + #\u{18823}; + #\u{18824}; + #\u{18825}; + #\u{18826}; + #\u{18827}; + #\u{18828}; + #\u{18829}; + #\u{1882A}; + #\u{1882B}; + #\u{1882C}; + #\u{1882D}; + #\u{1882E}; + #\u{1882F}; + #\u{18830}; + #\u{18831}; + #\u{18832}; + #\u{18833}; + #\u{18834}; + #\u{18835}; + #\u{18836}; + #\u{18837}; + #\u{18838}; + #\u{18839}; + #\u{1883A}; + #\u{1883B}; + #\u{1883C}; + #\u{1883D}; + #\u{1883E}; + #\u{1883F}; + #\u{18840}; + #\u{18841}; + #\u{18842}; + #\u{18843}; + #\u{18844}; + #\u{18845}; + #\u{18846}; + #\u{18847}; + #\u{18848}; + #\u{18849}; + #\u{1884A}; + #\u{1884B}; + #\u{1884C}; + #\u{1884D}; + #\u{1884E}; + #\u{1884F}; + #\u{18850}; + #\u{18851}; + #\u{18852}; + #\u{18853}; + #\u{18854}; + #\u{18855}; + #\u{18856}; + #\u{18857}; + #\u{18858}; + #\u{18859}; + #\u{1885A}; + #\u{1885B}; + #\u{1885C}; + #\u{1885D}; + #\u{1885E}; + #\u{1885F}; + #\u{18860}; + #\u{18861}; + #\u{18862}; + #\u{18863}; + #\u{18864}; + #\u{18865}; + #\u{18866}; + #\u{18867}; + #\u{18868}; + #\u{18869}; + #\u{1886A}; + #\u{1886B}; + #\u{1886C}; + #\u{1886D}; + #\u{1886E}; + #\u{1886F}; + #\u{18870}; + #\u{18871}; + #\u{18872}; + #\u{18873}; + #\u{18874}; + #\u{18875}; + #\u{18876}; + #\u{18877}; + #\u{18878}; + #\u{18879}; + #\u{1887A}; + #\u{1887B}; + #\u{1887C}; + #\u{1887D}; + #\u{1887E}; + #\u{1887F}; + #\u{18880}; + #\u{18881}; + #\u{18882}; + #\u{18883}; + #\u{18884}; + #\u{18885}; + #\u{18886}; + #\u{18887}; + #\u{18888}; + #\u{18889}; + #\u{1888A}; + #\u{1888B}; + #\u{1888C}; + #\u{1888D}; + #\u{1888E}; + #\u{1888F}; + #\u{18890}; + #\u{18891}; + #\u{18892}; + #\u{18893}; + #\u{18894}; + #\u{18895}; + #\u{18896}; + #\u{18897}; + #\u{18898}; + #\u{18899}; + #\u{1889A}; + #\u{1889B}; + #\u{1889C}; + #\u{1889D}; + #\u{1889E}; + #\u{1889F}; + #\u{188A0}; + #\u{188A1}; + #\u{188A2}; + #\u{188A3}; + #\u{188A4}; + #\u{188A5}; + #\u{188A6}; + #\u{188A7}; + #\u{188A8}; + #\u{188A9}; + #\u{188AA}; + #\u{188AB}; + #\u{188AC}; + #\u{188AD}; + #\u{188AE}; + #\u{188AF}; + #\u{188B0}; + #\u{188B1}; + #\u{188B2}; + #\u{188B3}; + #\u{188B4}; + #\u{188B5}; + #\u{188B6}; + #\u{188B7}; + #\u{188B8}; + #\u{188B9}; + #\u{188BA}; + #\u{188BB}; + #\u{188BC}; + #\u{188BD}; + #\u{188BE}; + #\u{188BF}; + #\u{188C0}; + #\u{188C1}; + #\u{188C2}; + #\u{188C3}; + #\u{188C4}; + #\u{188C5}; + #\u{188C6}; + #\u{188C7}; + #\u{188C8}; + #\u{188C9}; + #\u{188CA}; + #\u{188CB}; + #\u{188CC}; + #\u{188CD}; + #\u{188CE}; + #\u{188CF}; + #\u{188D0}; + #\u{188D1}; + #\u{188D2}; + #\u{188D3}; + #\u{188D4}; + #\u{188D5}; + #\u{188D6}; + #\u{188D7}; + #\u{188D8}; + #\u{188D9}; + #\u{188DA}; + #\u{188DB}; + #\u{188DC}; + #\u{188DD}; + #\u{188DE}; + #\u{188DF}; + #\u{188E0}; + #\u{188E1}; + #\u{188E2}; + #\u{188E3}; + #\u{188E4}; + #\u{188E5}; + #\u{188E6}; + #\u{188E7}; + #\u{188E8}; + #\u{188E9}; + #\u{188EA}; + #\u{188EB}; + #\u{188EC}; + #\u{188ED}; + #\u{188EE}; + #\u{188EF}; + #\u{188F0}; + #\u{188F1}; + #\u{188F2}; + #\u{188F3}; + #\u{188F4}; + #\u{188F5}; + #\u{188F6}; + #\u{188F7}; + #\u{188F8}; + #\u{188F9}; + #\u{188FA}; + #\u{188FB}; + #\u{188FC}; + #\u{188FD}; + #\u{188FE}; + #\u{188FF}; + #\u{18900}; + #\u{18901}; + #\u{18902}; + #\u{18903}; + #\u{18904}; + #\u{18905}; + #\u{18906}; + #\u{18907}; + #\u{18908}; + #\u{18909}; + #\u{1890A}; + #\u{1890B}; + #\u{1890C}; + #\u{1890D}; + #\u{1890E}; + #\u{1890F}; + #\u{18910}; + #\u{18911}; + #\u{18912}; + #\u{18913}; + #\u{18914}; + #\u{18915}; + #\u{18916}; + #\u{18917}; + #\u{18918}; + #\u{18919}; + #\u{1891A}; + #\u{1891B}; + #\u{1891C}; + #\u{1891D}; + #\u{1891E}; + #\u{1891F}; + #\u{18920}; + #\u{18921}; + #\u{18922}; + #\u{18923}; + #\u{18924}; + #\u{18925}; + #\u{18926}; + #\u{18927}; + #\u{18928}; + #\u{18929}; + #\u{1892A}; + #\u{1892B}; + #\u{1892C}; + #\u{1892D}; + #\u{1892E}; + #\u{1892F}; + #\u{18930}; + #\u{18931}; + #\u{18932}; + #\u{18933}; + #\u{18934}; + #\u{18935}; + #\u{18936}; + #\u{18937}; + #\u{18938}; + #\u{18939}; + #\u{1893A}; + #\u{1893B}; + #\u{1893C}; + #\u{1893D}; + #\u{1893E}; + #\u{1893F}; + #\u{18940}; + #\u{18941}; + #\u{18942}; + #\u{18943}; + #\u{18944}; + #\u{18945}; + #\u{18946}; + #\u{18947}; + #\u{18948}; + #\u{18949}; + #\u{1894A}; + #\u{1894B}; + #\u{1894C}; + #\u{1894D}; + #\u{1894E}; + #\u{1894F}; + #\u{18950}; + #\u{18951}; + #\u{18952}; + #\u{18953}; + #\u{18954}; + #\u{18955}; + #\u{18956}; + #\u{18957}; + #\u{18958}; + #\u{18959}; + #\u{1895A}; + #\u{1895B}; + #\u{1895C}; + #\u{1895D}; + #\u{1895E}; + #\u{1895F}; + #\u{18960}; + #\u{18961}; + #\u{18962}; + #\u{18963}; + #\u{18964}; + #\u{18965}; + #\u{18966}; + #\u{18967}; + #\u{18968}; + #\u{18969}; + #\u{1896A}; + #\u{1896B}; + #\u{1896C}; + #\u{1896D}; + #\u{1896E}; + #\u{1896F}; + #\u{18970}; + #\u{18971}; + #\u{18972}; + #\u{18973}; + #\u{18974}; + #\u{18975}; + #\u{18976}; + #\u{18977}; + #\u{18978}; + #\u{18979}; + #\u{1897A}; + #\u{1897B}; + #\u{1897C}; + #\u{1897D}; + #\u{1897E}; + #\u{1897F}; + #\u{18980}; + #\u{18981}; + #\u{18982}; + #\u{18983}; + #\u{18984}; + #\u{18985}; + #\u{18986}; + #\u{18987}; + #\u{18988}; + #\u{18989}; + #\u{1898A}; + #\u{1898B}; + #\u{1898C}; + #\u{1898D}; + #\u{1898E}; + #\u{1898F}; + #\u{18990}; + #\u{18991}; + #\u{18992}; + #\u{18993}; + #\u{18994}; + #\u{18995}; + #\u{18996}; + #\u{18997}; + #\u{18998}; + #\u{18999}; + #\u{1899A}; + #\u{1899B}; + #\u{1899C}; + #\u{1899D}; + #\u{1899E}; + #\u{1899F}; + #\u{189A0}; + #\u{189A1}; + #\u{189A2}; + #\u{189A3}; + #\u{189A4}; + #\u{189A5}; + #\u{189A6}; + #\u{189A7}; + #\u{189A8}; + #\u{189A9}; + #\u{189AA}; + #\u{189AB}; + #\u{189AC}; + #\u{189AD}; + #\u{189AE}; + #\u{189AF}; + #\u{189B0}; + #\u{189B1}; + #\u{189B2}; + #\u{189B3}; + #\u{189B4}; + #\u{189B5}; + #\u{189B6}; + #\u{189B7}; + #\u{189B8}; + #\u{189B9}; + #\u{189BA}; + #\u{189BB}; + #\u{189BC}; + #\u{189BD}; + #\u{189BE}; + #\u{189BF}; + #\u{189C0}; + #\u{189C1}; + #\u{189C2}; + #\u{189C3}; + #\u{189C4}; + #\u{189C5}; + #\u{189C6}; + #\u{189C7}; + #\u{189C8}; + #\u{189C9}; + #\u{189CA}; + #\u{189CB}; + #\u{189CC}; + #\u{189CD}; + #\u{189CE}; + #\u{189CF}; + #\u{189D0}; + #\u{189D1}; + #\u{189D2}; + #\u{189D3}; + #\u{189D4}; + #\u{189D5}; + #\u{189D6}; + #\u{189D7}; + #\u{189D8}; + #\u{189D9}; + #\u{189DA}; + #\u{189DB}; + #\u{189DC}; + #\u{189DD}; + #\u{189DE}; + #\u{189DF}; + #\u{189E0}; + #\u{189E1}; + #\u{189E2}; + #\u{189E3}; + #\u{189E4}; + #\u{189E5}; + #\u{189E6}; + #\u{189E7}; + #\u{189E8}; + #\u{189E9}; + #\u{189EA}; + #\u{189EB}; + #\u{189EC}; + #\u{189ED}; + #\u{189EE}; + #\u{189EF}; + #\u{189F0}; + #\u{189F1}; + #\u{189F2}; + #\u{189F3}; + #\u{189F4}; + #\u{189F5}; + #\u{189F6}; + #\u{189F7}; + #\u{189F8}; + #\u{189F9}; + #\u{189FA}; + #\u{189FB}; + #\u{189FC}; + #\u{189FD}; + #\u{189FE}; + #\u{189FF}; + #\u{18A00}; + #\u{18A01}; + #\u{18A02}; + #\u{18A03}; + #\u{18A04}; + #\u{18A05}; + #\u{18A06}; + #\u{18A07}; + #\u{18A08}; + #\u{18A09}; + #\u{18A0A}; + #\u{18A0B}; + #\u{18A0C}; + #\u{18A0D}; + #\u{18A0E}; + #\u{18A0F}; + #\u{18A10}; + #\u{18A11}; + #\u{18A12}; + #\u{18A13}; + #\u{18A14}; + #\u{18A15}; + #\u{18A16}; + #\u{18A17}; + #\u{18A18}; + #\u{18A19}; + #\u{18A1A}; + #\u{18A1B}; + #\u{18A1C}; + #\u{18A1D}; + #\u{18A1E}; + #\u{18A1F}; + #\u{18A20}; + #\u{18A21}; + #\u{18A22}; + #\u{18A23}; + #\u{18A24}; + #\u{18A25}; + #\u{18A26}; + #\u{18A27}; + #\u{18A28}; + #\u{18A29}; + #\u{18A2A}; + #\u{18A2B}; + #\u{18A2C}; + #\u{18A2D}; + #\u{18A2E}; + #\u{18A2F}; + #\u{18A30}; + #\u{18A31}; + #\u{18A32}; + #\u{18A33}; + #\u{18A34}; + #\u{18A35}; + #\u{18A36}; + #\u{18A37}; + #\u{18A38}; + #\u{18A39}; + #\u{18A3A}; + #\u{18A3B}; + #\u{18A3C}; + #\u{18A3D}; + #\u{18A3E}; + #\u{18A3F}; + #\u{18A40}; + #\u{18A41}; + #\u{18A42}; + #\u{18A43}; + #\u{18A44}; + #\u{18A45}; + #\u{18A46}; + #\u{18A47}; + #\u{18A48}; + #\u{18A49}; + #\u{18A4A}; + #\u{18A4B}; + #\u{18A4C}; + #\u{18A4D}; + #\u{18A4E}; + #\u{18A4F}; + #\u{18A50}; + #\u{18A51}; + #\u{18A52}; + #\u{18A53}; + #\u{18A54}; + #\u{18A55}; + #\u{18A56}; + #\u{18A57}; + #\u{18A58}; + #\u{18A59}; + #\u{18A5A}; + #\u{18A5B}; + #\u{18A5C}; + #\u{18A5D}; + #\u{18A5E}; + #\u{18A5F}; + #\u{18A60}; + #\u{18A61}; + #\u{18A62}; + #\u{18A63}; + #\u{18A64}; + #\u{18A65}; + #\u{18A66}; + #\u{18A67}; + #\u{18A68}; + #\u{18A69}; + #\u{18A6A}; + #\u{18A6B}; + #\u{18A6C}; + #\u{18A6D}; + #\u{18A6E}; + #\u{18A6F}; + #\u{18A70}; + #\u{18A71}; + #\u{18A72}; + #\u{18A73}; + #\u{18A74}; + #\u{18A75}; + #\u{18A76}; + #\u{18A77}; + #\u{18A78}; + #\u{18A79}; + #\u{18A7A}; + #\u{18A7B}; + #\u{18A7C}; + #\u{18A7D}; + #\u{18A7E}; + #\u{18A7F}; + #\u{18A80}; + #\u{18A81}; + #\u{18A82}; + #\u{18A83}; + #\u{18A84}; + #\u{18A85}; + #\u{18A86}; + #\u{18A87}; + #\u{18A88}; + #\u{18A89}; + #\u{18A8A}; + #\u{18A8B}; + #\u{18A8C}; + #\u{18A8D}; + #\u{18A8E}; + #\u{18A8F}; + #\u{18A90}; + #\u{18A91}; + #\u{18A92}; + #\u{18A93}; + #\u{18A94}; + #\u{18A95}; + #\u{18A96}; + #\u{18A97}; + #\u{18A98}; + #\u{18A99}; + #\u{18A9A}; + #\u{18A9B}; + #\u{18A9C}; + #\u{18A9D}; + #\u{18A9E}; + #\u{18A9F}; + #\u{18AA0}; + #\u{18AA1}; + #\u{18AA2}; + #\u{18AA3}; + #\u{18AA4}; + #\u{18AA5}; + #\u{18AA6}; + #\u{18AA7}; + #\u{18AA8}; + #\u{18AA9}; + #\u{18AAA}; + #\u{18AAB}; + #\u{18AAC}; + #\u{18AAD}; + #\u{18AAE}; + #\u{18AAF}; + #\u{18AB0}; + #\u{18AB1}; + #\u{18AB2}; + #\u{18AB3}; + #\u{18AB4}; + #\u{18AB5}; + #\u{18AB6}; + #\u{18AB7}; + #\u{18AB8}; + #\u{18AB9}; + #\u{18ABA}; + #\u{18ABB}; + #\u{18ABC}; + #\u{18ABD}; + #\u{18ABE}; + #\u{18ABF}; + #\u{18AC0}; + #\u{18AC1}; + #\u{18AC2}; + #\u{18AC3}; + #\u{18AC4}; + #\u{18AC5}; + #\u{18AC6}; + #\u{18AC7}; + #\u{18AC8}; + #\u{18AC9}; + #\u{18ACA}; + #\u{18ACB}; + #\u{18ACC}; + #\u{18ACD}; + #\u{18ACE}; + #\u{18ACF}; + #\u{18AD0}; + #\u{18AD1}; + #\u{18AD2}; + #\u{18AD3}; + #\u{18AD4}; + #\u{18AD5}; + #\u{18AD6}; + #\u{18AD7}; + #\u{18AD8}; + #\u{18AD9}; + #\u{18ADA}; + #\u{18ADB}; + #\u{18ADC}; + #\u{18ADD}; + #\u{18ADE}; + #\u{18ADF}; + #\u{18AE0}; + #\u{18AE1}; + #\u{18AE2}; + #\u{18AE3}; + #\u{18AE4}; + #\u{18AE5}; + #\u{18AE6}; + #\u{18AE7}; + #\u{18AE8}; + #\u{18AE9}; + #\u{18AEA}; + #\u{18AEB}; + #\u{18AEC}; + #\u{18AED}; + #\u{18AEE}; + #\u{18AEF}; + #\u{18AF0}; + #\u{18AF1}; + #\u{18AF2}; + #\u{1E900}; + #\u{1E901}; + #\u{1E902}; + #\u{1E903}; + #\u{1E904}; + #\u{1E905}; + #\u{1E906}; + #\u{1E907}; + #\u{1E908}; + #\u{1E909}; + #\u{1E90A}; + #\u{1E90B}; + #\u{1E90C}; + #\u{1E90D}; + #\u{1E90E}; + #\u{1E90F}; + #\u{1E910}; + #\u{1E911}; + #\u{1E912}; + #\u{1E913}; + #\u{1E914}; + #\u{1E915}; + #\u{1E916}; + #\u{1E917}; + #\u{1E918}; + #\u{1E919}; + #\u{1E91A}; + #\u{1E91B}; + #\u{1E91C}; + #\u{1E91D}; + #\u{1E91E}; + #\u{1E91F}; + #\u{1E920}; + #\u{1E921}; + #\u{1E922}; + #\u{1E923}; + #\u{1E924}; + #\u{1E925}; + #\u{1E926}; + #\u{1E927}; + #\u{1E928}; + #\u{1E929}; + #\u{1E92A}; + #\u{1E92B}; + #\u{1E92C}; + #\u{1E92D}; + #\u{1E92E}; + #\u{1E92F}; + #\u{1E930}; + #\u{1E931}; + #\u{1E932}; + #\u{1E933}; + #\u{1E934}; + #\u{1E935}; + #\u{1E936}; + #\u{1E937}; + #\u{1E938}; + #\u{1E939}; + #\u{1E93A}; + #\u{1E93B}; + #\u{1E93C}; + #\u{1E93D}; + #\u{1E93E}; + #\u{1E93F}; + #\u{1E940}; + #\u{1E941}; + #\u{1E942}; + #\u{1E943}; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0-class.js new file mode 100644 index 000000000..78c66d6cf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0-class.js @@ -0,0 +1,7193 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: prod-PrivateIdentifier +description: | + Test that Unicode v9.0.0 ID_Start characters are accepted as + identifier start characters in private class fields. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +features: [class, class-fields-private] +---*/ + +class _ { + #ࢶ; + #ࢷ; + #ࢸ; + #ࢹ; + #ࢺ; + #ࢻ; + #ࢼ; + #ࢽ; + #ಀ; + #ൔ; + #ൕ; + #ൖ; + #ᲀ; + #ᲁ; + #ᲂ; + #ᲃ; + #ᲄ; + #ᲅ; + #ᲆ; + #ᲇ; + #ᲈ; + #Ɪ; + #𐒰; + #𐒱; + #𐒲; + #𐒳; + #𐒴; + #𐒵; + #𐒶; + #𐒷; + #𐒸; + #𐒹; + #𐒺; + #𐒻; + #𐒼; + #𐒽; + #𐒾; + #𐒿; + #𐓀; + #𐓁; + #𐓂; + #𐓃; + #𐓄; + #𐓅; + #𐓆; + #𐓇; + #𐓈; + #𐓉; + #𐓊; + #𐓋; + #𐓌; + #𐓍; + #𐓎; + #𐓏; + #𐓐; + #𐓑; + #𐓒; + #𐓓; + #𐓘; + #𐓙; + #𐓚; + #𐓛; + #𐓜; + #𐓝; + #𐓞; + #𐓟; + #𐓠; + #𐓡; + #𐓢; + #𐓣; + #𐓤; + #𐓥; + #𐓦; + #𐓧; + #𐓨; + #𐓩; + #𐓪; + #𐓫; + #𐓬; + #𐓭; + #𐓮; + #𐓯; + #𐓰; + #𐓱; + #𐓲; + #𐓳; + #𐓴; + #𐓵; + #𐓶; + #𐓷; + #𐓸; + #𐓹; + #𐓺; + #𐓻; + #𑐀; + #𑐁; + #𑐂; + #𑐃; + #𑐄; + #𑐅; + #𑐆; + #𑐇; + #𑐈; + #𑐉; + #𑐊; + #𑐋; + #𑐌; + #𑐍; + #𑐎; + #𑐏; + #𑐐; + #𑐑; + #𑐒; + #𑐓; + #𑐔; + #𑐕; + #𑐖; + #𑐗; + #𑐘; + #𑐙; + #𑐚; + #𑐛; + #𑐜; + #𑐝; + #𑐞; + #𑐟; + #𑐠; + #𑐡; + #𑐢; + #𑐣; + #𑐤; + #𑐥; + #𑐦; + #𑐧; + #𑐨; + #𑐩; + #𑐪; + #𑐫; + #𑐬; + #𑐭; + #𑐮; + #𑐯; + #𑐰; + #𑐱; + #𑐲; + #𑐳; + #𑐴; + #𑑇; + #𑑈; + #𑑉; + #𑑊; + #𑰀; + #𑰁; + #𑰂; + #𑰃; + #𑰄; + #𑰅; + #𑰆; + #𑰇; + #𑰈; + #𑰊; + #𑰋; + #𑰌; + #𑰍; + #𑰎; + #𑰏; + #𑰐; + #𑰑; + #𑰒; + #𑰓; + #𑰔; + #𑰕; + #𑰖; + #𑰗; + #𑰘; + #𑰙; + #𑰚; + #𑰛; + #𑰜; + #𑰝; + #𑰞; + #𑰟; + #𑰠; + #𑰡; + #𑰢; + #𑰣; + #𑰤; + #𑰥; + #𑰦; + #𑰧; + #𑰨; + #𑰩; + #𑰪; + #𑰫; + #𑰬; + #𑰭; + #𑰮; + #𑱀; + #𑱲; + #𑱳; + #𑱴; + #𑱵; + #𑱶; + #𑱷; + #𑱸; + #𑱹; + #𑱺; + #𑱻; + #𑱼; + #𑱽; + #𑱾; + #𑱿; + #𑲀; + #𑲁; + #𑲂; + #𑲃; + #𑲄; + #𑲅; + #𑲆; + #𑲇; + #𑲈; + #𑲉; + #𑲊; + #𑲋; + #𑲌; + #𑲍; + #𑲎; + #𑲏; + #𖿠; + #𗀀; + #𗀁; + #𗀂; + #𗀃; + #𗀄; + #𗀅; + #𗀆; + #𗀇; + #𗀈; + #𗀉; + #𗀊; + #𗀋; + #𗀌; + #𗀍; + #𗀎; + #𗀏; + #𗀐; + #𗀑; + #𗀒; + #𗀓; + #𗀔; + #𗀕; + #𗀖; + #𗀗; + #𗀘; + #𗀙; + #𗀚; + #𗀛; + #𗀜; + #𗀝; + #𗀞; + #𗀟; + #𗀠; + #𗀡; + #𗀢; + #𗀣; + #𗀤; + #𗀥; + #𗀦; + #𗀧; + #𗀨; + #𗀩; + #𗀪; + #𗀫; + #𗀬; + #𗀭; + #𗀮; + #𗀯; + #𗀰; + #𗀱; + #𗀲; + #𗀳; + #𗀴; + #𗀵; + #𗀶; + #𗀷; + #𗀸; + #𗀹; + #𗀺; + #𗀻; + #𗀼; + #𗀽; + #𗀾; + #𗀿; + #𗁀; + #𗁁; + #𗁂; + #𗁃; + #𗁄; + #𗁅; + #𗁆; + #𗁇; + #𗁈; + #𗁉; + #𗁊; + #𗁋; + #𗁌; + #𗁍; + #𗁎; + #𗁏; + #𗁐; + #𗁑; + #𗁒; + #𗁓; + #𗁔; + #𗁕; + #𗁖; + #𗁗; + #𗁘; + #𗁙; + #𗁚; + #𗁛; + #𗁜; + #𗁝; + #𗁞; + #𗁟; + #𗁠; + #𗁡; + #𗁢; + #𗁣; + #𗁤; + #𗁥; + #𗁦; + #𗁧; + #𗁨; + #𗁩; + #𗁪; + #𗁫; + #𗁬; + #𗁭; + #𗁮; + #𗁯; + #𗁰; + #𗁱; + #𗁲; + #𗁳; + #𗁴; + #𗁵; + #𗁶; + #𗁷; + #𗁸; + #𗁹; + #𗁺; + #𗁻; + #𗁼; + #𗁽; + #𗁾; + #𗁿; + #𗂀; + #𗂁; + #𗂂; + #𗂃; + #𗂄; + #𗂅; + #𗂆; + #𗂇; + #𗂈; + #𗂉; + #𗂊; + #𗂋; + #𗂌; + #𗂍; + #𗂎; + #𗂏; + #𗂐; + #𗂑; + #𗂒; + #𗂓; + #𗂔; + #𗂕; + #𗂖; + #𗂗; + #𗂘; + #𗂙; + #𗂚; + #𗂛; + #𗂜; + #𗂝; + #𗂞; + #𗂟; + #𗂠; + #𗂡; + #𗂢; + #𗂣; + #𗂤; + #𗂥; + #𗂦; + #𗂧; + #𗂨; + #𗂩; + #𗂪; + #𗂫; + #𗂬; + #𗂭; + #𗂮; + #𗂯; + #𗂰; + #𗂱; + #𗂲; + #𗂳; + #𗂴; + #𗂵; + #𗂶; + #𗂷; + #𗂸; + #𗂹; + #𗂺; + #𗂻; + #𗂼; + #𗂽; + #𗂾; + #𗂿; + #𗃀; + #𗃁; + #𗃂; + #𗃃; + #𗃄; + #𗃅; + #𗃆; + #𗃇; + #𗃈; + #𗃉; + #𗃊; + #𗃋; + #𗃌; + #𗃍; + #𗃎; + #𗃏; + #𗃐; + #𗃑; + #𗃒; + #𗃓; + #𗃔; + #𗃕; + #𗃖; + #𗃗; + #𗃘; + #𗃙; + #𗃚; + #𗃛; + #𗃜; + #𗃝; + #𗃞; + #𗃟; + #𗃠; + #𗃡; + #𗃢; + #𗃣; + #𗃤; + #𗃥; + #𗃦; + #𗃧; + #𗃨; + #𗃩; + #𗃪; + #𗃫; + #𗃬; + #𗃭; + #𗃮; + #𗃯; + #𗃰; + #𗃱; + #𗃲; + #𗃳; + #𗃴; + #𗃵; + #𗃶; + #𗃷; + #𗃸; + #𗃹; + #𗃺; + #𗃻; + #𗃼; + #𗃽; + #𗃾; + #𗃿; + #𗄀; + #𗄁; + #𗄂; + #𗄃; + #𗄄; + #𗄅; + #𗄆; + #𗄇; + #𗄈; + #𗄉; + #𗄊; + #𗄋; + #𗄌; + #𗄍; + #𗄎; + #𗄏; + #𗄐; + #𗄑; + #𗄒; + #𗄓; + #𗄔; + #𗄕; + #𗄖; + #𗄗; + #𗄘; + #𗄙; + #𗄚; + #𗄛; + #𗄜; + #𗄝; + #𗄞; + #𗄟; + #𗄠; + #𗄡; + #𗄢; + #𗄣; + #𗄤; + #𗄥; + #𗄦; + #𗄧; + #𗄨; + #𗄩; + #𗄪; + #𗄫; + #𗄬; + #𗄭; + #𗄮; + #𗄯; + #𗄰; + #𗄱; + #𗄲; + #𗄳; + #𗄴; + #𗄵; + #𗄶; + #𗄷; + #𗄸; + #𗄹; + #𗄺; + #𗄻; + #𗄼; + #𗄽; + #𗄾; + #𗄿; + #𗅀; + #𗅁; + #𗅂; + #𗅃; + #𗅄; + #𗅅; + #𗅆; + #𗅇; + #𗅈; + #𗅉; + #𗅊; + #𗅋; + #𗅌; + #𗅍; + #𗅎; + #𗅏; + #𗅐; + #𗅑; + #𗅒; + #𗅓; + #𗅔; + #𗅕; + #𗅖; + #𗅗; + #𗅘; + #𗅙; + #𗅚; + #𗅛; + #𗅜; + #𗅝; + #𗅞; + #𗅟; + #𗅠; + #𗅡; + #𗅢; + #𗅣; + #𗅤; + #𗅥; + #𗅦; + #𗅧; + #𗅨; + #𗅩; + #𗅪; + #𗅫; + #𗅬; + #𗅭; + #𗅮; + #𗅯; + #𗅰; + #𗅱; + #𗅲; + #𗅳; + #𗅴; + #𗅵; + #𗅶; + #𗅷; + #𗅸; + #𗅹; + #𗅺; + #𗅻; + #𗅼; + #𗅽; + #𗅾; + #𗅿; + #𗆀; + #𗆁; + #𗆂; + #𗆃; + #𗆄; + #𗆅; + #𗆆; + #𗆇; + #𗆈; + #𗆉; + #𗆊; + #𗆋; + #𗆌; + #𗆍; + #𗆎; + #𗆏; + #𗆐; + #𗆑; + #𗆒; + #𗆓; + #𗆔; + #𗆕; + #𗆖; + #𗆗; + #𗆘; + #𗆙; + #𗆚; + #𗆛; + #𗆜; + #𗆝; + #𗆞; + #𗆟; + #𗆠; + #𗆡; + #𗆢; + #𗆣; + #𗆤; + #𗆥; + #𗆦; + #𗆧; + #𗆨; + #𗆩; + #𗆪; + #𗆫; + #𗆬; + #𗆭; + #𗆮; + #𗆯; + #𗆰; + #𗆱; + #𗆲; + #𗆳; + #𗆴; + #𗆵; + #𗆶; + #𗆷; + #𗆸; + #𗆹; + #𗆺; + #𗆻; + #𗆼; + #𗆽; + #𗆾; + #𗆿; + #𗇀; + #𗇁; + #𗇂; + #𗇃; + #𗇄; + #𗇅; + #𗇆; + #𗇇; + #𗇈; + #𗇉; + #𗇊; + #𗇋; + #𗇌; + #𗇍; + #𗇎; + #𗇏; + #𗇐; + #𗇑; + #𗇒; + #𗇓; + #𗇔; + #𗇕; + #𗇖; + #𗇗; + #𗇘; + #𗇙; + #𗇚; + #𗇛; + #𗇜; + #𗇝; + #𗇞; + #𗇟; + #𗇠; + #𗇡; + #𗇢; + #𗇣; + #𗇤; + #𗇥; + #𗇦; + #𗇧; + #𗇨; + #𗇩; + #𗇪; + #𗇫; + #𗇬; + #𗇭; + #𗇮; + #𗇯; + #𗇰; + #𗇱; + #𗇲; + #𗇳; + #𗇴; + #𗇵; + #𗇶; + #𗇷; + #𗇸; + #𗇹; + #𗇺; + #𗇻; + #𗇼; + #𗇽; + #𗇾; + #𗇿; + #𗈀; + #𗈁; + #𗈂; + #𗈃; + #𗈄; + #𗈅; + #𗈆; + #𗈇; + #𗈈; + #𗈉; + #𗈊; + #𗈋; + #𗈌; + #𗈍; + #𗈎; + #𗈏; + #𗈐; + #𗈑; + #𗈒; + #𗈓; + #𗈔; + #𗈕; + #𗈖; + #𗈗; + #𗈘; + #𗈙; + #𗈚; + #𗈛; + #𗈜; + #𗈝; + #𗈞; + #𗈟; + #𗈠; + #𗈡; + #𗈢; + #𗈣; + #𗈤; + #𗈥; + #𗈦; + #𗈧; + #𗈨; + #𗈩; + #𗈪; + #𗈫; + #𗈬; + #𗈭; + #𗈮; + #𗈯; + #𗈰; + #𗈱; + #𗈲; + #𗈳; + #𗈴; + #𗈵; + #𗈶; + #𗈷; + #𗈸; + #𗈹; + #𗈺; + #𗈻; + #𗈼; + #𗈽; + #𗈾; + #𗈿; + #𗉀; + #𗉁; + #𗉂; + #𗉃; + #𗉄; + #𗉅; + #𗉆; + #𗉇; + #𗉈; + #𗉉; + #𗉊; + #𗉋; + #𗉌; + #𗉍; + #𗉎; + #𗉏; + #𗉐; + #𗉑; + #𗉒; + #𗉓; + #𗉔; + #𗉕; + #𗉖; + #𗉗; + #𗉘; + #𗉙; + #𗉚; + #𗉛; + #𗉜; + #𗉝; + #𗉞; + #𗉟; + #𗉠; + #𗉡; + #𗉢; + #𗉣; + #𗉤; + #𗉥; + #𗉦; + #𗉧; + #𗉨; + #𗉩; + #𗉪; + #𗉫; + #𗉬; + #𗉭; + #𗉮; + #𗉯; + #𗉰; + #𗉱; + #𗉲; + #𗉳; + #𗉴; + #𗉵; + #𗉶; + #𗉷; + #𗉸; + #𗉹; + #𗉺; + #𗉻; + #𗉼; + #𗉽; + #𗉾; + #𗉿; + #𗊀; + #𗊁; + #𗊂; + #𗊃; + #𗊄; + #𗊅; + #𗊆; + #𗊇; + #𗊈; + #𗊉; + #𗊊; + #𗊋; + #𗊌; + #𗊍; + #𗊎; + #𗊏; + #𗊐; + #𗊑; + #𗊒; + #𗊓; + #𗊔; + #𗊕; + #𗊖; + #𗊗; + #𗊘; + #𗊙; + #𗊚; + #𗊛; + #𗊜; + #𗊝; + #𗊞; + #𗊟; + #𗊠; + #𗊡; + #𗊢; + #𗊣; + #𗊤; + #𗊥; + #𗊦; + #𗊧; + #𗊨; + #𗊩; + #𗊪; + #𗊫; + #𗊬; + #𗊭; + #𗊮; + #𗊯; + #𗊰; + #𗊱; + #𗊲; + #𗊳; + #𗊴; + #𗊵; + #𗊶; + #𗊷; + #𗊸; + #𗊹; + #𗊺; + #𗊻; + #𗊼; + #𗊽; + #𗊾; + #𗊿; + #𗋀; + #𗋁; + #𗋂; + #𗋃; + #𗋄; + #𗋅; + #𗋆; + #𗋇; + #𗋈; + #𗋉; + #𗋊; + #𗋋; + #𗋌; + #𗋍; + #𗋎; + #𗋏; + #𗋐; + #𗋑; + #𗋒; + #𗋓; + #𗋔; + #𗋕; + #𗋖; + #𗋗; + #𗋘; + #𗋙; + #𗋚; + #𗋛; + #𗋜; + #𗋝; + #𗋞; + #𗋟; + #𗋠; + #𗋡; + #𗋢; + #𗋣; + #𗋤; + #𗋥; + #𗋦; + #𗋧; + #𗋨; + #𗋩; + #𗋪; + #𗋫; + #𗋬; + #𗋭; + #𗋮; + #𗋯; + #𗋰; + #𗋱; + #𗋲; + #𗋳; + #𗋴; + #𗋵; + #𗋶; + #𗋷; + #𗋸; + #𗋹; + #𗋺; + #𗋻; + #𗋼; + #𗋽; + #𗋾; + #𗋿; + #𗌀; + #𗌁; + #𗌂; + #𗌃; + #𗌄; + #𗌅; + #𗌆; + #𗌇; + #𗌈; + #𗌉; + #𗌊; + #𗌋; + #𗌌; + #𗌍; + #𗌎; + #𗌏; + #𗌐; + #𗌑; + #𗌒; + #𗌓; + #𗌔; + #𗌕; + #𗌖; + #𗌗; + #𗌘; + #𗌙; + #𗌚; + #𗌛; + #𗌜; + #𗌝; + #𗌞; + #𗌟; + #𗌠; + #𗌡; + #𗌢; + #𗌣; + #𗌤; + #𗌥; + #𗌦; + #𗌧; + #𗌨; + #𗌩; + #𗌪; + #𗌫; + #𗌬; + #𗌭; + #𗌮; + #𗌯; + #𗌰; + #𗌱; + #𗌲; + #𗌳; + #𗌴; + #𗌵; + #𗌶; + #𗌷; + #𗌸; + #𗌹; + #𗌺; + #𗌻; + #𗌼; + #𗌽; + #𗌾; + #𗌿; + #𗍀; + #𗍁; + #𗍂; + #𗍃; + #𗍄; + #𗍅; + #𗍆; + #𗍇; + #𗍈; + #𗍉; + #𗍊; + #𗍋; + #𗍌; + #𗍍; + #𗍎; + #𗍏; + #𗍐; + #𗍑; + #𗍒; + #𗍓; + #𗍔; + #𗍕; + #𗍖; + #𗍗; + #𗍘; + #𗍙; + #𗍚; + #𗍛; + #𗍜; + #𗍝; + #𗍞; + #𗍟; + #𗍠; + #𗍡; + #𗍢; + #𗍣; + #𗍤; + #𗍥; + #𗍦; + #𗍧; + #𗍨; + #𗍩; + #𗍪; + #𗍫; + #𗍬; + #𗍭; + #𗍮; + #𗍯; + #𗍰; + #𗍱; + #𗍲; + #𗍳; + #𗍴; + #𗍵; + #𗍶; + #𗍷; + #𗍸; + #𗍹; + #𗍺; + #𗍻; + #𗍼; + #𗍽; + #𗍾; + #𗍿; + #𗎀; + #𗎁; + #𗎂; + #𗎃; + #𗎄; + #𗎅; + #𗎆; + #𗎇; + #𗎈; + #𗎉; + #𗎊; + #𗎋; + #𗎌; + #𗎍; + #𗎎; + #𗎏; + #𗎐; + #𗎑; + #𗎒; + #𗎓; + #𗎔; + #𗎕; + #𗎖; + #𗎗; + #𗎘; + #𗎙; + #𗎚; + #𗎛; + #𗎜; + #𗎝; + #𗎞; + #𗎟; + #𗎠; + #𗎡; + #𗎢; + #𗎣; + #𗎤; + #𗎥; + #𗎦; + #𗎧; + #𗎨; + #𗎩; + #𗎪; + #𗎫; + #𗎬; + #𗎭; + #𗎮; + #𗎯; + #𗎰; + #𗎱; + #𗎲; + #𗎳; + #𗎴; + #𗎵; + #𗎶; + #𗎷; + #𗎸; + #𗎹; + #𗎺; + #𗎻; + #𗎼; + #𗎽; + #𗎾; + #𗎿; + #𗏀; + #𗏁; + #𗏂; + #𗏃; + #𗏄; + #𗏅; + #𗏆; + #𗏇; + #𗏈; + #𗏉; + #𗏊; + #𗏋; + #𗏌; + #𗏍; + #𗏎; + #𗏏; + #𗏐; + #𗏑; + #𗏒; + #𗏓; + #𗏔; + #𗏕; + #𗏖; + #𗏗; + #𗏘; + #𗏙; + #𗏚; + #𗏛; + #𗏜; + #𗏝; + #𗏞; + #𗏟; + #𗏠; + #𗏡; + #𗏢; + #𗏣; + #𗏤; + #𗏥; + #𗏦; + #𗏧; + #𗏨; + #𗏩; + #𗏪; + #𗏫; + #𗏬; + #𗏭; + #𗏮; + #𗏯; + #𗏰; + #𗏱; + #𗏲; + #𗏳; + #𗏴; + #𗏵; + #𗏶; + #𗏷; + #𗏸; + #𗏹; + #𗏺; + #𗏻; + #𗏼; + #𗏽; + #𗏾; + #𗏿; + #𗐀; + #𗐁; + #𗐂; + #𗐃; + #𗐄; + #𗐅; + #𗐆; + #𗐇; + #𗐈; + #𗐉; + #𗐊; + #𗐋; + #𗐌; + #𗐍; + #𗐎; + #𗐏; + #𗐐; + #𗐑; + #𗐒; + #𗐓; + #𗐔; + #𗐕; + #𗐖; + #𗐗; + #𗐘; + #𗐙; + #𗐚; + #𗐛; + #𗐜; + #𗐝; + #𗐞; + #𗐟; + #𗐠; + #𗐡; + #𗐢; + #𗐣; + #𗐤; + #𗐥; + #𗐦; + #𗐧; + #𗐨; + #𗐩; + #𗐪; + #𗐫; + #𗐬; + #𗐭; + #𗐮; + #𗐯; + #𗐰; + #𗐱; + #𗐲; + #𗐳; + #𗐴; + #𗐵; + #𗐶; + #𗐷; + #𗐸; + #𗐹; + #𗐺; + #𗐻; + #𗐼; + #𗐽; + #𗐾; + #𗐿; + #𗑀; + #𗑁; + #𗑂; + #𗑃; + #𗑄; + #𗑅; + #𗑆; + #𗑇; + #𗑈; + #𗑉; + #𗑊; + #𗑋; + #𗑌; + #𗑍; + #𗑎; + #𗑏; + #𗑐; + #𗑑; + #𗑒; + #𗑓; + #𗑔; + #𗑕; + #𗑖; + #𗑗; + #𗑘; + #𗑙; + #𗑚; + #𗑛; + #𗑜; + #𗑝; + #𗑞; + #𗑟; + #𗑠; + #𗑡; + #𗑢; + #𗑣; + #𗑤; + #𗑥; + #𗑦; + #𗑧; + #𗑨; + #𗑩; + #𗑪; + #𗑫; + #𗑬; + #𗑭; + #𗑮; + #𗑯; + #𗑰; + #𗑱; + #𗑲; + #𗑳; + #𗑴; + #𗑵; + #𗑶; + #𗑷; + #𗑸; + #𗑹; + #𗑺; + #𗑻; + #𗑼; + #𗑽; + #𗑾; + #𗑿; + #𗒀; + #𗒁; + #𗒂; + #𗒃; + #𗒄; + #𗒅; + #𗒆; + #𗒇; + #𗒈; + #𗒉; + #𗒊; + #𗒋; + #𗒌; + #𗒍; + #𗒎; + #𗒏; + #𗒐; + #𗒑; + #𗒒; + #𗒓; + #𗒔; + #𗒕; + #𗒖; + #𗒗; + #𗒘; + #𗒙; + #𗒚; + #𗒛; + #𗒜; + #𗒝; + #𗒞; + #𗒟; + #𗒠; + #𗒡; + #𗒢; + #𗒣; + #𗒤; + #𗒥; + #𗒦; + #𗒧; + #𗒨; + #𗒩; + #𗒪; + #𗒫; + #𗒬; + #𗒭; + #𗒮; + #𗒯; + #𗒰; + #𗒱; + #𗒲; + #𗒳; + #𗒴; + #𗒵; + #𗒶; + #𗒷; + #𗒸; + #𗒹; + #𗒺; + #𗒻; + #𗒼; + #𗒽; + #𗒾; + #𗒿; + #𗓀; + #𗓁; + #𗓂; + #𗓃; + #𗓄; + #𗓅; + #𗓆; + #𗓇; + #𗓈; + #𗓉; + #𗓊; + #𗓋; + #𗓌; + #𗓍; + #𗓎; + #𗓏; + #𗓐; + #𗓑; + #𗓒; + #𗓓; + #𗓔; + #𗓕; + #𗓖; + #𗓗; + #𗓘; + #𗓙; + #𗓚; + #𗓛; + #𗓜; + #𗓝; + #𗓞; + #𗓟; + #𗓠; + #𗓡; + #𗓢; + #𗓣; + #𗓤; + #𗓥; + #𗓦; + #𗓧; + #𗓨; + #𗓩; + #𗓪; + #𗓫; + #𗓬; + #𗓭; + #𗓮; + #𗓯; + #𗓰; + #𗓱; + #𗓲; + #𗓳; + #𗓴; + #𗓵; + #𗓶; + #𗓷; + #𗓸; + #𗓹; + #𗓺; + #𗓻; + #𗓼; + #𗓽; + #𗓾; + #𗓿; + #𗔀; + #𗔁; + #𗔂; + #𗔃; + #𗔄; + #𗔅; + #𗔆; + #𗔇; + #𗔈; + #𗔉; + #𗔊; + #𗔋; + #𗔌; + #𗔍; + #𗔎; + #𗔏; + #𗔐; + #𗔑; + #𗔒; + #𗔓; + #𗔔; + #𗔕; + #𗔖; + #𗔗; + #𗔘; + #𗔙; + #𗔚; + #𗔛; + #𗔜; + #𗔝; + #𗔞; + #𗔟; + #𗔠; + #𗔡; + #𗔢; + #𗔣; + #𗔤; + #𗔥; + #𗔦; + #𗔧; + #𗔨; + #𗔩; + #𗔪; + #𗔫; + #𗔬; + #𗔭; + #𗔮; + #𗔯; + #𗔰; + #𗔱; + #𗔲; + #𗔳; + #𗔴; + #𗔵; + #𗔶; + #𗔷; + #𗔸; + #𗔹; + #𗔺; + #𗔻; + #𗔼; + #𗔽; + #𗔾; + #𗔿; + #𗕀; + #𗕁; + #𗕂; + #𗕃; + #𗕄; + #𗕅; + #𗕆; + #𗕇; + #𗕈; + #𗕉; + #𗕊; + #𗕋; + #𗕌; + #𗕍; + #𗕎; + #𗕏; + #𗕐; + #𗕑; + #𗕒; + #𗕓; + #𗕔; + #𗕕; + #𗕖; + #𗕗; + #𗕘; + #𗕙; + #𗕚; + #𗕛; + #𗕜; + #𗕝; + #𗕞; + #𗕟; + #𗕠; + #𗕡; + #𗕢; + #𗕣; + #𗕤; + #𗕥; + #𗕦; + #𗕧; + #𗕨; + #𗕩; + #𗕪; + #𗕫; + #𗕬; + #𗕭; + #𗕮; + #𗕯; + #𗕰; + #𗕱; + #𗕲; + #𗕳; + #𗕴; + #𗕵; + #𗕶; + #𗕷; + #𗕸; + #𗕹; + #𗕺; + #𗕻; + #𗕼; + #𗕽; + #𗕾; + #𗕿; + #𗖀; + #𗖁; + #𗖂; + #𗖃; + #𗖄; + #𗖅; + #𗖆; + #𗖇; + #𗖈; + #𗖉; + #𗖊; + #𗖋; + #𗖌; + #𗖍; + #𗖎; + #𗖏; + #𗖐; + #𗖑; + #𗖒; + #𗖓; + #𗖔; + #𗖕; + #𗖖; + #𗖗; + #𗖘; + #𗖙; + #𗖚; + #𗖛; + #𗖜; + #𗖝; + #𗖞; + #𗖟; + #𗖠; + #𗖡; + #𗖢; + #𗖣; + #𗖤; + #𗖥; + #𗖦; + #𗖧; + #𗖨; + #𗖩; + #𗖪; + #𗖫; + #𗖬; + #𗖭; + #𗖮; + #𗖯; + #𗖰; + #𗖱; + #𗖲; + #𗖳; + #𗖴; + #𗖵; + #𗖶; + #𗖷; + #𗖸; + #𗖹; + #𗖺; + #𗖻; + #𗖼; + #𗖽; + #𗖾; + #𗖿; + #𗗀; + #𗗁; + #𗗂; + #𗗃; + #𗗄; + #𗗅; + #𗗆; + #𗗇; + #𗗈; + #𗗉; + #𗗊; + #𗗋; + #𗗌; + #𗗍; + #𗗎; + #𗗏; + #𗗐; + #𗗑; + #𗗒; + #𗗓; + #𗗔; + #𗗕; + #𗗖; + #𗗗; + #𗗘; + #𗗙; + #𗗚; + #𗗛; + #𗗜; + #𗗝; + #𗗞; + #𗗟; + #𗗠; + #𗗡; + #𗗢; + #𗗣; + #𗗤; + #𗗥; + #𗗦; + #𗗧; + #𗗨; + #𗗩; + #𗗪; + #𗗫; + #𗗬; + #𗗭; + #𗗮; + #𗗯; + #𗗰; + #𗗱; + #𗗲; + #𗗳; + #𗗴; + #𗗵; + #𗗶; + #𗗷; + #𗗸; + #𗗹; + #𗗺; + #𗗻; + #𗗼; + #𗗽; + #𗗾; + #𗗿; + #𗘀; + #𗘁; + #𗘂; + #𗘃; + #𗘄; + #𗘅; + #𗘆; + #𗘇; + #𗘈; + #𗘉; + #𗘊; + #𗘋; + #𗘌; + #𗘍; + #𗘎; + #𗘏; + #𗘐; + #𗘑; + #𗘒; + #𗘓; + #𗘔; + #𗘕; + #𗘖; + #𗘗; + #𗘘; + #𗘙; + #𗘚; + #𗘛; + #𗘜; + #𗘝; + #𗘞; + #𗘟; + #𗘠; + #𗘡; + #𗘢; + #𗘣; + #𗘤; + #𗘥; + #𗘦; + #𗘧; + #𗘨; + #𗘩; + #𗘪; + #𗘫; + #𗘬; + #𗘭; + #𗘮; + #𗘯; + #𗘰; + #𗘱; + #𗘲; + #𗘳; + #𗘴; + #𗘵; + #𗘶; + #𗘷; + #𗘸; + #𗘹; + #𗘺; + #𗘻; + #𗘼; + #𗘽; + #𗘾; + #𗘿; + #𗙀; + #𗙁; + #𗙂; + #𗙃; + #𗙄; + #𗙅; + #𗙆; + #𗙇; + #𗙈; + #𗙉; + #𗙊; + #𗙋; + #𗙌; + #𗙍; + #𗙎; + #𗙏; + #𗙐; + #𗙑; + #𗙒; + #𗙓; + #𗙔; + #𗙕; + #𗙖; + #𗙗; + #𗙘; + #𗙙; + #𗙚; + #𗙛; + #𗙜; + #𗙝; + #𗙞; + #𗙟; + #𗙠; + #𗙡; + #𗙢; + #𗙣; + #𗙤; + #𗙥; + #𗙦; + #𗙧; + #𗙨; + #𗙩; + #𗙪; + #𗙫; + #𗙬; + #𗙭; + #𗙮; + #𗙯; + #𗙰; + #𗙱; + #𗙲; + #𗙳; + #𗙴; + #𗙵; + #𗙶; + #𗙷; + #𗙸; + #𗙹; + #𗙺; + #𗙻; + #𗙼; + #𗙽; + #𗙾; + #𗙿; + #𗚀; + #𗚁; + #𗚂; + #𗚃; + #𗚄; + #𗚅; + #𗚆; + #𗚇; + #𗚈; + #𗚉; + #𗚊; + #𗚋; + #𗚌; + #𗚍; + #𗚎; + #𗚏; + #𗚐; + #𗚑; + #𗚒; + #𗚓; + #𗚔; + #𗚕; + #𗚖; + #𗚗; + #𗚘; + #𗚙; + #𗚚; + #𗚛; + #𗚜; + #𗚝; + #𗚞; + #𗚟; + #𗚠; + #𗚡; + #𗚢; + #𗚣; + #𗚤; + #𗚥; + #𗚦; + #𗚧; + #𗚨; + #𗚩; + #𗚪; + #𗚫; + #𗚬; + #𗚭; + #𗚮; + #𗚯; + #𗚰; + #𗚱; + #𗚲; + #𗚳; + #𗚴; + #𗚵; + #𗚶; + #𗚷; + #𗚸; + #𗚹; + #𗚺; + #𗚻; + #𗚼; + #𗚽; + #𗚾; + #𗚿; + #𗛀; + #𗛁; + #𗛂; + #𗛃; + #𗛄; + #𗛅; + #𗛆; + #𗛇; + #𗛈; + #𗛉; + #𗛊; + #𗛋; + #𗛌; + #𗛍; + #𗛎; + #𗛏; + #𗛐; + #𗛑; + #𗛒; + #𗛓; + #𗛔; + #𗛕; + #𗛖; + #𗛗; + #𗛘; + #𗛙; + #𗛚; + #𗛛; + #𗛜; + #𗛝; + #𗛞; + #𗛟; + #𗛠; + #𗛡; + #𗛢; + #𗛣; + #𗛤; + #𗛥; + #𗛦; + #𗛧; + #𗛨; + #𗛩; + #𗛪; + #𗛫; + #𗛬; + #𗛭; + #𗛮; + #𗛯; + #𗛰; + #𗛱; + #𗛲; + #𗛳; + #𗛴; + #𗛵; + #𗛶; + #𗛷; + #𗛸; + #𗛹; + #𗛺; + #𗛻; + #𗛼; + #𗛽; + #𗛾; + #𗛿; + #𗜀; + #𗜁; + #𗜂; + #𗜃; + #𗜄; + #𗜅; + #𗜆; + #𗜇; + #𗜈; + #𗜉; + #𗜊; + #𗜋; + #𗜌; + #𗜍; + #𗜎; + #𗜏; + #𗜐; + #𗜑; + #𗜒; + #𗜓; + #𗜔; + #𗜕; + #𗜖; + #𗜗; + #𗜘; + #𗜙; + #𗜚; + #𗜛; + #𗜜; + #𗜝; + #𗜞; + #𗜟; + #𗜠; + #𗜡; + #𗜢; + #𗜣; + #𗜤; + #𗜥; + #𗜦; + #𗜧; + #𗜨; + #𗜩; + #𗜪; + #𗜫; + #𗜬; + #𗜭; + #𗜮; + #𗜯; + #𗜰; + #𗜱; + #𗜲; + #𗜳; + #𗜴; + #𗜵; + #𗜶; + #𗜷; + #𗜸; + #𗜹; + #𗜺; + #𗜻; + #𗜼; + #𗜽; + #𗜾; + #𗜿; + #𗝀; + #𗝁; + #𗝂; + #𗝃; + #𗝄; + #𗝅; + #𗝆; + #𗝇; + #𗝈; + #𗝉; + #𗝊; + #𗝋; + #𗝌; + #𗝍; + #𗝎; + #𗝏; + #𗝐; + #𗝑; + #𗝒; + #𗝓; + #𗝔; + #𗝕; + #𗝖; + #𗝗; + #𗝘; + #𗝙; + #𗝚; + #𗝛; + #𗝜; + #𗝝; + #𗝞; + #𗝟; + #𗝠; + #𗝡; + #𗝢; + #𗝣; + #𗝤; + #𗝥; + #𗝦; + #𗝧; + #𗝨; + #𗝩; + #𗝪; + #𗝫; + #𗝬; + #𗝭; + #𗝮; + #𗝯; + #𗝰; + #𗝱; + #𗝲; + #𗝳; + #𗝴; + #𗝵; + #𗝶; + #𗝷; + #𗝸; + #𗝹; + #𗝺; + #𗝻; + #𗝼; + #𗝽; + #𗝾; + #𗝿; + #𗞀; + #𗞁; + #𗞂; + #𗞃; + #𗞄; + #𗞅; + #𗞆; + #𗞇; + #𗞈; + #𗞉; + #𗞊; + #𗞋; + #𗞌; + #𗞍; + #𗞎; + #𗞏; + #𗞐; + #𗞑; + #𗞒; + #𗞓; + #𗞔; + #𗞕; + #𗞖; + #𗞗; + #𗞘; + #𗞙; + #𗞚; + #𗞛; + #𗞜; + #𗞝; + #𗞞; + #𗞟; + #𗞠; + #𗞡; + #𗞢; + #𗞣; + #𗞤; + #𗞥; + #𗞦; + #𗞧; + #𗞨; + #𗞩; + #𗞪; + #𗞫; + #𗞬; + #𗞭; + #𗞮; + #𗞯; + #𗞰; + #𗞱; + #𗞲; + #𗞳; + #𗞴; + #𗞵; + #𗞶; + #𗞷; + #𗞸; + #𗞹; + #𗞺; + #𗞻; + #𗞼; + #𗞽; + #𗞾; + #𗞿; + #𗟀; + #𗟁; + #𗟂; + #𗟃; + #𗟄; + #𗟅; + #𗟆; + #𗟇; + #𗟈; + #𗟉; + #𗟊; + #𗟋; + #𗟌; + #𗟍; + #𗟎; + #𗟏; + #𗟐; + #𗟑; + #𗟒; + #𗟓; + #𗟔; + #𗟕; + #𗟖; + #𗟗; + #𗟘; + #𗟙; + #𗟚; + #𗟛; + #𗟜; + #𗟝; + #𗟞; + #𗟟; + #𗟠; + #𗟡; + #𗟢; + #𗟣; + #𗟤; + #𗟥; + #𗟦; + #𗟧; + #𗟨; + #𗟩; + #𗟪; + #𗟫; + #𗟬; + #𗟭; + #𗟮; + #𗟯; + #𗟰; + #𗟱; + #𗟲; + #𗟳; + #𗟴; + #𗟵; + #𗟶; + #𗟷; + #𗟸; + #𗟹; + #𗟺; + #𗟻; + #𗟼; + #𗟽; + #𗟾; + #𗟿; + #𗠀; + #𗠁; + #𗠂; + #𗠃; + #𗠄; + #𗠅; + #𗠆; + #𗠇; + #𗠈; + #𗠉; + #𗠊; + #𗠋; + #𗠌; + #𗠍; + #𗠎; + #𗠏; + #𗠐; + #𗠑; + #𗠒; + #𗠓; + #𗠔; + #𗠕; + #𗠖; + #𗠗; + #𗠘; + #𗠙; + #𗠚; + #𗠛; + #𗠜; + #𗠝; + #𗠞; + #𗠟; + #𗠠; + #𗠡; + #𗠢; + #𗠣; + #𗠤; + #𗠥; + #𗠦; + #𗠧; + #𗠨; + #𗠩; + #𗠪; + #𗠫; + #𗠬; + #𗠭; + #𗠮; + #𗠯; + #𗠰; + #𗠱; + #𗠲; + #𗠳; + #𗠴; + #𗠵; + #𗠶; + #𗠷; + #𗠸; + #𗠹; + #𗠺; + #𗠻; + #𗠼; + #𗠽; + #𗠾; + #𗠿; + #𗡀; + #𗡁; + #𗡂; + #𗡃; + #𗡄; + #𗡅; + #𗡆; + #𗡇; + #𗡈; + #𗡉; + #𗡊; + #𗡋; + #𗡌; + #𗡍; + #𗡎; + #𗡏; + #𗡐; + #𗡑; + #𗡒; + #𗡓; + #𗡔; + #𗡕; + #𗡖; + #𗡗; + #𗡘; + #𗡙; + #𗡚; + #𗡛; + #𗡜; + #𗡝; + #𗡞; + #𗡟; + #𗡠; + #𗡡; + #𗡢; + #𗡣; + #𗡤; + #𗡥; + #𗡦; + #𗡧; + #𗡨; + #𗡩; + #𗡪; + #𗡫; + #𗡬; + #𗡭; + #𗡮; + #𗡯; + #𗡰; + #𗡱; + #𗡲; + #𗡳; + #𗡴; + #𗡵; + #𗡶; + #𗡷; + #𗡸; + #𗡹; + #𗡺; + #𗡻; + #𗡼; + #𗡽; + #𗡾; + #𗡿; + #𗢀; + #𗢁; + #𗢂; + #𗢃; + #𗢄; + #𗢅; + #𗢆; + #𗢇; + #𗢈; + #𗢉; + #𗢊; + #𗢋; + #𗢌; + #𗢍; + #𗢎; + #𗢏; + #𗢐; + #𗢑; + #𗢒; + #𗢓; + #𗢔; + #𗢕; + #𗢖; + #𗢗; + #𗢘; + #𗢙; + #𗢚; + #𗢛; + #𗢜; + #𗢝; + #𗢞; + #𗢟; + #𗢠; + #𗢡; + #𗢢; + #𗢣; + #𗢤; + #𗢥; + #𗢦; + #𗢧; + #𗢨; + #𗢩; + #𗢪; + #𗢫; + #𗢬; + #𗢭; + #𗢮; + #𗢯; + #𗢰; + #𗢱; + #𗢲; + #𗢳; + #𗢴; + #𗢵; + #𗢶; + #𗢷; + #𗢸; + #𗢹; + #𗢺; + #𗢻; + #𗢼; + #𗢽; + #𗢾; + #𗢿; + #𗣀; + #𗣁; + #𗣂; + #𗣃; + #𗣄; + #𗣅; + #𗣆; + #𗣇; + #𗣈; + #𗣉; + #𗣊; + #𗣋; + #𗣌; + #𗣍; + #𗣎; + #𗣏; + #𗣐; + #𗣑; + #𗣒; + #𗣓; + #𗣔; + #𗣕; + #𗣖; + #𗣗; + #𗣘; + #𗣙; + #𗣚; + #𗣛; + #𗣜; + #𗣝; + #𗣞; + #𗣟; + #𗣠; + #𗣡; + #𗣢; + #𗣣; + #𗣤; + #𗣥; + #𗣦; + #𗣧; + #𗣨; + #𗣩; + #𗣪; + #𗣫; + #𗣬; + #𗣭; + #𗣮; + #𗣯; + #𗣰; + #𗣱; + #𗣲; + #𗣳; + #𗣴; + #𗣵; + #𗣶; + #𗣷; + #𗣸; + #𗣹; + #𗣺; + #𗣻; + #𗣼; + #𗣽; + #𗣾; + #𗣿; + #𗤀; + #𗤁; + #𗤂; + #𗤃; + #𗤄; + #𗤅; + #𗤆; + #𗤇; + #𗤈; + #𗤉; + #𗤊; + #𗤋; + #𗤌; + #𗤍; + #𗤎; + #𗤏; + #𗤐; + #𗤑; + #𗤒; + #𗤓; + #𗤔; + #𗤕; + #𗤖; + #𗤗; + #𗤘; + #𗤙; + #𗤚; + #𗤛; + #𗤜; + #𗤝; + #𗤞; + #𗤟; + #𗤠; + #𗤡; + #𗤢; + #𗤣; + #𗤤; + #𗤥; + #𗤦; + #𗤧; + #𗤨; + #𗤩; + #𗤪; + #𗤫; + #𗤬; + #𗤭; + #𗤮; + #𗤯; + #𗤰; + #𗤱; + #𗤲; + #𗤳; + #𗤴; + #𗤵; + #𗤶; + #𗤷; + #𗤸; + #𗤹; + #𗤺; + #𗤻; + #𗤼; + #𗤽; + #𗤾; + #𗤿; + #𗥀; + #𗥁; + #𗥂; + #𗥃; + #𗥄; + #𗥅; + #𗥆; + #𗥇; + #𗥈; + #𗥉; + #𗥊; + #𗥋; + #𗥌; + #𗥍; + #𗥎; + #𗥏; + #𗥐; + #𗥑; + #𗥒; + #𗥓; + #𗥔; + #𗥕; + #𗥖; + #𗥗; + #𗥘; + #𗥙; + #𗥚; + #𗥛; + #𗥜; + #𗥝; + #𗥞; + #𗥟; + #𗥠; + #𗥡; + #𗥢; + #𗥣; + #𗥤; + #𗥥; + #𗥦; + #𗥧; + #𗥨; + #𗥩; + #𗥪; + #𗥫; + #𗥬; + #𗥭; + #𗥮; + #𗥯; + #𗥰; + #𗥱; + #𗥲; + #𗥳; + #𗥴; + #𗥵; + #𗥶; + #𗥷; + #𗥸; + #𗥹; + #𗥺; + #𗥻; + #𗥼; + #𗥽; + #𗥾; + #𗥿; + #𗦀; + #𗦁; + #𗦂; + #𗦃; + #𗦄; + #𗦅; + #𗦆; + #𗦇; + #𗦈; + #𗦉; + #𗦊; + #𗦋; + #𗦌; + #𗦍; + #𗦎; + #𗦏; + #𗦐; + #𗦑; + #𗦒; + #𗦓; + #𗦔; + #𗦕; + #𗦖; + #𗦗; + #𗦘; + #𗦙; + #𗦚; + #𗦛; + #𗦜; + #𗦝; + #𗦞; + #𗦟; + #𗦠; + #𗦡; + #𗦢; + #𗦣; + #𗦤; + #𗦥; + #𗦦; + #𗦧; + #𗦨; + #𗦩; + #𗦪; + #𗦫; + #𗦬; + #𗦭; + #𗦮; + #𗦯; + #𗦰; + #𗦱; + #𗦲; + #𗦳; + #𗦴; + #𗦵; + #𗦶; + #𗦷; + #𗦸; + #𗦹; + #𗦺; + #𗦻; + #𗦼; + #𗦽; + #𗦾; + #𗦿; + #𗧀; + #𗧁; + #𗧂; + #𗧃; + #𗧄; + #𗧅; + #𗧆; + #𗧇; + #𗧈; + #𗧉; + #𗧊; + #𗧋; + #𗧌; + #𗧍; + #𗧎; + #𗧏; + #𗧐; + #𗧑; + #𗧒; + #𗧓; + #𗧔; + #𗧕; + #𗧖; + #𗧗; + #𗧘; + #𗧙; + #𗧚; + #𗧛; + #𗧜; + #𗧝; + #𗧞; + #𗧟; + #𗧠; + #𗧡; + #𗧢; + #𗧣; + #𗧤; + #𗧥; + #𗧦; + #𗧧; + #𗧨; + #𗧩; + #𗧪; + #𗧫; + #𗧬; + #𗧭; + #𗧮; + #𗧯; + #𗧰; + #𗧱; + #𗧲; + #𗧳; + #𗧴; + #𗧵; + #𗧶; + #𗧷; + #𗧸; + #𗧹; + #𗧺; + #𗧻; + #𗧼; + #𗧽; + #𗧾; + #𗧿; + #𗨀; + #𗨁; + #𗨂; + #𗨃; + #𗨄; + #𗨅; + #𗨆; + #𗨇; + #𗨈; + #𗨉; + #𗨊; + #𗨋; + #𗨌; + #𗨍; + #𗨎; + #𗨏; + #𗨐; + #𗨑; + #𗨒; + #𗨓; + #𗨔; + #𗨕; + #𗨖; + #𗨗; + #𗨘; + #𗨙; + #𗨚; + #𗨛; + #𗨜; + #𗨝; + #𗨞; + #𗨟; + #𗨠; + #𗨡; + #𗨢; + #𗨣; + #𗨤; + #𗨥; + #𗨦; + #𗨧; + #𗨨; + #𗨩; + #𗨪; + #𗨫; + #𗨬; + #𗨭; + #𗨮; + #𗨯; + #𗨰; + #𗨱; + #𗨲; + #𗨳; + #𗨴; + #𗨵; + #𗨶; + #𗨷; + #𗨸; + #𗨹; + #𗨺; + #𗨻; + #𗨼; + #𗨽; + #𗨾; + #𗨿; + #𗩀; + #𗩁; + #𗩂; + #𗩃; + #𗩄; + #𗩅; + #𗩆; + #𗩇; + #𗩈; + #𗩉; + #𗩊; + #𗩋; + #𗩌; + #𗩍; + #𗩎; + #𗩏; + #𗩐; + #𗩑; + #𗩒; + #𗩓; + #𗩔; + #𗩕; + #𗩖; + #𗩗; + #𗩘; + #𗩙; + #𗩚; + #𗩛; + #𗩜; + #𗩝; + #𗩞; + #𗩟; + #𗩠; + #𗩡; + #𗩢; + #𗩣; + #𗩤; + #𗩥; + #𗩦; + #𗩧; + #𗩨; + #𗩩; + #𗩪; + #𗩫; + #𗩬; + #𗩭; + #𗩮; + #𗩯; + #𗩰; + #𗩱; + #𗩲; + #𗩳; + #𗩴; + #𗩵; + #𗩶; + #𗩷; + #𗩸; + #𗩹; + #𗩺; + #𗩻; + #𗩼; + #𗩽; + #𗩾; + #𗩿; + #𗪀; + #𗪁; + #𗪂; + #𗪃; + #𗪄; + #𗪅; + #𗪆; + #𗪇; + #𗪈; + #𗪉; + #𗪊; + #𗪋; + #𗪌; + #𗪍; + #𗪎; + #𗪏; + #𗪐; + #𗪑; + #𗪒; + #𗪓; + #𗪔; + #𗪕; + #𗪖; + #𗪗; + #𗪘; + #𗪙; + #𗪚; + #𗪛; + #𗪜; + #𗪝; + #𗪞; + #𗪟; + #𗪠; + #𗪡; + #𗪢; + #𗪣; + #𗪤; + #𗪥; + #𗪦; + #𗪧; + #𗪨; + #𗪩; + #𗪪; + #𗪫; + #𗪬; + #𗪭; + #𗪮; + #𗪯; + #𗪰; + #𗪱; + #𗪲; + #𗪳; + #𗪴; + #𗪵; + #𗪶; + #𗪷; + #𗪸; + #𗪹; + #𗪺; + #𗪻; + #𗪼; + #𗪽; + #𗪾; + #𗪿; + #𗫀; + #𗫁; + #𗫂; + #𗫃; + #𗫄; + #𗫅; + #𗫆; + #𗫇; + #𗫈; + #𗫉; + #𗫊; + #𗫋; + #𗫌; + #𗫍; + #𗫎; + #𗫏; + #𗫐; + #𗫑; + #𗫒; + #𗫓; + #𗫔; + #𗫕; + #𗫖; + #𗫗; + #𗫘; + #𗫙; + #𗫚; + #𗫛; + #𗫜; + #𗫝; + #𗫞; + #𗫟; + #𗫠; + #𗫡; + #𗫢; + #𗫣; + #𗫤; + #𗫥; + #𗫦; + #𗫧; + #𗫨; + #𗫩; + #𗫪; + #𗫫; + #𗫬; + #𗫭; + #𗫮; + #𗫯; + #𗫰; + #𗫱; + #𗫲; + #𗫳; + #𗫴; + #𗫵; + #𗫶; + #𗫷; + #𗫸; + #𗫹; + #𗫺; + #𗫻; + #𗫼; + #𗫽; + #𗫾; + #𗫿; + #𗬀; + #𗬁; + #𗬂; + #𗬃; + #𗬄; + #𗬅; + #𗬆; + #𗬇; + #𗬈; + #𗬉; + #𗬊; + #𗬋; + #𗬌; + #𗬍; + #𗬎; + #𗬏; + #𗬐; + #𗬑; + #𗬒; + #𗬓; + #𗬔; + #𗬕; + #𗬖; + #𗬗; + #𗬘; + #𗬙; + #𗬚; + #𗬛; + #𗬜; + #𗬝; + #𗬞; + #𗬟; + #𗬠; + #𗬡; + #𗬢; + #𗬣; + #𗬤; + #𗬥; + #𗬦; + #𗬧; + #𗬨; + #𗬩; + #𗬪; + #𗬫; + #𗬬; + #𗬭; + #𗬮; + #𗬯; + #𗬰; + #𗬱; + #𗬲; + #𗬳; + #𗬴; + #𗬵; + #𗬶; + #𗬷; + #𗬸; + #𗬹; + #𗬺; + #𗬻; + #𗬼; + #𗬽; + #𗬾; + #𗬿; + #𗭀; + #𗭁; + #𗭂; + #𗭃; + #𗭄; + #𗭅; + #𗭆; + #𗭇; + #𗭈; + #𗭉; + #𗭊; + #𗭋; + #𗭌; + #𗭍; + #𗭎; + #𗭏; + #𗭐; + #𗭑; + #𗭒; + #𗭓; + #𗭔; + #𗭕; + #𗭖; + #𗭗; + #𗭘; + #𗭙; + #𗭚; + #𗭛; + #𗭜; + #𗭝; + #𗭞; + #𗭟; + #𗭠; + #𗭡; + #𗭢; + #𗭣; + #𗭤; + #𗭥; + #𗭦; + #𗭧; + #𗭨; + #𗭩; + #𗭪; + #𗭫; + #𗭬; + #𗭭; + #𗭮; + #𗭯; + #𗭰; + #𗭱; + #𗭲; + #𗭳; + #𗭴; + #𗭵; + #𗭶; + #𗭷; + #𗭸; + #𗭹; + #𗭺; + #𗭻; + #𗭼; + #𗭽; + #𗭾; + #𗭿; + #𗮀; + #𗮁; + #𗮂; + #𗮃; + #𗮄; + #𗮅; + #𗮆; + #𗮇; + #𗮈; + #𗮉; + #𗮊; + #𗮋; + #𗮌; + #𗮍; + #𗮎; + #𗮏; + #𗮐; + #𗮑; + #𗮒; + #𗮓; + #𗮔; + #𗮕; + #𗮖; + #𗮗; + #𗮘; + #𗮙; + #𗮚; + #𗮛; + #𗮜; + #𗮝; + #𗮞; + #𗮟; + #𗮠; + #𗮡; + #𗮢; + #𗮣; + #𗮤; + #𗮥; + #𗮦; + #𗮧; + #𗮨; + #𗮩; + #𗮪; + #𗮫; + #𗮬; + #𗮭; + #𗮮; + #𗮯; + #𗮰; + #𗮱; + #𗮲; + #𗮳; + #𗮴; + #𗮵; + #𗮶; + #𗮷; + #𗮸; + #𗮹; + #𗮺; + #𗮻; + #𗮼; + #𗮽; + #𗮾; + #𗮿; + #𗯀; + #𗯁; + #𗯂; + #𗯃; + #𗯄; + #𗯅; + #𗯆; + #𗯇; + #𗯈; + #𗯉; + #𗯊; + #𗯋; + #𗯌; + #𗯍; + #𗯎; + #𗯏; + #𗯐; + #𗯑; + #𗯒; + #𗯓; + #𗯔; + #𗯕; + #𗯖; + #𗯗; + #𗯘; + #𗯙; + #𗯚; + #𗯛; + #𗯜; + #𗯝; + #𗯞; + #𗯟; + #𗯠; + #𗯡; + #𗯢; + #𗯣; + #𗯤; + #𗯥; + #𗯦; + #𗯧; + #𗯨; + #𗯩; + #𗯪; + #𗯫; + #𗯬; + #𗯭; + #𗯮; + #𗯯; + #𗯰; + #𗯱; + #𗯲; + #𗯳; + #𗯴; + #𗯵; + #𗯶; + #𗯷; + #𗯸; + #𗯹; + #𗯺; + #𗯻; + #𗯼; + #𗯽; + #𗯾; + #𗯿; + #𗰀; + #𗰁; + #𗰂; + #𗰃; + #𗰄; + #𗰅; + #𗰆; + #𗰇; + #𗰈; + #𗰉; + #𗰊; + #𗰋; + #𗰌; + #𗰍; + #𗰎; + #𗰏; + #𗰐; + #𗰑; + #𗰒; + #𗰓; + #𗰔; + #𗰕; + #𗰖; + #𗰗; + #𗰘; + #𗰙; + #𗰚; + #𗰛; + #𗰜; + #𗰝; + #𗰞; + #𗰟; + #𗰠; + #𗰡; + #𗰢; + #𗰣; + #𗰤; + #𗰥; + #𗰦; + #𗰧; + #𗰨; + #𗰩; + #𗰪; + #𗰫; + #𗰬; + #𗰭; + #𗰮; + #𗰯; + #𗰰; + #𗰱; + #𗰲; + #𗰳; + #𗰴; + #𗰵; + #𗰶; + #𗰷; + #𗰸; + #𗰹; + #𗰺; + #𗰻; + #𗰼; + #𗰽; + #𗰾; + #𗰿; + #𗱀; + #𗱁; + #𗱂; + #𗱃; + #𗱄; + #𗱅; + #𗱆; + #𗱇; + #𗱈; + #𗱉; + #𗱊; + #𗱋; + #𗱌; + #𗱍; + #𗱎; + #𗱏; + #𗱐; + #𗱑; + #𗱒; + #𗱓; + #𗱔; + #𗱕; + #𗱖; + #𗱗; + #𗱘; + #𗱙; + #𗱚; + #𗱛; + #𗱜; + #𗱝; + #𗱞; + #𗱟; + #𗱠; + #𗱡; + #𗱢; + #𗱣; + #𗱤; + #𗱥; + #𗱦; + #𗱧; + #𗱨; + #𗱩; + #𗱪; + #𗱫; + #𗱬; + #𗱭; + #𗱮; + #𗱯; + #𗱰; + #𗱱; + #𗱲; + #𗱳; + #𗱴; + #𗱵; + #𗱶; + #𗱷; + #𗱸; + #𗱹; + #𗱺; + #𗱻; + #𗱼; + #𗱽; + #𗱾; + #𗱿; + #𗲀; + #𗲁; + #𗲂; + #𗲃; + #𗲄; + #𗲅; + #𗲆; + #𗲇; + #𗲈; + #𗲉; + #𗲊; + #𗲋; + #𗲌; + #𗲍; + #𗲎; + #𗲏; + #𗲐; + #𗲑; + #𗲒; + #𗲓; + #𗲔; + #𗲕; + #𗲖; + #𗲗; + #𗲘; + #𗲙; + #𗲚; + #𗲛; + #𗲜; + #𗲝; + #𗲞; + #𗲟; + #𗲠; + #𗲡; + #𗲢; + #𗲣; + #𗲤; + #𗲥; + #𗲦; + #𗲧; + #𗲨; + #𗲩; + #𗲪; + #𗲫; + #𗲬; + #𗲭; + #𗲮; + #𗲯; + #𗲰; + #𗲱; + #𗲲; + #𗲳; + #𗲴; + #𗲵; + #𗲶; + #𗲷; + #𗲸; + #𗲹; + #𗲺; + #𗲻; + #𗲼; + #𗲽; + #𗲾; + #𗲿; + #𗳀; + #𗳁; + #𗳂; + #𗳃; + #𗳄; + #𗳅; + #𗳆; + #𗳇; + #𗳈; + #𗳉; + #𗳊; + #𗳋; + #𗳌; + #𗳍; + #𗳎; + #𗳏; + #𗳐; + #𗳑; + #𗳒; + #𗳓; + #𗳔; + #𗳕; + #𗳖; + #𗳗; + #𗳘; + #𗳙; + #𗳚; + #𗳛; + #𗳜; + #𗳝; + #𗳞; + #𗳟; + #𗳠; + #𗳡; + #𗳢; + #𗳣; + #𗳤; + #𗳥; + #𗳦; + #𗳧; + #𗳨; + #𗳩; + #𗳪; + #𗳫; + #𗳬; + #𗳭; + #𗳮; + #𗳯; + #𗳰; + #𗳱; + #𗳲; + #𗳳; + #𗳴; + #𗳵; + #𗳶; + #𗳷; + #𗳸; + #𗳹; + #𗳺; + #𗳻; + #𗳼; + #𗳽; + #𗳾; + #𗳿; + #𗴀; + #𗴁; + #𗴂; + #𗴃; + #𗴄; + #𗴅; + #𗴆; + #𗴇; + #𗴈; + #𗴉; + #𗴊; + #𗴋; + #𗴌; + #𗴍; + #𗴎; + #𗴏; + #𗴐; + #𗴑; + #𗴒; + #𗴓; + #𗴔; + #𗴕; + #𗴖; + #𗴗; + #𗴘; + #𗴙; + #𗴚; + #𗴛; + #𗴜; + #𗴝; + #𗴞; + #𗴟; + #𗴠; + #𗴡; + #𗴢; + #𗴣; + #𗴤; + #𗴥; + #𗴦; + #𗴧; + #𗴨; + #𗴩; + #𗴪; + #𗴫; + #𗴬; + #𗴭; + #𗴮; + #𗴯; + #𗴰; + #𗴱; + #𗴲; + #𗴳; + #𗴴; + #𗴵; + #𗴶; + #𗴷; + #𗴸; + #𗴹; + #𗴺; + #𗴻; + #𗴼; + #𗴽; + #𗴾; + #𗴿; + #𗵀; + #𗵁; + #𗵂; + #𗵃; + #𗵄; + #𗵅; + #𗵆; + #𗵇; + #𗵈; + #𗵉; + #𗵊; + #𗵋; + #𗵌; + #𗵍; + #𗵎; + #𗵏; + #𗵐; + #𗵑; + #𗵒; + #𗵓; + #𗵔; + #𗵕; + #𗵖; + #𗵗; + #𗵘; + #𗵙; + #𗵚; + #𗵛; + #𗵜; + #𗵝; + #𗵞; + #𗵟; + #𗵠; + #𗵡; + #𗵢; + #𗵣; + #𗵤; + #𗵥; + #𗵦; + #𗵧; + #𗵨; + #𗵩; + #𗵪; + #𗵫; + #𗵬; + #𗵭; + #𗵮; + #𗵯; + #𗵰; + #𗵱; + #𗵲; + #𗵳; + #𗵴; + #𗵵; + #𗵶; + #𗵷; + #𗵸; + #𗵹; + #𗵺; + #𗵻; + #𗵼; + #𗵽; + #𗵾; + #𗵿; + #𗶀; + #𗶁; + #𗶂; + #𗶃; + #𗶄; + #𗶅; + #𗶆; + #𗶇; + #𗶈; + #𗶉; + #𗶊; + #𗶋; + #𗶌; + #𗶍; + #𗶎; + #𗶏; + #𗶐; + #𗶑; + #𗶒; + #𗶓; + #𗶔; + #𗶕; + #𗶖; + #𗶗; + #𗶘; + #𗶙; + #𗶚; + #𗶛; + #𗶜; + #𗶝; + #𗶞; + #𗶟; + #𗶠; + #𗶡; + #𗶢; + #𗶣; + #𗶤; + #𗶥; + #𗶦; + #𗶧; + #𗶨; + #𗶩; + #𗶪; + #𗶫; + #𗶬; + #𗶭; + #𗶮; + #𗶯; + #𗶰; + #𗶱; + #𗶲; + #𗶳; + #𗶴; + #𗶵; + #𗶶; + #𗶷; + #𗶸; + #𗶹; + #𗶺; + #𗶻; + #𗶼; + #𗶽; + #𗶾; + #𗶿; + #𗷀; + #𗷁; + #𗷂; + #𗷃; + #𗷄; + #𗷅; + #𗷆; + #𗷇; + #𗷈; + #𗷉; + #𗷊; + #𗷋; + #𗷌; + #𗷍; + #𗷎; + #𗷏; + #𗷐; + #𗷑; + #𗷒; + #𗷓; + #𗷔; + #𗷕; + #𗷖; + #𗷗; + #𗷘; + #𗷙; + #𗷚; + #𗷛; + #𗷜; + #𗷝; + #𗷞; + #𗷟; + #𗷠; + #𗷡; + #𗷢; + #𗷣; + #𗷤; + #𗷥; + #𗷦; + #𗷧; + #𗷨; + #𗷩; + #𗷪; + #𗷫; + #𗷬; + #𗷭; + #𗷮; + #𗷯; + #𗷰; + #𗷱; + #𗷲; + #𗷳; + #𗷴; + #𗷵; + #𗷶; + #𗷷; + #𗷸; + #𗷹; + #𗷺; + #𗷻; + #𗷼; + #𗷽; + #𗷾; + #𗷿; + #𗸀; + #𗸁; + #𗸂; + #𗸃; + #𗸄; + #𗸅; + #𗸆; + #𗸇; + #𗸈; + #𗸉; + #𗸊; + #𗸋; + #𗸌; + #𗸍; + #𗸎; + #𗸏; + #𗸐; + #𗸑; + #𗸒; + #𗸓; + #𗸔; + #𗸕; + #𗸖; + #𗸗; + #𗸘; + #𗸙; + #𗸚; + #𗸛; + #𗸜; + #𗸝; + #𗸞; + #𗸟; + #𗸠; + #𗸡; + #𗸢; + #𗸣; + #𗸤; + #𗸥; + #𗸦; + #𗸧; + #𗸨; + #𗸩; + #𗸪; + #𗸫; + #𗸬; + #𗸭; + #𗸮; + #𗸯; + #𗸰; + #𗸱; + #𗸲; + #𗸳; + #𗸴; + #𗸵; + #𗸶; + #𗸷; + #𗸸; + #𗸹; + #𗸺; + #𗸻; + #𗸼; + #𗸽; + #𗸾; + #𗸿; + #𗹀; + #𗹁; + #𗹂; + #𗹃; + #𗹄; + #𗹅; + #𗹆; + #𗹇; + #𗹈; + #𗹉; + #𗹊; + #𗹋; + #𗹌; + #𗹍; + #𗹎; + #𗹏; + #𗹐; + #𗹑; + #𗹒; + #𗹓; + #𗹔; + #𗹕; + #𗹖; + #𗹗; + #𗹘; + #𗹙; + #𗹚; + #𗹛; + #𗹜; + #𗹝; + #𗹞; + #𗹟; + #𗹠; + #𗹡; + #𗹢; + #𗹣; + #𗹤; + #𗹥; + #𗹦; + #𗹧; + #𗹨; + #𗹩; + #𗹪; + #𗹫; + #𗹬; + #𗹭; + #𗹮; + #𗹯; + #𗹰; + #𗹱; + #𗹲; + #𗹳; + #𗹴; + #𗹵; + #𗹶; + #𗹷; + #𗹸; + #𗹹; + #𗹺; + #𗹻; + #𗹼; + #𗹽; + #𗹾; + #𗹿; + #𗺀; + #𗺁; + #𗺂; + #𗺃; + #𗺄; + #𗺅; + #𗺆; + #𗺇; + #𗺈; + #𗺉; + #𗺊; + #𗺋; + #𗺌; + #𗺍; + #𗺎; + #𗺏; + #𗺐; + #𗺑; + #𗺒; + #𗺓; + #𗺔; + #𗺕; + #𗺖; + #𗺗; + #𗺘; + #𗺙; + #𗺚; + #𗺛; + #𗺜; + #𗺝; + #𗺞; + #𗺟; + #𗺠; + #𗺡; + #𗺢; + #𗺣; + #𗺤; + #𗺥; + #𗺦; + #𗺧; + #𗺨; + #𗺩; + #𗺪; + #𗺫; + #𗺬; + #𗺭; + #𗺮; + #𗺯; + #𗺰; + #𗺱; + #𗺲; + #𗺳; + #𗺴; + #𗺵; + #𗺶; + #𗺷; + #𗺸; + #𗺹; + #𗺺; + #𗺻; + #𗺼; + #𗺽; + #𗺾; + #𗺿; + #𗻀; + #𗻁; + #𗻂; + #𗻃; + #𗻄; + #𗻅; + #𗻆; + #𗻇; + #𗻈; + #𗻉; + #𗻊; + #𗻋; + #𗻌; + #𗻍; + #𗻎; + #𗻏; + #𗻐; + #𗻑; + #𗻒; + #𗻓; + #𗻔; + #𗻕; + #𗻖; + #𗻗; + #𗻘; + #𗻙; + #𗻚; + #𗻛; + #𗻜; + #𗻝; + #𗻞; + #𗻟; + #𗻠; + #𗻡; + #𗻢; + #𗻣; + #𗻤; + #𗻥; + #𗻦; + #𗻧; + #𗻨; + #𗻩; + #𗻪; + #𗻫; + #𗻬; + #𗻭; + #𗻮; + #𗻯; + #𗻰; + #𗻱; + #𗻲; + #𗻳; + #𗻴; + #𗻵; + #𗻶; + #𗻷; + #𗻸; + #𗻹; + #𗻺; + #𗻻; + #𗻼; + #𗻽; + #𗻾; + #𗻿; + #𗼀; + #𗼁; + #𗼂; + #𗼃; + #𗼄; + #𗼅; + #𗼆; + #𗼇; + #𗼈; + #𗼉; + #𗼊; + #𗼋; + #𗼌; + #𗼍; + #𗼎; + #𗼏; + #𗼐; + #𗼑; + #𗼒; + #𗼓; + #𗼔; + #𗼕; + #𗼖; + #𗼗; + #𗼘; + #𗼙; + #𗼚; + #𗼛; + #𗼜; + #𗼝; + #𗼞; + #𗼟; + #𗼠; + #𗼡; + #𗼢; + #𗼣; + #𗼤; + #𗼥; + #𗼦; + #𗼧; + #𗼨; + #𗼩; + #𗼪; + #𗼫; + #𗼬; + #𗼭; + #𗼮; + #𗼯; + #𗼰; + #𗼱; + #𗼲; + #𗼳; + #𗼴; + #𗼵; + #𗼶; + #𗼷; + #𗼸; + #𗼹; + #𗼺; + #𗼻; + #𗼼; + #𗼽; + #𗼾; + #𗼿; + #𗽀; + #𗽁; + #𗽂; + #𗽃; + #𗽄; + #𗽅; + #𗽆; + #𗽇; + #𗽈; + #𗽉; + #𗽊; + #𗽋; + #𗽌; + #𗽍; + #𗽎; + #𗽏; + #𗽐; + #𗽑; + #𗽒; + #𗽓; + #𗽔; + #𗽕; + #𗽖; + #𗽗; + #𗽘; + #𗽙; + #𗽚; + #𗽛; + #𗽜; + #𗽝; + #𗽞; + #𗽟; + #𗽠; + #𗽡; + #𗽢; + #𗽣; + #𗽤; + #𗽥; + #𗽦; + #𗽧; + #𗽨; + #𗽩; + #𗽪; + #𗽫; + #𗽬; + #𗽭; + #𗽮; + #𗽯; + #𗽰; + #𗽱; + #𗽲; + #𗽳; + #𗽴; + #𗽵; + #𗽶; + #𗽷; + #𗽸; + #𗽹; + #𗽺; + #𗽻; + #𗽼; + #𗽽; + #𗽾; + #𗽿; + #𗾀; + #𗾁; + #𗾂; + #𗾃; + #𗾄; + #𗾅; + #𗾆; + #𗾇; + #𗾈; + #𗾉; + #𗾊; + #𗾋; + #𗾌; + #𗾍; + #𗾎; + #𗾏; + #𗾐; + #𗾑; + #𗾒; + #𗾓; + #𗾔; + #𗾕; + #𗾖; + #𗾗; + #𗾘; + #𗾙; + #𗾚; + #𗾛; + #𗾜; + #𗾝; + #𗾞; + #𗾟; + #𗾠; + #𗾡; + #𗾢; + #𗾣; + #𗾤; + #𗾥; + #𗾦; + #𗾧; + #𗾨; + #𗾩; + #𗾪; + #𗾫; + #𗾬; + #𗾭; + #𗾮; + #𗾯; + #𗾰; + #𗾱; + #𗾲; + #𗾳; + #𗾴; + #𗾵; + #𗾶; + #𗾷; + #𗾸; + #𗾹; + #𗾺; + #𗾻; + #𗾼; + #𗾽; + #𗾾; + #𗾿; + #𗿀; + #𗿁; + #𗿂; + #𗿃; + #𗿄; + #𗿅; + #𗿆; + #𗿇; + #𗿈; + #𗿉; + #𗿊; + #𗿋; + #𗿌; + #𗿍; + #𗿎; + #𗿏; + #𗿐; + #𗿑; + #𗿒; + #𗿓; + #𗿔; + #𗿕; + #𗿖; + #𗿗; + #𗿘; + #𗿙; + #𗿚; + #𗿛; + #𗿜; + #𗿝; + #𗿞; + #𗿟; + #𗿠; + #𗿡; + #𗿢; + #𗿣; + #𗿤; + #𗿥; + #𗿦; + #𗿧; + #𗿨; + #𗿩; + #𗿪; + #𗿫; + #𗿬; + #𗿭; + #𗿮; + #𗿯; + #𗿰; + #𗿱; + #𗿲; + #𗿳; + #𗿴; + #𗿵; + #𗿶; + #𗿷; + #𗿸; + #𗿹; + #𗿺; + #𗿻; + #𗿼; + #𗿽; + #𗿾; + #𗿿; + #𘀀; + #𘀁; + #𘀂; + #𘀃; + #𘀄; + #𘀅; + #𘀆; + #𘀇; + #𘀈; + #𘀉; + #𘀊; + #𘀋; + #𘀌; + #𘀍; + #𘀎; + #𘀏; + #𘀐; + #𘀑; + #𘀒; + #𘀓; + #𘀔; + #𘀕; + #𘀖; + #𘀗; + #𘀘; + #𘀙; + #𘀚; + #𘀛; + #𘀜; + #𘀝; + #𘀞; + #𘀟; + #𘀠; + #𘀡; + #𘀢; + #𘀣; + #𘀤; + #𘀥; + #𘀦; + #𘀧; + #𘀨; + #𘀩; + #𘀪; + #𘀫; + #𘀬; + #𘀭; + #𘀮; + #𘀯; + #𘀰; + #𘀱; + #𘀲; + #𘀳; + #𘀴; + #𘀵; + #𘀶; + #𘀷; + #𘀸; + #𘀹; + #𘀺; + #𘀻; + #𘀼; + #𘀽; + #𘀾; + #𘀿; + #𘁀; + #𘁁; + #𘁂; + #𘁃; + #𘁄; + #𘁅; + #𘁆; + #𘁇; + #𘁈; + #𘁉; + #𘁊; + #𘁋; + #𘁌; + #𘁍; + #𘁎; + #𘁏; + #𘁐; + #𘁑; + #𘁒; + #𘁓; + #𘁔; + #𘁕; + #𘁖; + #𘁗; + #𘁘; + #𘁙; + #𘁚; + #𘁛; + #𘁜; + #𘁝; + #𘁞; + #𘁟; + #𘁠; + #𘁡; + #𘁢; + #𘁣; + #𘁤; + #𘁥; + #𘁦; + #𘁧; + #𘁨; + #𘁩; + #𘁪; + #𘁫; + #𘁬; + #𘁭; + #𘁮; + #𘁯; + #𘁰; + #𘁱; + #𘁲; + #𘁳; + #𘁴; + #𘁵; + #𘁶; + #𘁷; + #𘁸; + #𘁹; + #𘁺; + #𘁻; + #𘁼; + #𘁽; + #𘁾; + #𘁿; + #𘂀; + #𘂁; + #𘂂; + #𘂃; + #𘂄; + #𘂅; + #𘂆; + #𘂇; + #𘂈; + #𘂉; + #𘂊; + #𘂋; + #𘂌; + #𘂍; + #𘂎; + #𘂏; + #𘂐; + #𘂑; + #𘂒; + #𘂓; + #𘂔; + #𘂕; + #𘂖; + #𘂗; + #𘂘; + #𘂙; + #𘂚; + #𘂛; + #𘂜; + #𘂝; + #𘂞; + #𘂟; + #𘂠; + #𘂡; + #𘂢; + #𘂣; + #𘂤; + #𘂥; + #𘂦; + #𘂧; + #𘂨; + #𘂩; + #𘂪; + #𘂫; + #𘂬; + #𘂭; + #𘂮; + #𘂯; + #𘂰; + #𘂱; + #𘂲; + #𘂳; + #𘂴; + #𘂵; + #𘂶; + #𘂷; + #𘂸; + #𘂹; + #𘂺; + #𘂻; + #𘂼; + #𘂽; + #𘂾; + #𘂿; + #𘃀; + #𘃁; + #𘃂; + #𘃃; + #𘃄; + #𘃅; + #𘃆; + #𘃇; + #𘃈; + #𘃉; + #𘃊; + #𘃋; + #𘃌; + #𘃍; + #𘃎; + #𘃏; + #𘃐; + #𘃑; + #𘃒; + #𘃓; + #𘃔; + #𘃕; + #𘃖; + #𘃗; + #𘃘; + #𘃙; + #𘃚; + #𘃛; + #𘃜; + #𘃝; + #𘃞; + #𘃟; + #𘃠; + #𘃡; + #𘃢; + #𘃣; + #𘃤; + #𘃥; + #𘃦; + #𘃧; + #𘃨; + #𘃩; + #𘃪; + #𘃫; + #𘃬; + #𘃭; + #𘃮; + #𘃯; + #𘃰; + #𘃱; + #𘃲; + #𘃳; + #𘃴; + #𘃵; + #𘃶; + #𘃷; + #𘃸; + #𘃹; + #𘃺; + #𘃻; + #𘃼; + #𘃽; + #𘃾; + #𘃿; + #𘄀; + #𘄁; + #𘄂; + #𘄃; + #𘄄; + #𘄅; + #𘄆; + #𘄇; + #𘄈; + #𘄉; + #𘄊; + #𘄋; + #𘄌; + #𘄍; + #𘄎; + #𘄏; + #𘄐; + #𘄑; + #𘄒; + #𘄓; + #𘄔; + #𘄕; + #𘄖; + #𘄗; + #𘄘; + #𘄙; + #𘄚; + #𘄛; + #𘄜; + #𘄝; + #𘄞; + #𘄟; + #𘄠; + #𘄡; + #𘄢; + #𘄣; + #𘄤; + #𘄥; + #𘄦; + #𘄧; + #𘄨; + #𘄩; + #𘄪; + #𘄫; + #𘄬; + #𘄭; + #𘄮; + #𘄯; + #𘄰; + #𘄱; + #𘄲; + #𘄳; + #𘄴; + #𘄵; + #𘄶; + #𘄷; + #𘄸; + #𘄹; + #𘄺; + #𘄻; + #𘄼; + #𘄽; + #𘄾; + #𘄿; + #𘅀; + #𘅁; + #𘅂; + #𘅃; + #𘅄; + #𘅅; + #𘅆; + #𘅇; + #𘅈; + #𘅉; + #𘅊; + #𘅋; + #𘅌; + #𘅍; + #𘅎; + #𘅏; + #𘅐; + #𘅑; + #𘅒; + #𘅓; + #𘅔; + #𘅕; + #𘅖; + #𘅗; + #𘅘; + #𘅙; + #𘅚; + #𘅛; + #𘅜; + #𘅝; + #𘅞; + #𘅟; + #𘅠; + #𘅡; + #𘅢; + #𘅣; + #𘅤; + #𘅥; + #𘅦; + #𘅧; + #𘅨; + #𘅩; + #𘅪; + #𘅫; + #𘅬; + #𘅭; + #𘅮; + #𘅯; + #𘅰; + #𘅱; + #𘅲; + #𘅳; + #𘅴; + #𘅵; + #𘅶; + #𘅷; + #𘅸; + #𘅹; + #𘅺; + #𘅻; + #𘅼; + #𘅽; + #𘅾; + #𘅿; + #𘆀; + #𘆁; + #𘆂; + #𘆃; + #𘆄; + #𘆅; + #𘆆; + #𘆇; + #𘆈; + #𘆉; + #𘆊; + #𘆋; + #𘆌; + #𘆍; + #𘆎; + #𘆏; + #𘆐; + #𘆑; + #𘆒; + #𘆓; + #𘆔; + #𘆕; + #𘆖; + #𘆗; + #𘆘; + #𘆙; + #𘆚; + #𘆛; + #𘆜; + #𘆝; + #𘆞; + #𘆟; + #𘆠; + #𘆡; + #𘆢; + #𘆣; + #𘆤; + #𘆥; + #𘆦; + #𘆧; + #𘆨; + #𘆩; + #𘆪; + #𘆫; + #𘆬; + #𘆭; + #𘆮; + #𘆯; + #𘆰; + #𘆱; + #𘆲; + #𘆳; + #𘆴; + #𘆵; + #𘆶; + #𘆷; + #𘆸; + #𘆹; + #𘆺; + #𘆻; + #𘆼; + #𘆽; + #𘆾; + #𘆿; + #𘇀; + #𘇁; + #𘇂; + #𘇃; + #𘇄; + #𘇅; + #𘇆; + #𘇇; + #𘇈; + #𘇉; + #𘇊; + #𘇋; + #𘇌; + #𘇍; + #𘇎; + #𘇏; + #𘇐; + #𘇑; + #𘇒; + #𘇓; + #𘇔; + #𘇕; + #𘇖; + #𘇗; + #𘇘; + #𘇙; + #𘇚; + #𘇛; + #𘇜; + #𘇝; + #𘇞; + #𘇟; + #𘇠; + #𘇡; + #𘇢; + #𘇣; + #𘇤; + #𘇥; + #𘇦; + #𘇧; + #𘇨; + #𘇩; + #𘇪; + #𘇫; + #𘇬; + #𘇭; + #𘇮; + #𘇯; + #𘇰; + #𘇱; + #𘇲; + #𘇳; + #𘇴; + #𘇵; + #𘇶; + #𘇷; + #𘇸; + #𘇹; + #𘇺; + #𘇻; + #𘇼; + #𘇽; + #𘇾; + #𘇿; + #𘈀; + #𘈁; + #𘈂; + #𘈃; + #𘈄; + #𘈅; + #𘈆; + #𘈇; + #𘈈; + #𘈉; + #𘈊; + #𘈋; + #𘈌; + #𘈍; + #𘈎; + #𘈏; + #𘈐; + #𘈑; + #𘈒; + #𘈓; + #𘈔; + #𘈕; + #𘈖; + #𘈗; + #𘈘; + #𘈙; + #𘈚; + #𘈛; + #𘈜; + #𘈝; + #𘈞; + #𘈟; + #𘈠; + #𘈡; + #𘈢; + #𘈣; + #𘈤; + #𘈥; + #𘈦; + #𘈧; + #𘈨; + #𘈩; + #𘈪; + #𘈫; + #𘈬; + #𘈭; + #𘈮; + #𘈯; + #𘈰; + #𘈱; + #𘈲; + #𘈳; + #𘈴; + #𘈵; + #𘈶; + #𘈷; + #𘈸; + #𘈹; + #𘈺; + #𘈻; + #𘈼; + #𘈽; + #𘈾; + #𘈿; + #𘉀; + #𘉁; + #𘉂; + #𘉃; + #𘉄; + #𘉅; + #𘉆; + #𘉇; + #𘉈; + #𘉉; + #𘉊; + #𘉋; + #𘉌; + #𘉍; + #𘉎; + #𘉏; + #𘉐; + #𘉑; + #𘉒; + #𘉓; + #𘉔; + #𘉕; + #𘉖; + #𘉗; + #𘉘; + #𘉙; + #𘉚; + #𘉛; + #𘉜; + #𘉝; + #𘉞; + #𘉟; + #𘉠; + #𘉡; + #𘉢; + #𘉣; + #𘉤; + #𘉥; + #𘉦; + #𘉧; + #𘉨; + #𘉩; + #𘉪; + #𘉫; + #𘉬; + #𘉭; + #𘉮; + #𘉯; + #𘉰; + #𘉱; + #𘉲; + #𘉳; + #𘉴; + #𘉵; + #𘉶; + #𘉷; + #𘉸; + #𘉹; + #𘉺; + #𘉻; + #𘉼; + #𘉽; + #𘉾; + #𘉿; + #𘊀; + #𘊁; + #𘊂; + #𘊃; + #𘊄; + #𘊅; + #𘊆; + #𘊇; + #𘊈; + #𘊉; + #𘊊; + #𘊋; + #𘊌; + #𘊍; + #𘊎; + #𘊏; + #𘊐; + #𘊑; + #𘊒; + #𘊓; + #𘊔; + #𘊕; + #𘊖; + #𘊗; + #𘊘; + #𘊙; + #𘊚; + #𘊛; + #𘊜; + #𘊝; + #𘊞; + #𘊟; + #𘊠; + #𘊡; + #𘊢; + #𘊣; + #𘊤; + #𘊥; + #𘊦; + #𘊧; + #𘊨; + #𘊩; + #𘊪; + #𘊫; + #𘊬; + #𘊭; + #𘊮; + #𘊯; + #𘊰; + #𘊱; + #𘊲; + #𘊳; + #𘊴; + #𘊵; + #𘊶; + #𘊷; + #𘊸; + #𘊹; + #𘊺; + #𘊻; + #𘊼; + #𘊽; + #𘊾; + #𘊿; + #𘋀; + #𘋁; + #𘋂; + #𘋃; + #𘋄; + #𘋅; + #𘋆; + #𘋇; + #𘋈; + #𘋉; + #𘋊; + #𘋋; + #𘋌; + #𘋍; + #𘋎; + #𘋏; + #𘋐; + #𘋑; + #𘋒; + #𘋓; + #𘋔; + #𘋕; + #𘋖; + #𘋗; + #𘋘; + #𘋙; + #𘋚; + #𘋛; + #𘋜; + #𘋝; + #𘋞; + #𘋟; + #𘋠; + #𘋡; + #𘋢; + #𘋣; + #𘋤; + #𘋥; + #𘋦; + #𘋧; + #𘋨; + #𘋩; + #𘋪; + #𘋫; + #𘋬; + #𘋭; + #𘋮; + #𘋯; + #𘋰; + #𘋱; + #𘋲; + #𘋳; + #𘋴; + #𘋵; + #𘋶; + #𘋷; + #𘋸; + #𘋹; + #𘋺; + #𘋻; + #𘋼; + #𘋽; + #𘋾; + #𘋿; + #𘌀; + #𘌁; + #𘌂; + #𘌃; + #𘌄; + #𘌅; + #𘌆; + #𘌇; + #𘌈; + #𘌉; + #𘌊; + #𘌋; + #𘌌; + #𘌍; + #𘌎; + #𘌏; + #𘌐; + #𘌑; + #𘌒; + #𘌓; + #𘌔; + #𘌕; + #𘌖; + #𘌗; + #𘌘; + #𘌙; + #𘌚; + #𘌛; + #𘌜; + #𘌝; + #𘌞; + #𘌟; + #𘌠; + #𘌡; + #𘌢; + #𘌣; + #𘌤; + #𘌥; + #𘌦; + #𘌧; + #𘌨; + #𘌩; + #𘌪; + #𘌫; + #𘌬; + #𘌭; + #𘌮; + #𘌯; + #𘌰; + #𘌱; + #𘌲; + #𘌳; + #𘌴; + #𘌵; + #𘌶; + #𘌷; + #𘌸; + #𘌹; + #𘌺; + #𘌻; + #𘌼; + #𘌽; + #𘌾; + #𘌿; + #𘍀; + #𘍁; + #𘍂; + #𘍃; + #𘍄; + #𘍅; + #𘍆; + #𘍇; + #𘍈; + #𘍉; + #𘍊; + #𘍋; + #𘍌; + #𘍍; + #𘍎; + #𘍏; + #𘍐; + #𘍑; + #𘍒; + #𘍓; + #𘍔; + #𘍕; + #𘍖; + #𘍗; + #𘍘; + #𘍙; + #𘍚; + #𘍛; + #𘍜; + #𘍝; + #𘍞; + #𘍟; + #𘍠; + #𘍡; + #𘍢; + #𘍣; + #𘍤; + #𘍥; + #𘍦; + #𘍧; + #𘍨; + #𘍩; + #𘍪; + #𘍫; + #𘍬; + #𘍭; + #𘍮; + #𘍯; + #𘍰; + #𘍱; + #𘍲; + #𘍳; + #𘍴; + #𘍵; + #𘍶; + #𘍷; + #𘍸; + #𘍹; + #𘍺; + #𘍻; + #𘍼; + #𘍽; + #𘍾; + #𘍿; + #𘎀; + #𘎁; + #𘎂; + #𘎃; + #𘎄; + #𘎅; + #𘎆; + #𘎇; + #𘎈; + #𘎉; + #𘎊; + #𘎋; + #𘎌; + #𘎍; + #𘎎; + #𘎏; + #𘎐; + #𘎑; + #𘎒; + #𘎓; + #𘎔; + #𘎕; + #𘎖; + #𘎗; + #𘎘; + #𘎙; + #𘎚; + #𘎛; + #𘎜; + #𘎝; + #𘎞; + #𘎟; + #𘎠; + #𘎡; + #𘎢; + #𘎣; + #𘎤; + #𘎥; + #𘎦; + #𘎧; + #𘎨; + #𘎩; + #𘎪; + #𘎫; + #𘎬; + #𘎭; + #𘎮; + #𘎯; + #𘎰; + #𘎱; + #𘎲; + #𘎳; + #𘎴; + #𘎵; + #𘎶; + #𘎷; + #𘎸; + #𘎹; + #𘎺; + #𘎻; + #𘎼; + #𘎽; + #𘎾; + #𘎿; + #𘏀; + #𘏁; + #𘏂; + #𘏃; + #𘏄; + #𘏅; + #𘏆; + #𘏇; + #𘏈; + #𘏉; + #𘏊; + #𘏋; + #𘏌; + #𘏍; + #𘏎; + #𘏏; + #𘏐; + #𘏑; + #𘏒; + #𘏓; + #𘏔; + #𘏕; + #𘏖; + #𘏗; + #𘏘; + #𘏙; + #𘏚; + #𘏛; + #𘏜; + #𘏝; + #𘏞; + #𘏟; + #𘏠; + #𘏡; + #𘏢; + #𘏣; + #𘏤; + #𘏥; + #𘏦; + #𘏧; + #𘏨; + #𘏩; + #𘏪; + #𘏫; + #𘏬; + #𘏭; + #𘏮; + #𘏯; + #𘏰; + #𘏱; + #𘏲; + #𘏳; + #𘏴; + #𘏵; + #𘏶; + #𘏷; + #𘏸; + #𘏹; + #𘏺; + #𘏻; + #𘏼; + #𘏽; + #𘏾; + #𘏿; + #𘐀; + #𘐁; + #𘐂; + #𘐃; + #𘐄; + #𘐅; + #𘐆; + #𘐇; + #𘐈; + #𘐉; + #𘐊; + #𘐋; + #𘐌; + #𘐍; + #𘐎; + #𘐏; + #𘐐; + #𘐑; + #𘐒; + #𘐓; + #𘐔; + #𘐕; + #𘐖; + #𘐗; + #𘐘; + #𘐙; + #𘐚; + #𘐛; + #𘐜; + #𘐝; + #𘐞; + #𘐟; + #𘐠; + #𘐡; + #𘐢; + #𘐣; + #𘐤; + #𘐥; + #𘐦; + #𘐧; + #𘐨; + #𘐩; + #𘐪; + #𘐫; + #𘐬; + #𘐭; + #𘐮; + #𘐯; + #𘐰; + #𘐱; + #𘐲; + #𘐳; + #𘐴; + #𘐵; + #𘐶; + #𘐷; + #𘐸; + #𘐹; + #𘐺; + #𘐻; + #𘐼; + #𘐽; + #𘐾; + #𘐿; + #𘑀; + #𘑁; + #𘑂; + #𘑃; + #𘑄; + #𘑅; + #𘑆; + #𘑇; + #𘑈; + #𘑉; + #𘑊; + #𘑋; + #𘑌; + #𘑍; + #𘑎; + #𘑏; + #𘑐; + #𘑑; + #𘑒; + #𘑓; + #𘑔; + #𘑕; + #𘑖; + #𘑗; + #𘑘; + #𘑙; + #𘑚; + #𘑛; + #𘑜; + #𘑝; + #𘑞; + #𘑟; + #𘑠; + #𘑡; + #𘑢; + #𘑣; + #𘑤; + #𘑥; + #𘑦; + #𘑧; + #𘑨; + #𘑩; + #𘑪; + #𘑫; + #𘑬; + #𘑭; + #𘑮; + #𘑯; + #𘑰; + #𘑱; + #𘑲; + #𘑳; + #𘑴; + #𘑵; + #𘑶; + #𘑷; + #𘑸; + #𘑹; + #𘑺; + #𘑻; + #𘑼; + #𘑽; + #𘑾; + #𘑿; + #𘒀; + #𘒁; + #𘒂; + #𘒃; + #𘒄; + #𘒅; + #𘒆; + #𘒇; + #𘒈; + #𘒉; + #𘒊; + #𘒋; + #𘒌; + #𘒍; + #𘒎; + #𘒏; + #𘒐; + #𘒑; + #𘒒; + #𘒓; + #𘒔; + #𘒕; + #𘒖; + #𘒗; + #𘒘; + #𘒙; + #𘒚; + #𘒛; + #𘒜; + #𘒝; + #𘒞; + #𘒟; + #𘒠; + #𘒡; + #𘒢; + #𘒣; + #𘒤; + #𘒥; + #𘒦; + #𘒧; + #𘒨; + #𘒩; + #𘒪; + #𘒫; + #𘒬; + #𘒭; + #𘒮; + #𘒯; + #𘒰; + #𘒱; + #𘒲; + #𘒳; + #𘒴; + #𘒵; + #𘒶; + #𘒷; + #𘒸; + #𘒹; + #𘒺; + #𘒻; + #𘒼; + #𘒽; + #𘒾; + #𘒿; + #𘓀; + #𘓁; + #𘓂; + #𘓃; + #𘓄; + #𘓅; + #𘓆; + #𘓇; + #𘓈; + #𘓉; + #𘓊; + #𘓋; + #𘓌; + #𘓍; + #𘓎; + #𘓏; + #𘓐; + #𘓑; + #𘓒; + #𘓓; + #𘓔; + #𘓕; + #𘓖; + #𘓗; + #𘓘; + #𘓙; + #𘓚; + #𘓛; + #𘓜; + #𘓝; + #𘓞; + #𘓟; + #𘓠; + #𘓡; + #𘓢; + #𘓣; + #𘓤; + #𘓥; + #𘓦; + #𘓧; + #𘓨; + #𘓩; + #𘓪; + #𘓫; + #𘓬; + #𘓭; + #𘓮; + #𘓯; + #𘓰; + #𘓱; + #𘓲; + #𘓳; + #𘓴; + #𘓵; + #𘓶; + #𘓷; + #𘓸; + #𘓹; + #𘓺; + #𘓻; + #𘓼; + #𘓽; + #𘓾; + #𘓿; + #𘔀; + #𘔁; + #𘔂; + #𘔃; + #𘔄; + #𘔅; + #𘔆; + #𘔇; + #𘔈; + #𘔉; + #𘔊; + #𘔋; + #𘔌; + #𘔍; + #𘔎; + #𘔏; + #𘔐; + #𘔑; + #𘔒; + #𘔓; + #𘔔; + #𘔕; + #𘔖; + #𘔗; + #𘔘; + #𘔙; + #𘔚; + #𘔛; + #𘔜; + #𘔝; + #𘔞; + #𘔟; + #𘔠; + #𘔡; + #𘔢; + #𘔣; + #𘔤; + #𘔥; + #𘔦; + #𘔧; + #𘔨; + #𘔩; + #𘔪; + #𘔫; + #𘔬; + #𘔭; + #𘔮; + #𘔯; + #𘔰; + #𘔱; + #𘔲; + #𘔳; + #𘔴; + #𘔵; + #𘔶; + #𘔷; + #𘔸; + #𘔹; + #𘔺; + #𘔻; + #𘔼; + #𘔽; + #𘔾; + #𘔿; + #𘕀; + #𘕁; + #𘕂; + #𘕃; + #𘕄; + #𘕅; + #𘕆; + #𘕇; + #𘕈; + #𘕉; + #𘕊; + #𘕋; + #𘕌; + #𘕍; + #𘕎; + #𘕏; + #𘕐; + #𘕑; + #𘕒; + #𘕓; + #𘕔; + #𘕕; + #𘕖; + #𘕗; + #𘕘; + #𘕙; + #𘕚; + #𘕛; + #𘕜; + #𘕝; + #𘕞; + #𘕟; + #𘕠; + #𘕡; + #𘕢; + #𘕣; + #𘕤; + #𘕥; + #𘕦; + #𘕧; + #𘕨; + #𘕩; + #𘕪; + #𘕫; + #𘕬; + #𘕭; + #𘕮; + #𘕯; + #𘕰; + #𘕱; + #𘕲; + #𘕳; + #𘕴; + #𘕵; + #𘕶; + #𘕷; + #𘕸; + #𘕹; + #𘕺; + #𘕻; + #𘕼; + #𘕽; + #𘕾; + #𘕿; + #𘖀; + #𘖁; + #𘖂; + #𘖃; + #𘖄; + #𘖅; + #𘖆; + #𘖇; + #𘖈; + #𘖉; + #𘖊; + #𘖋; + #𘖌; + #𘖍; + #𘖎; + #𘖏; + #𘖐; + #𘖑; + #𘖒; + #𘖓; + #𘖔; + #𘖕; + #𘖖; + #𘖗; + #𘖘; + #𘖙; + #𘖚; + #𘖛; + #𘖜; + #𘖝; + #𘖞; + #𘖟; + #𘖠; + #𘖡; + #𘖢; + #𘖣; + #𘖤; + #𘖥; + #𘖦; + #𘖧; + #𘖨; + #𘖩; + #𘖪; + #𘖫; + #𘖬; + #𘖭; + #𘖮; + #𘖯; + #𘖰; + #𘖱; + #𘖲; + #𘖳; + #𘖴; + #𘖵; + #𘖶; + #𘖷; + #𘖸; + #𘖹; + #𘖺; + #𘖻; + #𘖼; + #𘖽; + #𘖾; + #𘖿; + #𘗀; + #𘗁; + #𘗂; + #𘗃; + #𘗄; + #𘗅; + #𘗆; + #𘗇; + #𘗈; + #𘗉; + #𘗊; + #𘗋; + #𘗌; + #𘗍; + #𘗎; + #𘗏; + #𘗐; + #𘗑; + #𘗒; + #𘗓; + #𘗔; + #𘗕; + #𘗖; + #𘗗; + #𘗘; + #𘗙; + #𘗚; + #𘗛; + #𘗜; + #𘗝; + #𘗞; + #𘗟; + #𘗠; + #𘗡; + #𘗢; + #𘗣; + #𘗤; + #𘗥; + #𘗦; + #𘗧; + #𘗨; + #𘗩; + #𘗪; + #𘗫; + #𘗬; + #𘗭; + #𘗮; + #𘗯; + #𘗰; + #𘗱; + #𘗲; + #𘗳; + #𘗴; + #𘗵; + #𘗶; + #𘗷; + #𘗸; + #𘗹; + #𘗺; + #𘗻; + #𘗼; + #𘗽; + #𘗾; + #𘗿; + #𘘀; + #𘘁; + #𘘂; + #𘘃; + #𘘄; + #𘘅; + #𘘆; + #𘘇; + #𘘈; + #𘘉; + #𘘊; + #𘘋; + #𘘌; + #𘘍; + #𘘎; + #𘘏; + #𘘐; + #𘘑; + #𘘒; + #𘘓; + #𘘔; + #𘘕; + #𘘖; + #𘘗; + #𘘘; + #𘘙; + #𘘚; + #𘘛; + #𘘜; + #𘘝; + #𘘞; + #𘘟; + #𘘠; + #𘘡; + #𘘢; + #𘘣; + #𘘤; + #𘘥; + #𘘦; + #𘘧; + #𘘨; + #𘘩; + #𘘪; + #𘘫; + #𘘬; + #𘘭; + #𘘮; + #𘘯; + #𘘰; + #𘘱; + #𘘲; + #𘘳; + #𘘴; + #𘘵; + #𘘶; + #𘘷; + #𘘸; + #𘘹; + #𘘺; + #𘘻; + #𘘼; + #𘘽; + #𘘾; + #𘘿; + #𘙀; + #𘙁; + #𘙂; + #𘙃; + #𘙄; + #𘙅; + #𘙆; + #𘙇; + #𘙈; + #𘙉; + #𘙊; + #𘙋; + #𘙌; + #𘙍; + #𘙎; + #𘙏; + #𘙐; + #𘙑; + #𘙒; + #𘙓; + #𘙔; + #𘙕; + #𘙖; + #𘙗; + #𘙘; + #𘙙; + #𘙚; + #𘙛; + #𘙜; + #𘙝; + #𘙞; + #𘙟; + #𘙠; + #𘙡; + #𘙢; + #𘙣; + #𘙤; + #𘙥; + #𘙦; + #𘙧; + #𘙨; + #𘙩; + #𘙪; + #𘙫; + #𘙬; + #𘙭; + #𘙮; + #𘙯; + #𘙰; + #𘙱; + #𘙲; + #𘙳; + #𘙴; + #𘙵; + #𘙶; + #𘙷; + #𘙸; + #𘙹; + #𘙺; + #𘙻; + #𘙼; + #𘙽; + #𘙾; + #𘙿; + #𘚀; + #𘚁; + #𘚂; + #𘚃; + #𘚄; + #𘚅; + #𘚆; + #𘚇; + #𘚈; + #𘚉; + #𘚊; + #𘚋; + #𘚌; + #𘚍; + #𘚎; + #𘚏; + #𘚐; + #𘚑; + #𘚒; + #𘚓; + #𘚔; + #𘚕; + #𘚖; + #𘚗; + #𘚘; + #𘚙; + #𘚚; + #𘚛; + #𘚜; + #𘚝; + #𘚞; + #𘚟; + #𘚠; + #𘚡; + #𘚢; + #𘚣; + #𘚤; + #𘚥; + #𘚦; + #𘚧; + #𘚨; + #𘚩; + #𘚪; + #𘚫; + #𘚬; + #𘚭; + #𘚮; + #𘚯; + #𘚰; + #𘚱; + #𘚲; + #𘚳; + #𘚴; + #𘚵; + #𘚶; + #𘚷; + #𘚸; + #𘚹; + #𘚺; + #𘚻; + #𘚼; + #𘚽; + #𘚾; + #𘚿; + #𘛀; + #𘛁; + #𘛂; + #𘛃; + #𘛄; + #𘛅; + #𘛆; + #𘛇; + #𘛈; + #𘛉; + #𘛊; + #𘛋; + #𘛌; + #𘛍; + #𘛎; + #𘛏; + #𘛐; + #𘛑; + #𘛒; + #𘛓; + #𘛔; + #𘛕; + #𘛖; + #𘛗; + #𘛘; + #𘛙; + #𘛚; + #𘛛; + #𘛜; + #𘛝; + #𘛞; + #𘛟; + #𘛠; + #𘛡; + #𘛢; + #𘛣; + #𘛤; + #𘛥; + #𘛦; + #𘛧; + #𘛨; + #𘛩; + #𘛪; + #𘛫; + #𘛬; + #𘛭; + #𘛮; + #𘛯; + #𘛰; + #𘛱; + #𘛲; + #𘛳; + #𘛴; + #𘛵; + #𘛶; + #𘛷; + #𘛸; + #𘛹; + #𘛺; + #𘛻; + #𘛼; + #𘛽; + #𘛾; + #𘛿; + #𘜀; + #𘜁; + #𘜂; + #𘜃; + #𘜄; + #𘜅; + #𘜆; + #𘜇; + #𘜈; + #𘜉; + #𘜊; + #𘜋; + #𘜌; + #𘜍; + #𘜎; + #𘜏; + #𘜐; + #𘜑; + #𘜒; + #𘜓; + #𘜔; + #𘜕; + #𘜖; + #𘜗; + #𘜘; + #𘜙; + #𘜚; + #𘜛; + #𘜜; + #𘜝; + #𘜞; + #𘜟; + #𘜠; + #𘜡; + #𘜢; + #𘜣; + #𘜤; + #𘜥; + #𘜦; + #𘜧; + #𘜨; + #𘜩; + #𘜪; + #𘜫; + #𘜬; + #𘜭; + #𘜮; + #𘜯; + #𘜰; + #𘜱; + #𘜲; + #𘜳; + #𘜴; + #𘜵; + #𘜶; + #𘜷; + #𘜸; + #𘜹; + #𘜺; + #𘜻; + #𘜼; + #𘜽; + #𘜾; + #𘜿; + #𘝀; + #𘝁; + #𘝂; + #𘝃; + #𘝄; + #𘝅; + #𘝆; + #𘝇; + #𘝈; + #𘝉; + #𘝊; + #𘝋; + #𘝌; + #𘝍; + #𘝎; + #𘝏; + #𘝐; + #𘝑; + #𘝒; + #𘝓; + #𘝔; + #𘝕; + #𘝖; + #𘝗; + #𘝘; + #𘝙; + #𘝚; + #𘝛; + #𘝜; + #𘝝; + #𘝞; + #𘝟; + #𘝠; + #𘝡; + #𘝢; + #𘝣; + #𘝤; + #𘝥; + #𘝦; + #𘝧; + #𘝨; + #𘝩; + #𘝪; + #𘝫; + #𘝬; + #𘝭; + #𘝮; + #𘝯; + #𘝰; + #𘝱; + #𘝲; + #𘝳; + #𘝴; + #𘝵; + #𘝶; + #𘝷; + #𘝸; + #𘝹; + #𘝺; + #𘝻; + #𘝼; + #𘝽; + #𘝾; + #𘝿; + #𘞀; + #𘞁; + #𘞂; + #𘞃; + #𘞄; + #𘞅; + #𘞆; + #𘞇; + #𘞈; + #𘞉; + #𘞊; + #𘞋; + #𘞌; + #𘞍; + #𘞎; + #𘞏; + #𘞐; + #𘞑; + #𘞒; + #𘞓; + #𘞔; + #𘞕; + #𘞖; + #𘞗; + #𘞘; + #𘞙; + #𘞚; + #𘞛; + #𘞜; + #𘞝; + #𘞞; + #𘞟; + #𘞠; + #𘞡; + #𘞢; + #𘞣; + #𘞤; + #𘞥; + #𘞦; + #𘞧; + #𘞨; + #𘞩; + #𘞪; + #𘞫; + #𘞬; + #𘞭; + #𘞮; + #𘞯; + #𘞰; + #𘞱; + #𘞲; + #𘞳; + #𘞴; + #𘞵; + #𘞶; + #𘞷; + #𘞸; + #𘞹; + #𘞺; + #𘞻; + #𘞼; + #𘞽; + #𘞾; + #𘞿; + #𘟀; + #𘟁; + #𘟂; + #𘟃; + #𘟄; + #𘟅; + #𘟆; + #𘟇; + #𘟈; + #𘟉; + #𘟊; + #𘟋; + #𘟌; + #𘟍; + #𘟎; + #𘟏; + #𘟐; + #𘟑; + #𘟒; + #𘟓; + #𘟔; + #𘟕; + #𘟖; + #𘟗; + #𘟘; + #𘟙; + #𘟚; + #𘟛; + #𘟜; + #𘟝; + #𘟞; + #𘟟; + #𘟠; + #𘟡; + #𘟢; + #𘟣; + #𘟤; + #𘟥; + #𘟦; + #𘟧; + #𘟨; + #𘟩; + #𘟪; + #𘟫; + #𘟬; + #𘠀; + #𘠁; + #𘠂; + #𘠃; + #𘠄; + #𘠅; + #𘠆; + #𘠇; + #𘠈; + #𘠉; + #𘠊; + #𘠋; + #𘠌; + #𘠍; + #𘠎; + #𘠏; + #𘠐; + #𘠑; + #𘠒; + #𘠓; + #𘠔; + #𘠕; + #𘠖; + #𘠗; + #𘠘; + #𘠙; + #𘠚; + #𘠛; + #𘠜; + #𘠝; + #𘠞; + #𘠟; + #𘠠; + #𘠡; + #𘠢; + #𘠣; + #𘠤; + #𘠥; + #𘠦; + #𘠧; + #𘠨; + #𘠩; + #𘠪; + #𘠫; + #𘠬; + #𘠭; + #𘠮; + #𘠯; + #𘠰; + #𘠱; + #𘠲; + #𘠳; + #𘠴; + #𘠵; + #𘠶; + #𘠷; + #𘠸; + #𘠹; + #𘠺; + #𘠻; + #𘠼; + #𘠽; + #𘠾; + #𘠿; + #𘡀; + #𘡁; + #𘡂; + #𘡃; + #𘡄; + #𘡅; + #𘡆; + #𘡇; + #𘡈; + #𘡉; + #𘡊; + #𘡋; + #𘡌; + #𘡍; + #𘡎; + #𘡏; + #𘡐; + #𘡑; + #𘡒; + #𘡓; + #𘡔; + #𘡕; + #𘡖; + #𘡗; + #𘡘; + #𘡙; + #𘡚; + #𘡛; + #𘡜; + #𘡝; + #𘡞; + #𘡟; + #𘡠; + #𘡡; + #𘡢; + #𘡣; + #𘡤; + #𘡥; + #𘡦; + #𘡧; + #𘡨; + #𘡩; + #𘡪; + #𘡫; + #𘡬; + #𘡭; + #𘡮; + #𘡯; + #𘡰; + #𘡱; + #𘡲; + #𘡳; + #𘡴; + #𘡵; + #𘡶; + #𘡷; + #𘡸; + #𘡹; + #𘡺; + #𘡻; + #𘡼; + #𘡽; + #𘡾; + #𘡿; + #𘢀; + #𘢁; + #𘢂; + #𘢃; + #𘢄; + #𘢅; + #𘢆; + #𘢇; + #𘢈; + #𘢉; + #𘢊; + #𘢋; + #𘢌; + #𘢍; + #𘢎; + #𘢏; + #𘢐; + #𘢑; + #𘢒; + #𘢓; + #𘢔; + #𘢕; + #𘢖; + #𘢗; + #𘢘; + #𘢙; + #𘢚; + #𘢛; + #𘢜; + #𘢝; + #𘢞; + #𘢟; + #𘢠; + #𘢡; + #𘢢; + #𘢣; + #𘢤; + #𘢥; + #𘢦; + #𘢧; + #𘢨; + #𘢩; + #𘢪; + #𘢫; + #𘢬; + #𘢭; + #𘢮; + #𘢯; + #𘢰; + #𘢱; + #𘢲; + #𘢳; + #𘢴; + #𘢵; + #𘢶; + #𘢷; + #𘢸; + #𘢹; + #𘢺; + #𘢻; + #𘢼; + #𘢽; + #𘢾; + #𘢿; + #𘣀; + #𘣁; + #𘣂; + #𘣃; + #𘣄; + #𘣅; + #𘣆; + #𘣇; + #𘣈; + #𘣉; + #𘣊; + #𘣋; + #𘣌; + #𘣍; + #𘣎; + #𘣏; + #𘣐; + #𘣑; + #𘣒; + #𘣓; + #𘣔; + #𘣕; + #𘣖; + #𘣗; + #𘣘; + #𘣙; + #𘣚; + #𘣛; + #𘣜; + #𘣝; + #𘣞; + #𘣟; + #𘣠; + #𘣡; + #𘣢; + #𘣣; + #𘣤; + #𘣥; + #𘣦; + #𘣧; + #𘣨; + #𘣩; + #𘣪; + #𘣫; + #𘣬; + #𘣭; + #𘣮; + #𘣯; + #𘣰; + #𘣱; + #𘣲; + #𘣳; + #𘣴; + #𘣵; + #𘣶; + #𘣷; + #𘣸; + #𘣹; + #𘣺; + #𘣻; + #𘣼; + #𘣽; + #𘣾; + #𘣿; + #𘤀; + #𘤁; + #𘤂; + #𘤃; + #𘤄; + #𘤅; + #𘤆; + #𘤇; + #𘤈; + #𘤉; + #𘤊; + #𘤋; + #𘤌; + #𘤍; + #𘤎; + #𘤏; + #𘤐; + #𘤑; + #𘤒; + #𘤓; + #𘤔; + #𘤕; + #𘤖; + #𘤗; + #𘤘; + #𘤙; + #𘤚; + #𘤛; + #𘤜; + #𘤝; + #𘤞; + #𘤟; + #𘤠; + #𘤡; + #𘤢; + #𘤣; + #𘤤; + #𘤥; + #𘤦; + #𘤧; + #𘤨; + #𘤩; + #𘤪; + #𘤫; + #𘤬; + #𘤭; + #𘤮; + #𘤯; + #𘤰; + #𘤱; + #𘤲; + #𘤳; + #𘤴; + #𘤵; + #𘤶; + #𘤷; + #𘤸; + #𘤹; + #𘤺; + #𘤻; + #𘤼; + #𘤽; + #𘤾; + #𘤿; + #𘥀; + #𘥁; + #𘥂; + #𘥃; + #𘥄; + #𘥅; + #𘥆; + #𘥇; + #𘥈; + #𘥉; + #𘥊; + #𘥋; + #𘥌; + #𘥍; + #𘥎; + #𘥏; + #𘥐; + #𘥑; + #𘥒; + #𘥓; + #𘥔; + #𘥕; + #𘥖; + #𘥗; + #𘥘; + #𘥙; + #𘥚; + #𘥛; + #𘥜; + #𘥝; + #𘥞; + #𘥟; + #𘥠; + #𘥡; + #𘥢; + #𘥣; + #𘥤; + #𘥥; + #𘥦; + #𘥧; + #𘥨; + #𘥩; + #𘥪; + #𘥫; + #𘥬; + #𘥭; + #𘥮; + #𘥯; + #𘥰; + #𘥱; + #𘥲; + #𘥳; + #𘥴; + #𘥵; + #𘥶; + #𘥷; + #𘥸; + #𘥹; + #𘥺; + #𘥻; + #𘥼; + #𘥽; + #𘥾; + #𘥿; + #𘦀; + #𘦁; + #𘦂; + #𘦃; + #𘦄; + #𘦅; + #𘦆; + #𘦇; + #𘦈; + #𘦉; + #𘦊; + #𘦋; + #𘦌; + #𘦍; + #𘦎; + #𘦏; + #𘦐; + #𘦑; + #𘦒; + #𘦓; + #𘦔; + #𘦕; + #𘦖; + #𘦗; + #𘦘; + #𘦙; + #𘦚; + #𘦛; + #𘦜; + #𘦝; + #𘦞; + #𘦟; + #𘦠; + #𘦡; + #𘦢; + #𘦣; + #𘦤; + #𘦥; + #𘦦; + #𘦧; + #𘦨; + #𘦩; + #𘦪; + #𘦫; + #𘦬; + #𘦭; + #𘦮; + #𘦯; + #𘦰; + #𘦱; + #𘦲; + #𘦳; + #𘦴; + #𘦵; + #𘦶; + #𘦷; + #𘦸; + #𘦹; + #𘦺; + #𘦻; + #𘦼; + #𘦽; + #𘦾; + #𘦿; + #𘧀; + #𘧁; + #𘧂; + #𘧃; + #𘧄; + #𘧅; + #𘧆; + #𘧇; + #𘧈; + #𘧉; + #𘧊; + #𘧋; + #𘧌; + #𘧍; + #𘧎; + #𘧏; + #𘧐; + #𘧑; + #𘧒; + #𘧓; + #𘧔; + #𘧕; + #𘧖; + #𘧗; + #𘧘; + #𘧙; + #𘧚; + #𘧛; + #𘧜; + #𘧝; + #𘧞; + #𘧟; + #𘧠; + #𘧡; + #𘧢; + #𘧣; + #𘧤; + #𘧥; + #𘧦; + #𘧧; + #𘧨; + #𘧩; + #𘧪; + #𘧫; + #𘧬; + #𘧭; + #𘧮; + #𘧯; + #𘧰; + #𘧱; + #𘧲; + #𘧳; + #𘧴; + #𘧵; + #𘧶; + #𘧷; + #𘧸; + #𘧹; + #𘧺; + #𘧻; + #𘧼; + #𘧽; + #𘧾; + #𘧿; + #𘨀; + #𘨁; + #𘨂; + #𘨃; + #𘨄; + #𘨅; + #𘨆; + #𘨇; + #𘨈; + #𘨉; + #𘨊; + #𘨋; + #𘨌; + #𘨍; + #𘨎; + #𘨏; + #𘨐; + #𘨑; + #𘨒; + #𘨓; + #𘨔; + #𘨕; + #𘨖; + #𘨗; + #𘨘; + #𘨙; + #𘨚; + #𘨛; + #𘨜; + #𘨝; + #𘨞; + #𘨟; + #𘨠; + #𘨡; + #𘨢; + #𘨣; + #𘨤; + #𘨥; + #𘨦; + #𘨧; + #𘨨; + #𘨩; + #𘨪; + #𘨫; + #𘨬; + #𘨭; + #𘨮; + #𘨯; + #𘨰; + #𘨱; + #𘨲; + #𘨳; + #𘨴; + #𘨵; + #𘨶; + #𘨷; + #𘨸; + #𘨹; + #𘨺; + #𘨻; + #𘨼; + #𘨽; + #𘨾; + #𘨿; + #𘩀; + #𘩁; + #𘩂; + #𘩃; + #𘩄; + #𘩅; + #𘩆; + #𘩇; + #𘩈; + #𘩉; + #𘩊; + #𘩋; + #𘩌; + #𘩍; + #𘩎; + #𘩏; + #𘩐; + #𘩑; + #𘩒; + #𘩓; + #𘩔; + #𘩕; + #𘩖; + #𘩗; + #𘩘; + #𘩙; + #𘩚; + #𘩛; + #𘩜; + #𘩝; + #𘩞; + #𘩟; + #𘩠; + #𘩡; + #𘩢; + #𘩣; + #𘩤; + #𘩥; + #𘩦; + #𘩧; + #𘩨; + #𘩩; + #𘩪; + #𘩫; + #𘩬; + #𘩭; + #𘩮; + #𘩯; + #𘩰; + #𘩱; + #𘩲; + #𘩳; + #𘩴; + #𘩵; + #𘩶; + #𘩷; + #𘩸; + #𘩹; + #𘩺; + #𘩻; + #𘩼; + #𘩽; + #𘩾; + #𘩿; + #𘪀; + #𘪁; + #𘪂; + #𘪃; + #𘪄; + #𘪅; + #𘪆; + #𘪇; + #𘪈; + #𘪉; + #𘪊; + #𘪋; + #𘪌; + #𘪍; + #𘪎; + #𘪏; + #𘪐; + #𘪑; + #𘪒; + #𘪓; + #𘪔; + #𘪕; + #𘪖; + #𘪗; + #𘪘; + #𘪙; + #𘪚; + #𘪛; + #𘪜; + #𘪝; + #𘪞; + #𘪟; + #𘪠; + #𘪡; + #𘪢; + #𘪣; + #𘪤; + #𘪥; + #𘪦; + #𘪧; + #𘪨; + #𘪩; + #𘪪; + #𘪫; + #𘪬; + #𘪭; + #𘪮; + #𘪯; + #𘪰; + #𘪱; + #𘪲; + #𘪳; + #𘪴; + #𘪵; + #𘪶; + #𘪷; + #𘪸; + #𘪹; + #𘪺; + #𘪻; + #𘪼; + #𘪽; + #𘪾; + #𘪿; + #𘫀; + #𘫁; + #𘫂; + #𘫃; + #𘫄; + #𘫅; + #𘫆; + #𘫇; + #𘫈; + #𘫉; + #𘫊; + #𘫋; + #𘫌; + #𘫍; + #𘫎; + #𘫏; + #𘫐; + #𘫑; + #𘫒; + #𘫓; + #𘫔; + #𘫕; + #𘫖; + #𘫗; + #𘫘; + #𘫙; + #𘫚; + #𘫛; + #𘫜; + #𘫝; + #𘫞; + #𘫟; + #𘫠; + #𘫡; + #𘫢; + #𘫣; + #𘫤; + #𘫥; + #𘫦; + #𘫧; + #𘫨; + #𘫩; + #𘫪; + #𘫫; + #𘫬; + #𘫭; + #𘫮; + #𘫯; + #𘫰; + #𘫱; + #𘫲; + #𞤀; + #𞤁; + #𞤂; + #𞤃; + #𞤄; + #𞤅; + #𞤆; + #𞤇; + #𞤈; + #𞤉; + #𞤊; + #𞤋; + #𞤌; + #𞤍; + #𞤎; + #𞤏; + #𞤐; + #𞤑; + #𞤒; + #𞤓; + #𞤔; + #𞤕; + #𞤖; + #𞤗; + #𞤘; + #𞤙; + #𞤚; + #𞤛; + #𞤜; + #𞤝; + #𞤞; + #𞤟; + #𞤠; + #𞤡; + #𞤢; + #𞤣; + #𞤤; + #𞤥; + #𞤦; + #𞤧; + #𞤨; + #𞤩; + #𞤪; + #𞤫; + #𞤬; + #𞤭; + #𞤮; + #𞤯; + #𞤰; + #𞤱; + #𞤲; + #𞤳; + #𞤴; + #𞤵; + #𞤶; + #𞤷; + #𞤸; + #𞤹; + #𞤺; + #𞤻; + #𞤼; + #𞤽; + #𞤾; + #𞤿; + #𞥀; + #𞥁; + #𞥂; + #𞥃; +}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0-escaped.js new file mode 100644 index 000000000..32cfd563d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0-escaped.js @@ -0,0 +1,7192 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v9.0.0 ID_Start characters are accepted as + identifier start characters in escaped form, i.e. + - \uXXXX or \u{XXXX} for BMP symbols + - \u{XXXXXX} for astral symbols +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var \u08B6; +var \u08B7; +var \u08B8; +var \u08B9; +var \u08BA; +var \u08BB; +var \u08BC; +var \u08BD; +var \u0C80; +var \u0D54; +var \u0D55; +var \u0D56; +var \u1C80; +var \u1C81; +var \u1C82; +var \u1C83; +var \u1C84; +var \u1C85; +var \u1C86; +var \u1C87; +var \u1C88; +var \uA7AE; +var \u{104B0}; +var \u{104B1}; +var \u{104B2}; +var \u{104B3}; +var \u{104B4}; +var \u{104B5}; +var \u{104B6}; +var \u{104B7}; +var \u{104B8}; +var \u{104B9}; +var \u{104BA}; +var \u{104BB}; +var \u{104BC}; +var \u{104BD}; +var \u{104BE}; +var \u{104BF}; +var \u{104C0}; +var \u{104C1}; +var \u{104C2}; +var \u{104C3}; +var \u{104C4}; +var \u{104C5}; +var \u{104C6}; +var \u{104C7}; +var \u{104C8}; +var \u{104C9}; +var \u{104CA}; +var \u{104CB}; +var \u{104CC}; +var \u{104CD}; +var \u{104CE}; +var \u{104CF}; +var \u{104D0}; +var \u{104D1}; +var \u{104D2}; +var \u{104D3}; +var \u{104D8}; +var \u{104D9}; +var \u{104DA}; +var \u{104DB}; +var \u{104DC}; +var \u{104DD}; +var \u{104DE}; +var \u{104DF}; +var \u{104E0}; +var \u{104E1}; +var \u{104E2}; +var \u{104E3}; +var \u{104E4}; +var \u{104E5}; +var \u{104E6}; +var \u{104E7}; +var \u{104E8}; +var \u{104E9}; +var \u{104EA}; +var \u{104EB}; +var \u{104EC}; +var \u{104ED}; +var \u{104EE}; +var \u{104EF}; +var \u{104F0}; +var \u{104F1}; +var \u{104F2}; +var \u{104F3}; +var \u{104F4}; +var \u{104F5}; +var \u{104F6}; +var \u{104F7}; +var \u{104F8}; +var \u{104F9}; +var \u{104FA}; +var \u{104FB}; +var \u{11400}; +var \u{11401}; +var \u{11402}; +var \u{11403}; +var \u{11404}; +var \u{11405}; +var \u{11406}; +var \u{11407}; +var \u{11408}; +var \u{11409}; +var \u{1140A}; +var \u{1140B}; +var \u{1140C}; +var \u{1140D}; +var \u{1140E}; +var \u{1140F}; +var \u{11410}; +var \u{11411}; +var \u{11412}; +var \u{11413}; +var \u{11414}; +var \u{11415}; +var \u{11416}; +var \u{11417}; +var \u{11418}; +var \u{11419}; +var \u{1141A}; +var \u{1141B}; +var \u{1141C}; +var \u{1141D}; +var \u{1141E}; +var \u{1141F}; +var \u{11420}; +var \u{11421}; +var \u{11422}; +var \u{11423}; +var \u{11424}; +var \u{11425}; +var \u{11426}; +var \u{11427}; +var \u{11428}; +var \u{11429}; +var \u{1142A}; +var \u{1142B}; +var \u{1142C}; +var \u{1142D}; +var \u{1142E}; +var \u{1142F}; +var \u{11430}; +var \u{11431}; +var \u{11432}; +var \u{11433}; +var \u{11434}; +var \u{11447}; +var \u{11448}; +var \u{11449}; +var \u{1144A}; +var \u{11C00}; +var \u{11C01}; +var \u{11C02}; +var \u{11C03}; +var \u{11C04}; +var \u{11C05}; +var \u{11C06}; +var \u{11C07}; +var \u{11C08}; +var \u{11C0A}; +var \u{11C0B}; +var \u{11C0C}; +var \u{11C0D}; +var \u{11C0E}; +var \u{11C0F}; +var \u{11C10}; +var \u{11C11}; +var \u{11C12}; +var \u{11C13}; +var \u{11C14}; +var \u{11C15}; +var \u{11C16}; +var \u{11C17}; +var \u{11C18}; +var \u{11C19}; +var \u{11C1A}; +var \u{11C1B}; +var \u{11C1C}; +var \u{11C1D}; +var \u{11C1E}; +var \u{11C1F}; +var \u{11C20}; +var \u{11C21}; +var \u{11C22}; +var \u{11C23}; +var \u{11C24}; +var \u{11C25}; +var \u{11C26}; +var \u{11C27}; +var \u{11C28}; +var \u{11C29}; +var \u{11C2A}; +var \u{11C2B}; +var \u{11C2C}; +var \u{11C2D}; +var \u{11C2E}; +var \u{11C40}; +var \u{11C72}; +var \u{11C73}; +var \u{11C74}; +var \u{11C75}; +var \u{11C76}; +var \u{11C77}; +var \u{11C78}; +var \u{11C79}; +var \u{11C7A}; +var \u{11C7B}; +var \u{11C7C}; +var \u{11C7D}; +var \u{11C7E}; +var \u{11C7F}; +var \u{11C80}; +var \u{11C81}; +var \u{11C82}; +var \u{11C83}; +var \u{11C84}; +var \u{11C85}; +var \u{11C86}; +var \u{11C87}; +var \u{11C88}; +var \u{11C89}; +var \u{11C8A}; +var \u{11C8B}; +var \u{11C8C}; +var \u{11C8D}; +var \u{11C8E}; +var \u{11C8F}; +var \u{16FE0}; +var \u{17000}; +var \u{17001}; +var \u{17002}; +var \u{17003}; +var \u{17004}; +var \u{17005}; +var \u{17006}; +var \u{17007}; +var \u{17008}; +var \u{17009}; +var \u{1700A}; +var \u{1700B}; +var \u{1700C}; +var \u{1700D}; +var \u{1700E}; +var \u{1700F}; +var \u{17010}; +var \u{17011}; +var \u{17012}; +var \u{17013}; +var \u{17014}; +var \u{17015}; +var \u{17016}; +var \u{17017}; +var \u{17018}; +var \u{17019}; +var \u{1701A}; +var \u{1701B}; +var \u{1701C}; +var \u{1701D}; +var \u{1701E}; +var \u{1701F}; +var \u{17020}; +var \u{17021}; +var \u{17022}; +var \u{17023}; +var \u{17024}; +var \u{17025}; +var \u{17026}; +var \u{17027}; +var \u{17028}; +var \u{17029}; +var \u{1702A}; +var \u{1702B}; +var \u{1702C}; +var \u{1702D}; +var \u{1702E}; +var \u{1702F}; +var \u{17030}; +var \u{17031}; +var \u{17032}; +var \u{17033}; +var \u{17034}; +var \u{17035}; +var \u{17036}; +var \u{17037}; +var \u{17038}; +var \u{17039}; +var \u{1703A}; +var \u{1703B}; +var \u{1703C}; +var \u{1703D}; +var \u{1703E}; +var \u{1703F}; +var \u{17040}; +var \u{17041}; +var \u{17042}; +var \u{17043}; +var \u{17044}; +var \u{17045}; +var \u{17046}; +var \u{17047}; +var \u{17048}; +var \u{17049}; +var \u{1704A}; +var \u{1704B}; +var \u{1704C}; +var \u{1704D}; +var \u{1704E}; +var \u{1704F}; +var \u{17050}; +var \u{17051}; +var \u{17052}; +var \u{17053}; +var \u{17054}; +var \u{17055}; +var \u{17056}; +var \u{17057}; +var \u{17058}; +var \u{17059}; +var \u{1705A}; +var \u{1705B}; +var \u{1705C}; +var \u{1705D}; +var \u{1705E}; +var \u{1705F}; +var \u{17060}; +var \u{17061}; +var \u{17062}; +var \u{17063}; +var \u{17064}; +var \u{17065}; +var \u{17066}; +var \u{17067}; +var \u{17068}; +var \u{17069}; +var \u{1706A}; +var \u{1706B}; +var \u{1706C}; +var \u{1706D}; +var \u{1706E}; +var \u{1706F}; +var \u{17070}; +var \u{17071}; +var \u{17072}; +var \u{17073}; +var \u{17074}; +var \u{17075}; +var \u{17076}; +var \u{17077}; +var \u{17078}; +var \u{17079}; +var \u{1707A}; +var \u{1707B}; +var \u{1707C}; +var \u{1707D}; +var \u{1707E}; +var \u{1707F}; +var \u{17080}; +var \u{17081}; +var \u{17082}; +var \u{17083}; +var \u{17084}; +var \u{17085}; +var \u{17086}; +var \u{17087}; +var \u{17088}; +var \u{17089}; +var \u{1708A}; +var \u{1708B}; +var \u{1708C}; +var \u{1708D}; +var \u{1708E}; +var \u{1708F}; +var \u{17090}; +var \u{17091}; +var \u{17092}; +var \u{17093}; +var \u{17094}; +var \u{17095}; +var \u{17096}; +var \u{17097}; +var \u{17098}; +var \u{17099}; +var \u{1709A}; +var \u{1709B}; +var \u{1709C}; +var \u{1709D}; +var \u{1709E}; +var \u{1709F}; +var \u{170A0}; +var \u{170A1}; +var \u{170A2}; +var \u{170A3}; +var \u{170A4}; +var \u{170A5}; +var \u{170A6}; +var \u{170A7}; +var \u{170A8}; +var \u{170A9}; +var \u{170AA}; +var \u{170AB}; +var \u{170AC}; +var \u{170AD}; +var \u{170AE}; +var \u{170AF}; +var \u{170B0}; +var \u{170B1}; +var \u{170B2}; +var \u{170B3}; +var \u{170B4}; +var \u{170B5}; +var \u{170B6}; +var \u{170B7}; +var \u{170B8}; +var \u{170B9}; +var \u{170BA}; +var \u{170BB}; +var \u{170BC}; +var \u{170BD}; +var \u{170BE}; +var \u{170BF}; +var \u{170C0}; +var \u{170C1}; +var \u{170C2}; +var \u{170C3}; +var \u{170C4}; +var \u{170C5}; +var \u{170C6}; +var \u{170C7}; +var \u{170C8}; +var \u{170C9}; +var \u{170CA}; +var \u{170CB}; +var \u{170CC}; +var \u{170CD}; +var \u{170CE}; +var \u{170CF}; +var \u{170D0}; +var \u{170D1}; +var \u{170D2}; +var \u{170D3}; +var \u{170D4}; +var \u{170D5}; +var \u{170D6}; +var \u{170D7}; +var \u{170D8}; +var \u{170D9}; +var \u{170DA}; +var \u{170DB}; +var \u{170DC}; +var \u{170DD}; +var \u{170DE}; +var \u{170DF}; +var \u{170E0}; +var \u{170E1}; +var \u{170E2}; +var \u{170E3}; +var \u{170E4}; +var \u{170E5}; +var \u{170E6}; +var \u{170E7}; +var \u{170E8}; +var \u{170E9}; +var \u{170EA}; +var \u{170EB}; +var \u{170EC}; +var \u{170ED}; +var \u{170EE}; +var \u{170EF}; +var \u{170F0}; +var \u{170F1}; +var \u{170F2}; +var \u{170F3}; +var \u{170F4}; +var \u{170F5}; +var \u{170F6}; +var \u{170F7}; +var \u{170F8}; +var \u{170F9}; +var \u{170FA}; +var \u{170FB}; +var \u{170FC}; +var \u{170FD}; +var \u{170FE}; +var \u{170FF}; +var \u{17100}; +var \u{17101}; +var \u{17102}; +var \u{17103}; +var \u{17104}; +var \u{17105}; +var \u{17106}; +var \u{17107}; +var \u{17108}; +var \u{17109}; +var \u{1710A}; +var \u{1710B}; +var \u{1710C}; +var \u{1710D}; +var \u{1710E}; +var \u{1710F}; +var \u{17110}; +var \u{17111}; +var \u{17112}; +var \u{17113}; +var \u{17114}; +var \u{17115}; +var \u{17116}; +var \u{17117}; +var \u{17118}; +var \u{17119}; +var \u{1711A}; +var \u{1711B}; +var \u{1711C}; +var \u{1711D}; +var \u{1711E}; +var \u{1711F}; +var \u{17120}; +var \u{17121}; +var \u{17122}; +var \u{17123}; +var \u{17124}; +var \u{17125}; +var \u{17126}; +var \u{17127}; +var \u{17128}; +var \u{17129}; +var \u{1712A}; +var \u{1712B}; +var \u{1712C}; +var \u{1712D}; +var \u{1712E}; +var \u{1712F}; +var \u{17130}; +var \u{17131}; +var \u{17132}; +var \u{17133}; +var \u{17134}; +var \u{17135}; +var \u{17136}; +var \u{17137}; +var \u{17138}; +var \u{17139}; +var \u{1713A}; +var \u{1713B}; +var \u{1713C}; +var \u{1713D}; +var \u{1713E}; +var \u{1713F}; +var \u{17140}; +var \u{17141}; +var \u{17142}; +var \u{17143}; +var \u{17144}; +var \u{17145}; +var \u{17146}; +var \u{17147}; +var \u{17148}; +var \u{17149}; +var \u{1714A}; +var \u{1714B}; +var \u{1714C}; +var \u{1714D}; +var \u{1714E}; +var \u{1714F}; +var \u{17150}; +var \u{17151}; +var \u{17152}; +var \u{17153}; +var \u{17154}; +var \u{17155}; +var \u{17156}; +var \u{17157}; +var \u{17158}; +var \u{17159}; +var \u{1715A}; +var \u{1715B}; +var \u{1715C}; +var \u{1715D}; +var \u{1715E}; +var \u{1715F}; +var \u{17160}; +var \u{17161}; +var \u{17162}; +var \u{17163}; +var \u{17164}; +var \u{17165}; +var \u{17166}; +var \u{17167}; +var \u{17168}; +var \u{17169}; +var \u{1716A}; +var \u{1716B}; +var \u{1716C}; +var \u{1716D}; +var \u{1716E}; +var \u{1716F}; +var \u{17170}; +var \u{17171}; +var \u{17172}; +var \u{17173}; +var \u{17174}; +var \u{17175}; +var \u{17176}; +var \u{17177}; +var \u{17178}; +var \u{17179}; +var \u{1717A}; +var \u{1717B}; +var \u{1717C}; +var \u{1717D}; +var \u{1717E}; +var \u{1717F}; +var \u{17180}; +var \u{17181}; +var \u{17182}; +var \u{17183}; +var \u{17184}; +var \u{17185}; +var \u{17186}; +var \u{17187}; +var \u{17188}; +var \u{17189}; +var \u{1718A}; +var \u{1718B}; +var \u{1718C}; +var \u{1718D}; +var \u{1718E}; +var \u{1718F}; +var \u{17190}; +var \u{17191}; +var \u{17192}; +var \u{17193}; +var \u{17194}; +var \u{17195}; +var \u{17196}; +var \u{17197}; +var \u{17198}; +var \u{17199}; +var \u{1719A}; +var \u{1719B}; +var \u{1719C}; +var \u{1719D}; +var \u{1719E}; +var \u{1719F}; +var \u{171A0}; +var \u{171A1}; +var \u{171A2}; +var \u{171A3}; +var \u{171A4}; +var \u{171A5}; +var \u{171A6}; +var \u{171A7}; +var \u{171A8}; +var \u{171A9}; +var \u{171AA}; +var \u{171AB}; +var \u{171AC}; +var \u{171AD}; +var \u{171AE}; +var \u{171AF}; +var \u{171B0}; +var \u{171B1}; +var \u{171B2}; +var \u{171B3}; +var \u{171B4}; +var \u{171B5}; +var \u{171B6}; +var \u{171B7}; +var \u{171B8}; +var \u{171B9}; +var \u{171BA}; +var \u{171BB}; +var \u{171BC}; +var \u{171BD}; +var \u{171BE}; +var \u{171BF}; +var \u{171C0}; +var \u{171C1}; +var \u{171C2}; +var \u{171C3}; +var \u{171C4}; +var \u{171C5}; +var \u{171C6}; +var \u{171C7}; +var \u{171C8}; +var \u{171C9}; +var \u{171CA}; +var \u{171CB}; +var \u{171CC}; +var \u{171CD}; +var \u{171CE}; +var \u{171CF}; +var \u{171D0}; +var \u{171D1}; +var \u{171D2}; +var \u{171D3}; +var \u{171D4}; +var \u{171D5}; +var \u{171D6}; +var \u{171D7}; +var \u{171D8}; +var \u{171D9}; +var \u{171DA}; +var \u{171DB}; +var \u{171DC}; +var \u{171DD}; +var \u{171DE}; +var \u{171DF}; +var \u{171E0}; +var \u{171E1}; +var \u{171E2}; +var \u{171E3}; +var \u{171E4}; +var \u{171E5}; +var \u{171E6}; +var \u{171E7}; +var \u{171E8}; +var \u{171E9}; +var \u{171EA}; +var \u{171EB}; +var \u{171EC}; +var \u{171ED}; +var \u{171EE}; +var \u{171EF}; +var \u{171F0}; +var \u{171F1}; +var \u{171F2}; +var \u{171F3}; +var \u{171F4}; +var \u{171F5}; +var \u{171F6}; +var \u{171F7}; +var \u{171F8}; +var \u{171F9}; +var \u{171FA}; +var \u{171FB}; +var \u{171FC}; +var \u{171FD}; +var \u{171FE}; +var \u{171FF}; +var \u{17200}; +var \u{17201}; +var \u{17202}; +var \u{17203}; +var \u{17204}; +var \u{17205}; +var \u{17206}; +var \u{17207}; +var \u{17208}; +var \u{17209}; +var \u{1720A}; +var \u{1720B}; +var \u{1720C}; +var \u{1720D}; +var \u{1720E}; +var \u{1720F}; +var \u{17210}; +var \u{17211}; +var \u{17212}; +var \u{17213}; +var \u{17214}; +var \u{17215}; +var \u{17216}; +var \u{17217}; +var \u{17218}; +var \u{17219}; +var \u{1721A}; +var \u{1721B}; +var \u{1721C}; +var \u{1721D}; +var \u{1721E}; +var \u{1721F}; +var \u{17220}; +var \u{17221}; +var \u{17222}; +var \u{17223}; +var \u{17224}; +var \u{17225}; +var \u{17226}; +var \u{17227}; +var \u{17228}; +var \u{17229}; +var \u{1722A}; +var \u{1722B}; +var \u{1722C}; +var \u{1722D}; +var \u{1722E}; +var \u{1722F}; +var \u{17230}; +var \u{17231}; +var \u{17232}; +var \u{17233}; +var \u{17234}; +var \u{17235}; +var \u{17236}; +var \u{17237}; +var \u{17238}; +var \u{17239}; +var \u{1723A}; +var \u{1723B}; +var \u{1723C}; +var \u{1723D}; +var \u{1723E}; +var \u{1723F}; +var \u{17240}; +var \u{17241}; +var \u{17242}; +var \u{17243}; +var \u{17244}; +var \u{17245}; +var \u{17246}; +var \u{17247}; +var \u{17248}; +var \u{17249}; +var \u{1724A}; +var \u{1724B}; +var \u{1724C}; +var \u{1724D}; +var \u{1724E}; +var \u{1724F}; +var \u{17250}; +var \u{17251}; +var \u{17252}; +var \u{17253}; +var \u{17254}; +var \u{17255}; +var \u{17256}; +var \u{17257}; +var \u{17258}; +var \u{17259}; +var \u{1725A}; +var \u{1725B}; +var \u{1725C}; +var \u{1725D}; +var \u{1725E}; +var \u{1725F}; +var \u{17260}; +var \u{17261}; +var \u{17262}; +var \u{17263}; +var \u{17264}; +var \u{17265}; +var \u{17266}; +var \u{17267}; +var \u{17268}; +var \u{17269}; +var \u{1726A}; +var \u{1726B}; +var \u{1726C}; +var \u{1726D}; +var \u{1726E}; +var \u{1726F}; +var \u{17270}; +var \u{17271}; +var \u{17272}; +var \u{17273}; +var \u{17274}; +var \u{17275}; +var \u{17276}; +var \u{17277}; +var \u{17278}; +var \u{17279}; +var \u{1727A}; +var \u{1727B}; +var \u{1727C}; +var \u{1727D}; +var \u{1727E}; +var \u{1727F}; +var \u{17280}; +var \u{17281}; +var \u{17282}; +var \u{17283}; +var \u{17284}; +var \u{17285}; +var \u{17286}; +var \u{17287}; +var \u{17288}; +var \u{17289}; +var \u{1728A}; +var \u{1728B}; +var \u{1728C}; +var \u{1728D}; +var \u{1728E}; +var \u{1728F}; +var \u{17290}; +var \u{17291}; +var \u{17292}; +var \u{17293}; +var \u{17294}; +var \u{17295}; +var \u{17296}; +var \u{17297}; +var \u{17298}; +var \u{17299}; +var \u{1729A}; +var \u{1729B}; +var \u{1729C}; +var \u{1729D}; +var \u{1729E}; +var \u{1729F}; +var \u{172A0}; +var \u{172A1}; +var \u{172A2}; +var \u{172A3}; +var \u{172A4}; +var \u{172A5}; +var \u{172A6}; +var \u{172A7}; +var \u{172A8}; +var \u{172A9}; +var \u{172AA}; +var \u{172AB}; +var \u{172AC}; +var \u{172AD}; +var \u{172AE}; +var \u{172AF}; +var \u{172B0}; +var \u{172B1}; +var \u{172B2}; +var \u{172B3}; +var \u{172B4}; +var \u{172B5}; +var \u{172B6}; +var \u{172B7}; +var \u{172B8}; +var \u{172B9}; +var \u{172BA}; +var \u{172BB}; +var \u{172BC}; +var \u{172BD}; +var \u{172BE}; +var \u{172BF}; +var \u{172C0}; +var \u{172C1}; +var \u{172C2}; +var \u{172C3}; +var \u{172C4}; +var \u{172C5}; +var \u{172C6}; +var \u{172C7}; +var \u{172C8}; +var \u{172C9}; +var \u{172CA}; +var \u{172CB}; +var \u{172CC}; +var \u{172CD}; +var \u{172CE}; +var \u{172CF}; +var \u{172D0}; +var \u{172D1}; +var \u{172D2}; +var \u{172D3}; +var \u{172D4}; +var \u{172D5}; +var \u{172D6}; +var \u{172D7}; +var \u{172D8}; +var \u{172D9}; +var \u{172DA}; +var \u{172DB}; +var \u{172DC}; +var \u{172DD}; +var \u{172DE}; +var \u{172DF}; +var \u{172E0}; +var \u{172E1}; +var \u{172E2}; +var \u{172E3}; +var \u{172E4}; +var \u{172E5}; +var \u{172E6}; +var \u{172E7}; +var \u{172E8}; +var \u{172E9}; +var \u{172EA}; +var \u{172EB}; +var \u{172EC}; +var \u{172ED}; +var \u{172EE}; +var \u{172EF}; +var \u{172F0}; +var \u{172F1}; +var \u{172F2}; +var \u{172F3}; +var \u{172F4}; +var \u{172F5}; +var \u{172F6}; +var \u{172F7}; +var \u{172F8}; +var \u{172F9}; +var \u{172FA}; +var \u{172FB}; +var \u{172FC}; +var \u{172FD}; +var \u{172FE}; +var \u{172FF}; +var \u{17300}; +var \u{17301}; +var \u{17302}; +var \u{17303}; +var \u{17304}; +var \u{17305}; +var \u{17306}; +var \u{17307}; +var \u{17308}; +var \u{17309}; +var \u{1730A}; +var \u{1730B}; +var \u{1730C}; +var \u{1730D}; +var \u{1730E}; +var \u{1730F}; +var \u{17310}; +var \u{17311}; +var \u{17312}; +var \u{17313}; +var \u{17314}; +var \u{17315}; +var \u{17316}; +var \u{17317}; +var \u{17318}; +var \u{17319}; +var \u{1731A}; +var \u{1731B}; +var \u{1731C}; +var \u{1731D}; +var \u{1731E}; +var \u{1731F}; +var \u{17320}; +var \u{17321}; +var \u{17322}; +var \u{17323}; +var \u{17324}; +var \u{17325}; +var \u{17326}; +var \u{17327}; +var \u{17328}; +var \u{17329}; +var \u{1732A}; +var \u{1732B}; +var \u{1732C}; +var \u{1732D}; +var \u{1732E}; +var \u{1732F}; +var \u{17330}; +var \u{17331}; +var \u{17332}; +var \u{17333}; +var \u{17334}; +var \u{17335}; +var \u{17336}; +var \u{17337}; +var \u{17338}; +var \u{17339}; +var \u{1733A}; +var \u{1733B}; +var \u{1733C}; +var \u{1733D}; +var \u{1733E}; +var \u{1733F}; +var \u{17340}; +var \u{17341}; +var \u{17342}; +var \u{17343}; +var \u{17344}; +var \u{17345}; +var \u{17346}; +var \u{17347}; +var \u{17348}; +var \u{17349}; +var \u{1734A}; +var \u{1734B}; +var \u{1734C}; +var \u{1734D}; +var \u{1734E}; +var \u{1734F}; +var \u{17350}; +var \u{17351}; +var \u{17352}; +var \u{17353}; +var \u{17354}; +var \u{17355}; +var \u{17356}; +var \u{17357}; +var \u{17358}; +var \u{17359}; +var \u{1735A}; +var \u{1735B}; +var \u{1735C}; +var \u{1735D}; +var \u{1735E}; +var \u{1735F}; +var \u{17360}; +var \u{17361}; +var \u{17362}; +var \u{17363}; +var \u{17364}; +var \u{17365}; +var \u{17366}; +var \u{17367}; +var \u{17368}; +var \u{17369}; +var \u{1736A}; +var \u{1736B}; +var \u{1736C}; +var \u{1736D}; +var \u{1736E}; +var \u{1736F}; +var \u{17370}; +var \u{17371}; +var \u{17372}; +var \u{17373}; +var \u{17374}; +var \u{17375}; +var \u{17376}; +var \u{17377}; +var \u{17378}; +var \u{17379}; +var \u{1737A}; +var \u{1737B}; +var \u{1737C}; +var \u{1737D}; +var \u{1737E}; +var \u{1737F}; +var \u{17380}; +var \u{17381}; +var \u{17382}; +var \u{17383}; +var \u{17384}; +var \u{17385}; +var \u{17386}; +var \u{17387}; +var \u{17388}; +var \u{17389}; +var \u{1738A}; +var \u{1738B}; +var \u{1738C}; +var \u{1738D}; +var \u{1738E}; +var \u{1738F}; +var \u{17390}; +var \u{17391}; +var \u{17392}; +var \u{17393}; +var \u{17394}; +var \u{17395}; +var \u{17396}; +var \u{17397}; +var \u{17398}; +var \u{17399}; +var \u{1739A}; +var \u{1739B}; +var \u{1739C}; +var \u{1739D}; +var \u{1739E}; +var \u{1739F}; +var \u{173A0}; +var \u{173A1}; +var \u{173A2}; +var \u{173A3}; +var \u{173A4}; +var \u{173A5}; +var \u{173A6}; +var \u{173A7}; +var \u{173A8}; +var \u{173A9}; +var \u{173AA}; +var \u{173AB}; +var \u{173AC}; +var \u{173AD}; +var \u{173AE}; +var \u{173AF}; +var \u{173B0}; +var \u{173B1}; +var \u{173B2}; +var \u{173B3}; +var \u{173B4}; +var \u{173B5}; +var \u{173B6}; +var \u{173B7}; +var \u{173B8}; +var \u{173B9}; +var \u{173BA}; +var \u{173BB}; +var \u{173BC}; +var \u{173BD}; +var \u{173BE}; +var \u{173BF}; +var \u{173C0}; +var \u{173C1}; +var \u{173C2}; +var \u{173C3}; +var \u{173C4}; +var \u{173C5}; +var \u{173C6}; +var \u{173C7}; +var \u{173C8}; +var \u{173C9}; +var \u{173CA}; +var \u{173CB}; +var \u{173CC}; +var \u{173CD}; +var \u{173CE}; +var \u{173CF}; +var \u{173D0}; +var \u{173D1}; +var \u{173D2}; +var \u{173D3}; +var \u{173D4}; +var \u{173D5}; +var \u{173D6}; +var \u{173D7}; +var \u{173D8}; +var \u{173D9}; +var \u{173DA}; +var \u{173DB}; +var \u{173DC}; +var \u{173DD}; +var \u{173DE}; +var \u{173DF}; +var \u{173E0}; +var \u{173E1}; +var \u{173E2}; +var \u{173E3}; +var \u{173E4}; +var \u{173E5}; +var \u{173E6}; +var \u{173E7}; +var \u{173E8}; +var \u{173E9}; +var \u{173EA}; +var \u{173EB}; +var \u{173EC}; +var \u{173ED}; +var \u{173EE}; +var \u{173EF}; +var \u{173F0}; +var \u{173F1}; +var \u{173F2}; +var \u{173F3}; +var \u{173F4}; +var \u{173F5}; +var \u{173F6}; +var \u{173F7}; +var \u{173F8}; +var \u{173F9}; +var \u{173FA}; +var \u{173FB}; +var \u{173FC}; +var \u{173FD}; +var \u{173FE}; +var \u{173FF}; +var \u{17400}; +var \u{17401}; +var \u{17402}; +var \u{17403}; +var \u{17404}; +var \u{17405}; +var \u{17406}; +var \u{17407}; +var \u{17408}; +var \u{17409}; +var \u{1740A}; +var \u{1740B}; +var \u{1740C}; +var \u{1740D}; +var \u{1740E}; +var \u{1740F}; +var \u{17410}; +var \u{17411}; +var \u{17412}; +var \u{17413}; +var \u{17414}; +var \u{17415}; +var \u{17416}; +var \u{17417}; +var \u{17418}; +var \u{17419}; +var \u{1741A}; +var \u{1741B}; +var \u{1741C}; +var \u{1741D}; +var \u{1741E}; +var \u{1741F}; +var \u{17420}; +var \u{17421}; +var \u{17422}; +var \u{17423}; +var \u{17424}; +var \u{17425}; +var \u{17426}; +var \u{17427}; +var \u{17428}; +var \u{17429}; +var \u{1742A}; +var \u{1742B}; +var \u{1742C}; +var \u{1742D}; +var \u{1742E}; +var \u{1742F}; +var \u{17430}; +var \u{17431}; +var \u{17432}; +var \u{17433}; +var \u{17434}; +var \u{17435}; +var \u{17436}; +var \u{17437}; +var \u{17438}; +var \u{17439}; +var \u{1743A}; +var \u{1743B}; +var \u{1743C}; +var \u{1743D}; +var \u{1743E}; +var \u{1743F}; +var \u{17440}; +var \u{17441}; +var \u{17442}; +var \u{17443}; +var \u{17444}; +var \u{17445}; +var \u{17446}; +var \u{17447}; +var \u{17448}; +var \u{17449}; +var \u{1744A}; +var \u{1744B}; +var \u{1744C}; +var \u{1744D}; +var \u{1744E}; +var \u{1744F}; +var \u{17450}; +var \u{17451}; +var \u{17452}; +var \u{17453}; +var \u{17454}; +var \u{17455}; +var \u{17456}; +var \u{17457}; +var \u{17458}; +var \u{17459}; +var \u{1745A}; +var \u{1745B}; +var \u{1745C}; +var \u{1745D}; +var \u{1745E}; +var \u{1745F}; +var \u{17460}; +var \u{17461}; +var \u{17462}; +var \u{17463}; +var \u{17464}; +var \u{17465}; +var \u{17466}; +var \u{17467}; +var \u{17468}; +var \u{17469}; +var \u{1746A}; +var \u{1746B}; +var \u{1746C}; +var \u{1746D}; +var \u{1746E}; +var \u{1746F}; +var \u{17470}; +var \u{17471}; +var \u{17472}; +var \u{17473}; +var \u{17474}; +var \u{17475}; +var \u{17476}; +var \u{17477}; +var \u{17478}; +var \u{17479}; +var \u{1747A}; +var \u{1747B}; +var \u{1747C}; +var \u{1747D}; +var \u{1747E}; +var \u{1747F}; +var \u{17480}; +var \u{17481}; +var \u{17482}; +var \u{17483}; +var \u{17484}; +var \u{17485}; +var \u{17486}; +var \u{17487}; +var \u{17488}; +var \u{17489}; +var \u{1748A}; +var \u{1748B}; +var \u{1748C}; +var \u{1748D}; +var \u{1748E}; +var \u{1748F}; +var \u{17490}; +var \u{17491}; +var \u{17492}; +var \u{17493}; +var \u{17494}; +var \u{17495}; +var \u{17496}; +var \u{17497}; +var \u{17498}; +var \u{17499}; +var \u{1749A}; +var \u{1749B}; +var \u{1749C}; +var \u{1749D}; +var \u{1749E}; +var \u{1749F}; +var \u{174A0}; +var \u{174A1}; +var \u{174A2}; +var \u{174A3}; +var \u{174A4}; +var \u{174A5}; +var \u{174A6}; +var \u{174A7}; +var \u{174A8}; +var \u{174A9}; +var \u{174AA}; +var \u{174AB}; +var \u{174AC}; +var \u{174AD}; +var \u{174AE}; +var \u{174AF}; +var \u{174B0}; +var \u{174B1}; +var \u{174B2}; +var \u{174B3}; +var \u{174B4}; +var \u{174B5}; +var \u{174B6}; +var \u{174B7}; +var \u{174B8}; +var \u{174B9}; +var \u{174BA}; +var \u{174BB}; +var \u{174BC}; +var \u{174BD}; +var \u{174BE}; +var \u{174BF}; +var \u{174C0}; +var \u{174C1}; +var \u{174C2}; +var \u{174C3}; +var \u{174C4}; +var \u{174C5}; +var \u{174C6}; +var \u{174C7}; +var \u{174C8}; +var \u{174C9}; +var \u{174CA}; +var \u{174CB}; +var \u{174CC}; +var \u{174CD}; +var \u{174CE}; +var \u{174CF}; +var \u{174D0}; +var \u{174D1}; +var \u{174D2}; +var \u{174D3}; +var \u{174D4}; +var \u{174D5}; +var \u{174D6}; +var \u{174D7}; +var \u{174D8}; +var \u{174D9}; +var \u{174DA}; +var \u{174DB}; +var \u{174DC}; +var \u{174DD}; +var \u{174DE}; +var \u{174DF}; +var \u{174E0}; +var \u{174E1}; +var \u{174E2}; +var \u{174E3}; +var \u{174E4}; +var \u{174E5}; +var \u{174E6}; +var \u{174E7}; +var \u{174E8}; +var \u{174E9}; +var \u{174EA}; +var \u{174EB}; +var \u{174EC}; +var \u{174ED}; +var \u{174EE}; +var \u{174EF}; +var \u{174F0}; +var \u{174F1}; +var \u{174F2}; +var \u{174F3}; +var \u{174F4}; +var \u{174F5}; +var \u{174F6}; +var \u{174F7}; +var \u{174F8}; +var \u{174F9}; +var \u{174FA}; +var \u{174FB}; +var \u{174FC}; +var \u{174FD}; +var \u{174FE}; +var \u{174FF}; +var \u{17500}; +var \u{17501}; +var \u{17502}; +var \u{17503}; +var \u{17504}; +var \u{17505}; +var \u{17506}; +var \u{17507}; +var \u{17508}; +var \u{17509}; +var \u{1750A}; +var \u{1750B}; +var \u{1750C}; +var \u{1750D}; +var \u{1750E}; +var \u{1750F}; +var \u{17510}; +var \u{17511}; +var \u{17512}; +var \u{17513}; +var \u{17514}; +var \u{17515}; +var \u{17516}; +var \u{17517}; +var \u{17518}; +var \u{17519}; +var \u{1751A}; +var \u{1751B}; +var \u{1751C}; +var \u{1751D}; +var \u{1751E}; +var \u{1751F}; +var \u{17520}; +var \u{17521}; +var \u{17522}; +var \u{17523}; +var \u{17524}; +var \u{17525}; +var \u{17526}; +var \u{17527}; +var \u{17528}; +var \u{17529}; +var \u{1752A}; +var \u{1752B}; +var \u{1752C}; +var \u{1752D}; +var \u{1752E}; +var \u{1752F}; +var \u{17530}; +var \u{17531}; +var \u{17532}; +var \u{17533}; +var \u{17534}; +var \u{17535}; +var \u{17536}; +var \u{17537}; +var \u{17538}; +var \u{17539}; +var \u{1753A}; +var \u{1753B}; +var \u{1753C}; +var \u{1753D}; +var \u{1753E}; +var \u{1753F}; +var \u{17540}; +var \u{17541}; +var \u{17542}; +var \u{17543}; +var \u{17544}; +var \u{17545}; +var \u{17546}; +var \u{17547}; +var \u{17548}; +var \u{17549}; +var \u{1754A}; +var \u{1754B}; +var \u{1754C}; +var \u{1754D}; +var \u{1754E}; +var \u{1754F}; +var \u{17550}; +var \u{17551}; +var \u{17552}; +var \u{17553}; +var \u{17554}; +var \u{17555}; +var \u{17556}; +var \u{17557}; +var \u{17558}; +var \u{17559}; +var \u{1755A}; +var \u{1755B}; +var \u{1755C}; +var \u{1755D}; +var \u{1755E}; +var \u{1755F}; +var \u{17560}; +var \u{17561}; +var \u{17562}; +var \u{17563}; +var \u{17564}; +var \u{17565}; +var \u{17566}; +var \u{17567}; +var \u{17568}; +var \u{17569}; +var \u{1756A}; +var \u{1756B}; +var \u{1756C}; +var \u{1756D}; +var \u{1756E}; +var \u{1756F}; +var \u{17570}; +var \u{17571}; +var \u{17572}; +var \u{17573}; +var \u{17574}; +var \u{17575}; +var \u{17576}; +var \u{17577}; +var \u{17578}; +var \u{17579}; +var \u{1757A}; +var \u{1757B}; +var \u{1757C}; +var \u{1757D}; +var \u{1757E}; +var \u{1757F}; +var \u{17580}; +var \u{17581}; +var \u{17582}; +var \u{17583}; +var \u{17584}; +var \u{17585}; +var \u{17586}; +var \u{17587}; +var \u{17588}; +var \u{17589}; +var \u{1758A}; +var \u{1758B}; +var \u{1758C}; +var \u{1758D}; +var \u{1758E}; +var \u{1758F}; +var \u{17590}; +var \u{17591}; +var \u{17592}; +var \u{17593}; +var \u{17594}; +var \u{17595}; +var \u{17596}; +var \u{17597}; +var \u{17598}; +var \u{17599}; +var \u{1759A}; +var \u{1759B}; +var \u{1759C}; +var \u{1759D}; +var \u{1759E}; +var \u{1759F}; +var \u{175A0}; +var \u{175A1}; +var \u{175A2}; +var \u{175A3}; +var \u{175A4}; +var \u{175A5}; +var \u{175A6}; +var \u{175A7}; +var \u{175A8}; +var \u{175A9}; +var \u{175AA}; +var \u{175AB}; +var \u{175AC}; +var \u{175AD}; +var \u{175AE}; +var \u{175AF}; +var \u{175B0}; +var \u{175B1}; +var \u{175B2}; +var \u{175B3}; +var \u{175B4}; +var \u{175B5}; +var \u{175B6}; +var \u{175B7}; +var \u{175B8}; +var \u{175B9}; +var \u{175BA}; +var \u{175BB}; +var \u{175BC}; +var \u{175BD}; +var \u{175BE}; +var \u{175BF}; +var \u{175C0}; +var \u{175C1}; +var \u{175C2}; +var \u{175C3}; +var \u{175C4}; +var \u{175C5}; +var \u{175C6}; +var \u{175C7}; +var \u{175C8}; +var \u{175C9}; +var \u{175CA}; +var \u{175CB}; +var \u{175CC}; +var \u{175CD}; +var \u{175CE}; +var \u{175CF}; +var \u{175D0}; +var \u{175D1}; +var \u{175D2}; +var \u{175D3}; +var \u{175D4}; +var \u{175D5}; +var \u{175D6}; +var \u{175D7}; +var \u{175D8}; +var \u{175D9}; +var \u{175DA}; +var \u{175DB}; +var \u{175DC}; +var \u{175DD}; +var \u{175DE}; +var \u{175DF}; +var \u{175E0}; +var \u{175E1}; +var \u{175E2}; +var \u{175E3}; +var \u{175E4}; +var \u{175E5}; +var \u{175E6}; +var \u{175E7}; +var \u{175E8}; +var \u{175E9}; +var \u{175EA}; +var \u{175EB}; +var \u{175EC}; +var \u{175ED}; +var \u{175EE}; +var \u{175EF}; +var \u{175F0}; +var \u{175F1}; +var \u{175F2}; +var \u{175F3}; +var \u{175F4}; +var \u{175F5}; +var \u{175F6}; +var \u{175F7}; +var \u{175F8}; +var \u{175F9}; +var \u{175FA}; +var \u{175FB}; +var \u{175FC}; +var \u{175FD}; +var \u{175FE}; +var \u{175FF}; +var \u{17600}; +var \u{17601}; +var \u{17602}; +var \u{17603}; +var \u{17604}; +var \u{17605}; +var \u{17606}; +var \u{17607}; +var \u{17608}; +var \u{17609}; +var \u{1760A}; +var \u{1760B}; +var \u{1760C}; +var \u{1760D}; +var \u{1760E}; +var \u{1760F}; +var \u{17610}; +var \u{17611}; +var \u{17612}; +var \u{17613}; +var \u{17614}; +var \u{17615}; +var \u{17616}; +var \u{17617}; +var \u{17618}; +var \u{17619}; +var \u{1761A}; +var \u{1761B}; +var \u{1761C}; +var \u{1761D}; +var \u{1761E}; +var \u{1761F}; +var \u{17620}; +var \u{17621}; +var \u{17622}; +var \u{17623}; +var \u{17624}; +var \u{17625}; +var \u{17626}; +var \u{17627}; +var \u{17628}; +var \u{17629}; +var \u{1762A}; +var \u{1762B}; +var \u{1762C}; +var \u{1762D}; +var \u{1762E}; +var \u{1762F}; +var \u{17630}; +var \u{17631}; +var \u{17632}; +var \u{17633}; +var \u{17634}; +var \u{17635}; +var \u{17636}; +var \u{17637}; +var \u{17638}; +var \u{17639}; +var \u{1763A}; +var \u{1763B}; +var \u{1763C}; +var \u{1763D}; +var \u{1763E}; +var \u{1763F}; +var \u{17640}; +var \u{17641}; +var \u{17642}; +var \u{17643}; +var \u{17644}; +var \u{17645}; +var \u{17646}; +var \u{17647}; +var \u{17648}; +var \u{17649}; +var \u{1764A}; +var \u{1764B}; +var \u{1764C}; +var \u{1764D}; +var \u{1764E}; +var \u{1764F}; +var \u{17650}; +var \u{17651}; +var \u{17652}; +var \u{17653}; +var \u{17654}; +var \u{17655}; +var \u{17656}; +var \u{17657}; +var \u{17658}; +var \u{17659}; +var \u{1765A}; +var \u{1765B}; +var \u{1765C}; +var \u{1765D}; +var \u{1765E}; +var \u{1765F}; +var \u{17660}; +var \u{17661}; +var \u{17662}; +var \u{17663}; +var \u{17664}; +var \u{17665}; +var \u{17666}; +var \u{17667}; +var \u{17668}; +var \u{17669}; +var \u{1766A}; +var \u{1766B}; +var \u{1766C}; +var \u{1766D}; +var \u{1766E}; +var \u{1766F}; +var \u{17670}; +var \u{17671}; +var \u{17672}; +var \u{17673}; +var \u{17674}; +var \u{17675}; +var \u{17676}; +var \u{17677}; +var \u{17678}; +var \u{17679}; +var \u{1767A}; +var \u{1767B}; +var \u{1767C}; +var \u{1767D}; +var \u{1767E}; +var \u{1767F}; +var \u{17680}; +var \u{17681}; +var \u{17682}; +var \u{17683}; +var \u{17684}; +var \u{17685}; +var \u{17686}; +var \u{17687}; +var \u{17688}; +var \u{17689}; +var \u{1768A}; +var \u{1768B}; +var \u{1768C}; +var \u{1768D}; +var \u{1768E}; +var \u{1768F}; +var \u{17690}; +var \u{17691}; +var \u{17692}; +var \u{17693}; +var \u{17694}; +var \u{17695}; +var \u{17696}; +var \u{17697}; +var \u{17698}; +var \u{17699}; +var \u{1769A}; +var \u{1769B}; +var \u{1769C}; +var \u{1769D}; +var \u{1769E}; +var \u{1769F}; +var \u{176A0}; +var \u{176A1}; +var \u{176A2}; +var \u{176A3}; +var \u{176A4}; +var \u{176A5}; +var \u{176A6}; +var \u{176A7}; +var \u{176A8}; +var \u{176A9}; +var \u{176AA}; +var \u{176AB}; +var \u{176AC}; +var \u{176AD}; +var \u{176AE}; +var \u{176AF}; +var \u{176B0}; +var \u{176B1}; +var \u{176B2}; +var \u{176B3}; +var \u{176B4}; +var \u{176B5}; +var \u{176B6}; +var \u{176B7}; +var \u{176B8}; +var \u{176B9}; +var \u{176BA}; +var \u{176BB}; +var \u{176BC}; +var \u{176BD}; +var \u{176BE}; +var \u{176BF}; +var \u{176C0}; +var \u{176C1}; +var \u{176C2}; +var \u{176C3}; +var \u{176C4}; +var \u{176C5}; +var \u{176C6}; +var \u{176C7}; +var \u{176C8}; +var \u{176C9}; +var \u{176CA}; +var \u{176CB}; +var \u{176CC}; +var \u{176CD}; +var \u{176CE}; +var \u{176CF}; +var \u{176D0}; +var \u{176D1}; +var \u{176D2}; +var \u{176D3}; +var \u{176D4}; +var \u{176D5}; +var \u{176D6}; +var \u{176D7}; +var \u{176D8}; +var \u{176D9}; +var \u{176DA}; +var \u{176DB}; +var \u{176DC}; +var \u{176DD}; +var \u{176DE}; +var \u{176DF}; +var \u{176E0}; +var \u{176E1}; +var \u{176E2}; +var \u{176E3}; +var \u{176E4}; +var \u{176E5}; +var \u{176E6}; +var \u{176E7}; +var \u{176E8}; +var \u{176E9}; +var \u{176EA}; +var \u{176EB}; +var \u{176EC}; +var \u{176ED}; +var \u{176EE}; +var \u{176EF}; +var \u{176F0}; +var \u{176F1}; +var \u{176F2}; +var \u{176F3}; +var \u{176F4}; +var \u{176F5}; +var \u{176F6}; +var \u{176F7}; +var \u{176F8}; +var \u{176F9}; +var \u{176FA}; +var \u{176FB}; +var \u{176FC}; +var \u{176FD}; +var \u{176FE}; +var \u{176FF}; +var \u{17700}; +var \u{17701}; +var \u{17702}; +var \u{17703}; +var \u{17704}; +var \u{17705}; +var \u{17706}; +var \u{17707}; +var \u{17708}; +var \u{17709}; +var \u{1770A}; +var \u{1770B}; +var \u{1770C}; +var \u{1770D}; +var \u{1770E}; +var \u{1770F}; +var \u{17710}; +var \u{17711}; +var \u{17712}; +var \u{17713}; +var \u{17714}; +var \u{17715}; +var \u{17716}; +var \u{17717}; +var \u{17718}; +var \u{17719}; +var \u{1771A}; +var \u{1771B}; +var \u{1771C}; +var \u{1771D}; +var \u{1771E}; +var \u{1771F}; +var \u{17720}; +var \u{17721}; +var \u{17722}; +var \u{17723}; +var \u{17724}; +var \u{17725}; +var \u{17726}; +var \u{17727}; +var \u{17728}; +var \u{17729}; +var \u{1772A}; +var \u{1772B}; +var \u{1772C}; +var \u{1772D}; +var \u{1772E}; +var \u{1772F}; +var \u{17730}; +var \u{17731}; +var \u{17732}; +var \u{17733}; +var \u{17734}; +var \u{17735}; +var \u{17736}; +var \u{17737}; +var \u{17738}; +var \u{17739}; +var \u{1773A}; +var \u{1773B}; +var \u{1773C}; +var \u{1773D}; +var \u{1773E}; +var \u{1773F}; +var \u{17740}; +var \u{17741}; +var \u{17742}; +var \u{17743}; +var \u{17744}; +var \u{17745}; +var \u{17746}; +var \u{17747}; +var \u{17748}; +var \u{17749}; +var \u{1774A}; +var \u{1774B}; +var \u{1774C}; +var \u{1774D}; +var \u{1774E}; +var \u{1774F}; +var \u{17750}; +var \u{17751}; +var \u{17752}; +var \u{17753}; +var \u{17754}; +var \u{17755}; +var \u{17756}; +var \u{17757}; +var \u{17758}; +var \u{17759}; +var \u{1775A}; +var \u{1775B}; +var \u{1775C}; +var \u{1775D}; +var \u{1775E}; +var \u{1775F}; +var \u{17760}; +var \u{17761}; +var \u{17762}; +var \u{17763}; +var \u{17764}; +var \u{17765}; +var \u{17766}; +var \u{17767}; +var \u{17768}; +var \u{17769}; +var \u{1776A}; +var \u{1776B}; +var \u{1776C}; +var \u{1776D}; +var \u{1776E}; +var \u{1776F}; +var \u{17770}; +var \u{17771}; +var \u{17772}; +var \u{17773}; +var \u{17774}; +var \u{17775}; +var \u{17776}; +var \u{17777}; +var \u{17778}; +var \u{17779}; +var \u{1777A}; +var \u{1777B}; +var \u{1777C}; +var \u{1777D}; +var \u{1777E}; +var \u{1777F}; +var \u{17780}; +var \u{17781}; +var \u{17782}; +var \u{17783}; +var \u{17784}; +var \u{17785}; +var \u{17786}; +var \u{17787}; +var \u{17788}; +var \u{17789}; +var \u{1778A}; +var \u{1778B}; +var \u{1778C}; +var \u{1778D}; +var \u{1778E}; +var \u{1778F}; +var \u{17790}; +var \u{17791}; +var \u{17792}; +var \u{17793}; +var \u{17794}; +var \u{17795}; +var \u{17796}; +var \u{17797}; +var \u{17798}; +var \u{17799}; +var \u{1779A}; +var \u{1779B}; +var \u{1779C}; +var \u{1779D}; +var \u{1779E}; +var \u{1779F}; +var \u{177A0}; +var \u{177A1}; +var \u{177A2}; +var \u{177A3}; +var \u{177A4}; +var \u{177A5}; +var \u{177A6}; +var \u{177A7}; +var \u{177A8}; +var \u{177A9}; +var \u{177AA}; +var \u{177AB}; +var \u{177AC}; +var \u{177AD}; +var \u{177AE}; +var \u{177AF}; +var \u{177B0}; +var \u{177B1}; +var \u{177B2}; +var \u{177B3}; +var \u{177B4}; +var \u{177B5}; +var \u{177B6}; +var \u{177B7}; +var \u{177B8}; +var \u{177B9}; +var \u{177BA}; +var \u{177BB}; +var \u{177BC}; +var \u{177BD}; +var \u{177BE}; +var \u{177BF}; +var \u{177C0}; +var \u{177C1}; +var \u{177C2}; +var \u{177C3}; +var \u{177C4}; +var \u{177C5}; +var \u{177C6}; +var \u{177C7}; +var \u{177C8}; +var \u{177C9}; +var \u{177CA}; +var \u{177CB}; +var \u{177CC}; +var \u{177CD}; +var \u{177CE}; +var \u{177CF}; +var \u{177D0}; +var \u{177D1}; +var \u{177D2}; +var \u{177D3}; +var \u{177D4}; +var \u{177D5}; +var \u{177D6}; +var \u{177D7}; +var \u{177D8}; +var \u{177D9}; +var \u{177DA}; +var \u{177DB}; +var \u{177DC}; +var \u{177DD}; +var \u{177DE}; +var \u{177DF}; +var \u{177E0}; +var \u{177E1}; +var \u{177E2}; +var \u{177E3}; +var \u{177E4}; +var \u{177E5}; +var \u{177E6}; +var \u{177E7}; +var \u{177E8}; +var \u{177E9}; +var \u{177EA}; +var \u{177EB}; +var \u{177EC}; +var \u{177ED}; +var \u{177EE}; +var \u{177EF}; +var \u{177F0}; +var \u{177F1}; +var \u{177F2}; +var \u{177F3}; +var \u{177F4}; +var \u{177F5}; +var \u{177F6}; +var \u{177F7}; +var \u{177F8}; +var \u{177F9}; +var \u{177FA}; +var \u{177FB}; +var \u{177FC}; +var \u{177FD}; +var \u{177FE}; +var \u{177FF}; +var \u{17800}; +var \u{17801}; +var \u{17802}; +var \u{17803}; +var \u{17804}; +var \u{17805}; +var \u{17806}; +var \u{17807}; +var \u{17808}; +var \u{17809}; +var \u{1780A}; +var \u{1780B}; +var \u{1780C}; +var \u{1780D}; +var \u{1780E}; +var \u{1780F}; +var \u{17810}; +var \u{17811}; +var \u{17812}; +var \u{17813}; +var \u{17814}; +var \u{17815}; +var \u{17816}; +var \u{17817}; +var \u{17818}; +var \u{17819}; +var \u{1781A}; +var \u{1781B}; +var \u{1781C}; +var \u{1781D}; +var \u{1781E}; +var \u{1781F}; +var \u{17820}; +var \u{17821}; +var \u{17822}; +var \u{17823}; +var \u{17824}; +var \u{17825}; +var \u{17826}; +var \u{17827}; +var \u{17828}; +var \u{17829}; +var \u{1782A}; +var \u{1782B}; +var \u{1782C}; +var \u{1782D}; +var \u{1782E}; +var \u{1782F}; +var \u{17830}; +var \u{17831}; +var \u{17832}; +var \u{17833}; +var \u{17834}; +var \u{17835}; +var \u{17836}; +var \u{17837}; +var \u{17838}; +var \u{17839}; +var \u{1783A}; +var \u{1783B}; +var \u{1783C}; +var \u{1783D}; +var \u{1783E}; +var \u{1783F}; +var \u{17840}; +var \u{17841}; +var \u{17842}; +var \u{17843}; +var \u{17844}; +var \u{17845}; +var \u{17846}; +var \u{17847}; +var \u{17848}; +var \u{17849}; +var \u{1784A}; +var \u{1784B}; +var \u{1784C}; +var \u{1784D}; +var \u{1784E}; +var \u{1784F}; +var \u{17850}; +var \u{17851}; +var \u{17852}; +var \u{17853}; +var \u{17854}; +var \u{17855}; +var \u{17856}; +var \u{17857}; +var \u{17858}; +var \u{17859}; +var \u{1785A}; +var \u{1785B}; +var \u{1785C}; +var \u{1785D}; +var \u{1785E}; +var \u{1785F}; +var \u{17860}; +var \u{17861}; +var \u{17862}; +var \u{17863}; +var \u{17864}; +var \u{17865}; +var \u{17866}; +var \u{17867}; +var \u{17868}; +var \u{17869}; +var \u{1786A}; +var \u{1786B}; +var \u{1786C}; +var \u{1786D}; +var \u{1786E}; +var \u{1786F}; +var \u{17870}; +var \u{17871}; +var \u{17872}; +var \u{17873}; +var \u{17874}; +var \u{17875}; +var \u{17876}; +var \u{17877}; +var \u{17878}; +var \u{17879}; +var \u{1787A}; +var \u{1787B}; +var \u{1787C}; +var \u{1787D}; +var \u{1787E}; +var \u{1787F}; +var \u{17880}; +var \u{17881}; +var \u{17882}; +var \u{17883}; +var \u{17884}; +var \u{17885}; +var \u{17886}; +var \u{17887}; +var \u{17888}; +var \u{17889}; +var \u{1788A}; +var \u{1788B}; +var \u{1788C}; +var \u{1788D}; +var \u{1788E}; +var \u{1788F}; +var \u{17890}; +var \u{17891}; +var \u{17892}; +var \u{17893}; +var \u{17894}; +var \u{17895}; +var \u{17896}; +var \u{17897}; +var \u{17898}; +var \u{17899}; +var \u{1789A}; +var \u{1789B}; +var \u{1789C}; +var \u{1789D}; +var \u{1789E}; +var \u{1789F}; +var \u{178A0}; +var \u{178A1}; +var \u{178A2}; +var \u{178A3}; +var \u{178A4}; +var \u{178A5}; +var \u{178A6}; +var \u{178A7}; +var \u{178A8}; +var \u{178A9}; +var \u{178AA}; +var \u{178AB}; +var \u{178AC}; +var \u{178AD}; +var \u{178AE}; +var \u{178AF}; +var \u{178B0}; +var \u{178B1}; +var \u{178B2}; +var \u{178B3}; +var \u{178B4}; +var \u{178B5}; +var \u{178B6}; +var \u{178B7}; +var \u{178B8}; +var \u{178B9}; +var \u{178BA}; +var \u{178BB}; +var \u{178BC}; +var \u{178BD}; +var \u{178BE}; +var \u{178BF}; +var \u{178C0}; +var \u{178C1}; +var \u{178C2}; +var \u{178C3}; +var \u{178C4}; +var \u{178C5}; +var \u{178C6}; +var \u{178C7}; +var \u{178C8}; +var \u{178C9}; +var \u{178CA}; +var \u{178CB}; +var \u{178CC}; +var \u{178CD}; +var \u{178CE}; +var \u{178CF}; +var \u{178D0}; +var \u{178D1}; +var \u{178D2}; +var \u{178D3}; +var \u{178D4}; +var \u{178D5}; +var \u{178D6}; +var \u{178D7}; +var \u{178D8}; +var \u{178D9}; +var \u{178DA}; +var \u{178DB}; +var \u{178DC}; +var \u{178DD}; +var \u{178DE}; +var \u{178DF}; +var \u{178E0}; +var \u{178E1}; +var \u{178E2}; +var \u{178E3}; +var \u{178E4}; +var \u{178E5}; +var \u{178E6}; +var \u{178E7}; +var \u{178E8}; +var \u{178E9}; +var \u{178EA}; +var \u{178EB}; +var \u{178EC}; +var \u{178ED}; +var \u{178EE}; +var \u{178EF}; +var \u{178F0}; +var \u{178F1}; +var \u{178F2}; +var \u{178F3}; +var \u{178F4}; +var \u{178F5}; +var \u{178F6}; +var \u{178F7}; +var \u{178F8}; +var \u{178F9}; +var \u{178FA}; +var \u{178FB}; +var \u{178FC}; +var \u{178FD}; +var \u{178FE}; +var \u{178FF}; +var \u{17900}; +var \u{17901}; +var \u{17902}; +var \u{17903}; +var \u{17904}; +var \u{17905}; +var \u{17906}; +var \u{17907}; +var \u{17908}; +var \u{17909}; +var \u{1790A}; +var \u{1790B}; +var \u{1790C}; +var \u{1790D}; +var \u{1790E}; +var \u{1790F}; +var \u{17910}; +var \u{17911}; +var \u{17912}; +var \u{17913}; +var \u{17914}; +var \u{17915}; +var \u{17916}; +var \u{17917}; +var \u{17918}; +var \u{17919}; +var \u{1791A}; +var \u{1791B}; +var \u{1791C}; +var \u{1791D}; +var \u{1791E}; +var \u{1791F}; +var \u{17920}; +var \u{17921}; +var \u{17922}; +var \u{17923}; +var \u{17924}; +var \u{17925}; +var \u{17926}; +var \u{17927}; +var \u{17928}; +var \u{17929}; +var \u{1792A}; +var \u{1792B}; +var \u{1792C}; +var \u{1792D}; +var \u{1792E}; +var \u{1792F}; +var \u{17930}; +var \u{17931}; +var \u{17932}; +var \u{17933}; +var \u{17934}; +var \u{17935}; +var \u{17936}; +var \u{17937}; +var \u{17938}; +var \u{17939}; +var \u{1793A}; +var \u{1793B}; +var \u{1793C}; +var \u{1793D}; +var \u{1793E}; +var \u{1793F}; +var \u{17940}; +var \u{17941}; +var \u{17942}; +var \u{17943}; +var \u{17944}; +var \u{17945}; +var \u{17946}; +var \u{17947}; +var \u{17948}; +var \u{17949}; +var \u{1794A}; +var \u{1794B}; +var \u{1794C}; +var \u{1794D}; +var \u{1794E}; +var \u{1794F}; +var \u{17950}; +var \u{17951}; +var \u{17952}; +var \u{17953}; +var \u{17954}; +var \u{17955}; +var \u{17956}; +var \u{17957}; +var \u{17958}; +var \u{17959}; +var \u{1795A}; +var \u{1795B}; +var \u{1795C}; +var \u{1795D}; +var \u{1795E}; +var \u{1795F}; +var \u{17960}; +var \u{17961}; +var \u{17962}; +var \u{17963}; +var \u{17964}; +var \u{17965}; +var \u{17966}; +var \u{17967}; +var \u{17968}; +var \u{17969}; +var \u{1796A}; +var \u{1796B}; +var \u{1796C}; +var \u{1796D}; +var \u{1796E}; +var \u{1796F}; +var \u{17970}; +var \u{17971}; +var \u{17972}; +var \u{17973}; +var \u{17974}; +var \u{17975}; +var \u{17976}; +var \u{17977}; +var \u{17978}; +var \u{17979}; +var \u{1797A}; +var \u{1797B}; +var \u{1797C}; +var \u{1797D}; +var \u{1797E}; +var \u{1797F}; +var \u{17980}; +var \u{17981}; +var \u{17982}; +var \u{17983}; +var \u{17984}; +var \u{17985}; +var \u{17986}; +var \u{17987}; +var \u{17988}; +var \u{17989}; +var \u{1798A}; +var \u{1798B}; +var \u{1798C}; +var \u{1798D}; +var \u{1798E}; +var \u{1798F}; +var \u{17990}; +var \u{17991}; +var \u{17992}; +var \u{17993}; +var \u{17994}; +var \u{17995}; +var \u{17996}; +var \u{17997}; +var \u{17998}; +var \u{17999}; +var \u{1799A}; +var \u{1799B}; +var \u{1799C}; +var \u{1799D}; +var \u{1799E}; +var \u{1799F}; +var \u{179A0}; +var \u{179A1}; +var \u{179A2}; +var \u{179A3}; +var \u{179A4}; +var \u{179A5}; +var \u{179A6}; +var \u{179A7}; +var \u{179A8}; +var \u{179A9}; +var \u{179AA}; +var \u{179AB}; +var \u{179AC}; +var \u{179AD}; +var \u{179AE}; +var \u{179AF}; +var \u{179B0}; +var \u{179B1}; +var \u{179B2}; +var \u{179B3}; +var \u{179B4}; +var \u{179B5}; +var \u{179B6}; +var \u{179B7}; +var \u{179B8}; +var \u{179B9}; +var \u{179BA}; +var \u{179BB}; +var \u{179BC}; +var \u{179BD}; +var \u{179BE}; +var \u{179BF}; +var \u{179C0}; +var \u{179C1}; +var \u{179C2}; +var \u{179C3}; +var \u{179C4}; +var \u{179C5}; +var \u{179C6}; +var \u{179C7}; +var \u{179C8}; +var \u{179C9}; +var \u{179CA}; +var \u{179CB}; +var \u{179CC}; +var \u{179CD}; +var \u{179CE}; +var \u{179CF}; +var \u{179D0}; +var \u{179D1}; +var \u{179D2}; +var \u{179D3}; +var \u{179D4}; +var \u{179D5}; +var \u{179D6}; +var \u{179D7}; +var \u{179D8}; +var \u{179D9}; +var \u{179DA}; +var \u{179DB}; +var \u{179DC}; +var \u{179DD}; +var \u{179DE}; +var \u{179DF}; +var \u{179E0}; +var \u{179E1}; +var \u{179E2}; +var \u{179E3}; +var \u{179E4}; +var \u{179E5}; +var \u{179E6}; +var \u{179E7}; +var \u{179E8}; +var \u{179E9}; +var \u{179EA}; +var \u{179EB}; +var \u{179EC}; +var \u{179ED}; +var \u{179EE}; +var \u{179EF}; +var \u{179F0}; +var \u{179F1}; +var \u{179F2}; +var \u{179F3}; +var \u{179F4}; +var \u{179F5}; +var \u{179F6}; +var \u{179F7}; +var \u{179F8}; +var \u{179F9}; +var \u{179FA}; +var \u{179FB}; +var \u{179FC}; +var \u{179FD}; +var \u{179FE}; +var \u{179FF}; +var \u{17A00}; +var \u{17A01}; +var \u{17A02}; +var \u{17A03}; +var \u{17A04}; +var \u{17A05}; +var \u{17A06}; +var \u{17A07}; +var \u{17A08}; +var \u{17A09}; +var \u{17A0A}; +var \u{17A0B}; +var \u{17A0C}; +var \u{17A0D}; +var \u{17A0E}; +var \u{17A0F}; +var \u{17A10}; +var \u{17A11}; +var \u{17A12}; +var \u{17A13}; +var \u{17A14}; +var \u{17A15}; +var \u{17A16}; +var \u{17A17}; +var \u{17A18}; +var \u{17A19}; +var \u{17A1A}; +var \u{17A1B}; +var \u{17A1C}; +var \u{17A1D}; +var \u{17A1E}; +var \u{17A1F}; +var \u{17A20}; +var \u{17A21}; +var \u{17A22}; +var \u{17A23}; +var \u{17A24}; +var \u{17A25}; +var \u{17A26}; +var \u{17A27}; +var \u{17A28}; +var \u{17A29}; +var \u{17A2A}; +var \u{17A2B}; +var \u{17A2C}; +var \u{17A2D}; +var \u{17A2E}; +var \u{17A2F}; +var \u{17A30}; +var \u{17A31}; +var \u{17A32}; +var \u{17A33}; +var \u{17A34}; +var \u{17A35}; +var \u{17A36}; +var \u{17A37}; +var \u{17A38}; +var \u{17A39}; +var \u{17A3A}; +var \u{17A3B}; +var \u{17A3C}; +var \u{17A3D}; +var \u{17A3E}; +var \u{17A3F}; +var \u{17A40}; +var \u{17A41}; +var \u{17A42}; +var \u{17A43}; +var \u{17A44}; +var \u{17A45}; +var \u{17A46}; +var \u{17A47}; +var \u{17A48}; +var \u{17A49}; +var \u{17A4A}; +var \u{17A4B}; +var \u{17A4C}; +var \u{17A4D}; +var \u{17A4E}; +var \u{17A4F}; +var \u{17A50}; +var \u{17A51}; +var \u{17A52}; +var \u{17A53}; +var \u{17A54}; +var \u{17A55}; +var \u{17A56}; +var \u{17A57}; +var \u{17A58}; +var \u{17A59}; +var \u{17A5A}; +var \u{17A5B}; +var \u{17A5C}; +var \u{17A5D}; +var \u{17A5E}; +var \u{17A5F}; +var \u{17A60}; +var \u{17A61}; +var \u{17A62}; +var \u{17A63}; +var \u{17A64}; +var \u{17A65}; +var \u{17A66}; +var \u{17A67}; +var \u{17A68}; +var \u{17A69}; +var \u{17A6A}; +var \u{17A6B}; +var \u{17A6C}; +var \u{17A6D}; +var \u{17A6E}; +var \u{17A6F}; +var \u{17A70}; +var \u{17A71}; +var \u{17A72}; +var \u{17A73}; +var \u{17A74}; +var \u{17A75}; +var \u{17A76}; +var \u{17A77}; +var \u{17A78}; +var \u{17A79}; +var \u{17A7A}; +var \u{17A7B}; +var \u{17A7C}; +var \u{17A7D}; +var \u{17A7E}; +var \u{17A7F}; +var \u{17A80}; +var \u{17A81}; +var \u{17A82}; +var \u{17A83}; +var \u{17A84}; +var \u{17A85}; +var \u{17A86}; +var \u{17A87}; +var \u{17A88}; +var \u{17A89}; +var \u{17A8A}; +var \u{17A8B}; +var \u{17A8C}; +var \u{17A8D}; +var \u{17A8E}; +var \u{17A8F}; +var \u{17A90}; +var \u{17A91}; +var \u{17A92}; +var \u{17A93}; +var \u{17A94}; +var \u{17A95}; +var \u{17A96}; +var \u{17A97}; +var \u{17A98}; +var \u{17A99}; +var \u{17A9A}; +var \u{17A9B}; +var \u{17A9C}; +var \u{17A9D}; +var \u{17A9E}; +var \u{17A9F}; +var \u{17AA0}; +var \u{17AA1}; +var \u{17AA2}; +var \u{17AA3}; +var \u{17AA4}; +var \u{17AA5}; +var \u{17AA6}; +var \u{17AA7}; +var \u{17AA8}; +var \u{17AA9}; +var \u{17AAA}; +var \u{17AAB}; +var \u{17AAC}; +var \u{17AAD}; +var \u{17AAE}; +var \u{17AAF}; +var \u{17AB0}; +var \u{17AB1}; +var \u{17AB2}; +var \u{17AB3}; +var \u{17AB4}; +var \u{17AB5}; +var \u{17AB6}; +var \u{17AB7}; +var \u{17AB8}; +var \u{17AB9}; +var \u{17ABA}; +var \u{17ABB}; +var \u{17ABC}; +var \u{17ABD}; +var \u{17ABE}; +var \u{17ABF}; +var \u{17AC0}; +var \u{17AC1}; +var \u{17AC2}; +var \u{17AC3}; +var \u{17AC4}; +var \u{17AC5}; +var \u{17AC6}; +var \u{17AC7}; +var \u{17AC8}; +var \u{17AC9}; +var \u{17ACA}; +var \u{17ACB}; +var \u{17ACC}; +var \u{17ACD}; +var \u{17ACE}; +var \u{17ACF}; +var \u{17AD0}; +var \u{17AD1}; +var \u{17AD2}; +var \u{17AD3}; +var \u{17AD4}; +var \u{17AD5}; +var \u{17AD6}; +var \u{17AD7}; +var \u{17AD8}; +var \u{17AD9}; +var \u{17ADA}; +var \u{17ADB}; +var \u{17ADC}; +var \u{17ADD}; +var \u{17ADE}; +var \u{17ADF}; +var \u{17AE0}; +var \u{17AE1}; +var \u{17AE2}; +var \u{17AE3}; +var \u{17AE4}; +var \u{17AE5}; +var \u{17AE6}; +var \u{17AE7}; +var \u{17AE8}; +var \u{17AE9}; +var \u{17AEA}; +var \u{17AEB}; +var \u{17AEC}; +var \u{17AED}; +var \u{17AEE}; +var \u{17AEF}; +var \u{17AF0}; +var \u{17AF1}; +var \u{17AF2}; +var \u{17AF3}; +var \u{17AF4}; +var \u{17AF5}; +var \u{17AF6}; +var \u{17AF7}; +var \u{17AF8}; +var \u{17AF9}; +var \u{17AFA}; +var \u{17AFB}; +var \u{17AFC}; +var \u{17AFD}; +var \u{17AFE}; +var \u{17AFF}; +var \u{17B00}; +var \u{17B01}; +var \u{17B02}; +var \u{17B03}; +var \u{17B04}; +var \u{17B05}; +var \u{17B06}; +var \u{17B07}; +var \u{17B08}; +var \u{17B09}; +var \u{17B0A}; +var \u{17B0B}; +var \u{17B0C}; +var \u{17B0D}; +var \u{17B0E}; +var \u{17B0F}; +var \u{17B10}; +var \u{17B11}; +var \u{17B12}; +var \u{17B13}; +var \u{17B14}; +var \u{17B15}; +var \u{17B16}; +var \u{17B17}; +var \u{17B18}; +var \u{17B19}; +var \u{17B1A}; +var \u{17B1B}; +var \u{17B1C}; +var \u{17B1D}; +var \u{17B1E}; +var \u{17B1F}; +var \u{17B20}; +var \u{17B21}; +var \u{17B22}; +var \u{17B23}; +var \u{17B24}; +var \u{17B25}; +var \u{17B26}; +var \u{17B27}; +var \u{17B28}; +var \u{17B29}; +var \u{17B2A}; +var \u{17B2B}; +var \u{17B2C}; +var \u{17B2D}; +var \u{17B2E}; +var \u{17B2F}; +var \u{17B30}; +var \u{17B31}; +var \u{17B32}; +var \u{17B33}; +var \u{17B34}; +var \u{17B35}; +var \u{17B36}; +var \u{17B37}; +var \u{17B38}; +var \u{17B39}; +var \u{17B3A}; +var \u{17B3B}; +var \u{17B3C}; +var \u{17B3D}; +var \u{17B3E}; +var \u{17B3F}; +var \u{17B40}; +var \u{17B41}; +var \u{17B42}; +var \u{17B43}; +var \u{17B44}; +var \u{17B45}; +var \u{17B46}; +var \u{17B47}; +var \u{17B48}; +var \u{17B49}; +var \u{17B4A}; +var \u{17B4B}; +var \u{17B4C}; +var \u{17B4D}; +var \u{17B4E}; +var \u{17B4F}; +var \u{17B50}; +var \u{17B51}; +var \u{17B52}; +var \u{17B53}; +var \u{17B54}; +var \u{17B55}; +var \u{17B56}; +var \u{17B57}; +var \u{17B58}; +var \u{17B59}; +var \u{17B5A}; +var \u{17B5B}; +var \u{17B5C}; +var \u{17B5D}; +var \u{17B5E}; +var \u{17B5F}; +var \u{17B60}; +var \u{17B61}; +var \u{17B62}; +var \u{17B63}; +var \u{17B64}; +var \u{17B65}; +var \u{17B66}; +var \u{17B67}; +var \u{17B68}; +var \u{17B69}; +var \u{17B6A}; +var \u{17B6B}; +var \u{17B6C}; +var \u{17B6D}; +var \u{17B6E}; +var \u{17B6F}; +var \u{17B70}; +var \u{17B71}; +var \u{17B72}; +var \u{17B73}; +var \u{17B74}; +var \u{17B75}; +var \u{17B76}; +var \u{17B77}; +var \u{17B78}; +var \u{17B79}; +var \u{17B7A}; +var \u{17B7B}; +var \u{17B7C}; +var \u{17B7D}; +var \u{17B7E}; +var \u{17B7F}; +var \u{17B80}; +var \u{17B81}; +var \u{17B82}; +var \u{17B83}; +var \u{17B84}; +var \u{17B85}; +var \u{17B86}; +var \u{17B87}; +var \u{17B88}; +var \u{17B89}; +var \u{17B8A}; +var \u{17B8B}; +var \u{17B8C}; +var \u{17B8D}; +var \u{17B8E}; +var \u{17B8F}; +var \u{17B90}; +var \u{17B91}; +var \u{17B92}; +var \u{17B93}; +var \u{17B94}; +var \u{17B95}; +var \u{17B96}; +var \u{17B97}; +var \u{17B98}; +var \u{17B99}; +var \u{17B9A}; +var \u{17B9B}; +var \u{17B9C}; +var \u{17B9D}; +var \u{17B9E}; +var \u{17B9F}; +var \u{17BA0}; +var \u{17BA1}; +var \u{17BA2}; +var \u{17BA3}; +var \u{17BA4}; +var \u{17BA5}; +var \u{17BA6}; +var \u{17BA7}; +var \u{17BA8}; +var \u{17BA9}; +var \u{17BAA}; +var \u{17BAB}; +var \u{17BAC}; +var \u{17BAD}; +var \u{17BAE}; +var \u{17BAF}; +var \u{17BB0}; +var \u{17BB1}; +var \u{17BB2}; +var \u{17BB3}; +var \u{17BB4}; +var \u{17BB5}; +var \u{17BB6}; +var \u{17BB7}; +var \u{17BB8}; +var \u{17BB9}; +var \u{17BBA}; +var \u{17BBB}; +var \u{17BBC}; +var \u{17BBD}; +var \u{17BBE}; +var \u{17BBF}; +var \u{17BC0}; +var \u{17BC1}; +var \u{17BC2}; +var \u{17BC3}; +var \u{17BC4}; +var \u{17BC5}; +var \u{17BC6}; +var \u{17BC7}; +var \u{17BC8}; +var \u{17BC9}; +var \u{17BCA}; +var \u{17BCB}; +var \u{17BCC}; +var \u{17BCD}; +var \u{17BCE}; +var \u{17BCF}; +var \u{17BD0}; +var \u{17BD1}; +var \u{17BD2}; +var \u{17BD3}; +var \u{17BD4}; +var \u{17BD5}; +var \u{17BD6}; +var \u{17BD7}; +var \u{17BD8}; +var \u{17BD9}; +var \u{17BDA}; +var \u{17BDB}; +var \u{17BDC}; +var \u{17BDD}; +var \u{17BDE}; +var \u{17BDF}; +var \u{17BE0}; +var \u{17BE1}; +var \u{17BE2}; +var \u{17BE3}; +var \u{17BE4}; +var \u{17BE5}; +var \u{17BE6}; +var \u{17BE7}; +var \u{17BE8}; +var \u{17BE9}; +var \u{17BEA}; +var \u{17BEB}; +var \u{17BEC}; +var \u{17BED}; +var \u{17BEE}; +var \u{17BEF}; +var \u{17BF0}; +var \u{17BF1}; +var \u{17BF2}; +var \u{17BF3}; +var \u{17BF4}; +var \u{17BF5}; +var \u{17BF6}; +var \u{17BF7}; +var \u{17BF8}; +var \u{17BF9}; +var \u{17BFA}; +var \u{17BFB}; +var \u{17BFC}; +var \u{17BFD}; +var \u{17BFE}; +var \u{17BFF}; +var \u{17C00}; +var \u{17C01}; +var \u{17C02}; +var \u{17C03}; +var \u{17C04}; +var \u{17C05}; +var \u{17C06}; +var \u{17C07}; +var \u{17C08}; +var \u{17C09}; +var \u{17C0A}; +var \u{17C0B}; +var \u{17C0C}; +var \u{17C0D}; +var \u{17C0E}; +var \u{17C0F}; +var \u{17C10}; +var \u{17C11}; +var \u{17C12}; +var \u{17C13}; +var \u{17C14}; +var \u{17C15}; +var \u{17C16}; +var \u{17C17}; +var \u{17C18}; +var \u{17C19}; +var \u{17C1A}; +var \u{17C1B}; +var \u{17C1C}; +var \u{17C1D}; +var \u{17C1E}; +var \u{17C1F}; +var \u{17C20}; +var \u{17C21}; +var \u{17C22}; +var \u{17C23}; +var \u{17C24}; +var \u{17C25}; +var \u{17C26}; +var \u{17C27}; +var \u{17C28}; +var \u{17C29}; +var \u{17C2A}; +var \u{17C2B}; +var \u{17C2C}; +var \u{17C2D}; +var \u{17C2E}; +var \u{17C2F}; +var \u{17C30}; +var \u{17C31}; +var \u{17C32}; +var \u{17C33}; +var \u{17C34}; +var \u{17C35}; +var \u{17C36}; +var \u{17C37}; +var \u{17C38}; +var \u{17C39}; +var \u{17C3A}; +var \u{17C3B}; +var \u{17C3C}; +var \u{17C3D}; +var \u{17C3E}; +var \u{17C3F}; +var \u{17C40}; +var \u{17C41}; +var \u{17C42}; +var \u{17C43}; +var \u{17C44}; +var \u{17C45}; +var \u{17C46}; +var \u{17C47}; +var \u{17C48}; +var \u{17C49}; +var \u{17C4A}; +var \u{17C4B}; +var \u{17C4C}; +var \u{17C4D}; +var \u{17C4E}; +var \u{17C4F}; +var \u{17C50}; +var \u{17C51}; +var \u{17C52}; +var \u{17C53}; +var \u{17C54}; +var \u{17C55}; +var \u{17C56}; +var \u{17C57}; +var \u{17C58}; +var \u{17C59}; +var \u{17C5A}; +var \u{17C5B}; +var \u{17C5C}; +var \u{17C5D}; +var \u{17C5E}; +var \u{17C5F}; +var \u{17C60}; +var \u{17C61}; +var \u{17C62}; +var \u{17C63}; +var \u{17C64}; +var \u{17C65}; +var \u{17C66}; +var \u{17C67}; +var \u{17C68}; +var \u{17C69}; +var \u{17C6A}; +var \u{17C6B}; +var \u{17C6C}; +var \u{17C6D}; +var \u{17C6E}; +var \u{17C6F}; +var \u{17C70}; +var \u{17C71}; +var \u{17C72}; +var \u{17C73}; +var \u{17C74}; +var \u{17C75}; +var \u{17C76}; +var \u{17C77}; +var \u{17C78}; +var \u{17C79}; +var \u{17C7A}; +var \u{17C7B}; +var \u{17C7C}; +var \u{17C7D}; +var \u{17C7E}; +var \u{17C7F}; +var \u{17C80}; +var \u{17C81}; +var \u{17C82}; +var \u{17C83}; +var \u{17C84}; +var \u{17C85}; +var \u{17C86}; +var \u{17C87}; +var \u{17C88}; +var \u{17C89}; +var \u{17C8A}; +var \u{17C8B}; +var \u{17C8C}; +var \u{17C8D}; +var \u{17C8E}; +var \u{17C8F}; +var \u{17C90}; +var \u{17C91}; +var \u{17C92}; +var \u{17C93}; +var \u{17C94}; +var \u{17C95}; +var \u{17C96}; +var \u{17C97}; +var \u{17C98}; +var \u{17C99}; +var \u{17C9A}; +var \u{17C9B}; +var \u{17C9C}; +var \u{17C9D}; +var \u{17C9E}; +var \u{17C9F}; +var \u{17CA0}; +var \u{17CA1}; +var \u{17CA2}; +var \u{17CA3}; +var \u{17CA4}; +var \u{17CA5}; +var \u{17CA6}; +var \u{17CA7}; +var \u{17CA8}; +var \u{17CA9}; +var \u{17CAA}; +var \u{17CAB}; +var \u{17CAC}; +var \u{17CAD}; +var \u{17CAE}; +var \u{17CAF}; +var \u{17CB0}; +var \u{17CB1}; +var \u{17CB2}; +var \u{17CB3}; +var \u{17CB4}; +var \u{17CB5}; +var \u{17CB6}; +var \u{17CB7}; +var \u{17CB8}; +var \u{17CB9}; +var \u{17CBA}; +var \u{17CBB}; +var \u{17CBC}; +var \u{17CBD}; +var \u{17CBE}; +var \u{17CBF}; +var \u{17CC0}; +var \u{17CC1}; +var \u{17CC2}; +var \u{17CC3}; +var \u{17CC4}; +var \u{17CC5}; +var \u{17CC6}; +var \u{17CC7}; +var \u{17CC8}; +var \u{17CC9}; +var \u{17CCA}; +var \u{17CCB}; +var \u{17CCC}; +var \u{17CCD}; +var \u{17CCE}; +var \u{17CCF}; +var \u{17CD0}; +var \u{17CD1}; +var \u{17CD2}; +var \u{17CD3}; +var \u{17CD4}; +var \u{17CD5}; +var \u{17CD6}; +var \u{17CD7}; +var \u{17CD8}; +var \u{17CD9}; +var \u{17CDA}; +var \u{17CDB}; +var \u{17CDC}; +var \u{17CDD}; +var \u{17CDE}; +var \u{17CDF}; +var \u{17CE0}; +var \u{17CE1}; +var \u{17CE2}; +var \u{17CE3}; +var \u{17CE4}; +var \u{17CE5}; +var \u{17CE6}; +var \u{17CE7}; +var \u{17CE8}; +var \u{17CE9}; +var \u{17CEA}; +var \u{17CEB}; +var \u{17CEC}; +var \u{17CED}; +var \u{17CEE}; +var \u{17CEF}; +var \u{17CF0}; +var \u{17CF1}; +var \u{17CF2}; +var \u{17CF3}; +var \u{17CF4}; +var \u{17CF5}; +var \u{17CF6}; +var \u{17CF7}; +var \u{17CF8}; +var \u{17CF9}; +var \u{17CFA}; +var \u{17CFB}; +var \u{17CFC}; +var \u{17CFD}; +var \u{17CFE}; +var \u{17CFF}; +var \u{17D00}; +var \u{17D01}; +var \u{17D02}; +var \u{17D03}; +var \u{17D04}; +var \u{17D05}; +var \u{17D06}; +var \u{17D07}; +var \u{17D08}; +var \u{17D09}; +var \u{17D0A}; +var \u{17D0B}; +var \u{17D0C}; +var \u{17D0D}; +var \u{17D0E}; +var \u{17D0F}; +var \u{17D10}; +var \u{17D11}; +var \u{17D12}; +var \u{17D13}; +var \u{17D14}; +var \u{17D15}; +var \u{17D16}; +var \u{17D17}; +var \u{17D18}; +var \u{17D19}; +var \u{17D1A}; +var \u{17D1B}; +var \u{17D1C}; +var \u{17D1D}; +var \u{17D1E}; +var \u{17D1F}; +var \u{17D20}; +var \u{17D21}; +var \u{17D22}; +var \u{17D23}; +var \u{17D24}; +var \u{17D25}; +var \u{17D26}; +var \u{17D27}; +var \u{17D28}; +var \u{17D29}; +var \u{17D2A}; +var \u{17D2B}; +var \u{17D2C}; +var \u{17D2D}; +var \u{17D2E}; +var \u{17D2F}; +var \u{17D30}; +var \u{17D31}; +var \u{17D32}; +var \u{17D33}; +var \u{17D34}; +var \u{17D35}; +var \u{17D36}; +var \u{17D37}; +var \u{17D38}; +var \u{17D39}; +var \u{17D3A}; +var \u{17D3B}; +var \u{17D3C}; +var \u{17D3D}; +var \u{17D3E}; +var \u{17D3F}; +var \u{17D40}; +var \u{17D41}; +var \u{17D42}; +var \u{17D43}; +var \u{17D44}; +var \u{17D45}; +var \u{17D46}; +var \u{17D47}; +var \u{17D48}; +var \u{17D49}; +var \u{17D4A}; +var \u{17D4B}; +var \u{17D4C}; +var \u{17D4D}; +var \u{17D4E}; +var \u{17D4F}; +var \u{17D50}; +var \u{17D51}; +var \u{17D52}; +var \u{17D53}; +var \u{17D54}; +var \u{17D55}; +var \u{17D56}; +var \u{17D57}; +var \u{17D58}; +var \u{17D59}; +var \u{17D5A}; +var \u{17D5B}; +var \u{17D5C}; +var \u{17D5D}; +var \u{17D5E}; +var \u{17D5F}; +var \u{17D60}; +var \u{17D61}; +var \u{17D62}; +var \u{17D63}; +var \u{17D64}; +var \u{17D65}; +var \u{17D66}; +var \u{17D67}; +var \u{17D68}; +var \u{17D69}; +var \u{17D6A}; +var \u{17D6B}; +var \u{17D6C}; +var \u{17D6D}; +var \u{17D6E}; +var \u{17D6F}; +var \u{17D70}; +var \u{17D71}; +var \u{17D72}; +var \u{17D73}; +var \u{17D74}; +var \u{17D75}; +var \u{17D76}; +var \u{17D77}; +var \u{17D78}; +var \u{17D79}; +var \u{17D7A}; +var \u{17D7B}; +var \u{17D7C}; +var \u{17D7D}; +var \u{17D7E}; +var \u{17D7F}; +var \u{17D80}; +var \u{17D81}; +var \u{17D82}; +var \u{17D83}; +var \u{17D84}; +var \u{17D85}; +var \u{17D86}; +var \u{17D87}; +var \u{17D88}; +var \u{17D89}; +var \u{17D8A}; +var \u{17D8B}; +var \u{17D8C}; +var \u{17D8D}; +var \u{17D8E}; +var \u{17D8F}; +var \u{17D90}; +var \u{17D91}; +var \u{17D92}; +var \u{17D93}; +var \u{17D94}; +var \u{17D95}; +var \u{17D96}; +var \u{17D97}; +var \u{17D98}; +var \u{17D99}; +var \u{17D9A}; +var \u{17D9B}; +var \u{17D9C}; +var \u{17D9D}; +var \u{17D9E}; +var \u{17D9F}; +var \u{17DA0}; +var \u{17DA1}; +var \u{17DA2}; +var \u{17DA3}; +var \u{17DA4}; +var \u{17DA5}; +var \u{17DA6}; +var \u{17DA7}; +var \u{17DA8}; +var \u{17DA9}; +var \u{17DAA}; +var \u{17DAB}; +var \u{17DAC}; +var \u{17DAD}; +var \u{17DAE}; +var \u{17DAF}; +var \u{17DB0}; +var \u{17DB1}; +var \u{17DB2}; +var \u{17DB3}; +var \u{17DB4}; +var \u{17DB5}; +var \u{17DB6}; +var \u{17DB7}; +var \u{17DB8}; +var \u{17DB9}; +var \u{17DBA}; +var \u{17DBB}; +var \u{17DBC}; +var \u{17DBD}; +var \u{17DBE}; +var \u{17DBF}; +var \u{17DC0}; +var \u{17DC1}; +var \u{17DC2}; +var \u{17DC3}; +var \u{17DC4}; +var \u{17DC5}; +var \u{17DC6}; +var \u{17DC7}; +var \u{17DC8}; +var \u{17DC9}; +var \u{17DCA}; +var \u{17DCB}; +var \u{17DCC}; +var \u{17DCD}; +var \u{17DCE}; +var \u{17DCF}; +var \u{17DD0}; +var \u{17DD1}; +var \u{17DD2}; +var \u{17DD3}; +var \u{17DD4}; +var \u{17DD5}; +var \u{17DD6}; +var \u{17DD7}; +var \u{17DD8}; +var \u{17DD9}; +var \u{17DDA}; +var \u{17DDB}; +var \u{17DDC}; +var \u{17DDD}; +var \u{17DDE}; +var \u{17DDF}; +var \u{17DE0}; +var \u{17DE1}; +var \u{17DE2}; +var \u{17DE3}; +var \u{17DE4}; +var \u{17DE5}; +var \u{17DE6}; +var \u{17DE7}; +var \u{17DE8}; +var \u{17DE9}; +var \u{17DEA}; +var \u{17DEB}; +var \u{17DEC}; +var \u{17DED}; +var \u{17DEE}; +var \u{17DEF}; +var \u{17DF0}; +var \u{17DF1}; +var \u{17DF2}; +var \u{17DF3}; +var \u{17DF4}; +var \u{17DF5}; +var \u{17DF6}; +var \u{17DF7}; +var \u{17DF8}; +var \u{17DF9}; +var \u{17DFA}; +var \u{17DFB}; +var \u{17DFC}; +var \u{17DFD}; +var \u{17DFE}; +var \u{17DFF}; +var \u{17E00}; +var \u{17E01}; +var \u{17E02}; +var \u{17E03}; +var \u{17E04}; +var \u{17E05}; +var \u{17E06}; +var \u{17E07}; +var \u{17E08}; +var \u{17E09}; +var \u{17E0A}; +var \u{17E0B}; +var \u{17E0C}; +var \u{17E0D}; +var \u{17E0E}; +var \u{17E0F}; +var \u{17E10}; +var \u{17E11}; +var \u{17E12}; +var \u{17E13}; +var \u{17E14}; +var \u{17E15}; +var \u{17E16}; +var \u{17E17}; +var \u{17E18}; +var \u{17E19}; +var \u{17E1A}; +var \u{17E1B}; +var \u{17E1C}; +var \u{17E1D}; +var \u{17E1E}; +var \u{17E1F}; +var \u{17E20}; +var \u{17E21}; +var \u{17E22}; +var \u{17E23}; +var \u{17E24}; +var \u{17E25}; +var \u{17E26}; +var \u{17E27}; +var \u{17E28}; +var \u{17E29}; +var \u{17E2A}; +var \u{17E2B}; +var \u{17E2C}; +var \u{17E2D}; +var \u{17E2E}; +var \u{17E2F}; +var \u{17E30}; +var \u{17E31}; +var \u{17E32}; +var \u{17E33}; +var \u{17E34}; +var \u{17E35}; +var \u{17E36}; +var \u{17E37}; +var \u{17E38}; +var \u{17E39}; +var \u{17E3A}; +var \u{17E3B}; +var \u{17E3C}; +var \u{17E3D}; +var \u{17E3E}; +var \u{17E3F}; +var \u{17E40}; +var \u{17E41}; +var \u{17E42}; +var \u{17E43}; +var \u{17E44}; +var \u{17E45}; +var \u{17E46}; +var \u{17E47}; +var \u{17E48}; +var \u{17E49}; +var \u{17E4A}; +var \u{17E4B}; +var \u{17E4C}; +var \u{17E4D}; +var \u{17E4E}; +var \u{17E4F}; +var \u{17E50}; +var \u{17E51}; +var \u{17E52}; +var \u{17E53}; +var \u{17E54}; +var \u{17E55}; +var \u{17E56}; +var \u{17E57}; +var \u{17E58}; +var \u{17E59}; +var \u{17E5A}; +var \u{17E5B}; +var \u{17E5C}; +var \u{17E5D}; +var \u{17E5E}; +var \u{17E5F}; +var \u{17E60}; +var \u{17E61}; +var \u{17E62}; +var \u{17E63}; +var \u{17E64}; +var \u{17E65}; +var \u{17E66}; +var \u{17E67}; +var \u{17E68}; +var \u{17E69}; +var \u{17E6A}; +var \u{17E6B}; +var \u{17E6C}; +var \u{17E6D}; +var \u{17E6E}; +var \u{17E6F}; +var \u{17E70}; +var \u{17E71}; +var \u{17E72}; +var \u{17E73}; +var \u{17E74}; +var \u{17E75}; +var \u{17E76}; +var \u{17E77}; +var \u{17E78}; +var \u{17E79}; +var \u{17E7A}; +var \u{17E7B}; +var \u{17E7C}; +var \u{17E7D}; +var \u{17E7E}; +var \u{17E7F}; +var \u{17E80}; +var \u{17E81}; +var \u{17E82}; +var \u{17E83}; +var \u{17E84}; +var \u{17E85}; +var \u{17E86}; +var \u{17E87}; +var \u{17E88}; +var \u{17E89}; +var \u{17E8A}; +var \u{17E8B}; +var \u{17E8C}; +var \u{17E8D}; +var \u{17E8E}; +var \u{17E8F}; +var \u{17E90}; +var \u{17E91}; +var \u{17E92}; +var \u{17E93}; +var \u{17E94}; +var \u{17E95}; +var \u{17E96}; +var \u{17E97}; +var \u{17E98}; +var \u{17E99}; +var \u{17E9A}; +var \u{17E9B}; +var \u{17E9C}; +var \u{17E9D}; +var \u{17E9E}; +var \u{17E9F}; +var \u{17EA0}; +var \u{17EA1}; +var \u{17EA2}; +var \u{17EA3}; +var \u{17EA4}; +var \u{17EA5}; +var \u{17EA6}; +var \u{17EA7}; +var \u{17EA8}; +var \u{17EA9}; +var \u{17EAA}; +var \u{17EAB}; +var \u{17EAC}; +var \u{17EAD}; +var \u{17EAE}; +var \u{17EAF}; +var \u{17EB0}; +var \u{17EB1}; +var \u{17EB2}; +var \u{17EB3}; +var \u{17EB4}; +var \u{17EB5}; +var \u{17EB6}; +var \u{17EB7}; +var \u{17EB8}; +var \u{17EB9}; +var \u{17EBA}; +var \u{17EBB}; +var \u{17EBC}; +var \u{17EBD}; +var \u{17EBE}; +var \u{17EBF}; +var \u{17EC0}; +var \u{17EC1}; +var \u{17EC2}; +var \u{17EC3}; +var \u{17EC4}; +var \u{17EC5}; +var \u{17EC6}; +var \u{17EC7}; +var \u{17EC8}; +var \u{17EC9}; +var \u{17ECA}; +var \u{17ECB}; +var \u{17ECC}; +var \u{17ECD}; +var \u{17ECE}; +var \u{17ECF}; +var \u{17ED0}; +var \u{17ED1}; +var \u{17ED2}; +var \u{17ED3}; +var \u{17ED4}; +var \u{17ED5}; +var \u{17ED6}; +var \u{17ED7}; +var \u{17ED8}; +var \u{17ED9}; +var \u{17EDA}; +var \u{17EDB}; +var \u{17EDC}; +var \u{17EDD}; +var \u{17EDE}; +var \u{17EDF}; +var \u{17EE0}; +var \u{17EE1}; +var \u{17EE2}; +var \u{17EE3}; +var \u{17EE4}; +var \u{17EE5}; +var \u{17EE6}; +var \u{17EE7}; +var \u{17EE8}; +var \u{17EE9}; +var \u{17EEA}; +var \u{17EEB}; +var \u{17EEC}; +var \u{17EED}; +var \u{17EEE}; +var \u{17EEF}; +var \u{17EF0}; +var \u{17EF1}; +var \u{17EF2}; +var \u{17EF3}; +var \u{17EF4}; +var \u{17EF5}; +var \u{17EF6}; +var \u{17EF7}; +var \u{17EF8}; +var \u{17EF9}; +var \u{17EFA}; +var \u{17EFB}; +var \u{17EFC}; +var \u{17EFD}; +var \u{17EFE}; +var \u{17EFF}; +var \u{17F00}; +var \u{17F01}; +var \u{17F02}; +var \u{17F03}; +var \u{17F04}; +var \u{17F05}; +var \u{17F06}; +var \u{17F07}; +var \u{17F08}; +var \u{17F09}; +var \u{17F0A}; +var \u{17F0B}; +var \u{17F0C}; +var \u{17F0D}; +var \u{17F0E}; +var \u{17F0F}; +var \u{17F10}; +var \u{17F11}; +var \u{17F12}; +var \u{17F13}; +var \u{17F14}; +var \u{17F15}; +var \u{17F16}; +var \u{17F17}; +var \u{17F18}; +var \u{17F19}; +var \u{17F1A}; +var \u{17F1B}; +var \u{17F1C}; +var \u{17F1D}; +var \u{17F1E}; +var \u{17F1F}; +var \u{17F20}; +var \u{17F21}; +var \u{17F22}; +var \u{17F23}; +var \u{17F24}; +var \u{17F25}; +var \u{17F26}; +var \u{17F27}; +var \u{17F28}; +var \u{17F29}; +var \u{17F2A}; +var \u{17F2B}; +var \u{17F2C}; +var \u{17F2D}; +var \u{17F2E}; +var \u{17F2F}; +var \u{17F30}; +var \u{17F31}; +var \u{17F32}; +var \u{17F33}; +var \u{17F34}; +var \u{17F35}; +var \u{17F36}; +var \u{17F37}; +var \u{17F38}; +var \u{17F39}; +var \u{17F3A}; +var \u{17F3B}; +var \u{17F3C}; +var \u{17F3D}; +var \u{17F3E}; +var \u{17F3F}; +var \u{17F40}; +var \u{17F41}; +var \u{17F42}; +var \u{17F43}; +var \u{17F44}; +var \u{17F45}; +var \u{17F46}; +var \u{17F47}; +var \u{17F48}; +var \u{17F49}; +var \u{17F4A}; +var \u{17F4B}; +var \u{17F4C}; +var \u{17F4D}; +var \u{17F4E}; +var \u{17F4F}; +var \u{17F50}; +var \u{17F51}; +var \u{17F52}; +var \u{17F53}; +var \u{17F54}; +var \u{17F55}; +var \u{17F56}; +var \u{17F57}; +var \u{17F58}; +var \u{17F59}; +var \u{17F5A}; +var \u{17F5B}; +var \u{17F5C}; +var \u{17F5D}; +var \u{17F5E}; +var \u{17F5F}; +var \u{17F60}; +var \u{17F61}; +var \u{17F62}; +var \u{17F63}; +var \u{17F64}; +var \u{17F65}; +var \u{17F66}; +var \u{17F67}; +var \u{17F68}; +var \u{17F69}; +var \u{17F6A}; +var \u{17F6B}; +var \u{17F6C}; +var \u{17F6D}; +var \u{17F6E}; +var \u{17F6F}; +var \u{17F70}; +var \u{17F71}; +var \u{17F72}; +var \u{17F73}; +var \u{17F74}; +var \u{17F75}; +var \u{17F76}; +var \u{17F77}; +var \u{17F78}; +var \u{17F79}; +var \u{17F7A}; +var \u{17F7B}; +var \u{17F7C}; +var \u{17F7D}; +var \u{17F7E}; +var \u{17F7F}; +var \u{17F80}; +var \u{17F81}; +var \u{17F82}; +var \u{17F83}; +var \u{17F84}; +var \u{17F85}; +var \u{17F86}; +var \u{17F87}; +var \u{17F88}; +var \u{17F89}; +var \u{17F8A}; +var \u{17F8B}; +var \u{17F8C}; +var \u{17F8D}; +var \u{17F8E}; +var \u{17F8F}; +var \u{17F90}; +var \u{17F91}; +var \u{17F92}; +var \u{17F93}; +var \u{17F94}; +var \u{17F95}; +var \u{17F96}; +var \u{17F97}; +var \u{17F98}; +var \u{17F99}; +var \u{17F9A}; +var \u{17F9B}; +var \u{17F9C}; +var \u{17F9D}; +var \u{17F9E}; +var \u{17F9F}; +var \u{17FA0}; +var \u{17FA1}; +var \u{17FA2}; +var \u{17FA3}; +var \u{17FA4}; +var \u{17FA5}; +var \u{17FA6}; +var \u{17FA7}; +var \u{17FA8}; +var \u{17FA9}; +var \u{17FAA}; +var \u{17FAB}; +var \u{17FAC}; +var \u{17FAD}; +var \u{17FAE}; +var \u{17FAF}; +var \u{17FB0}; +var \u{17FB1}; +var \u{17FB2}; +var \u{17FB3}; +var \u{17FB4}; +var \u{17FB5}; +var \u{17FB6}; +var \u{17FB7}; +var \u{17FB8}; +var \u{17FB9}; +var \u{17FBA}; +var \u{17FBB}; +var \u{17FBC}; +var \u{17FBD}; +var \u{17FBE}; +var \u{17FBF}; +var \u{17FC0}; +var \u{17FC1}; +var \u{17FC2}; +var \u{17FC3}; +var \u{17FC4}; +var \u{17FC5}; +var \u{17FC6}; +var \u{17FC7}; +var \u{17FC8}; +var \u{17FC9}; +var \u{17FCA}; +var \u{17FCB}; +var \u{17FCC}; +var \u{17FCD}; +var \u{17FCE}; +var \u{17FCF}; +var \u{17FD0}; +var \u{17FD1}; +var \u{17FD2}; +var \u{17FD3}; +var \u{17FD4}; +var \u{17FD5}; +var \u{17FD6}; +var \u{17FD7}; +var \u{17FD8}; +var \u{17FD9}; +var \u{17FDA}; +var \u{17FDB}; +var \u{17FDC}; +var \u{17FDD}; +var \u{17FDE}; +var \u{17FDF}; +var \u{17FE0}; +var \u{17FE1}; +var \u{17FE2}; +var \u{17FE3}; +var \u{17FE4}; +var \u{17FE5}; +var \u{17FE6}; +var \u{17FE7}; +var \u{17FE8}; +var \u{17FE9}; +var \u{17FEA}; +var \u{17FEB}; +var \u{17FEC}; +var \u{17FED}; +var \u{17FEE}; +var \u{17FEF}; +var \u{17FF0}; +var \u{17FF1}; +var \u{17FF2}; +var \u{17FF3}; +var \u{17FF4}; +var \u{17FF5}; +var \u{17FF6}; +var \u{17FF7}; +var \u{17FF8}; +var \u{17FF9}; +var \u{17FFA}; +var \u{17FFB}; +var \u{17FFC}; +var \u{17FFD}; +var \u{17FFE}; +var \u{17FFF}; +var \u{18000}; +var \u{18001}; +var \u{18002}; +var \u{18003}; +var \u{18004}; +var \u{18005}; +var \u{18006}; +var \u{18007}; +var \u{18008}; +var \u{18009}; +var \u{1800A}; +var \u{1800B}; +var \u{1800C}; +var \u{1800D}; +var \u{1800E}; +var \u{1800F}; +var \u{18010}; +var \u{18011}; +var \u{18012}; +var \u{18013}; +var \u{18014}; +var \u{18015}; +var \u{18016}; +var \u{18017}; +var \u{18018}; +var \u{18019}; +var \u{1801A}; +var \u{1801B}; +var \u{1801C}; +var \u{1801D}; +var \u{1801E}; +var \u{1801F}; +var \u{18020}; +var \u{18021}; +var \u{18022}; +var \u{18023}; +var \u{18024}; +var \u{18025}; +var \u{18026}; +var \u{18027}; +var \u{18028}; +var \u{18029}; +var \u{1802A}; +var \u{1802B}; +var \u{1802C}; +var \u{1802D}; +var \u{1802E}; +var \u{1802F}; +var \u{18030}; +var \u{18031}; +var \u{18032}; +var \u{18033}; +var \u{18034}; +var \u{18035}; +var \u{18036}; +var \u{18037}; +var \u{18038}; +var \u{18039}; +var \u{1803A}; +var \u{1803B}; +var \u{1803C}; +var \u{1803D}; +var \u{1803E}; +var \u{1803F}; +var \u{18040}; +var \u{18041}; +var \u{18042}; +var \u{18043}; +var \u{18044}; +var \u{18045}; +var \u{18046}; +var \u{18047}; +var \u{18048}; +var \u{18049}; +var \u{1804A}; +var \u{1804B}; +var \u{1804C}; +var \u{1804D}; +var \u{1804E}; +var \u{1804F}; +var \u{18050}; +var \u{18051}; +var \u{18052}; +var \u{18053}; +var \u{18054}; +var \u{18055}; +var \u{18056}; +var \u{18057}; +var \u{18058}; +var \u{18059}; +var \u{1805A}; +var \u{1805B}; +var \u{1805C}; +var \u{1805D}; +var \u{1805E}; +var \u{1805F}; +var \u{18060}; +var \u{18061}; +var \u{18062}; +var \u{18063}; +var \u{18064}; +var \u{18065}; +var \u{18066}; +var \u{18067}; +var \u{18068}; +var \u{18069}; +var \u{1806A}; +var \u{1806B}; +var \u{1806C}; +var \u{1806D}; +var \u{1806E}; +var \u{1806F}; +var \u{18070}; +var \u{18071}; +var \u{18072}; +var \u{18073}; +var \u{18074}; +var \u{18075}; +var \u{18076}; +var \u{18077}; +var \u{18078}; +var \u{18079}; +var \u{1807A}; +var \u{1807B}; +var \u{1807C}; +var \u{1807D}; +var \u{1807E}; +var \u{1807F}; +var \u{18080}; +var \u{18081}; +var \u{18082}; +var \u{18083}; +var \u{18084}; +var \u{18085}; +var \u{18086}; +var \u{18087}; +var \u{18088}; +var \u{18089}; +var \u{1808A}; +var \u{1808B}; +var \u{1808C}; +var \u{1808D}; +var \u{1808E}; +var \u{1808F}; +var \u{18090}; +var \u{18091}; +var \u{18092}; +var \u{18093}; +var \u{18094}; +var \u{18095}; +var \u{18096}; +var \u{18097}; +var \u{18098}; +var \u{18099}; +var \u{1809A}; +var \u{1809B}; +var \u{1809C}; +var \u{1809D}; +var \u{1809E}; +var \u{1809F}; +var \u{180A0}; +var \u{180A1}; +var \u{180A2}; +var \u{180A3}; +var \u{180A4}; +var \u{180A5}; +var \u{180A6}; +var \u{180A7}; +var \u{180A8}; +var \u{180A9}; +var \u{180AA}; +var \u{180AB}; +var \u{180AC}; +var \u{180AD}; +var \u{180AE}; +var \u{180AF}; +var \u{180B0}; +var \u{180B1}; +var \u{180B2}; +var \u{180B3}; +var \u{180B4}; +var \u{180B5}; +var \u{180B6}; +var \u{180B7}; +var \u{180B8}; +var \u{180B9}; +var \u{180BA}; +var \u{180BB}; +var \u{180BC}; +var \u{180BD}; +var \u{180BE}; +var \u{180BF}; +var \u{180C0}; +var \u{180C1}; +var \u{180C2}; +var \u{180C3}; +var \u{180C4}; +var \u{180C5}; +var \u{180C6}; +var \u{180C7}; +var \u{180C8}; +var \u{180C9}; +var \u{180CA}; +var \u{180CB}; +var \u{180CC}; +var \u{180CD}; +var \u{180CE}; +var \u{180CF}; +var \u{180D0}; +var \u{180D1}; +var \u{180D2}; +var \u{180D3}; +var \u{180D4}; +var \u{180D5}; +var \u{180D6}; +var \u{180D7}; +var \u{180D8}; +var \u{180D9}; +var \u{180DA}; +var \u{180DB}; +var \u{180DC}; +var \u{180DD}; +var \u{180DE}; +var \u{180DF}; +var \u{180E0}; +var \u{180E1}; +var \u{180E2}; +var \u{180E3}; +var \u{180E4}; +var \u{180E5}; +var \u{180E6}; +var \u{180E7}; +var \u{180E8}; +var \u{180E9}; +var \u{180EA}; +var \u{180EB}; +var \u{180EC}; +var \u{180ED}; +var \u{180EE}; +var \u{180EF}; +var \u{180F0}; +var \u{180F1}; +var \u{180F2}; +var \u{180F3}; +var \u{180F4}; +var \u{180F5}; +var \u{180F6}; +var \u{180F7}; +var \u{180F8}; +var \u{180F9}; +var \u{180FA}; +var \u{180FB}; +var \u{180FC}; +var \u{180FD}; +var \u{180FE}; +var \u{180FF}; +var \u{18100}; +var \u{18101}; +var \u{18102}; +var \u{18103}; +var \u{18104}; +var \u{18105}; +var \u{18106}; +var \u{18107}; +var \u{18108}; +var \u{18109}; +var \u{1810A}; +var \u{1810B}; +var \u{1810C}; +var \u{1810D}; +var \u{1810E}; +var \u{1810F}; +var \u{18110}; +var \u{18111}; +var \u{18112}; +var \u{18113}; +var \u{18114}; +var \u{18115}; +var \u{18116}; +var \u{18117}; +var \u{18118}; +var \u{18119}; +var \u{1811A}; +var \u{1811B}; +var \u{1811C}; +var \u{1811D}; +var \u{1811E}; +var \u{1811F}; +var \u{18120}; +var \u{18121}; +var \u{18122}; +var \u{18123}; +var \u{18124}; +var \u{18125}; +var \u{18126}; +var \u{18127}; +var \u{18128}; +var \u{18129}; +var \u{1812A}; +var \u{1812B}; +var \u{1812C}; +var \u{1812D}; +var \u{1812E}; +var \u{1812F}; +var \u{18130}; +var \u{18131}; +var \u{18132}; +var \u{18133}; +var \u{18134}; +var \u{18135}; +var \u{18136}; +var \u{18137}; +var \u{18138}; +var \u{18139}; +var \u{1813A}; +var \u{1813B}; +var \u{1813C}; +var \u{1813D}; +var \u{1813E}; +var \u{1813F}; +var \u{18140}; +var \u{18141}; +var \u{18142}; +var \u{18143}; +var \u{18144}; +var \u{18145}; +var \u{18146}; +var \u{18147}; +var \u{18148}; +var \u{18149}; +var \u{1814A}; +var \u{1814B}; +var \u{1814C}; +var \u{1814D}; +var \u{1814E}; +var \u{1814F}; +var \u{18150}; +var \u{18151}; +var \u{18152}; +var \u{18153}; +var \u{18154}; +var \u{18155}; +var \u{18156}; +var \u{18157}; +var \u{18158}; +var \u{18159}; +var \u{1815A}; +var \u{1815B}; +var \u{1815C}; +var \u{1815D}; +var \u{1815E}; +var \u{1815F}; +var \u{18160}; +var \u{18161}; +var \u{18162}; +var \u{18163}; +var \u{18164}; +var \u{18165}; +var \u{18166}; +var \u{18167}; +var \u{18168}; +var \u{18169}; +var \u{1816A}; +var \u{1816B}; +var \u{1816C}; +var \u{1816D}; +var \u{1816E}; +var \u{1816F}; +var \u{18170}; +var \u{18171}; +var \u{18172}; +var \u{18173}; +var \u{18174}; +var \u{18175}; +var \u{18176}; +var \u{18177}; +var \u{18178}; +var \u{18179}; +var \u{1817A}; +var \u{1817B}; +var \u{1817C}; +var \u{1817D}; +var \u{1817E}; +var \u{1817F}; +var \u{18180}; +var \u{18181}; +var \u{18182}; +var \u{18183}; +var \u{18184}; +var \u{18185}; +var \u{18186}; +var \u{18187}; +var \u{18188}; +var \u{18189}; +var \u{1818A}; +var \u{1818B}; +var \u{1818C}; +var \u{1818D}; +var \u{1818E}; +var \u{1818F}; +var \u{18190}; +var \u{18191}; +var \u{18192}; +var \u{18193}; +var \u{18194}; +var \u{18195}; +var \u{18196}; +var \u{18197}; +var \u{18198}; +var \u{18199}; +var \u{1819A}; +var \u{1819B}; +var \u{1819C}; +var \u{1819D}; +var \u{1819E}; +var \u{1819F}; +var \u{181A0}; +var \u{181A1}; +var \u{181A2}; +var \u{181A3}; +var \u{181A4}; +var \u{181A5}; +var \u{181A6}; +var \u{181A7}; +var \u{181A8}; +var \u{181A9}; +var \u{181AA}; +var \u{181AB}; +var \u{181AC}; +var \u{181AD}; +var \u{181AE}; +var \u{181AF}; +var \u{181B0}; +var \u{181B1}; +var \u{181B2}; +var \u{181B3}; +var \u{181B4}; +var \u{181B5}; +var \u{181B6}; +var \u{181B7}; +var \u{181B8}; +var \u{181B9}; +var \u{181BA}; +var \u{181BB}; +var \u{181BC}; +var \u{181BD}; +var \u{181BE}; +var \u{181BF}; +var \u{181C0}; +var \u{181C1}; +var \u{181C2}; +var \u{181C3}; +var \u{181C4}; +var \u{181C5}; +var \u{181C6}; +var \u{181C7}; +var \u{181C8}; +var \u{181C9}; +var \u{181CA}; +var \u{181CB}; +var \u{181CC}; +var \u{181CD}; +var \u{181CE}; +var \u{181CF}; +var \u{181D0}; +var \u{181D1}; +var \u{181D2}; +var \u{181D3}; +var \u{181D4}; +var \u{181D5}; +var \u{181D6}; +var \u{181D7}; +var \u{181D8}; +var \u{181D9}; +var \u{181DA}; +var \u{181DB}; +var \u{181DC}; +var \u{181DD}; +var \u{181DE}; +var \u{181DF}; +var \u{181E0}; +var \u{181E1}; +var \u{181E2}; +var \u{181E3}; +var \u{181E4}; +var \u{181E5}; +var \u{181E6}; +var \u{181E7}; +var \u{181E8}; +var \u{181E9}; +var \u{181EA}; +var \u{181EB}; +var \u{181EC}; +var \u{181ED}; +var \u{181EE}; +var \u{181EF}; +var \u{181F0}; +var \u{181F1}; +var \u{181F2}; +var \u{181F3}; +var \u{181F4}; +var \u{181F5}; +var \u{181F6}; +var \u{181F7}; +var \u{181F8}; +var \u{181F9}; +var \u{181FA}; +var \u{181FB}; +var \u{181FC}; +var \u{181FD}; +var \u{181FE}; +var \u{181FF}; +var \u{18200}; +var \u{18201}; +var \u{18202}; +var \u{18203}; +var \u{18204}; +var \u{18205}; +var \u{18206}; +var \u{18207}; +var \u{18208}; +var \u{18209}; +var \u{1820A}; +var \u{1820B}; +var \u{1820C}; +var \u{1820D}; +var \u{1820E}; +var \u{1820F}; +var \u{18210}; +var \u{18211}; +var \u{18212}; +var \u{18213}; +var \u{18214}; +var \u{18215}; +var \u{18216}; +var \u{18217}; +var \u{18218}; +var \u{18219}; +var \u{1821A}; +var \u{1821B}; +var \u{1821C}; +var \u{1821D}; +var \u{1821E}; +var \u{1821F}; +var \u{18220}; +var \u{18221}; +var \u{18222}; +var \u{18223}; +var \u{18224}; +var \u{18225}; +var \u{18226}; +var \u{18227}; +var \u{18228}; +var \u{18229}; +var \u{1822A}; +var \u{1822B}; +var \u{1822C}; +var \u{1822D}; +var \u{1822E}; +var \u{1822F}; +var \u{18230}; +var \u{18231}; +var \u{18232}; +var \u{18233}; +var \u{18234}; +var \u{18235}; +var \u{18236}; +var \u{18237}; +var \u{18238}; +var \u{18239}; +var \u{1823A}; +var \u{1823B}; +var \u{1823C}; +var \u{1823D}; +var \u{1823E}; +var \u{1823F}; +var \u{18240}; +var \u{18241}; +var \u{18242}; +var \u{18243}; +var \u{18244}; +var \u{18245}; +var \u{18246}; +var \u{18247}; +var \u{18248}; +var \u{18249}; +var \u{1824A}; +var \u{1824B}; +var \u{1824C}; +var \u{1824D}; +var \u{1824E}; +var \u{1824F}; +var \u{18250}; +var \u{18251}; +var \u{18252}; +var \u{18253}; +var \u{18254}; +var \u{18255}; +var \u{18256}; +var \u{18257}; +var \u{18258}; +var \u{18259}; +var \u{1825A}; +var \u{1825B}; +var \u{1825C}; +var \u{1825D}; +var \u{1825E}; +var \u{1825F}; +var \u{18260}; +var \u{18261}; +var \u{18262}; +var \u{18263}; +var \u{18264}; +var \u{18265}; +var \u{18266}; +var \u{18267}; +var \u{18268}; +var \u{18269}; +var \u{1826A}; +var \u{1826B}; +var \u{1826C}; +var \u{1826D}; +var \u{1826E}; +var \u{1826F}; +var \u{18270}; +var \u{18271}; +var \u{18272}; +var \u{18273}; +var \u{18274}; +var \u{18275}; +var \u{18276}; +var \u{18277}; +var \u{18278}; +var \u{18279}; +var \u{1827A}; +var \u{1827B}; +var \u{1827C}; +var \u{1827D}; +var \u{1827E}; +var \u{1827F}; +var \u{18280}; +var \u{18281}; +var \u{18282}; +var \u{18283}; +var \u{18284}; +var \u{18285}; +var \u{18286}; +var \u{18287}; +var \u{18288}; +var \u{18289}; +var \u{1828A}; +var \u{1828B}; +var \u{1828C}; +var \u{1828D}; +var \u{1828E}; +var \u{1828F}; +var \u{18290}; +var \u{18291}; +var \u{18292}; +var \u{18293}; +var \u{18294}; +var \u{18295}; +var \u{18296}; +var \u{18297}; +var \u{18298}; +var \u{18299}; +var \u{1829A}; +var \u{1829B}; +var \u{1829C}; +var \u{1829D}; +var \u{1829E}; +var \u{1829F}; +var \u{182A0}; +var \u{182A1}; +var \u{182A2}; +var \u{182A3}; +var \u{182A4}; +var \u{182A5}; +var \u{182A6}; +var \u{182A7}; +var \u{182A8}; +var \u{182A9}; +var \u{182AA}; +var \u{182AB}; +var \u{182AC}; +var \u{182AD}; +var \u{182AE}; +var \u{182AF}; +var \u{182B0}; +var \u{182B1}; +var \u{182B2}; +var \u{182B3}; +var \u{182B4}; +var \u{182B5}; +var \u{182B6}; +var \u{182B7}; +var \u{182B8}; +var \u{182B9}; +var \u{182BA}; +var \u{182BB}; +var \u{182BC}; +var \u{182BD}; +var \u{182BE}; +var \u{182BF}; +var \u{182C0}; +var \u{182C1}; +var \u{182C2}; +var \u{182C3}; +var \u{182C4}; +var \u{182C5}; +var \u{182C6}; +var \u{182C7}; +var \u{182C8}; +var \u{182C9}; +var \u{182CA}; +var \u{182CB}; +var \u{182CC}; +var \u{182CD}; +var \u{182CE}; +var \u{182CF}; +var \u{182D0}; +var \u{182D1}; +var \u{182D2}; +var \u{182D3}; +var \u{182D4}; +var \u{182D5}; +var \u{182D6}; +var \u{182D7}; +var \u{182D8}; +var \u{182D9}; +var \u{182DA}; +var \u{182DB}; +var \u{182DC}; +var \u{182DD}; +var \u{182DE}; +var \u{182DF}; +var \u{182E0}; +var \u{182E1}; +var \u{182E2}; +var \u{182E3}; +var \u{182E4}; +var \u{182E5}; +var \u{182E6}; +var \u{182E7}; +var \u{182E8}; +var \u{182E9}; +var \u{182EA}; +var \u{182EB}; +var \u{182EC}; +var \u{182ED}; +var \u{182EE}; +var \u{182EF}; +var \u{182F0}; +var \u{182F1}; +var \u{182F2}; +var \u{182F3}; +var \u{182F4}; +var \u{182F5}; +var \u{182F6}; +var \u{182F7}; +var \u{182F8}; +var \u{182F9}; +var \u{182FA}; +var \u{182FB}; +var \u{182FC}; +var \u{182FD}; +var \u{182FE}; +var \u{182FF}; +var \u{18300}; +var \u{18301}; +var \u{18302}; +var \u{18303}; +var \u{18304}; +var \u{18305}; +var \u{18306}; +var \u{18307}; +var \u{18308}; +var \u{18309}; +var \u{1830A}; +var \u{1830B}; +var \u{1830C}; +var \u{1830D}; +var \u{1830E}; +var \u{1830F}; +var \u{18310}; +var \u{18311}; +var \u{18312}; +var \u{18313}; +var \u{18314}; +var \u{18315}; +var \u{18316}; +var \u{18317}; +var \u{18318}; +var \u{18319}; +var \u{1831A}; +var \u{1831B}; +var \u{1831C}; +var \u{1831D}; +var \u{1831E}; +var \u{1831F}; +var \u{18320}; +var \u{18321}; +var \u{18322}; +var \u{18323}; +var \u{18324}; +var \u{18325}; +var \u{18326}; +var \u{18327}; +var \u{18328}; +var \u{18329}; +var \u{1832A}; +var \u{1832B}; +var \u{1832C}; +var \u{1832D}; +var \u{1832E}; +var \u{1832F}; +var \u{18330}; +var \u{18331}; +var \u{18332}; +var \u{18333}; +var \u{18334}; +var \u{18335}; +var \u{18336}; +var \u{18337}; +var \u{18338}; +var \u{18339}; +var \u{1833A}; +var \u{1833B}; +var \u{1833C}; +var \u{1833D}; +var \u{1833E}; +var \u{1833F}; +var \u{18340}; +var \u{18341}; +var \u{18342}; +var \u{18343}; +var \u{18344}; +var \u{18345}; +var \u{18346}; +var \u{18347}; +var \u{18348}; +var \u{18349}; +var \u{1834A}; +var \u{1834B}; +var \u{1834C}; +var \u{1834D}; +var \u{1834E}; +var \u{1834F}; +var \u{18350}; +var \u{18351}; +var \u{18352}; +var \u{18353}; +var \u{18354}; +var \u{18355}; +var \u{18356}; +var \u{18357}; +var \u{18358}; +var \u{18359}; +var \u{1835A}; +var \u{1835B}; +var \u{1835C}; +var \u{1835D}; +var \u{1835E}; +var \u{1835F}; +var \u{18360}; +var \u{18361}; +var \u{18362}; +var \u{18363}; +var \u{18364}; +var \u{18365}; +var \u{18366}; +var \u{18367}; +var \u{18368}; +var \u{18369}; +var \u{1836A}; +var \u{1836B}; +var \u{1836C}; +var \u{1836D}; +var \u{1836E}; +var \u{1836F}; +var \u{18370}; +var \u{18371}; +var \u{18372}; +var \u{18373}; +var \u{18374}; +var \u{18375}; +var \u{18376}; +var \u{18377}; +var \u{18378}; +var \u{18379}; +var \u{1837A}; +var \u{1837B}; +var \u{1837C}; +var \u{1837D}; +var \u{1837E}; +var \u{1837F}; +var \u{18380}; +var \u{18381}; +var \u{18382}; +var \u{18383}; +var \u{18384}; +var \u{18385}; +var \u{18386}; +var \u{18387}; +var \u{18388}; +var \u{18389}; +var \u{1838A}; +var \u{1838B}; +var \u{1838C}; +var \u{1838D}; +var \u{1838E}; +var \u{1838F}; +var \u{18390}; +var \u{18391}; +var \u{18392}; +var \u{18393}; +var \u{18394}; +var \u{18395}; +var \u{18396}; +var \u{18397}; +var \u{18398}; +var \u{18399}; +var \u{1839A}; +var \u{1839B}; +var \u{1839C}; +var \u{1839D}; +var \u{1839E}; +var \u{1839F}; +var \u{183A0}; +var \u{183A1}; +var \u{183A2}; +var \u{183A3}; +var \u{183A4}; +var \u{183A5}; +var \u{183A6}; +var \u{183A7}; +var \u{183A8}; +var \u{183A9}; +var \u{183AA}; +var \u{183AB}; +var \u{183AC}; +var \u{183AD}; +var \u{183AE}; +var \u{183AF}; +var \u{183B0}; +var \u{183B1}; +var \u{183B2}; +var \u{183B3}; +var \u{183B4}; +var \u{183B5}; +var \u{183B6}; +var \u{183B7}; +var \u{183B8}; +var \u{183B9}; +var \u{183BA}; +var \u{183BB}; +var \u{183BC}; +var \u{183BD}; +var \u{183BE}; +var \u{183BF}; +var \u{183C0}; +var \u{183C1}; +var \u{183C2}; +var \u{183C3}; +var \u{183C4}; +var \u{183C5}; +var \u{183C6}; +var \u{183C7}; +var \u{183C8}; +var \u{183C9}; +var \u{183CA}; +var \u{183CB}; +var \u{183CC}; +var \u{183CD}; +var \u{183CE}; +var \u{183CF}; +var \u{183D0}; +var \u{183D1}; +var \u{183D2}; +var \u{183D3}; +var \u{183D4}; +var \u{183D5}; +var \u{183D6}; +var \u{183D7}; +var \u{183D8}; +var \u{183D9}; +var \u{183DA}; +var \u{183DB}; +var \u{183DC}; +var \u{183DD}; +var \u{183DE}; +var \u{183DF}; +var \u{183E0}; +var \u{183E1}; +var \u{183E2}; +var \u{183E3}; +var \u{183E4}; +var \u{183E5}; +var \u{183E6}; +var \u{183E7}; +var \u{183E8}; +var \u{183E9}; +var \u{183EA}; +var \u{183EB}; +var \u{183EC}; +var \u{183ED}; +var \u{183EE}; +var \u{183EF}; +var \u{183F0}; +var \u{183F1}; +var \u{183F2}; +var \u{183F3}; +var \u{183F4}; +var \u{183F5}; +var \u{183F6}; +var \u{183F7}; +var \u{183F8}; +var \u{183F9}; +var \u{183FA}; +var \u{183FB}; +var \u{183FC}; +var \u{183FD}; +var \u{183FE}; +var \u{183FF}; +var \u{18400}; +var \u{18401}; +var \u{18402}; +var \u{18403}; +var \u{18404}; +var \u{18405}; +var \u{18406}; +var \u{18407}; +var \u{18408}; +var \u{18409}; +var \u{1840A}; +var \u{1840B}; +var \u{1840C}; +var \u{1840D}; +var \u{1840E}; +var \u{1840F}; +var \u{18410}; +var \u{18411}; +var \u{18412}; +var \u{18413}; +var \u{18414}; +var \u{18415}; +var \u{18416}; +var \u{18417}; +var \u{18418}; +var \u{18419}; +var \u{1841A}; +var \u{1841B}; +var \u{1841C}; +var \u{1841D}; +var \u{1841E}; +var \u{1841F}; +var \u{18420}; +var \u{18421}; +var \u{18422}; +var \u{18423}; +var \u{18424}; +var \u{18425}; +var \u{18426}; +var \u{18427}; +var \u{18428}; +var \u{18429}; +var \u{1842A}; +var \u{1842B}; +var \u{1842C}; +var \u{1842D}; +var \u{1842E}; +var \u{1842F}; +var \u{18430}; +var \u{18431}; +var \u{18432}; +var \u{18433}; +var \u{18434}; +var \u{18435}; +var \u{18436}; +var \u{18437}; +var \u{18438}; +var \u{18439}; +var \u{1843A}; +var \u{1843B}; +var \u{1843C}; +var \u{1843D}; +var \u{1843E}; +var \u{1843F}; +var \u{18440}; +var \u{18441}; +var \u{18442}; +var \u{18443}; +var \u{18444}; +var \u{18445}; +var \u{18446}; +var \u{18447}; +var \u{18448}; +var \u{18449}; +var \u{1844A}; +var \u{1844B}; +var \u{1844C}; +var \u{1844D}; +var \u{1844E}; +var \u{1844F}; +var \u{18450}; +var \u{18451}; +var \u{18452}; +var \u{18453}; +var \u{18454}; +var \u{18455}; +var \u{18456}; +var \u{18457}; +var \u{18458}; +var \u{18459}; +var \u{1845A}; +var \u{1845B}; +var \u{1845C}; +var \u{1845D}; +var \u{1845E}; +var \u{1845F}; +var \u{18460}; +var \u{18461}; +var \u{18462}; +var \u{18463}; +var \u{18464}; +var \u{18465}; +var \u{18466}; +var \u{18467}; +var \u{18468}; +var \u{18469}; +var \u{1846A}; +var \u{1846B}; +var \u{1846C}; +var \u{1846D}; +var \u{1846E}; +var \u{1846F}; +var \u{18470}; +var \u{18471}; +var \u{18472}; +var \u{18473}; +var \u{18474}; +var \u{18475}; +var \u{18476}; +var \u{18477}; +var \u{18478}; +var \u{18479}; +var \u{1847A}; +var \u{1847B}; +var \u{1847C}; +var \u{1847D}; +var \u{1847E}; +var \u{1847F}; +var \u{18480}; +var \u{18481}; +var \u{18482}; +var \u{18483}; +var \u{18484}; +var \u{18485}; +var \u{18486}; +var \u{18487}; +var \u{18488}; +var \u{18489}; +var \u{1848A}; +var \u{1848B}; +var \u{1848C}; +var \u{1848D}; +var \u{1848E}; +var \u{1848F}; +var \u{18490}; +var \u{18491}; +var \u{18492}; +var \u{18493}; +var \u{18494}; +var \u{18495}; +var \u{18496}; +var \u{18497}; +var \u{18498}; +var \u{18499}; +var \u{1849A}; +var \u{1849B}; +var \u{1849C}; +var \u{1849D}; +var \u{1849E}; +var \u{1849F}; +var \u{184A0}; +var \u{184A1}; +var \u{184A2}; +var \u{184A3}; +var \u{184A4}; +var \u{184A5}; +var \u{184A6}; +var \u{184A7}; +var \u{184A8}; +var \u{184A9}; +var \u{184AA}; +var \u{184AB}; +var \u{184AC}; +var \u{184AD}; +var \u{184AE}; +var \u{184AF}; +var \u{184B0}; +var \u{184B1}; +var \u{184B2}; +var \u{184B3}; +var \u{184B4}; +var \u{184B5}; +var \u{184B6}; +var \u{184B7}; +var \u{184B8}; +var \u{184B9}; +var \u{184BA}; +var \u{184BB}; +var \u{184BC}; +var \u{184BD}; +var \u{184BE}; +var \u{184BF}; +var \u{184C0}; +var \u{184C1}; +var \u{184C2}; +var \u{184C3}; +var \u{184C4}; +var \u{184C5}; +var \u{184C6}; +var \u{184C7}; +var \u{184C8}; +var \u{184C9}; +var \u{184CA}; +var \u{184CB}; +var \u{184CC}; +var \u{184CD}; +var \u{184CE}; +var \u{184CF}; +var \u{184D0}; +var \u{184D1}; +var \u{184D2}; +var \u{184D3}; +var \u{184D4}; +var \u{184D5}; +var \u{184D6}; +var \u{184D7}; +var \u{184D8}; +var \u{184D9}; +var \u{184DA}; +var \u{184DB}; +var \u{184DC}; +var \u{184DD}; +var \u{184DE}; +var \u{184DF}; +var \u{184E0}; +var \u{184E1}; +var \u{184E2}; +var \u{184E3}; +var \u{184E4}; +var \u{184E5}; +var \u{184E6}; +var \u{184E7}; +var \u{184E8}; +var \u{184E9}; +var \u{184EA}; +var \u{184EB}; +var \u{184EC}; +var \u{184ED}; +var \u{184EE}; +var \u{184EF}; +var \u{184F0}; +var \u{184F1}; +var \u{184F2}; +var \u{184F3}; +var \u{184F4}; +var \u{184F5}; +var \u{184F6}; +var \u{184F7}; +var \u{184F8}; +var \u{184F9}; +var \u{184FA}; +var \u{184FB}; +var \u{184FC}; +var \u{184FD}; +var \u{184FE}; +var \u{184FF}; +var \u{18500}; +var \u{18501}; +var \u{18502}; +var \u{18503}; +var \u{18504}; +var \u{18505}; +var \u{18506}; +var \u{18507}; +var \u{18508}; +var \u{18509}; +var \u{1850A}; +var \u{1850B}; +var \u{1850C}; +var \u{1850D}; +var \u{1850E}; +var \u{1850F}; +var \u{18510}; +var \u{18511}; +var \u{18512}; +var \u{18513}; +var \u{18514}; +var \u{18515}; +var \u{18516}; +var \u{18517}; +var \u{18518}; +var \u{18519}; +var \u{1851A}; +var \u{1851B}; +var \u{1851C}; +var \u{1851D}; +var \u{1851E}; +var \u{1851F}; +var \u{18520}; +var \u{18521}; +var \u{18522}; +var \u{18523}; +var \u{18524}; +var \u{18525}; +var \u{18526}; +var \u{18527}; +var \u{18528}; +var \u{18529}; +var \u{1852A}; +var \u{1852B}; +var \u{1852C}; +var \u{1852D}; +var \u{1852E}; +var \u{1852F}; +var \u{18530}; +var \u{18531}; +var \u{18532}; +var \u{18533}; +var \u{18534}; +var \u{18535}; +var \u{18536}; +var \u{18537}; +var \u{18538}; +var \u{18539}; +var \u{1853A}; +var \u{1853B}; +var \u{1853C}; +var \u{1853D}; +var \u{1853E}; +var \u{1853F}; +var \u{18540}; +var \u{18541}; +var \u{18542}; +var \u{18543}; +var \u{18544}; +var \u{18545}; +var \u{18546}; +var \u{18547}; +var \u{18548}; +var \u{18549}; +var \u{1854A}; +var \u{1854B}; +var \u{1854C}; +var \u{1854D}; +var \u{1854E}; +var \u{1854F}; +var \u{18550}; +var \u{18551}; +var \u{18552}; +var \u{18553}; +var \u{18554}; +var \u{18555}; +var \u{18556}; +var \u{18557}; +var \u{18558}; +var \u{18559}; +var \u{1855A}; +var \u{1855B}; +var \u{1855C}; +var \u{1855D}; +var \u{1855E}; +var \u{1855F}; +var \u{18560}; +var \u{18561}; +var \u{18562}; +var \u{18563}; +var \u{18564}; +var \u{18565}; +var \u{18566}; +var \u{18567}; +var \u{18568}; +var \u{18569}; +var \u{1856A}; +var \u{1856B}; +var \u{1856C}; +var \u{1856D}; +var \u{1856E}; +var \u{1856F}; +var \u{18570}; +var \u{18571}; +var \u{18572}; +var \u{18573}; +var \u{18574}; +var \u{18575}; +var \u{18576}; +var \u{18577}; +var \u{18578}; +var \u{18579}; +var \u{1857A}; +var \u{1857B}; +var \u{1857C}; +var \u{1857D}; +var \u{1857E}; +var \u{1857F}; +var \u{18580}; +var \u{18581}; +var \u{18582}; +var \u{18583}; +var \u{18584}; +var \u{18585}; +var \u{18586}; +var \u{18587}; +var \u{18588}; +var \u{18589}; +var \u{1858A}; +var \u{1858B}; +var \u{1858C}; +var \u{1858D}; +var \u{1858E}; +var \u{1858F}; +var \u{18590}; +var \u{18591}; +var \u{18592}; +var \u{18593}; +var \u{18594}; +var \u{18595}; +var \u{18596}; +var \u{18597}; +var \u{18598}; +var \u{18599}; +var \u{1859A}; +var \u{1859B}; +var \u{1859C}; +var \u{1859D}; +var \u{1859E}; +var \u{1859F}; +var \u{185A0}; +var \u{185A1}; +var \u{185A2}; +var \u{185A3}; +var \u{185A4}; +var \u{185A5}; +var \u{185A6}; +var \u{185A7}; +var \u{185A8}; +var \u{185A9}; +var \u{185AA}; +var \u{185AB}; +var \u{185AC}; +var \u{185AD}; +var \u{185AE}; +var \u{185AF}; +var \u{185B0}; +var \u{185B1}; +var \u{185B2}; +var \u{185B3}; +var \u{185B4}; +var \u{185B5}; +var \u{185B6}; +var \u{185B7}; +var \u{185B8}; +var \u{185B9}; +var \u{185BA}; +var \u{185BB}; +var \u{185BC}; +var \u{185BD}; +var \u{185BE}; +var \u{185BF}; +var \u{185C0}; +var \u{185C1}; +var \u{185C2}; +var \u{185C3}; +var \u{185C4}; +var \u{185C5}; +var \u{185C6}; +var \u{185C7}; +var \u{185C8}; +var \u{185C9}; +var \u{185CA}; +var \u{185CB}; +var \u{185CC}; +var \u{185CD}; +var \u{185CE}; +var \u{185CF}; +var \u{185D0}; +var \u{185D1}; +var \u{185D2}; +var \u{185D3}; +var \u{185D4}; +var \u{185D5}; +var \u{185D6}; +var \u{185D7}; +var \u{185D8}; +var \u{185D9}; +var \u{185DA}; +var \u{185DB}; +var \u{185DC}; +var \u{185DD}; +var \u{185DE}; +var \u{185DF}; +var \u{185E0}; +var \u{185E1}; +var \u{185E2}; +var \u{185E3}; +var \u{185E4}; +var \u{185E5}; +var \u{185E6}; +var \u{185E7}; +var \u{185E8}; +var \u{185E9}; +var \u{185EA}; +var \u{185EB}; +var \u{185EC}; +var \u{185ED}; +var \u{185EE}; +var \u{185EF}; +var \u{185F0}; +var \u{185F1}; +var \u{185F2}; +var \u{185F3}; +var \u{185F4}; +var \u{185F5}; +var \u{185F6}; +var \u{185F7}; +var \u{185F8}; +var \u{185F9}; +var \u{185FA}; +var \u{185FB}; +var \u{185FC}; +var \u{185FD}; +var \u{185FE}; +var \u{185FF}; +var \u{18600}; +var \u{18601}; +var \u{18602}; +var \u{18603}; +var \u{18604}; +var \u{18605}; +var \u{18606}; +var \u{18607}; +var \u{18608}; +var \u{18609}; +var \u{1860A}; +var \u{1860B}; +var \u{1860C}; +var \u{1860D}; +var \u{1860E}; +var \u{1860F}; +var \u{18610}; +var \u{18611}; +var \u{18612}; +var \u{18613}; +var \u{18614}; +var \u{18615}; +var \u{18616}; +var \u{18617}; +var \u{18618}; +var \u{18619}; +var \u{1861A}; +var \u{1861B}; +var \u{1861C}; +var \u{1861D}; +var \u{1861E}; +var \u{1861F}; +var \u{18620}; +var \u{18621}; +var \u{18622}; +var \u{18623}; +var \u{18624}; +var \u{18625}; +var \u{18626}; +var \u{18627}; +var \u{18628}; +var \u{18629}; +var \u{1862A}; +var \u{1862B}; +var \u{1862C}; +var \u{1862D}; +var \u{1862E}; +var \u{1862F}; +var \u{18630}; +var \u{18631}; +var \u{18632}; +var \u{18633}; +var \u{18634}; +var \u{18635}; +var \u{18636}; +var \u{18637}; +var \u{18638}; +var \u{18639}; +var \u{1863A}; +var \u{1863B}; +var \u{1863C}; +var \u{1863D}; +var \u{1863E}; +var \u{1863F}; +var \u{18640}; +var \u{18641}; +var \u{18642}; +var \u{18643}; +var \u{18644}; +var \u{18645}; +var \u{18646}; +var \u{18647}; +var \u{18648}; +var \u{18649}; +var \u{1864A}; +var \u{1864B}; +var \u{1864C}; +var \u{1864D}; +var \u{1864E}; +var \u{1864F}; +var \u{18650}; +var \u{18651}; +var \u{18652}; +var \u{18653}; +var \u{18654}; +var \u{18655}; +var \u{18656}; +var \u{18657}; +var \u{18658}; +var \u{18659}; +var \u{1865A}; +var \u{1865B}; +var \u{1865C}; +var \u{1865D}; +var \u{1865E}; +var \u{1865F}; +var \u{18660}; +var \u{18661}; +var \u{18662}; +var \u{18663}; +var \u{18664}; +var \u{18665}; +var \u{18666}; +var \u{18667}; +var \u{18668}; +var \u{18669}; +var \u{1866A}; +var \u{1866B}; +var \u{1866C}; +var \u{1866D}; +var \u{1866E}; +var \u{1866F}; +var \u{18670}; +var \u{18671}; +var \u{18672}; +var \u{18673}; +var \u{18674}; +var \u{18675}; +var \u{18676}; +var \u{18677}; +var \u{18678}; +var \u{18679}; +var \u{1867A}; +var \u{1867B}; +var \u{1867C}; +var \u{1867D}; +var \u{1867E}; +var \u{1867F}; +var \u{18680}; +var \u{18681}; +var \u{18682}; +var \u{18683}; +var \u{18684}; +var \u{18685}; +var \u{18686}; +var \u{18687}; +var \u{18688}; +var \u{18689}; +var \u{1868A}; +var \u{1868B}; +var \u{1868C}; +var \u{1868D}; +var \u{1868E}; +var \u{1868F}; +var \u{18690}; +var \u{18691}; +var \u{18692}; +var \u{18693}; +var \u{18694}; +var \u{18695}; +var \u{18696}; +var \u{18697}; +var \u{18698}; +var \u{18699}; +var \u{1869A}; +var \u{1869B}; +var \u{1869C}; +var \u{1869D}; +var \u{1869E}; +var \u{1869F}; +var \u{186A0}; +var \u{186A1}; +var \u{186A2}; +var \u{186A3}; +var \u{186A4}; +var \u{186A5}; +var \u{186A6}; +var \u{186A7}; +var \u{186A8}; +var \u{186A9}; +var \u{186AA}; +var \u{186AB}; +var \u{186AC}; +var \u{186AD}; +var \u{186AE}; +var \u{186AF}; +var \u{186B0}; +var \u{186B1}; +var \u{186B2}; +var \u{186B3}; +var \u{186B4}; +var \u{186B5}; +var \u{186B6}; +var \u{186B7}; +var \u{186B8}; +var \u{186B9}; +var \u{186BA}; +var \u{186BB}; +var \u{186BC}; +var \u{186BD}; +var \u{186BE}; +var \u{186BF}; +var \u{186C0}; +var \u{186C1}; +var \u{186C2}; +var \u{186C3}; +var \u{186C4}; +var \u{186C5}; +var \u{186C6}; +var \u{186C7}; +var \u{186C8}; +var \u{186C9}; +var \u{186CA}; +var \u{186CB}; +var \u{186CC}; +var \u{186CD}; +var \u{186CE}; +var \u{186CF}; +var \u{186D0}; +var \u{186D1}; +var \u{186D2}; +var \u{186D3}; +var \u{186D4}; +var \u{186D5}; +var \u{186D6}; +var \u{186D7}; +var \u{186D8}; +var \u{186D9}; +var \u{186DA}; +var \u{186DB}; +var \u{186DC}; +var \u{186DD}; +var \u{186DE}; +var \u{186DF}; +var \u{186E0}; +var \u{186E1}; +var \u{186E2}; +var \u{186E3}; +var \u{186E4}; +var \u{186E5}; +var \u{186E6}; +var \u{186E7}; +var \u{186E8}; +var \u{186E9}; +var \u{186EA}; +var \u{186EB}; +var \u{186EC}; +var \u{186ED}; +var \u{186EE}; +var \u{186EF}; +var \u{186F0}; +var \u{186F1}; +var \u{186F2}; +var \u{186F3}; +var \u{186F4}; +var \u{186F5}; +var \u{186F6}; +var \u{186F7}; +var \u{186F8}; +var \u{186F9}; +var \u{186FA}; +var \u{186FB}; +var \u{186FC}; +var \u{186FD}; +var \u{186FE}; +var \u{186FF}; +var \u{18700}; +var \u{18701}; +var \u{18702}; +var \u{18703}; +var \u{18704}; +var \u{18705}; +var \u{18706}; +var \u{18707}; +var \u{18708}; +var \u{18709}; +var \u{1870A}; +var \u{1870B}; +var \u{1870C}; +var \u{1870D}; +var \u{1870E}; +var \u{1870F}; +var \u{18710}; +var \u{18711}; +var \u{18712}; +var \u{18713}; +var \u{18714}; +var \u{18715}; +var \u{18716}; +var \u{18717}; +var \u{18718}; +var \u{18719}; +var \u{1871A}; +var \u{1871B}; +var \u{1871C}; +var \u{1871D}; +var \u{1871E}; +var \u{1871F}; +var \u{18720}; +var \u{18721}; +var \u{18722}; +var \u{18723}; +var \u{18724}; +var \u{18725}; +var \u{18726}; +var \u{18727}; +var \u{18728}; +var \u{18729}; +var \u{1872A}; +var \u{1872B}; +var \u{1872C}; +var \u{1872D}; +var \u{1872E}; +var \u{1872F}; +var \u{18730}; +var \u{18731}; +var \u{18732}; +var \u{18733}; +var \u{18734}; +var \u{18735}; +var \u{18736}; +var \u{18737}; +var \u{18738}; +var \u{18739}; +var \u{1873A}; +var \u{1873B}; +var \u{1873C}; +var \u{1873D}; +var \u{1873E}; +var \u{1873F}; +var \u{18740}; +var \u{18741}; +var \u{18742}; +var \u{18743}; +var \u{18744}; +var \u{18745}; +var \u{18746}; +var \u{18747}; +var \u{18748}; +var \u{18749}; +var \u{1874A}; +var \u{1874B}; +var \u{1874C}; +var \u{1874D}; +var \u{1874E}; +var \u{1874F}; +var \u{18750}; +var \u{18751}; +var \u{18752}; +var \u{18753}; +var \u{18754}; +var \u{18755}; +var \u{18756}; +var \u{18757}; +var \u{18758}; +var \u{18759}; +var \u{1875A}; +var \u{1875B}; +var \u{1875C}; +var \u{1875D}; +var \u{1875E}; +var \u{1875F}; +var \u{18760}; +var \u{18761}; +var \u{18762}; +var \u{18763}; +var \u{18764}; +var \u{18765}; +var \u{18766}; +var \u{18767}; +var \u{18768}; +var \u{18769}; +var \u{1876A}; +var \u{1876B}; +var \u{1876C}; +var \u{1876D}; +var \u{1876E}; +var \u{1876F}; +var \u{18770}; +var \u{18771}; +var \u{18772}; +var \u{18773}; +var \u{18774}; +var \u{18775}; +var \u{18776}; +var \u{18777}; +var \u{18778}; +var \u{18779}; +var \u{1877A}; +var \u{1877B}; +var \u{1877C}; +var \u{1877D}; +var \u{1877E}; +var \u{1877F}; +var \u{18780}; +var \u{18781}; +var \u{18782}; +var \u{18783}; +var \u{18784}; +var \u{18785}; +var \u{18786}; +var \u{18787}; +var \u{18788}; +var \u{18789}; +var \u{1878A}; +var \u{1878B}; +var \u{1878C}; +var \u{1878D}; +var \u{1878E}; +var \u{1878F}; +var \u{18790}; +var \u{18791}; +var \u{18792}; +var \u{18793}; +var \u{18794}; +var \u{18795}; +var \u{18796}; +var \u{18797}; +var \u{18798}; +var \u{18799}; +var \u{1879A}; +var \u{1879B}; +var \u{1879C}; +var \u{1879D}; +var \u{1879E}; +var \u{1879F}; +var \u{187A0}; +var \u{187A1}; +var \u{187A2}; +var \u{187A3}; +var \u{187A4}; +var \u{187A5}; +var \u{187A6}; +var \u{187A7}; +var \u{187A8}; +var \u{187A9}; +var \u{187AA}; +var \u{187AB}; +var \u{187AC}; +var \u{187AD}; +var \u{187AE}; +var \u{187AF}; +var \u{187B0}; +var \u{187B1}; +var \u{187B2}; +var \u{187B3}; +var \u{187B4}; +var \u{187B5}; +var \u{187B6}; +var \u{187B7}; +var \u{187B8}; +var \u{187B9}; +var \u{187BA}; +var \u{187BB}; +var \u{187BC}; +var \u{187BD}; +var \u{187BE}; +var \u{187BF}; +var \u{187C0}; +var \u{187C1}; +var \u{187C2}; +var \u{187C3}; +var \u{187C4}; +var \u{187C5}; +var \u{187C6}; +var \u{187C7}; +var \u{187C8}; +var \u{187C9}; +var \u{187CA}; +var \u{187CB}; +var \u{187CC}; +var \u{187CD}; +var \u{187CE}; +var \u{187CF}; +var \u{187D0}; +var \u{187D1}; +var \u{187D2}; +var \u{187D3}; +var \u{187D4}; +var \u{187D5}; +var \u{187D6}; +var \u{187D7}; +var \u{187D8}; +var \u{187D9}; +var \u{187DA}; +var \u{187DB}; +var \u{187DC}; +var \u{187DD}; +var \u{187DE}; +var \u{187DF}; +var \u{187E0}; +var \u{187E1}; +var \u{187E2}; +var \u{187E3}; +var \u{187E4}; +var \u{187E5}; +var \u{187E6}; +var \u{187E7}; +var \u{187E8}; +var \u{187E9}; +var \u{187EA}; +var \u{187EB}; +var \u{187EC}; +var \u{18800}; +var \u{18801}; +var \u{18802}; +var \u{18803}; +var \u{18804}; +var \u{18805}; +var \u{18806}; +var \u{18807}; +var \u{18808}; +var \u{18809}; +var \u{1880A}; +var \u{1880B}; +var \u{1880C}; +var \u{1880D}; +var \u{1880E}; +var \u{1880F}; +var \u{18810}; +var \u{18811}; +var \u{18812}; +var \u{18813}; +var \u{18814}; +var \u{18815}; +var \u{18816}; +var \u{18817}; +var \u{18818}; +var \u{18819}; +var \u{1881A}; +var \u{1881B}; +var \u{1881C}; +var \u{1881D}; +var \u{1881E}; +var \u{1881F}; +var \u{18820}; +var \u{18821}; +var \u{18822}; +var \u{18823}; +var \u{18824}; +var \u{18825}; +var \u{18826}; +var \u{18827}; +var \u{18828}; +var \u{18829}; +var \u{1882A}; +var \u{1882B}; +var \u{1882C}; +var \u{1882D}; +var \u{1882E}; +var \u{1882F}; +var \u{18830}; +var \u{18831}; +var \u{18832}; +var \u{18833}; +var \u{18834}; +var \u{18835}; +var \u{18836}; +var \u{18837}; +var \u{18838}; +var \u{18839}; +var \u{1883A}; +var \u{1883B}; +var \u{1883C}; +var \u{1883D}; +var \u{1883E}; +var \u{1883F}; +var \u{18840}; +var \u{18841}; +var \u{18842}; +var \u{18843}; +var \u{18844}; +var \u{18845}; +var \u{18846}; +var \u{18847}; +var \u{18848}; +var \u{18849}; +var \u{1884A}; +var \u{1884B}; +var \u{1884C}; +var \u{1884D}; +var \u{1884E}; +var \u{1884F}; +var \u{18850}; +var \u{18851}; +var \u{18852}; +var \u{18853}; +var \u{18854}; +var \u{18855}; +var \u{18856}; +var \u{18857}; +var \u{18858}; +var \u{18859}; +var \u{1885A}; +var \u{1885B}; +var \u{1885C}; +var \u{1885D}; +var \u{1885E}; +var \u{1885F}; +var \u{18860}; +var \u{18861}; +var \u{18862}; +var \u{18863}; +var \u{18864}; +var \u{18865}; +var \u{18866}; +var \u{18867}; +var \u{18868}; +var \u{18869}; +var \u{1886A}; +var \u{1886B}; +var \u{1886C}; +var \u{1886D}; +var \u{1886E}; +var \u{1886F}; +var \u{18870}; +var \u{18871}; +var \u{18872}; +var \u{18873}; +var \u{18874}; +var \u{18875}; +var \u{18876}; +var \u{18877}; +var \u{18878}; +var \u{18879}; +var \u{1887A}; +var \u{1887B}; +var \u{1887C}; +var \u{1887D}; +var \u{1887E}; +var \u{1887F}; +var \u{18880}; +var \u{18881}; +var \u{18882}; +var \u{18883}; +var \u{18884}; +var \u{18885}; +var \u{18886}; +var \u{18887}; +var \u{18888}; +var \u{18889}; +var \u{1888A}; +var \u{1888B}; +var \u{1888C}; +var \u{1888D}; +var \u{1888E}; +var \u{1888F}; +var \u{18890}; +var \u{18891}; +var \u{18892}; +var \u{18893}; +var \u{18894}; +var \u{18895}; +var \u{18896}; +var \u{18897}; +var \u{18898}; +var \u{18899}; +var \u{1889A}; +var \u{1889B}; +var \u{1889C}; +var \u{1889D}; +var \u{1889E}; +var \u{1889F}; +var \u{188A0}; +var \u{188A1}; +var \u{188A2}; +var \u{188A3}; +var \u{188A4}; +var \u{188A5}; +var \u{188A6}; +var \u{188A7}; +var \u{188A8}; +var \u{188A9}; +var \u{188AA}; +var \u{188AB}; +var \u{188AC}; +var \u{188AD}; +var \u{188AE}; +var \u{188AF}; +var \u{188B0}; +var \u{188B1}; +var \u{188B2}; +var \u{188B3}; +var \u{188B4}; +var \u{188B5}; +var \u{188B6}; +var \u{188B7}; +var \u{188B8}; +var \u{188B9}; +var \u{188BA}; +var \u{188BB}; +var \u{188BC}; +var \u{188BD}; +var \u{188BE}; +var \u{188BF}; +var \u{188C0}; +var \u{188C1}; +var \u{188C2}; +var \u{188C3}; +var \u{188C4}; +var \u{188C5}; +var \u{188C6}; +var \u{188C7}; +var \u{188C8}; +var \u{188C9}; +var \u{188CA}; +var \u{188CB}; +var \u{188CC}; +var \u{188CD}; +var \u{188CE}; +var \u{188CF}; +var \u{188D0}; +var \u{188D1}; +var \u{188D2}; +var \u{188D3}; +var \u{188D4}; +var \u{188D5}; +var \u{188D6}; +var \u{188D7}; +var \u{188D8}; +var \u{188D9}; +var \u{188DA}; +var \u{188DB}; +var \u{188DC}; +var \u{188DD}; +var \u{188DE}; +var \u{188DF}; +var \u{188E0}; +var \u{188E1}; +var \u{188E2}; +var \u{188E3}; +var \u{188E4}; +var \u{188E5}; +var \u{188E6}; +var \u{188E7}; +var \u{188E8}; +var \u{188E9}; +var \u{188EA}; +var \u{188EB}; +var \u{188EC}; +var \u{188ED}; +var \u{188EE}; +var \u{188EF}; +var \u{188F0}; +var \u{188F1}; +var \u{188F2}; +var \u{188F3}; +var \u{188F4}; +var \u{188F5}; +var \u{188F6}; +var \u{188F7}; +var \u{188F8}; +var \u{188F9}; +var \u{188FA}; +var \u{188FB}; +var \u{188FC}; +var \u{188FD}; +var \u{188FE}; +var \u{188FF}; +var \u{18900}; +var \u{18901}; +var \u{18902}; +var \u{18903}; +var \u{18904}; +var \u{18905}; +var \u{18906}; +var \u{18907}; +var \u{18908}; +var \u{18909}; +var \u{1890A}; +var \u{1890B}; +var \u{1890C}; +var \u{1890D}; +var \u{1890E}; +var \u{1890F}; +var \u{18910}; +var \u{18911}; +var \u{18912}; +var \u{18913}; +var \u{18914}; +var \u{18915}; +var \u{18916}; +var \u{18917}; +var \u{18918}; +var \u{18919}; +var \u{1891A}; +var \u{1891B}; +var \u{1891C}; +var \u{1891D}; +var \u{1891E}; +var \u{1891F}; +var \u{18920}; +var \u{18921}; +var \u{18922}; +var \u{18923}; +var \u{18924}; +var \u{18925}; +var \u{18926}; +var \u{18927}; +var \u{18928}; +var \u{18929}; +var \u{1892A}; +var \u{1892B}; +var \u{1892C}; +var \u{1892D}; +var \u{1892E}; +var \u{1892F}; +var \u{18930}; +var \u{18931}; +var \u{18932}; +var \u{18933}; +var \u{18934}; +var \u{18935}; +var \u{18936}; +var \u{18937}; +var \u{18938}; +var \u{18939}; +var \u{1893A}; +var \u{1893B}; +var \u{1893C}; +var \u{1893D}; +var \u{1893E}; +var \u{1893F}; +var \u{18940}; +var \u{18941}; +var \u{18942}; +var \u{18943}; +var \u{18944}; +var \u{18945}; +var \u{18946}; +var \u{18947}; +var \u{18948}; +var \u{18949}; +var \u{1894A}; +var \u{1894B}; +var \u{1894C}; +var \u{1894D}; +var \u{1894E}; +var \u{1894F}; +var \u{18950}; +var \u{18951}; +var \u{18952}; +var \u{18953}; +var \u{18954}; +var \u{18955}; +var \u{18956}; +var \u{18957}; +var \u{18958}; +var \u{18959}; +var \u{1895A}; +var \u{1895B}; +var \u{1895C}; +var \u{1895D}; +var \u{1895E}; +var \u{1895F}; +var \u{18960}; +var \u{18961}; +var \u{18962}; +var \u{18963}; +var \u{18964}; +var \u{18965}; +var \u{18966}; +var \u{18967}; +var \u{18968}; +var \u{18969}; +var \u{1896A}; +var \u{1896B}; +var \u{1896C}; +var \u{1896D}; +var \u{1896E}; +var \u{1896F}; +var \u{18970}; +var \u{18971}; +var \u{18972}; +var \u{18973}; +var \u{18974}; +var \u{18975}; +var \u{18976}; +var \u{18977}; +var \u{18978}; +var \u{18979}; +var \u{1897A}; +var \u{1897B}; +var \u{1897C}; +var \u{1897D}; +var \u{1897E}; +var \u{1897F}; +var \u{18980}; +var \u{18981}; +var \u{18982}; +var \u{18983}; +var \u{18984}; +var \u{18985}; +var \u{18986}; +var \u{18987}; +var \u{18988}; +var \u{18989}; +var \u{1898A}; +var \u{1898B}; +var \u{1898C}; +var \u{1898D}; +var \u{1898E}; +var \u{1898F}; +var \u{18990}; +var \u{18991}; +var \u{18992}; +var \u{18993}; +var \u{18994}; +var \u{18995}; +var \u{18996}; +var \u{18997}; +var \u{18998}; +var \u{18999}; +var \u{1899A}; +var \u{1899B}; +var \u{1899C}; +var \u{1899D}; +var \u{1899E}; +var \u{1899F}; +var \u{189A0}; +var \u{189A1}; +var \u{189A2}; +var \u{189A3}; +var \u{189A4}; +var \u{189A5}; +var \u{189A6}; +var \u{189A7}; +var \u{189A8}; +var \u{189A9}; +var \u{189AA}; +var \u{189AB}; +var \u{189AC}; +var \u{189AD}; +var \u{189AE}; +var \u{189AF}; +var \u{189B0}; +var \u{189B1}; +var \u{189B2}; +var \u{189B3}; +var \u{189B4}; +var \u{189B5}; +var \u{189B6}; +var \u{189B7}; +var \u{189B8}; +var \u{189B9}; +var \u{189BA}; +var \u{189BB}; +var \u{189BC}; +var \u{189BD}; +var \u{189BE}; +var \u{189BF}; +var \u{189C0}; +var \u{189C1}; +var \u{189C2}; +var \u{189C3}; +var \u{189C4}; +var \u{189C5}; +var \u{189C6}; +var \u{189C7}; +var \u{189C8}; +var \u{189C9}; +var \u{189CA}; +var \u{189CB}; +var \u{189CC}; +var \u{189CD}; +var \u{189CE}; +var \u{189CF}; +var \u{189D0}; +var \u{189D1}; +var \u{189D2}; +var \u{189D3}; +var \u{189D4}; +var \u{189D5}; +var \u{189D6}; +var \u{189D7}; +var \u{189D8}; +var \u{189D9}; +var \u{189DA}; +var \u{189DB}; +var \u{189DC}; +var \u{189DD}; +var \u{189DE}; +var \u{189DF}; +var \u{189E0}; +var \u{189E1}; +var \u{189E2}; +var \u{189E3}; +var \u{189E4}; +var \u{189E5}; +var \u{189E6}; +var \u{189E7}; +var \u{189E8}; +var \u{189E9}; +var \u{189EA}; +var \u{189EB}; +var \u{189EC}; +var \u{189ED}; +var \u{189EE}; +var \u{189EF}; +var \u{189F0}; +var \u{189F1}; +var \u{189F2}; +var \u{189F3}; +var \u{189F4}; +var \u{189F5}; +var \u{189F6}; +var \u{189F7}; +var \u{189F8}; +var \u{189F9}; +var \u{189FA}; +var \u{189FB}; +var \u{189FC}; +var \u{189FD}; +var \u{189FE}; +var \u{189FF}; +var \u{18A00}; +var \u{18A01}; +var \u{18A02}; +var \u{18A03}; +var \u{18A04}; +var \u{18A05}; +var \u{18A06}; +var \u{18A07}; +var \u{18A08}; +var \u{18A09}; +var \u{18A0A}; +var \u{18A0B}; +var \u{18A0C}; +var \u{18A0D}; +var \u{18A0E}; +var \u{18A0F}; +var \u{18A10}; +var \u{18A11}; +var \u{18A12}; +var \u{18A13}; +var \u{18A14}; +var \u{18A15}; +var \u{18A16}; +var \u{18A17}; +var \u{18A18}; +var \u{18A19}; +var \u{18A1A}; +var \u{18A1B}; +var \u{18A1C}; +var \u{18A1D}; +var \u{18A1E}; +var \u{18A1F}; +var \u{18A20}; +var \u{18A21}; +var \u{18A22}; +var \u{18A23}; +var \u{18A24}; +var \u{18A25}; +var \u{18A26}; +var \u{18A27}; +var \u{18A28}; +var \u{18A29}; +var \u{18A2A}; +var \u{18A2B}; +var \u{18A2C}; +var \u{18A2D}; +var \u{18A2E}; +var \u{18A2F}; +var \u{18A30}; +var \u{18A31}; +var \u{18A32}; +var \u{18A33}; +var \u{18A34}; +var \u{18A35}; +var \u{18A36}; +var \u{18A37}; +var \u{18A38}; +var \u{18A39}; +var \u{18A3A}; +var \u{18A3B}; +var \u{18A3C}; +var \u{18A3D}; +var \u{18A3E}; +var \u{18A3F}; +var \u{18A40}; +var \u{18A41}; +var \u{18A42}; +var \u{18A43}; +var \u{18A44}; +var \u{18A45}; +var \u{18A46}; +var \u{18A47}; +var \u{18A48}; +var \u{18A49}; +var \u{18A4A}; +var \u{18A4B}; +var \u{18A4C}; +var \u{18A4D}; +var \u{18A4E}; +var \u{18A4F}; +var \u{18A50}; +var \u{18A51}; +var \u{18A52}; +var \u{18A53}; +var \u{18A54}; +var \u{18A55}; +var \u{18A56}; +var \u{18A57}; +var \u{18A58}; +var \u{18A59}; +var \u{18A5A}; +var \u{18A5B}; +var \u{18A5C}; +var \u{18A5D}; +var \u{18A5E}; +var \u{18A5F}; +var \u{18A60}; +var \u{18A61}; +var \u{18A62}; +var \u{18A63}; +var \u{18A64}; +var \u{18A65}; +var \u{18A66}; +var \u{18A67}; +var \u{18A68}; +var \u{18A69}; +var \u{18A6A}; +var \u{18A6B}; +var \u{18A6C}; +var \u{18A6D}; +var \u{18A6E}; +var \u{18A6F}; +var \u{18A70}; +var \u{18A71}; +var \u{18A72}; +var \u{18A73}; +var \u{18A74}; +var \u{18A75}; +var \u{18A76}; +var \u{18A77}; +var \u{18A78}; +var \u{18A79}; +var \u{18A7A}; +var \u{18A7B}; +var \u{18A7C}; +var \u{18A7D}; +var \u{18A7E}; +var \u{18A7F}; +var \u{18A80}; +var \u{18A81}; +var \u{18A82}; +var \u{18A83}; +var \u{18A84}; +var \u{18A85}; +var \u{18A86}; +var \u{18A87}; +var \u{18A88}; +var \u{18A89}; +var \u{18A8A}; +var \u{18A8B}; +var \u{18A8C}; +var \u{18A8D}; +var \u{18A8E}; +var \u{18A8F}; +var \u{18A90}; +var \u{18A91}; +var \u{18A92}; +var \u{18A93}; +var \u{18A94}; +var \u{18A95}; +var \u{18A96}; +var \u{18A97}; +var \u{18A98}; +var \u{18A99}; +var \u{18A9A}; +var \u{18A9B}; +var \u{18A9C}; +var \u{18A9D}; +var \u{18A9E}; +var \u{18A9F}; +var \u{18AA0}; +var \u{18AA1}; +var \u{18AA2}; +var \u{18AA3}; +var \u{18AA4}; +var \u{18AA5}; +var \u{18AA6}; +var \u{18AA7}; +var \u{18AA8}; +var \u{18AA9}; +var \u{18AAA}; +var \u{18AAB}; +var \u{18AAC}; +var \u{18AAD}; +var \u{18AAE}; +var \u{18AAF}; +var \u{18AB0}; +var \u{18AB1}; +var \u{18AB2}; +var \u{18AB3}; +var \u{18AB4}; +var \u{18AB5}; +var \u{18AB6}; +var \u{18AB7}; +var \u{18AB8}; +var \u{18AB9}; +var \u{18ABA}; +var \u{18ABB}; +var \u{18ABC}; +var \u{18ABD}; +var \u{18ABE}; +var \u{18ABF}; +var \u{18AC0}; +var \u{18AC1}; +var \u{18AC2}; +var \u{18AC3}; +var \u{18AC4}; +var \u{18AC5}; +var \u{18AC6}; +var \u{18AC7}; +var \u{18AC8}; +var \u{18AC9}; +var \u{18ACA}; +var \u{18ACB}; +var \u{18ACC}; +var \u{18ACD}; +var \u{18ACE}; +var \u{18ACF}; +var \u{18AD0}; +var \u{18AD1}; +var \u{18AD2}; +var \u{18AD3}; +var \u{18AD4}; +var \u{18AD5}; +var \u{18AD6}; +var \u{18AD7}; +var \u{18AD8}; +var \u{18AD9}; +var \u{18ADA}; +var \u{18ADB}; +var \u{18ADC}; +var \u{18ADD}; +var \u{18ADE}; +var \u{18ADF}; +var \u{18AE0}; +var \u{18AE1}; +var \u{18AE2}; +var \u{18AE3}; +var \u{18AE4}; +var \u{18AE5}; +var \u{18AE6}; +var \u{18AE7}; +var \u{18AE8}; +var \u{18AE9}; +var \u{18AEA}; +var \u{18AEB}; +var \u{18AEC}; +var \u{18AED}; +var \u{18AEE}; +var \u{18AEF}; +var \u{18AF0}; +var \u{18AF1}; +var \u{18AF2}; +var \u{1E900}; +var \u{1E901}; +var \u{1E902}; +var \u{1E903}; +var \u{1E904}; +var \u{1E905}; +var \u{1E906}; +var \u{1E907}; +var \u{1E908}; +var \u{1E909}; +var \u{1E90A}; +var \u{1E90B}; +var \u{1E90C}; +var \u{1E90D}; +var \u{1E90E}; +var \u{1E90F}; +var \u{1E910}; +var \u{1E911}; +var \u{1E912}; +var \u{1E913}; +var \u{1E914}; +var \u{1E915}; +var \u{1E916}; +var \u{1E917}; +var \u{1E918}; +var \u{1E919}; +var \u{1E91A}; +var \u{1E91B}; +var \u{1E91C}; +var \u{1E91D}; +var \u{1E91E}; +var \u{1E91F}; +var \u{1E920}; +var \u{1E921}; +var \u{1E922}; +var \u{1E923}; +var \u{1E924}; +var \u{1E925}; +var \u{1E926}; +var \u{1E927}; +var \u{1E928}; +var \u{1E929}; +var \u{1E92A}; +var \u{1E92B}; +var \u{1E92C}; +var \u{1E92D}; +var \u{1E92E}; +var \u{1E92F}; +var \u{1E930}; +var \u{1E931}; +var \u{1E932}; +var \u{1E933}; +var \u{1E934}; +var \u{1E935}; +var \u{1E936}; +var \u{1E937}; +var \u{1E938}; +var \u{1E939}; +var \u{1E93A}; +var \u{1E93B}; +var \u{1E93C}; +var \u{1E93D}; +var \u{1E93E}; +var \u{1E93F}; +var \u{1E940}; +var \u{1E941}; +var \u{1E942}; +var \u{1E943}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0.js new file mode 100644 index 000000000..056f9bf51 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-9.0.0.js @@ -0,0 +1,7190 @@ +// Copyright 2024 Mathias Bynens. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Mathias Bynens +esid: sec-names-and-keywords +description: | + Test that Unicode v9.0.0 ID_Start characters are accepted as + identifier start characters. +info: | + Generated by https://github.com/mathiasbynens/caniunicode +---*/ + +var ࢶ; +var ࢷ; +var ࢸ; +var ࢹ; +var ࢺ; +var ࢻ; +var ࢼ; +var ࢽ; +var ಀ; +var ൔ; +var ൕ; +var ൖ; +var ᲀ; +var ᲁ; +var ᲂ; +var ᲃ; +var ᲄ; +var ᲅ; +var ᲆ; +var ᲇ; +var ᲈ; +var Ɪ; +var 𐒰; +var 𐒱; +var 𐒲; +var 𐒳; +var 𐒴; +var 𐒵; +var 𐒶; +var 𐒷; +var 𐒸; +var 𐒹; +var 𐒺; +var 𐒻; +var 𐒼; +var 𐒽; +var 𐒾; +var 𐒿; +var 𐓀; +var 𐓁; +var 𐓂; +var 𐓃; +var 𐓄; +var 𐓅; +var 𐓆; +var 𐓇; +var 𐓈; +var 𐓉; +var 𐓊; +var 𐓋; +var 𐓌; +var 𐓍; +var 𐓎; +var 𐓏; +var 𐓐; +var 𐓑; +var 𐓒; +var 𐓓; +var 𐓘; +var 𐓙; +var 𐓚; +var 𐓛; +var 𐓜; +var 𐓝; +var 𐓞; +var 𐓟; +var 𐓠; +var 𐓡; +var 𐓢; +var 𐓣; +var 𐓤; +var 𐓥; +var 𐓦; +var 𐓧; +var 𐓨; +var 𐓩; +var 𐓪; +var 𐓫; +var 𐓬; +var 𐓭; +var 𐓮; +var 𐓯; +var 𐓰; +var 𐓱; +var 𐓲; +var 𐓳; +var 𐓴; +var 𐓵; +var 𐓶; +var 𐓷; +var 𐓸; +var 𐓹; +var 𐓺; +var 𐓻; +var 𑐀; +var 𑐁; +var 𑐂; +var 𑐃; +var 𑐄; +var 𑐅; +var 𑐆; +var 𑐇; +var 𑐈; +var 𑐉; +var 𑐊; +var 𑐋; +var 𑐌; +var 𑐍; +var 𑐎; +var 𑐏; +var 𑐐; +var 𑐑; +var 𑐒; +var 𑐓; +var 𑐔; +var 𑐕; +var 𑐖; +var 𑐗; +var 𑐘; +var 𑐙; +var 𑐚; +var 𑐛; +var 𑐜; +var 𑐝; +var 𑐞; +var 𑐟; +var 𑐠; +var 𑐡; +var 𑐢; +var 𑐣; +var 𑐤; +var 𑐥; +var 𑐦; +var 𑐧; +var 𑐨; +var 𑐩; +var 𑐪; +var 𑐫; +var 𑐬; +var 𑐭; +var 𑐮; +var 𑐯; +var 𑐰; +var 𑐱; +var 𑐲; +var 𑐳; +var 𑐴; +var 𑑇; +var 𑑈; +var 𑑉; +var 𑑊; +var 𑰀; +var 𑰁; +var 𑰂; +var 𑰃; +var 𑰄; +var 𑰅; +var 𑰆; +var 𑰇; +var 𑰈; +var 𑰊; +var 𑰋; +var 𑰌; +var 𑰍; +var 𑰎; +var 𑰏; +var 𑰐; +var 𑰑; +var 𑰒; +var 𑰓; +var 𑰔; +var 𑰕; +var 𑰖; +var 𑰗; +var 𑰘; +var 𑰙; +var 𑰚; +var 𑰛; +var 𑰜; +var 𑰝; +var 𑰞; +var 𑰟; +var 𑰠; +var 𑰡; +var 𑰢; +var 𑰣; +var 𑰤; +var 𑰥; +var 𑰦; +var 𑰧; +var 𑰨; +var 𑰩; +var 𑰪; +var 𑰫; +var 𑰬; +var 𑰭; +var 𑰮; +var 𑱀; +var 𑱲; +var 𑱳; +var 𑱴; +var 𑱵; +var 𑱶; +var 𑱷; +var 𑱸; +var 𑱹; +var 𑱺; +var 𑱻; +var 𑱼; +var 𑱽; +var 𑱾; +var 𑱿; +var 𑲀; +var 𑲁; +var 𑲂; +var 𑲃; +var 𑲄; +var 𑲅; +var 𑲆; +var 𑲇; +var 𑲈; +var 𑲉; +var 𑲊; +var 𑲋; +var 𑲌; +var 𑲍; +var 𑲎; +var 𑲏; +var 𖿠; +var 𗀀; +var 𗀁; +var 𗀂; +var 𗀃; +var 𗀄; +var 𗀅; +var 𗀆; +var 𗀇; +var 𗀈; +var 𗀉; +var 𗀊; +var 𗀋; +var 𗀌; +var 𗀍; +var 𗀎; +var 𗀏; +var 𗀐; +var 𗀑; +var 𗀒; +var 𗀓; +var 𗀔; +var 𗀕; +var 𗀖; +var 𗀗; +var 𗀘; +var 𗀙; +var 𗀚; +var 𗀛; +var 𗀜; +var 𗀝; +var 𗀞; +var 𗀟; +var 𗀠; +var 𗀡; +var 𗀢; +var 𗀣; +var 𗀤; +var 𗀥; +var 𗀦; +var 𗀧; +var 𗀨; +var 𗀩; +var 𗀪; +var 𗀫; +var 𗀬; +var 𗀭; +var 𗀮; +var 𗀯; +var 𗀰; +var 𗀱; +var 𗀲; +var 𗀳; +var 𗀴; +var 𗀵; +var 𗀶; +var 𗀷; +var 𗀸; +var 𗀹; +var 𗀺; +var 𗀻; +var 𗀼; +var 𗀽; +var 𗀾; +var 𗀿; +var 𗁀; +var 𗁁; +var 𗁂; +var 𗁃; +var 𗁄; +var 𗁅; +var 𗁆; +var 𗁇; +var 𗁈; +var 𗁉; +var 𗁊; +var 𗁋; +var 𗁌; +var 𗁍; +var 𗁎; +var 𗁏; +var 𗁐; +var 𗁑; +var 𗁒; +var 𗁓; +var 𗁔; +var 𗁕; +var 𗁖; +var 𗁗; +var 𗁘; +var 𗁙; +var 𗁚; +var 𗁛; +var 𗁜; +var 𗁝; +var 𗁞; +var 𗁟; +var 𗁠; +var 𗁡; +var 𗁢; +var 𗁣; +var 𗁤; +var 𗁥; +var 𗁦; +var 𗁧; +var 𗁨; +var 𗁩; +var 𗁪; +var 𗁫; +var 𗁬; +var 𗁭; +var 𗁮; +var 𗁯; +var 𗁰; +var 𗁱; +var 𗁲; +var 𗁳; +var 𗁴; +var 𗁵; +var 𗁶; +var 𗁷; +var 𗁸; +var 𗁹; +var 𗁺; +var 𗁻; +var 𗁼; +var 𗁽; +var 𗁾; +var 𗁿; +var 𗂀; +var 𗂁; +var 𗂂; +var 𗂃; +var 𗂄; +var 𗂅; +var 𗂆; +var 𗂇; +var 𗂈; +var 𗂉; +var 𗂊; +var 𗂋; +var 𗂌; +var 𗂍; +var 𗂎; +var 𗂏; +var 𗂐; +var 𗂑; +var 𗂒; +var 𗂓; +var 𗂔; +var 𗂕; +var 𗂖; +var 𗂗; +var 𗂘; +var 𗂙; +var 𗂚; +var 𗂛; +var 𗂜; +var 𗂝; +var 𗂞; +var 𗂟; +var 𗂠; +var 𗂡; +var 𗂢; +var 𗂣; +var 𗂤; +var 𗂥; +var 𗂦; +var 𗂧; +var 𗂨; +var 𗂩; +var 𗂪; +var 𗂫; +var 𗂬; +var 𗂭; +var 𗂮; +var 𗂯; +var 𗂰; +var 𗂱; +var 𗂲; +var 𗂳; +var 𗂴; +var 𗂵; +var 𗂶; +var 𗂷; +var 𗂸; +var 𗂹; +var 𗂺; +var 𗂻; +var 𗂼; +var 𗂽; +var 𗂾; +var 𗂿; +var 𗃀; +var 𗃁; +var 𗃂; +var 𗃃; +var 𗃄; +var 𗃅; +var 𗃆; +var 𗃇; +var 𗃈; +var 𗃉; +var 𗃊; +var 𗃋; +var 𗃌; +var 𗃍; +var 𗃎; +var 𗃏; +var 𗃐; +var 𗃑; +var 𗃒; +var 𗃓; +var 𗃔; +var 𗃕; +var 𗃖; +var 𗃗; +var 𗃘; +var 𗃙; +var 𗃚; +var 𗃛; +var 𗃜; +var 𗃝; +var 𗃞; +var 𗃟; +var 𗃠; +var 𗃡; +var 𗃢; +var 𗃣; +var 𗃤; +var 𗃥; +var 𗃦; +var 𗃧; +var 𗃨; +var 𗃩; +var 𗃪; +var 𗃫; +var 𗃬; +var 𗃭; +var 𗃮; +var 𗃯; +var 𗃰; +var 𗃱; +var 𗃲; +var 𗃳; +var 𗃴; +var 𗃵; +var 𗃶; +var 𗃷; +var 𗃸; +var 𗃹; +var 𗃺; +var 𗃻; +var 𗃼; +var 𗃽; +var 𗃾; +var 𗃿; +var 𗄀; +var 𗄁; +var 𗄂; +var 𗄃; +var 𗄄; +var 𗄅; +var 𗄆; +var 𗄇; +var 𗄈; +var 𗄉; +var 𗄊; +var 𗄋; +var 𗄌; +var 𗄍; +var 𗄎; +var 𗄏; +var 𗄐; +var 𗄑; +var 𗄒; +var 𗄓; +var 𗄔; +var 𗄕; +var 𗄖; +var 𗄗; +var 𗄘; +var 𗄙; +var 𗄚; +var 𗄛; +var 𗄜; +var 𗄝; +var 𗄞; +var 𗄟; +var 𗄠; +var 𗄡; +var 𗄢; +var 𗄣; +var 𗄤; +var 𗄥; +var 𗄦; +var 𗄧; +var 𗄨; +var 𗄩; +var 𗄪; +var 𗄫; +var 𗄬; +var 𗄭; +var 𗄮; +var 𗄯; +var 𗄰; +var 𗄱; +var 𗄲; +var 𗄳; +var 𗄴; +var 𗄵; +var 𗄶; +var 𗄷; +var 𗄸; +var 𗄹; +var 𗄺; +var 𗄻; +var 𗄼; +var 𗄽; +var 𗄾; +var 𗄿; +var 𗅀; +var 𗅁; +var 𗅂; +var 𗅃; +var 𗅄; +var 𗅅; +var 𗅆; +var 𗅇; +var 𗅈; +var 𗅉; +var 𗅊; +var 𗅋; +var 𗅌; +var 𗅍; +var 𗅎; +var 𗅏; +var 𗅐; +var 𗅑; +var 𗅒; +var 𗅓; +var 𗅔; +var 𗅕; +var 𗅖; +var 𗅗; +var 𗅘; +var 𗅙; +var 𗅚; +var 𗅛; +var 𗅜; +var 𗅝; +var 𗅞; +var 𗅟; +var 𗅠; +var 𗅡; +var 𗅢; +var 𗅣; +var 𗅤; +var 𗅥; +var 𗅦; +var 𗅧; +var 𗅨; +var 𗅩; +var 𗅪; +var 𗅫; +var 𗅬; +var 𗅭; +var 𗅮; +var 𗅯; +var 𗅰; +var 𗅱; +var 𗅲; +var 𗅳; +var 𗅴; +var 𗅵; +var 𗅶; +var 𗅷; +var 𗅸; +var 𗅹; +var 𗅺; +var 𗅻; +var 𗅼; +var 𗅽; +var 𗅾; +var 𗅿; +var 𗆀; +var 𗆁; +var 𗆂; +var 𗆃; +var 𗆄; +var 𗆅; +var 𗆆; +var 𗆇; +var 𗆈; +var 𗆉; +var 𗆊; +var 𗆋; +var 𗆌; +var 𗆍; +var 𗆎; +var 𗆏; +var 𗆐; +var 𗆑; +var 𗆒; +var 𗆓; +var 𗆔; +var 𗆕; +var 𗆖; +var 𗆗; +var 𗆘; +var 𗆙; +var 𗆚; +var 𗆛; +var 𗆜; +var 𗆝; +var 𗆞; +var 𗆟; +var 𗆠; +var 𗆡; +var 𗆢; +var 𗆣; +var 𗆤; +var 𗆥; +var 𗆦; +var 𗆧; +var 𗆨; +var 𗆩; +var 𗆪; +var 𗆫; +var 𗆬; +var 𗆭; +var 𗆮; +var 𗆯; +var 𗆰; +var 𗆱; +var 𗆲; +var 𗆳; +var 𗆴; +var 𗆵; +var 𗆶; +var 𗆷; +var 𗆸; +var 𗆹; +var 𗆺; +var 𗆻; +var 𗆼; +var 𗆽; +var 𗆾; +var 𗆿; +var 𗇀; +var 𗇁; +var 𗇂; +var 𗇃; +var 𗇄; +var 𗇅; +var 𗇆; +var 𗇇; +var 𗇈; +var 𗇉; +var 𗇊; +var 𗇋; +var 𗇌; +var 𗇍; +var 𗇎; +var 𗇏; +var 𗇐; +var 𗇑; +var 𗇒; +var 𗇓; +var 𗇔; +var 𗇕; +var 𗇖; +var 𗇗; +var 𗇘; +var 𗇙; +var 𗇚; +var 𗇛; +var 𗇜; +var 𗇝; +var 𗇞; +var 𗇟; +var 𗇠; +var 𗇡; +var 𗇢; +var 𗇣; +var 𗇤; +var 𗇥; +var 𗇦; +var 𗇧; +var 𗇨; +var 𗇩; +var 𗇪; +var 𗇫; +var 𗇬; +var 𗇭; +var 𗇮; +var 𗇯; +var 𗇰; +var 𗇱; +var 𗇲; +var 𗇳; +var 𗇴; +var 𗇵; +var 𗇶; +var 𗇷; +var 𗇸; +var 𗇹; +var 𗇺; +var 𗇻; +var 𗇼; +var 𗇽; +var 𗇾; +var 𗇿; +var 𗈀; +var 𗈁; +var 𗈂; +var 𗈃; +var 𗈄; +var 𗈅; +var 𗈆; +var 𗈇; +var 𗈈; +var 𗈉; +var 𗈊; +var 𗈋; +var 𗈌; +var 𗈍; +var 𗈎; +var 𗈏; +var 𗈐; +var 𗈑; +var 𗈒; +var 𗈓; +var 𗈔; +var 𗈕; +var 𗈖; +var 𗈗; +var 𗈘; +var 𗈙; +var 𗈚; +var 𗈛; +var 𗈜; +var 𗈝; +var 𗈞; +var 𗈟; +var 𗈠; +var 𗈡; +var 𗈢; +var 𗈣; +var 𗈤; +var 𗈥; +var 𗈦; +var 𗈧; +var 𗈨; +var 𗈩; +var 𗈪; +var 𗈫; +var 𗈬; +var 𗈭; +var 𗈮; +var 𗈯; +var 𗈰; +var 𗈱; +var 𗈲; +var 𗈳; +var 𗈴; +var 𗈵; +var 𗈶; +var 𗈷; +var 𗈸; +var 𗈹; +var 𗈺; +var 𗈻; +var 𗈼; +var 𗈽; +var 𗈾; +var 𗈿; +var 𗉀; +var 𗉁; +var 𗉂; +var 𗉃; +var 𗉄; +var 𗉅; +var 𗉆; +var 𗉇; +var 𗉈; +var 𗉉; +var 𗉊; +var 𗉋; +var 𗉌; +var 𗉍; +var 𗉎; +var 𗉏; +var 𗉐; +var 𗉑; +var 𗉒; +var 𗉓; +var 𗉔; +var 𗉕; +var 𗉖; +var 𗉗; +var 𗉘; +var 𗉙; +var 𗉚; +var 𗉛; +var 𗉜; +var 𗉝; +var 𗉞; +var 𗉟; +var 𗉠; +var 𗉡; +var 𗉢; +var 𗉣; +var 𗉤; +var 𗉥; +var 𗉦; +var 𗉧; +var 𗉨; +var 𗉩; +var 𗉪; +var 𗉫; +var 𗉬; +var 𗉭; +var 𗉮; +var 𗉯; +var 𗉰; +var 𗉱; +var 𗉲; +var 𗉳; +var 𗉴; +var 𗉵; +var 𗉶; +var 𗉷; +var 𗉸; +var 𗉹; +var 𗉺; +var 𗉻; +var 𗉼; +var 𗉽; +var 𗉾; +var 𗉿; +var 𗊀; +var 𗊁; +var 𗊂; +var 𗊃; +var 𗊄; +var 𗊅; +var 𗊆; +var 𗊇; +var 𗊈; +var 𗊉; +var 𗊊; +var 𗊋; +var 𗊌; +var 𗊍; +var 𗊎; +var 𗊏; +var 𗊐; +var 𗊑; +var 𗊒; +var 𗊓; +var 𗊔; +var 𗊕; +var 𗊖; +var 𗊗; +var 𗊘; +var 𗊙; +var 𗊚; +var 𗊛; +var 𗊜; +var 𗊝; +var 𗊞; +var 𗊟; +var 𗊠; +var 𗊡; +var 𗊢; +var 𗊣; +var 𗊤; +var 𗊥; +var 𗊦; +var 𗊧; +var 𗊨; +var 𗊩; +var 𗊪; +var 𗊫; +var 𗊬; +var 𗊭; +var 𗊮; +var 𗊯; +var 𗊰; +var 𗊱; +var 𗊲; +var 𗊳; +var 𗊴; +var 𗊵; +var 𗊶; +var 𗊷; +var 𗊸; +var 𗊹; +var 𗊺; +var 𗊻; +var 𗊼; +var 𗊽; +var 𗊾; +var 𗊿; +var 𗋀; +var 𗋁; +var 𗋂; +var 𗋃; +var 𗋄; +var 𗋅; +var 𗋆; +var 𗋇; +var 𗋈; +var 𗋉; +var 𗋊; +var 𗋋; +var 𗋌; +var 𗋍; +var 𗋎; +var 𗋏; +var 𗋐; +var 𗋑; +var 𗋒; +var 𗋓; +var 𗋔; +var 𗋕; +var 𗋖; +var 𗋗; +var 𗋘; +var 𗋙; +var 𗋚; +var 𗋛; +var 𗋜; +var 𗋝; +var 𗋞; +var 𗋟; +var 𗋠; +var 𗋡; +var 𗋢; +var 𗋣; +var 𗋤; +var 𗋥; +var 𗋦; +var 𗋧; +var 𗋨; +var 𗋩; +var 𗋪; +var 𗋫; +var 𗋬; +var 𗋭; +var 𗋮; +var 𗋯; +var 𗋰; +var 𗋱; +var 𗋲; +var 𗋳; +var 𗋴; +var 𗋵; +var 𗋶; +var 𗋷; +var 𗋸; +var 𗋹; +var 𗋺; +var 𗋻; +var 𗋼; +var 𗋽; +var 𗋾; +var 𗋿; +var 𗌀; +var 𗌁; +var 𗌂; +var 𗌃; +var 𗌄; +var 𗌅; +var 𗌆; +var 𗌇; +var 𗌈; +var 𗌉; +var 𗌊; +var 𗌋; +var 𗌌; +var 𗌍; +var 𗌎; +var 𗌏; +var 𗌐; +var 𗌑; +var 𗌒; +var 𗌓; +var 𗌔; +var 𗌕; +var 𗌖; +var 𗌗; +var 𗌘; +var 𗌙; +var 𗌚; +var 𗌛; +var 𗌜; +var 𗌝; +var 𗌞; +var 𗌟; +var 𗌠; +var 𗌡; +var 𗌢; +var 𗌣; +var 𗌤; +var 𗌥; +var 𗌦; +var 𗌧; +var 𗌨; +var 𗌩; +var 𗌪; +var 𗌫; +var 𗌬; +var 𗌭; +var 𗌮; +var 𗌯; +var 𗌰; +var 𗌱; +var 𗌲; +var 𗌳; +var 𗌴; +var 𗌵; +var 𗌶; +var 𗌷; +var 𗌸; +var 𗌹; +var 𗌺; +var 𗌻; +var 𗌼; +var 𗌽; +var 𗌾; +var 𗌿; +var 𗍀; +var 𗍁; +var 𗍂; +var 𗍃; +var 𗍄; +var 𗍅; +var 𗍆; +var 𗍇; +var 𗍈; +var 𗍉; +var 𗍊; +var 𗍋; +var 𗍌; +var 𗍍; +var 𗍎; +var 𗍏; +var 𗍐; +var 𗍑; +var 𗍒; +var 𗍓; +var 𗍔; +var 𗍕; +var 𗍖; +var 𗍗; +var 𗍘; +var 𗍙; +var 𗍚; +var 𗍛; +var 𗍜; +var 𗍝; +var 𗍞; +var 𗍟; +var 𗍠; +var 𗍡; +var 𗍢; +var 𗍣; +var 𗍤; +var 𗍥; +var 𗍦; +var 𗍧; +var 𗍨; +var 𗍩; +var 𗍪; +var 𗍫; +var 𗍬; +var 𗍭; +var 𗍮; +var 𗍯; +var 𗍰; +var 𗍱; +var 𗍲; +var 𗍳; +var 𗍴; +var 𗍵; +var 𗍶; +var 𗍷; +var 𗍸; +var 𗍹; +var 𗍺; +var 𗍻; +var 𗍼; +var 𗍽; +var 𗍾; +var 𗍿; +var 𗎀; +var 𗎁; +var 𗎂; +var 𗎃; +var 𗎄; +var 𗎅; +var 𗎆; +var 𗎇; +var 𗎈; +var 𗎉; +var 𗎊; +var 𗎋; +var 𗎌; +var 𗎍; +var 𗎎; +var 𗎏; +var 𗎐; +var 𗎑; +var 𗎒; +var 𗎓; +var 𗎔; +var 𗎕; +var 𗎖; +var 𗎗; +var 𗎘; +var 𗎙; +var 𗎚; +var 𗎛; +var 𗎜; +var 𗎝; +var 𗎞; +var 𗎟; +var 𗎠; +var 𗎡; +var 𗎢; +var 𗎣; +var 𗎤; +var 𗎥; +var 𗎦; +var 𗎧; +var 𗎨; +var 𗎩; +var 𗎪; +var 𗎫; +var 𗎬; +var 𗎭; +var 𗎮; +var 𗎯; +var 𗎰; +var 𗎱; +var 𗎲; +var 𗎳; +var 𗎴; +var 𗎵; +var 𗎶; +var 𗎷; +var 𗎸; +var 𗎹; +var 𗎺; +var 𗎻; +var 𗎼; +var 𗎽; +var 𗎾; +var 𗎿; +var 𗏀; +var 𗏁; +var 𗏂; +var 𗏃; +var 𗏄; +var 𗏅; +var 𗏆; +var 𗏇; +var 𗏈; +var 𗏉; +var 𗏊; +var 𗏋; +var 𗏌; +var 𗏍; +var 𗏎; +var 𗏏; +var 𗏐; +var 𗏑; +var 𗏒; +var 𗏓; +var 𗏔; +var 𗏕; +var 𗏖; +var 𗏗; +var 𗏘; +var 𗏙; +var 𗏚; +var 𗏛; +var 𗏜; +var 𗏝; +var 𗏞; +var 𗏟; +var 𗏠; +var 𗏡; +var 𗏢; +var 𗏣; +var 𗏤; +var 𗏥; +var 𗏦; +var 𗏧; +var 𗏨; +var 𗏩; +var 𗏪; +var 𗏫; +var 𗏬; +var 𗏭; +var 𗏮; +var 𗏯; +var 𗏰; +var 𗏱; +var 𗏲; +var 𗏳; +var 𗏴; +var 𗏵; +var 𗏶; +var 𗏷; +var 𗏸; +var 𗏹; +var 𗏺; +var 𗏻; +var 𗏼; +var 𗏽; +var 𗏾; +var 𗏿; +var 𗐀; +var 𗐁; +var 𗐂; +var 𗐃; +var 𗐄; +var 𗐅; +var 𗐆; +var 𗐇; +var 𗐈; +var 𗐉; +var 𗐊; +var 𗐋; +var 𗐌; +var 𗐍; +var 𗐎; +var 𗐏; +var 𗐐; +var 𗐑; +var 𗐒; +var 𗐓; +var 𗐔; +var 𗐕; +var 𗐖; +var 𗐗; +var 𗐘; +var 𗐙; +var 𗐚; +var 𗐛; +var 𗐜; +var 𗐝; +var 𗐞; +var 𗐟; +var 𗐠; +var 𗐡; +var 𗐢; +var 𗐣; +var 𗐤; +var 𗐥; +var 𗐦; +var 𗐧; +var 𗐨; +var 𗐩; +var 𗐪; +var 𗐫; +var 𗐬; +var 𗐭; +var 𗐮; +var 𗐯; +var 𗐰; +var 𗐱; +var 𗐲; +var 𗐳; +var 𗐴; +var 𗐵; +var 𗐶; +var 𗐷; +var 𗐸; +var 𗐹; +var 𗐺; +var 𗐻; +var 𗐼; +var 𗐽; +var 𗐾; +var 𗐿; +var 𗑀; +var 𗑁; +var 𗑂; +var 𗑃; +var 𗑄; +var 𗑅; +var 𗑆; +var 𗑇; +var 𗑈; +var 𗑉; +var 𗑊; +var 𗑋; +var 𗑌; +var 𗑍; +var 𗑎; +var 𗑏; +var 𗑐; +var 𗑑; +var 𗑒; +var 𗑓; +var 𗑔; +var 𗑕; +var 𗑖; +var 𗑗; +var 𗑘; +var 𗑙; +var 𗑚; +var 𗑛; +var 𗑜; +var 𗑝; +var 𗑞; +var 𗑟; +var 𗑠; +var 𗑡; +var 𗑢; +var 𗑣; +var 𗑤; +var 𗑥; +var 𗑦; +var 𗑧; +var 𗑨; +var 𗑩; +var 𗑪; +var 𗑫; +var 𗑬; +var 𗑭; +var 𗑮; +var 𗑯; +var 𗑰; +var 𗑱; +var 𗑲; +var 𗑳; +var 𗑴; +var 𗑵; +var 𗑶; +var 𗑷; +var 𗑸; +var 𗑹; +var 𗑺; +var 𗑻; +var 𗑼; +var 𗑽; +var 𗑾; +var 𗑿; +var 𗒀; +var 𗒁; +var 𗒂; +var 𗒃; +var 𗒄; +var 𗒅; +var 𗒆; +var 𗒇; +var 𗒈; +var 𗒉; +var 𗒊; +var 𗒋; +var 𗒌; +var 𗒍; +var 𗒎; +var 𗒏; +var 𗒐; +var 𗒑; +var 𗒒; +var 𗒓; +var 𗒔; +var 𗒕; +var 𗒖; +var 𗒗; +var 𗒘; +var 𗒙; +var 𗒚; +var 𗒛; +var 𗒜; +var 𗒝; +var 𗒞; +var 𗒟; +var 𗒠; +var 𗒡; +var 𗒢; +var 𗒣; +var 𗒤; +var 𗒥; +var 𗒦; +var 𗒧; +var 𗒨; +var 𗒩; +var 𗒪; +var 𗒫; +var 𗒬; +var 𗒭; +var 𗒮; +var 𗒯; +var 𗒰; +var 𗒱; +var 𗒲; +var 𗒳; +var 𗒴; +var 𗒵; +var 𗒶; +var 𗒷; +var 𗒸; +var 𗒹; +var 𗒺; +var 𗒻; +var 𗒼; +var 𗒽; +var 𗒾; +var 𗒿; +var 𗓀; +var 𗓁; +var 𗓂; +var 𗓃; +var 𗓄; +var 𗓅; +var 𗓆; +var 𗓇; +var 𗓈; +var 𗓉; +var 𗓊; +var 𗓋; +var 𗓌; +var 𗓍; +var 𗓎; +var 𗓏; +var 𗓐; +var 𗓑; +var 𗓒; +var 𗓓; +var 𗓔; +var 𗓕; +var 𗓖; +var 𗓗; +var 𗓘; +var 𗓙; +var 𗓚; +var 𗓛; +var 𗓜; +var 𗓝; +var 𗓞; +var 𗓟; +var 𗓠; +var 𗓡; +var 𗓢; +var 𗓣; +var 𗓤; +var 𗓥; +var 𗓦; +var 𗓧; +var 𗓨; +var 𗓩; +var 𗓪; +var 𗓫; +var 𗓬; +var 𗓭; +var 𗓮; +var 𗓯; +var 𗓰; +var 𗓱; +var 𗓲; +var 𗓳; +var 𗓴; +var 𗓵; +var 𗓶; +var 𗓷; +var 𗓸; +var 𗓹; +var 𗓺; +var 𗓻; +var 𗓼; +var 𗓽; +var 𗓾; +var 𗓿; +var 𗔀; +var 𗔁; +var 𗔂; +var 𗔃; +var 𗔄; +var 𗔅; +var 𗔆; +var 𗔇; +var 𗔈; +var 𗔉; +var 𗔊; +var 𗔋; +var 𗔌; +var 𗔍; +var 𗔎; +var 𗔏; +var 𗔐; +var 𗔑; +var 𗔒; +var 𗔓; +var 𗔔; +var 𗔕; +var 𗔖; +var 𗔗; +var 𗔘; +var 𗔙; +var 𗔚; +var 𗔛; +var 𗔜; +var 𗔝; +var 𗔞; +var 𗔟; +var 𗔠; +var 𗔡; +var 𗔢; +var 𗔣; +var 𗔤; +var 𗔥; +var 𗔦; +var 𗔧; +var 𗔨; +var 𗔩; +var 𗔪; +var 𗔫; +var 𗔬; +var 𗔭; +var 𗔮; +var 𗔯; +var 𗔰; +var 𗔱; +var 𗔲; +var 𗔳; +var 𗔴; +var 𗔵; +var 𗔶; +var 𗔷; +var 𗔸; +var 𗔹; +var 𗔺; +var 𗔻; +var 𗔼; +var 𗔽; +var 𗔾; +var 𗔿; +var 𗕀; +var 𗕁; +var 𗕂; +var 𗕃; +var 𗕄; +var 𗕅; +var 𗕆; +var 𗕇; +var 𗕈; +var 𗕉; +var 𗕊; +var 𗕋; +var 𗕌; +var 𗕍; +var 𗕎; +var 𗕏; +var 𗕐; +var 𗕑; +var 𗕒; +var 𗕓; +var 𗕔; +var 𗕕; +var 𗕖; +var 𗕗; +var 𗕘; +var 𗕙; +var 𗕚; +var 𗕛; +var 𗕜; +var 𗕝; +var 𗕞; +var 𗕟; +var 𗕠; +var 𗕡; +var 𗕢; +var 𗕣; +var 𗕤; +var 𗕥; +var 𗕦; +var 𗕧; +var 𗕨; +var 𗕩; +var 𗕪; +var 𗕫; +var 𗕬; +var 𗕭; +var 𗕮; +var 𗕯; +var 𗕰; +var 𗕱; +var 𗕲; +var 𗕳; +var 𗕴; +var 𗕵; +var 𗕶; +var 𗕷; +var 𗕸; +var 𗕹; +var 𗕺; +var 𗕻; +var 𗕼; +var 𗕽; +var 𗕾; +var 𗕿; +var 𗖀; +var 𗖁; +var 𗖂; +var 𗖃; +var 𗖄; +var 𗖅; +var 𗖆; +var 𗖇; +var 𗖈; +var 𗖉; +var 𗖊; +var 𗖋; +var 𗖌; +var 𗖍; +var 𗖎; +var 𗖏; +var 𗖐; +var 𗖑; +var 𗖒; +var 𗖓; +var 𗖔; +var 𗖕; +var 𗖖; +var 𗖗; +var 𗖘; +var 𗖙; +var 𗖚; +var 𗖛; +var 𗖜; +var 𗖝; +var 𗖞; +var 𗖟; +var 𗖠; +var 𗖡; +var 𗖢; +var 𗖣; +var 𗖤; +var 𗖥; +var 𗖦; +var 𗖧; +var 𗖨; +var 𗖩; +var 𗖪; +var 𗖫; +var 𗖬; +var 𗖭; +var 𗖮; +var 𗖯; +var 𗖰; +var 𗖱; +var 𗖲; +var 𗖳; +var 𗖴; +var 𗖵; +var 𗖶; +var 𗖷; +var 𗖸; +var 𗖹; +var 𗖺; +var 𗖻; +var 𗖼; +var 𗖽; +var 𗖾; +var 𗖿; +var 𗗀; +var 𗗁; +var 𗗂; +var 𗗃; +var 𗗄; +var 𗗅; +var 𗗆; +var 𗗇; +var 𗗈; +var 𗗉; +var 𗗊; +var 𗗋; +var 𗗌; +var 𗗍; +var 𗗎; +var 𗗏; +var 𗗐; +var 𗗑; +var 𗗒; +var 𗗓; +var 𗗔; +var 𗗕; +var 𗗖; +var 𗗗; +var 𗗘; +var 𗗙; +var 𗗚; +var 𗗛; +var 𗗜; +var 𗗝; +var 𗗞; +var 𗗟; +var 𗗠; +var 𗗡; +var 𗗢; +var 𗗣; +var 𗗤; +var 𗗥; +var 𗗦; +var 𗗧; +var 𗗨; +var 𗗩; +var 𗗪; +var 𗗫; +var 𗗬; +var 𗗭; +var 𗗮; +var 𗗯; +var 𗗰; +var 𗗱; +var 𗗲; +var 𗗳; +var 𗗴; +var 𗗵; +var 𗗶; +var 𗗷; +var 𗗸; +var 𗗹; +var 𗗺; +var 𗗻; +var 𗗼; +var 𗗽; +var 𗗾; +var 𗗿; +var 𗘀; +var 𗘁; +var 𗘂; +var 𗘃; +var 𗘄; +var 𗘅; +var 𗘆; +var 𗘇; +var 𗘈; +var 𗘉; +var 𗘊; +var 𗘋; +var 𗘌; +var 𗘍; +var 𗘎; +var 𗘏; +var 𗘐; +var 𗘑; +var 𗘒; +var 𗘓; +var 𗘔; +var 𗘕; +var 𗘖; +var 𗘗; +var 𗘘; +var 𗘙; +var 𗘚; +var 𗘛; +var 𗘜; +var 𗘝; +var 𗘞; +var 𗘟; +var 𗘠; +var 𗘡; +var 𗘢; +var 𗘣; +var 𗘤; +var 𗘥; +var 𗘦; +var 𗘧; +var 𗘨; +var 𗘩; +var 𗘪; +var 𗘫; +var 𗘬; +var 𗘭; +var 𗘮; +var 𗘯; +var 𗘰; +var 𗘱; +var 𗘲; +var 𗘳; +var 𗘴; +var 𗘵; +var 𗘶; +var 𗘷; +var 𗘸; +var 𗘹; +var 𗘺; +var 𗘻; +var 𗘼; +var 𗘽; +var 𗘾; +var 𗘿; +var 𗙀; +var 𗙁; +var 𗙂; +var 𗙃; +var 𗙄; +var 𗙅; +var 𗙆; +var 𗙇; +var 𗙈; +var 𗙉; +var 𗙊; +var 𗙋; +var 𗙌; +var 𗙍; +var 𗙎; +var 𗙏; +var 𗙐; +var 𗙑; +var 𗙒; +var 𗙓; +var 𗙔; +var 𗙕; +var 𗙖; +var 𗙗; +var 𗙘; +var 𗙙; +var 𗙚; +var 𗙛; +var 𗙜; +var 𗙝; +var 𗙞; +var 𗙟; +var 𗙠; +var 𗙡; +var 𗙢; +var 𗙣; +var 𗙤; +var 𗙥; +var 𗙦; +var 𗙧; +var 𗙨; +var 𗙩; +var 𗙪; +var 𗙫; +var 𗙬; +var 𗙭; +var 𗙮; +var 𗙯; +var 𗙰; +var 𗙱; +var 𗙲; +var 𗙳; +var 𗙴; +var 𗙵; +var 𗙶; +var 𗙷; +var 𗙸; +var 𗙹; +var 𗙺; +var 𗙻; +var 𗙼; +var 𗙽; +var 𗙾; +var 𗙿; +var 𗚀; +var 𗚁; +var 𗚂; +var 𗚃; +var 𗚄; +var 𗚅; +var 𗚆; +var 𗚇; +var 𗚈; +var 𗚉; +var 𗚊; +var 𗚋; +var 𗚌; +var 𗚍; +var 𗚎; +var 𗚏; +var 𗚐; +var 𗚑; +var 𗚒; +var 𗚓; +var 𗚔; +var 𗚕; +var 𗚖; +var 𗚗; +var 𗚘; +var 𗚙; +var 𗚚; +var 𗚛; +var 𗚜; +var 𗚝; +var 𗚞; +var 𗚟; +var 𗚠; +var 𗚡; +var 𗚢; +var 𗚣; +var 𗚤; +var 𗚥; +var 𗚦; +var 𗚧; +var 𗚨; +var 𗚩; +var 𗚪; +var 𗚫; +var 𗚬; +var 𗚭; +var 𗚮; +var 𗚯; +var 𗚰; +var 𗚱; +var 𗚲; +var 𗚳; +var 𗚴; +var 𗚵; +var 𗚶; +var 𗚷; +var 𗚸; +var 𗚹; +var 𗚺; +var 𗚻; +var 𗚼; +var 𗚽; +var 𗚾; +var 𗚿; +var 𗛀; +var 𗛁; +var 𗛂; +var 𗛃; +var 𗛄; +var 𗛅; +var 𗛆; +var 𗛇; +var 𗛈; +var 𗛉; +var 𗛊; +var 𗛋; +var 𗛌; +var 𗛍; +var 𗛎; +var 𗛏; +var 𗛐; +var 𗛑; +var 𗛒; +var 𗛓; +var 𗛔; +var 𗛕; +var 𗛖; +var 𗛗; +var 𗛘; +var 𗛙; +var 𗛚; +var 𗛛; +var 𗛜; +var 𗛝; +var 𗛞; +var 𗛟; +var 𗛠; +var 𗛡; +var 𗛢; +var 𗛣; +var 𗛤; +var 𗛥; +var 𗛦; +var 𗛧; +var 𗛨; +var 𗛩; +var 𗛪; +var 𗛫; +var 𗛬; +var 𗛭; +var 𗛮; +var 𗛯; +var 𗛰; +var 𗛱; +var 𗛲; +var 𗛳; +var 𗛴; +var 𗛵; +var 𗛶; +var 𗛷; +var 𗛸; +var 𗛹; +var 𗛺; +var 𗛻; +var 𗛼; +var 𗛽; +var 𗛾; +var 𗛿; +var 𗜀; +var 𗜁; +var 𗜂; +var 𗜃; +var 𗜄; +var 𗜅; +var 𗜆; +var 𗜇; +var 𗜈; +var 𗜉; +var 𗜊; +var 𗜋; +var 𗜌; +var 𗜍; +var 𗜎; +var 𗜏; +var 𗜐; +var 𗜑; +var 𗜒; +var 𗜓; +var 𗜔; +var 𗜕; +var 𗜖; +var 𗜗; +var 𗜘; +var 𗜙; +var 𗜚; +var 𗜛; +var 𗜜; +var 𗜝; +var 𗜞; +var 𗜟; +var 𗜠; +var 𗜡; +var 𗜢; +var 𗜣; +var 𗜤; +var 𗜥; +var 𗜦; +var 𗜧; +var 𗜨; +var 𗜩; +var 𗜪; +var 𗜫; +var 𗜬; +var 𗜭; +var 𗜮; +var 𗜯; +var 𗜰; +var 𗜱; +var 𗜲; +var 𗜳; +var 𗜴; +var 𗜵; +var 𗜶; +var 𗜷; +var 𗜸; +var 𗜹; +var 𗜺; +var 𗜻; +var 𗜼; +var 𗜽; +var 𗜾; +var 𗜿; +var 𗝀; +var 𗝁; +var 𗝂; +var 𗝃; +var 𗝄; +var 𗝅; +var 𗝆; +var 𗝇; +var 𗝈; +var 𗝉; +var 𗝊; +var 𗝋; +var 𗝌; +var 𗝍; +var 𗝎; +var 𗝏; +var 𗝐; +var 𗝑; +var 𗝒; +var 𗝓; +var 𗝔; +var 𗝕; +var 𗝖; +var 𗝗; +var 𗝘; +var 𗝙; +var 𗝚; +var 𗝛; +var 𗝜; +var 𗝝; +var 𗝞; +var 𗝟; +var 𗝠; +var 𗝡; +var 𗝢; +var 𗝣; +var 𗝤; +var 𗝥; +var 𗝦; +var 𗝧; +var 𗝨; +var 𗝩; +var 𗝪; +var 𗝫; +var 𗝬; +var 𗝭; +var 𗝮; +var 𗝯; +var 𗝰; +var 𗝱; +var 𗝲; +var 𗝳; +var 𗝴; +var 𗝵; +var 𗝶; +var 𗝷; +var 𗝸; +var 𗝹; +var 𗝺; +var 𗝻; +var 𗝼; +var 𗝽; +var 𗝾; +var 𗝿; +var 𗞀; +var 𗞁; +var 𗞂; +var 𗞃; +var 𗞄; +var 𗞅; +var 𗞆; +var 𗞇; +var 𗞈; +var 𗞉; +var 𗞊; +var 𗞋; +var 𗞌; +var 𗞍; +var 𗞎; +var 𗞏; +var 𗞐; +var 𗞑; +var 𗞒; +var 𗞓; +var 𗞔; +var 𗞕; +var 𗞖; +var 𗞗; +var 𗞘; +var 𗞙; +var 𗞚; +var 𗞛; +var 𗞜; +var 𗞝; +var 𗞞; +var 𗞟; +var 𗞠; +var 𗞡; +var 𗞢; +var 𗞣; +var 𗞤; +var 𗞥; +var 𗞦; +var 𗞧; +var 𗞨; +var 𗞩; +var 𗞪; +var 𗞫; +var 𗞬; +var 𗞭; +var 𗞮; +var 𗞯; +var 𗞰; +var 𗞱; +var 𗞲; +var 𗞳; +var 𗞴; +var 𗞵; +var 𗞶; +var 𗞷; +var 𗞸; +var 𗞹; +var 𗞺; +var 𗞻; +var 𗞼; +var 𗞽; +var 𗞾; +var 𗞿; +var 𗟀; +var 𗟁; +var 𗟂; +var 𗟃; +var 𗟄; +var 𗟅; +var 𗟆; +var 𗟇; +var 𗟈; +var 𗟉; +var 𗟊; +var 𗟋; +var 𗟌; +var 𗟍; +var 𗟎; +var 𗟏; +var 𗟐; +var 𗟑; +var 𗟒; +var 𗟓; +var 𗟔; +var 𗟕; +var 𗟖; +var 𗟗; +var 𗟘; +var 𗟙; +var 𗟚; +var 𗟛; +var 𗟜; +var 𗟝; +var 𗟞; +var 𗟟; +var 𗟠; +var 𗟡; +var 𗟢; +var 𗟣; +var 𗟤; +var 𗟥; +var 𗟦; +var 𗟧; +var 𗟨; +var 𗟩; +var 𗟪; +var 𗟫; +var 𗟬; +var 𗟭; +var 𗟮; +var 𗟯; +var 𗟰; +var 𗟱; +var 𗟲; +var 𗟳; +var 𗟴; +var 𗟵; +var 𗟶; +var 𗟷; +var 𗟸; +var 𗟹; +var 𗟺; +var 𗟻; +var 𗟼; +var 𗟽; +var 𗟾; +var 𗟿; +var 𗠀; +var 𗠁; +var 𗠂; +var 𗠃; +var 𗠄; +var 𗠅; +var 𗠆; +var 𗠇; +var 𗠈; +var 𗠉; +var 𗠊; +var 𗠋; +var 𗠌; +var 𗠍; +var 𗠎; +var 𗠏; +var 𗠐; +var 𗠑; +var 𗠒; +var 𗠓; +var 𗠔; +var 𗠕; +var 𗠖; +var 𗠗; +var 𗠘; +var 𗠙; +var 𗠚; +var 𗠛; +var 𗠜; +var 𗠝; +var 𗠞; +var 𗠟; +var 𗠠; +var 𗠡; +var 𗠢; +var 𗠣; +var 𗠤; +var 𗠥; +var 𗠦; +var 𗠧; +var 𗠨; +var 𗠩; +var 𗠪; +var 𗠫; +var 𗠬; +var 𗠭; +var 𗠮; +var 𗠯; +var 𗠰; +var 𗠱; +var 𗠲; +var 𗠳; +var 𗠴; +var 𗠵; +var 𗠶; +var 𗠷; +var 𗠸; +var 𗠹; +var 𗠺; +var 𗠻; +var 𗠼; +var 𗠽; +var 𗠾; +var 𗠿; +var 𗡀; +var 𗡁; +var 𗡂; +var 𗡃; +var 𗡄; +var 𗡅; +var 𗡆; +var 𗡇; +var 𗡈; +var 𗡉; +var 𗡊; +var 𗡋; +var 𗡌; +var 𗡍; +var 𗡎; +var 𗡏; +var 𗡐; +var 𗡑; +var 𗡒; +var 𗡓; +var 𗡔; +var 𗡕; +var 𗡖; +var 𗡗; +var 𗡘; +var 𗡙; +var 𗡚; +var 𗡛; +var 𗡜; +var 𗡝; +var 𗡞; +var 𗡟; +var 𗡠; +var 𗡡; +var 𗡢; +var 𗡣; +var 𗡤; +var 𗡥; +var 𗡦; +var 𗡧; +var 𗡨; +var 𗡩; +var 𗡪; +var 𗡫; +var 𗡬; +var 𗡭; +var 𗡮; +var 𗡯; +var 𗡰; +var 𗡱; +var 𗡲; +var 𗡳; +var 𗡴; +var 𗡵; +var 𗡶; +var 𗡷; +var 𗡸; +var 𗡹; +var 𗡺; +var 𗡻; +var 𗡼; +var 𗡽; +var 𗡾; +var 𗡿; +var 𗢀; +var 𗢁; +var 𗢂; +var 𗢃; +var 𗢄; +var 𗢅; +var 𗢆; +var 𗢇; +var 𗢈; +var 𗢉; +var 𗢊; +var 𗢋; +var 𗢌; +var 𗢍; +var 𗢎; +var 𗢏; +var 𗢐; +var 𗢑; +var 𗢒; +var 𗢓; +var 𗢔; +var 𗢕; +var 𗢖; +var 𗢗; +var 𗢘; +var 𗢙; +var 𗢚; +var 𗢛; +var 𗢜; +var 𗢝; +var 𗢞; +var 𗢟; +var 𗢠; +var 𗢡; +var 𗢢; +var 𗢣; +var 𗢤; +var 𗢥; +var 𗢦; +var 𗢧; +var 𗢨; +var 𗢩; +var 𗢪; +var 𗢫; +var 𗢬; +var 𗢭; +var 𗢮; +var 𗢯; +var 𗢰; +var 𗢱; +var 𗢲; +var 𗢳; +var 𗢴; +var 𗢵; +var 𗢶; +var 𗢷; +var 𗢸; +var 𗢹; +var 𗢺; +var 𗢻; +var 𗢼; +var 𗢽; +var 𗢾; +var 𗢿; +var 𗣀; +var 𗣁; +var 𗣂; +var 𗣃; +var 𗣄; +var 𗣅; +var 𗣆; +var 𗣇; +var 𗣈; +var 𗣉; +var 𗣊; +var 𗣋; +var 𗣌; +var 𗣍; +var 𗣎; +var 𗣏; +var 𗣐; +var 𗣑; +var 𗣒; +var 𗣓; +var 𗣔; +var 𗣕; +var 𗣖; +var 𗣗; +var 𗣘; +var 𗣙; +var 𗣚; +var 𗣛; +var 𗣜; +var 𗣝; +var 𗣞; +var 𗣟; +var 𗣠; +var 𗣡; +var 𗣢; +var 𗣣; +var 𗣤; +var 𗣥; +var 𗣦; +var 𗣧; +var 𗣨; +var 𗣩; +var 𗣪; +var 𗣫; +var 𗣬; +var 𗣭; +var 𗣮; +var 𗣯; +var 𗣰; +var 𗣱; +var 𗣲; +var 𗣳; +var 𗣴; +var 𗣵; +var 𗣶; +var 𗣷; +var 𗣸; +var 𗣹; +var 𗣺; +var 𗣻; +var 𗣼; +var 𗣽; +var 𗣾; +var 𗣿; +var 𗤀; +var 𗤁; +var 𗤂; +var 𗤃; +var 𗤄; +var 𗤅; +var 𗤆; +var 𗤇; +var 𗤈; +var 𗤉; +var 𗤊; +var 𗤋; +var 𗤌; +var 𗤍; +var 𗤎; +var 𗤏; +var 𗤐; +var 𗤑; +var 𗤒; +var 𗤓; +var 𗤔; +var 𗤕; +var 𗤖; +var 𗤗; +var 𗤘; +var 𗤙; +var 𗤚; +var 𗤛; +var 𗤜; +var 𗤝; +var 𗤞; +var 𗤟; +var 𗤠; +var 𗤡; +var 𗤢; +var 𗤣; +var 𗤤; +var 𗤥; +var 𗤦; +var 𗤧; +var 𗤨; +var 𗤩; +var 𗤪; +var 𗤫; +var 𗤬; +var 𗤭; +var 𗤮; +var 𗤯; +var 𗤰; +var 𗤱; +var 𗤲; +var 𗤳; +var 𗤴; +var 𗤵; +var 𗤶; +var 𗤷; +var 𗤸; +var 𗤹; +var 𗤺; +var 𗤻; +var 𗤼; +var 𗤽; +var 𗤾; +var 𗤿; +var 𗥀; +var 𗥁; +var 𗥂; +var 𗥃; +var 𗥄; +var 𗥅; +var 𗥆; +var 𗥇; +var 𗥈; +var 𗥉; +var 𗥊; +var 𗥋; +var 𗥌; +var 𗥍; +var 𗥎; +var 𗥏; +var 𗥐; +var 𗥑; +var 𗥒; +var 𗥓; +var 𗥔; +var 𗥕; +var 𗥖; +var 𗥗; +var 𗥘; +var 𗥙; +var 𗥚; +var 𗥛; +var 𗥜; +var 𗥝; +var 𗥞; +var 𗥟; +var 𗥠; +var 𗥡; +var 𗥢; +var 𗥣; +var 𗥤; +var 𗥥; +var 𗥦; +var 𗥧; +var 𗥨; +var 𗥩; +var 𗥪; +var 𗥫; +var 𗥬; +var 𗥭; +var 𗥮; +var 𗥯; +var 𗥰; +var 𗥱; +var 𗥲; +var 𗥳; +var 𗥴; +var 𗥵; +var 𗥶; +var 𗥷; +var 𗥸; +var 𗥹; +var 𗥺; +var 𗥻; +var 𗥼; +var 𗥽; +var 𗥾; +var 𗥿; +var 𗦀; +var 𗦁; +var 𗦂; +var 𗦃; +var 𗦄; +var 𗦅; +var 𗦆; +var 𗦇; +var 𗦈; +var 𗦉; +var 𗦊; +var 𗦋; +var 𗦌; +var 𗦍; +var 𗦎; +var 𗦏; +var 𗦐; +var 𗦑; +var 𗦒; +var 𗦓; +var 𗦔; +var 𗦕; +var 𗦖; +var 𗦗; +var 𗦘; +var 𗦙; +var 𗦚; +var 𗦛; +var 𗦜; +var 𗦝; +var 𗦞; +var 𗦟; +var 𗦠; +var 𗦡; +var 𗦢; +var 𗦣; +var 𗦤; +var 𗦥; +var 𗦦; +var 𗦧; +var 𗦨; +var 𗦩; +var 𗦪; +var 𗦫; +var 𗦬; +var 𗦭; +var 𗦮; +var 𗦯; +var 𗦰; +var 𗦱; +var 𗦲; +var 𗦳; +var 𗦴; +var 𗦵; +var 𗦶; +var 𗦷; +var 𗦸; +var 𗦹; +var 𗦺; +var 𗦻; +var 𗦼; +var 𗦽; +var 𗦾; +var 𗦿; +var 𗧀; +var 𗧁; +var 𗧂; +var 𗧃; +var 𗧄; +var 𗧅; +var 𗧆; +var 𗧇; +var 𗧈; +var 𗧉; +var 𗧊; +var 𗧋; +var 𗧌; +var 𗧍; +var 𗧎; +var 𗧏; +var 𗧐; +var 𗧑; +var 𗧒; +var 𗧓; +var 𗧔; +var 𗧕; +var 𗧖; +var 𗧗; +var 𗧘; +var 𗧙; +var 𗧚; +var 𗧛; +var 𗧜; +var 𗧝; +var 𗧞; +var 𗧟; +var 𗧠; +var 𗧡; +var 𗧢; +var 𗧣; +var 𗧤; +var 𗧥; +var 𗧦; +var 𗧧; +var 𗧨; +var 𗧩; +var 𗧪; +var 𗧫; +var 𗧬; +var 𗧭; +var 𗧮; +var 𗧯; +var 𗧰; +var 𗧱; +var 𗧲; +var 𗧳; +var 𗧴; +var 𗧵; +var 𗧶; +var 𗧷; +var 𗧸; +var 𗧹; +var 𗧺; +var 𗧻; +var 𗧼; +var 𗧽; +var 𗧾; +var 𗧿; +var 𗨀; +var 𗨁; +var 𗨂; +var 𗨃; +var 𗨄; +var 𗨅; +var 𗨆; +var 𗨇; +var 𗨈; +var 𗨉; +var 𗨊; +var 𗨋; +var 𗨌; +var 𗨍; +var 𗨎; +var 𗨏; +var 𗨐; +var 𗨑; +var 𗨒; +var 𗨓; +var 𗨔; +var 𗨕; +var 𗨖; +var 𗨗; +var 𗨘; +var 𗨙; +var 𗨚; +var 𗨛; +var 𗨜; +var 𗨝; +var 𗨞; +var 𗨟; +var 𗨠; +var 𗨡; +var 𗨢; +var 𗨣; +var 𗨤; +var 𗨥; +var 𗨦; +var 𗨧; +var 𗨨; +var 𗨩; +var 𗨪; +var 𗨫; +var 𗨬; +var 𗨭; +var 𗨮; +var 𗨯; +var 𗨰; +var 𗨱; +var 𗨲; +var 𗨳; +var 𗨴; +var 𗨵; +var 𗨶; +var 𗨷; +var 𗨸; +var 𗨹; +var 𗨺; +var 𗨻; +var 𗨼; +var 𗨽; +var 𗨾; +var 𗨿; +var 𗩀; +var 𗩁; +var 𗩂; +var 𗩃; +var 𗩄; +var 𗩅; +var 𗩆; +var 𗩇; +var 𗩈; +var 𗩉; +var 𗩊; +var 𗩋; +var 𗩌; +var 𗩍; +var 𗩎; +var 𗩏; +var 𗩐; +var 𗩑; +var 𗩒; +var 𗩓; +var 𗩔; +var 𗩕; +var 𗩖; +var 𗩗; +var 𗩘; +var 𗩙; +var 𗩚; +var 𗩛; +var 𗩜; +var 𗩝; +var 𗩞; +var 𗩟; +var 𗩠; +var 𗩡; +var 𗩢; +var 𗩣; +var 𗩤; +var 𗩥; +var 𗩦; +var 𗩧; +var 𗩨; +var 𗩩; +var 𗩪; +var 𗩫; +var 𗩬; +var 𗩭; +var 𗩮; +var 𗩯; +var 𗩰; +var 𗩱; +var 𗩲; +var 𗩳; +var 𗩴; +var 𗩵; +var 𗩶; +var 𗩷; +var 𗩸; +var 𗩹; +var 𗩺; +var 𗩻; +var 𗩼; +var 𗩽; +var 𗩾; +var 𗩿; +var 𗪀; +var 𗪁; +var 𗪂; +var 𗪃; +var 𗪄; +var 𗪅; +var 𗪆; +var 𗪇; +var 𗪈; +var 𗪉; +var 𗪊; +var 𗪋; +var 𗪌; +var 𗪍; +var 𗪎; +var 𗪏; +var 𗪐; +var 𗪑; +var 𗪒; +var 𗪓; +var 𗪔; +var 𗪕; +var 𗪖; +var 𗪗; +var 𗪘; +var 𗪙; +var 𗪚; +var 𗪛; +var 𗪜; +var 𗪝; +var 𗪞; +var 𗪟; +var 𗪠; +var 𗪡; +var 𗪢; +var 𗪣; +var 𗪤; +var 𗪥; +var 𗪦; +var 𗪧; +var 𗪨; +var 𗪩; +var 𗪪; +var 𗪫; +var 𗪬; +var 𗪭; +var 𗪮; +var 𗪯; +var 𗪰; +var 𗪱; +var 𗪲; +var 𗪳; +var 𗪴; +var 𗪵; +var 𗪶; +var 𗪷; +var 𗪸; +var 𗪹; +var 𗪺; +var 𗪻; +var 𗪼; +var 𗪽; +var 𗪾; +var 𗪿; +var 𗫀; +var 𗫁; +var 𗫂; +var 𗫃; +var 𗫄; +var 𗫅; +var 𗫆; +var 𗫇; +var 𗫈; +var 𗫉; +var 𗫊; +var 𗫋; +var 𗫌; +var 𗫍; +var 𗫎; +var 𗫏; +var 𗫐; +var 𗫑; +var 𗫒; +var 𗫓; +var 𗫔; +var 𗫕; +var 𗫖; +var 𗫗; +var 𗫘; +var 𗫙; +var 𗫚; +var 𗫛; +var 𗫜; +var 𗫝; +var 𗫞; +var 𗫟; +var 𗫠; +var 𗫡; +var 𗫢; +var 𗫣; +var 𗫤; +var 𗫥; +var 𗫦; +var 𗫧; +var 𗫨; +var 𗫩; +var 𗫪; +var 𗫫; +var 𗫬; +var 𗫭; +var 𗫮; +var 𗫯; +var 𗫰; +var 𗫱; +var 𗫲; +var 𗫳; +var 𗫴; +var 𗫵; +var 𗫶; +var 𗫷; +var 𗫸; +var 𗫹; +var 𗫺; +var 𗫻; +var 𗫼; +var 𗫽; +var 𗫾; +var 𗫿; +var 𗬀; +var 𗬁; +var 𗬂; +var 𗬃; +var 𗬄; +var 𗬅; +var 𗬆; +var 𗬇; +var 𗬈; +var 𗬉; +var 𗬊; +var 𗬋; +var 𗬌; +var 𗬍; +var 𗬎; +var 𗬏; +var 𗬐; +var 𗬑; +var 𗬒; +var 𗬓; +var 𗬔; +var 𗬕; +var 𗬖; +var 𗬗; +var 𗬘; +var 𗬙; +var 𗬚; +var 𗬛; +var 𗬜; +var 𗬝; +var 𗬞; +var 𗬟; +var 𗬠; +var 𗬡; +var 𗬢; +var 𗬣; +var 𗬤; +var 𗬥; +var 𗬦; +var 𗬧; +var 𗬨; +var 𗬩; +var 𗬪; +var 𗬫; +var 𗬬; +var 𗬭; +var 𗬮; +var 𗬯; +var 𗬰; +var 𗬱; +var 𗬲; +var 𗬳; +var 𗬴; +var 𗬵; +var 𗬶; +var 𗬷; +var 𗬸; +var 𗬹; +var 𗬺; +var 𗬻; +var 𗬼; +var 𗬽; +var 𗬾; +var 𗬿; +var 𗭀; +var 𗭁; +var 𗭂; +var 𗭃; +var 𗭄; +var 𗭅; +var 𗭆; +var 𗭇; +var 𗭈; +var 𗭉; +var 𗭊; +var 𗭋; +var 𗭌; +var 𗭍; +var 𗭎; +var 𗭏; +var 𗭐; +var 𗭑; +var 𗭒; +var 𗭓; +var 𗭔; +var 𗭕; +var 𗭖; +var 𗭗; +var 𗭘; +var 𗭙; +var 𗭚; +var 𗭛; +var 𗭜; +var 𗭝; +var 𗭞; +var 𗭟; +var 𗭠; +var 𗭡; +var 𗭢; +var 𗭣; +var 𗭤; +var 𗭥; +var 𗭦; +var 𗭧; +var 𗭨; +var 𗭩; +var 𗭪; +var 𗭫; +var 𗭬; +var 𗭭; +var 𗭮; +var 𗭯; +var 𗭰; +var 𗭱; +var 𗭲; +var 𗭳; +var 𗭴; +var 𗭵; +var 𗭶; +var 𗭷; +var 𗭸; +var 𗭹; +var 𗭺; +var 𗭻; +var 𗭼; +var 𗭽; +var 𗭾; +var 𗭿; +var 𗮀; +var 𗮁; +var 𗮂; +var 𗮃; +var 𗮄; +var 𗮅; +var 𗮆; +var 𗮇; +var 𗮈; +var 𗮉; +var 𗮊; +var 𗮋; +var 𗮌; +var 𗮍; +var 𗮎; +var 𗮏; +var 𗮐; +var 𗮑; +var 𗮒; +var 𗮓; +var 𗮔; +var 𗮕; +var 𗮖; +var 𗮗; +var 𗮘; +var 𗮙; +var 𗮚; +var 𗮛; +var 𗮜; +var 𗮝; +var 𗮞; +var 𗮟; +var 𗮠; +var 𗮡; +var 𗮢; +var 𗮣; +var 𗮤; +var 𗮥; +var 𗮦; +var 𗮧; +var 𗮨; +var 𗮩; +var 𗮪; +var 𗮫; +var 𗮬; +var 𗮭; +var 𗮮; +var 𗮯; +var 𗮰; +var 𗮱; +var 𗮲; +var 𗮳; +var 𗮴; +var 𗮵; +var 𗮶; +var 𗮷; +var 𗮸; +var 𗮹; +var 𗮺; +var 𗮻; +var 𗮼; +var 𗮽; +var 𗮾; +var 𗮿; +var 𗯀; +var 𗯁; +var 𗯂; +var 𗯃; +var 𗯄; +var 𗯅; +var 𗯆; +var 𗯇; +var 𗯈; +var 𗯉; +var 𗯊; +var 𗯋; +var 𗯌; +var 𗯍; +var 𗯎; +var 𗯏; +var 𗯐; +var 𗯑; +var 𗯒; +var 𗯓; +var 𗯔; +var 𗯕; +var 𗯖; +var 𗯗; +var 𗯘; +var 𗯙; +var 𗯚; +var 𗯛; +var 𗯜; +var 𗯝; +var 𗯞; +var 𗯟; +var 𗯠; +var 𗯡; +var 𗯢; +var 𗯣; +var 𗯤; +var 𗯥; +var 𗯦; +var 𗯧; +var 𗯨; +var 𗯩; +var 𗯪; +var 𗯫; +var 𗯬; +var 𗯭; +var 𗯮; +var 𗯯; +var 𗯰; +var 𗯱; +var 𗯲; +var 𗯳; +var 𗯴; +var 𗯵; +var 𗯶; +var 𗯷; +var 𗯸; +var 𗯹; +var 𗯺; +var 𗯻; +var 𗯼; +var 𗯽; +var 𗯾; +var 𗯿; +var 𗰀; +var 𗰁; +var 𗰂; +var 𗰃; +var 𗰄; +var 𗰅; +var 𗰆; +var 𗰇; +var 𗰈; +var 𗰉; +var 𗰊; +var 𗰋; +var 𗰌; +var 𗰍; +var 𗰎; +var 𗰏; +var 𗰐; +var 𗰑; +var 𗰒; +var 𗰓; +var 𗰔; +var 𗰕; +var 𗰖; +var 𗰗; +var 𗰘; +var 𗰙; +var 𗰚; +var 𗰛; +var 𗰜; +var 𗰝; +var 𗰞; +var 𗰟; +var 𗰠; +var 𗰡; +var 𗰢; +var 𗰣; +var 𗰤; +var 𗰥; +var 𗰦; +var 𗰧; +var 𗰨; +var 𗰩; +var 𗰪; +var 𗰫; +var 𗰬; +var 𗰭; +var 𗰮; +var 𗰯; +var 𗰰; +var 𗰱; +var 𗰲; +var 𗰳; +var 𗰴; +var 𗰵; +var 𗰶; +var 𗰷; +var 𗰸; +var 𗰹; +var 𗰺; +var 𗰻; +var 𗰼; +var 𗰽; +var 𗰾; +var 𗰿; +var 𗱀; +var 𗱁; +var 𗱂; +var 𗱃; +var 𗱄; +var 𗱅; +var 𗱆; +var 𗱇; +var 𗱈; +var 𗱉; +var 𗱊; +var 𗱋; +var 𗱌; +var 𗱍; +var 𗱎; +var 𗱏; +var 𗱐; +var 𗱑; +var 𗱒; +var 𗱓; +var 𗱔; +var 𗱕; +var 𗱖; +var 𗱗; +var 𗱘; +var 𗱙; +var 𗱚; +var 𗱛; +var 𗱜; +var 𗱝; +var 𗱞; +var 𗱟; +var 𗱠; +var 𗱡; +var 𗱢; +var 𗱣; +var 𗱤; +var 𗱥; +var 𗱦; +var 𗱧; +var 𗱨; +var 𗱩; +var 𗱪; +var 𗱫; +var 𗱬; +var 𗱭; +var 𗱮; +var 𗱯; +var 𗱰; +var 𗱱; +var 𗱲; +var 𗱳; +var 𗱴; +var 𗱵; +var 𗱶; +var 𗱷; +var 𗱸; +var 𗱹; +var 𗱺; +var 𗱻; +var 𗱼; +var 𗱽; +var 𗱾; +var 𗱿; +var 𗲀; +var 𗲁; +var 𗲂; +var 𗲃; +var 𗲄; +var 𗲅; +var 𗲆; +var 𗲇; +var 𗲈; +var 𗲉; +var 𗲊; +var 𗲋; +var 𗲌; +var 𗲍; +var 𗲎; +var 𗲏; +var 𗲐; +var 𗲑; +var 𗲒; +var 𗲓; +var 𗲔; +var 𗲕; +var 𗲖; +var 𗲗; +var 𗲘; +var 𗲙; +var 𗲚; +var 𗲛; +var 𗲜; +var 𗲝; +var 𗲞; +var 𗲟; +var 𗲠; +var 𗲡; +var 𗲢; +var 𗲣; +var 𗲤; +var 𗲥; +var 𗲦; +var 𗲧; +var 𗲨; +var 𗲩; +var 𗲪; +var 𗲫; +var 𗲬; +var 𗲭; +var 𗲮; +var 𗲯; +var 𗲰; +var 𗲱; +var 𗲲; +var 𗲳; +var 𗲴; +var 𗲵; +var 𗲶; +var 𗲷; +var 𗲸; +var 𗲹; +var 𗲺; +var 𗲻; +var 𗲼; +var 𗲽; +var 𗲾; +var 𗲿; +var 𗳀; +var 𗳁; +var 𗳂; +var 𗳃; +var 𗳄; +var 𗳅; +var 𗳆; +var 𗳇; +var 𗳈; +var 𗳉; +var 𗳊; +var 𗳋; +var 𗳌; +var 𗳍; +var 𗳎; +var 𗳏; +var 𗳐; +var 𗳑; +var 𗳒; +var 𗳓; +var 𗳔; +var 𗳕; +var 𗳖; +var 𗳗; +var 𗳘; +var 𗳙; +var 𗳚; +var 𗳛; +var 𗳜; +var 𗳝; +var 𗳞; +var 𗳟; +var 𗳠; +var 𗳡; +var 𗳢; +var 𗳣; +var 𗳤; +var 𗳥; +var 𗳦; +var 𗳧; +var 𗳨; +var 𗳩; +var 𗳪; +var 𗳫; +var 𗳬; +var 𗳭; +var 𗳮; +var 𗳯; +var 𗳰; +var 𗳱; +var 𗳲; +var 𗳳; +var 𗳴; +var 𗳵; +var 𗳶; +var 𗳷; +var 𗳸; +var 𗳹; +var 𗳺; +var 𗳻; +var 𗳼; +var 𗳽; +var 𗳾; +var 𗳿; +var 𗴀; +var 𗴁; +var 𗴂; +var 𗴃; +var 𗴄; +var 𗴅; +var 𗴆; +var 𗴇; +var 𗴈; +var 𗴉; +var 𗴊; +var 𗴋; +var 𗴌; +var 𗴍; +var 𗴎; +var 𗴏; +var 𗴐; +var 𗴑; +var 𗴒; +var 𗴓; +var 𗴔; +var 𗴕; +var 𗴖; +var 𗴗; +var 𗴘; +var 𗴙; +var 𗴚; +var 𗴛; +var 𗴜; +var 𗴝; +var 𗴞; +var 𗴟; +var 𗴠; +var 𗴡; +var 𗴢; +var 𗴣; +var 𗴤; +var 𗴥; +var 𗴦; +var 𗴧; +var 𗴨; +var 𗴩; +var 𗴪; +var 𗴫; +var 𗴬; +var 𗴭; +var 𗴮; +var 𗴯; +var 𗴰; +var 𗴱; +var 𗴲; +var 𗴳; +var 𗴴; +var 𗴵; +var 𗴶; +var 𗴷; +var 𗴸; +var 𗴹; +var 𗴺; +var 𗴻; +var 𗴼; +var 𗴽; +var 𗴾; +var 𗴿; +var 𗵀; +var 𗵁; +var 𗵂; +var 𗵃; +var 𗵄; +var 𗵅; +var 𗵆; +var 𗵇; +var 𗵈; +var 𗵉; +var 𗵊; +var 𗵋; +var 𗵌; +var 𗵍; +var 𗵎; +var 𗵏; +var 𗵐; +var 𗵑; +var 𗵒; +var 𗵓; +var 𗵔; +var 𗵕; +var 𗵖; +var 𗵗; +var 𗵘; +var 𗵙; +var 𗵚; +var 𗵛; +var 𗵜; +var 𗵝; +var 𗵞; +var 𗵟; +var 𗵠; +var 𗵡; +var 𗵢; +var 𗵣; +var 𗵤; +var 𗵥; +var 𗵦; +var 𗵧; +var 𗵨; +var 𗵩; +var 𗵪; +var 𗵫; +var 𗵬; +var 𗵭; +var 𗵮; +var 𗵯; +var 𗵰; +var 𗵱; +var 𗵲; +var 𗵳; +var 𗵴; +var 𗵵; +var 𗵶; +var 𗵷; +var 𗵸; +var 𗵹; +var 𗵺; +var 𗵻; +var 𗵼; +var 𗵽; +var 𗵾; +var 𗵿; +var 𗶀; +var 𗶁; +var 𗶂; +var 𗶃; +var 𗶄; +var 𗶅; +var 𗶆; +var 𗶇; +var 𗶈; +var 𗶉; +var 𗶊; +var 𗶋; +var 𗶌; +var 𗶍; +var 𗶎; +var 𗶏; +var 𗶐; +var 𗶑; +var 𗶒; +var 𗶓; +var 𗶔; +var 𗶕; +var 𗶖; +var 𗶗; +var 𗶘; +var 𗶙; +var 𗶚; +var 𗶛; +var 𗶜; +var 𗶝; +var 𗶞; +var 𗶟; +var 𗶠; +var 𗶡; +var 𗶢; +var 𗶣; +var 𗶤; +var 𗶥; +var 𗶦; +var 𗶧; +var 𗶨; +var 𗶩; +var 𗶪; +var 𗶫; +var 𗶬; +var 𗶭; +var 𗶮; +var 𗶯; +var 𗶰; +var 𗶱; +var 𗶲; +var 𗶳; +var 𗶴; +var 𗶵; +var 𗶶; +var 𗶷; +var 𗶸; +var 𗶹; +var 𗶺; +var 𗶻; +var 𗶼; +var 𗶽; +var 𗶾; +var 𗶿; +var 𗷀; +var 𗷁; +var 𗷂; +var 𗷃; +var 𗷄; +var 𗷅; +var 𗷆; +var 𗷇; +var 𗷈; +var 𗷉; +var 𗷊; +var 𗷋; +var 𗷌; +var 𗷍; +var 𗷎; +var 𗷏; +var 𗷐; +var 𗷑; +var 𗷒; +var 𗷓; +var 𗷔; +var 𗷕; +var 𗷖; +var 𗷗; +var 𗷘; +var 𗷙; +var 𗷚; +var 𗷛; +var 𗷜; +var 𗷝; +var 𗷞; +var 𗷟; +var 𗷠; +var 𗷡; +var 𗷢; +var 𗷣; +var 𗷤; +var 𗷥; +var 𗷦; +var 𗷧; +var 𗷨; +var 𗷩; +var 𗷪; +var 𗷫; +var 𗷬; +var 𗷭; +var 𗷮; +var 𗷯; +var 𗷰; +var 𗷱; +var 𗷲; +var 𗷳; +var 𗷴; +var 𗷵; +var 𗷶; +var 𗷷; +var 𗷸; +var 𗷹; +var 𗷺; +var 𗷻; +var 𗷼; +var 𗷽; +var 𗷾; +var 𗷿; +var 𗸀; +var 𗸁; +var 𗸂; +var 𗸃; +var 𗸄; +var 𗸅; +var 𗸆; +var 𗸇; +var 𗸈; +var 𗸉; +var 𗸊; +var 𗸋; +var 𗸌; +var 𗸍; +var 𗸎; +var 𗸏; +var 𗸐; +var 𗸑; +var 𗸒; +var 𗸓; +var 𗸔; +var 𗸕; +var 𗸖; +var 𗸗; +var 𗸘; +var 𗸙; +var 𗸚; +var 𗸛; +var 𗸜; +var 𗸝; +var 𗸞; +var 𗸟; +var 𗸠; +var 𗸡; +var 𗸢; +var 𗸣; +var 𗸤; +var 𗸥; +var 𗸦; +var 𗸧; +var 𗸨; +var 𗸩; +var 𗸪; +var 𗸫; +var 𗸬; +var 𗸭; +var 𗸮; +var 𗸯; +var 𗸰; +var 𗸱; +var 𗸲; +var 𗸳; +var 𗸴; +var 𗸵; +var 𗸶; +var 𗸷; +var 𗸸; +var 𗸹; +var 𗸺; +var 𗸻; +var 𗸼; +var 𗸽; +var 𗸾; +var 𗸿; +var 𗹀; +var 𗹁; +var 𗹂; +var 𗹃; +var 𗹄; +var 𗹅; +var 𗹆; +var 𗹇; +var 𗹈; +var 𗹉; +var 𗹊; +var 𗹋; +var 𗹌; +var 𗹍; +var 𗹎; +var 𗹏; +var 𗹐; +var 𗹑; +var 𗹒; +var 𗹓; +var 𗹔; +var 𗹕; +var 𗹖; +var 𗹗; +var 𗹘; +var 𗹙; +var 𗹚; +var 𗹛; +var 𗹜; +var 𗹝; +var 𗹞; +var 𗹟; +var 𗹠; +var 𗹡; +var 𗹢; +var 𗹣; +var 𗹤; +var 𗹥; +var 𗹦; +var 𗹧; +var 𗹨; +var 𗹩; +var 𗹪; +var 𗹫; +var 𗹬; +var 𗹭; +var 𗹮; +var 𗹯; +var 𗹰; +var 𗹱; +var 𗹲; +var 𗹳; +var 𗹴; +var 𗹵; +var 𗹶; +var 𗹷; +var 𗹸; +var 𗹹; +var 𗹺; +var 𗹻; +var 𗹼; +var 𗹽; +var 𗹾; +var 𗹿; +var 𗺀; +var 𗺁; +var 𗺂; +var 𗺃; +var 𗺄; +var 𗺅; +var 𗺆; +var 𗺇; +var 𗺈; +var 𗺉; +var 𗺊; +var 𗺋; +var 𗺌; +var 𗺍; +var 𗺎; +var 𗺏; +var 𗺐; +var 𗺑; +var 𗺒; +var 𗺓; +var 𗺔; +var 𗺕; +var 𗺖; +var 𗺗; +var 𗺘; +var 𗺙; +var 𗺚; +var 𗺛; +var 𗺜; +var 𗺝; +var 𗺞; +var 𗺟; +var 𗺠; +var 𗺡; +var 𗺢; +var 𗺣; +var 𗺤; +var 𗺥; +var 𗺦; +var 𗺧; +var 𗺨; +var 𗺩; +var 𗺪; +var 𗺫; +var 𗺬; +var 𗺭; +var 𗺮; +var 𗺯; +var 𗺰; +var 𗺱; +var 𗺲; +var 𗺳; +var 𗺴; +var 𗺵; +var 𗺶; +var 𗺷; +var 𗺸; +var 𗺹; +var 𗺺; +var 𗺻; +var 𗺼; +var 𗺽; +var 𗺾; +var 𗺿; +var 𗻀; +var 𗻁; +var 𗻂; +var 𗻃; +var 𗻄; +var 𗻅; +var 𗻆; +var 𗻇; +var 𗻈; +var 𗻉; +var 𗻊; +var 𗻋; +var 𗻌; +var 𗻍; +var 𗻎; +var 𗻏; +var 𗻐; +var 𗻑; +var 𗻒; +var 𗻓; +var 𗻔; +var 𗻕; +var 𗻖; +var 𗻗; +var 𗻘; +var 𗻙; +var 𗻚; +var 𗻛; +var 𗻜; +var 𗻝; +var 𗻞; +var 𗻟; +var 𗻠; +var 𗻡; +var 𗻢; +var 𗻣; +var 𗻤; +var 𗻥; +var 𗻦; +var 𗻧; +var 𗻨; +var 𗻩; +var 𗻪; +var 𗻫; +var 𗻬; +var 𗻭; +var 𗻮; +var 𗻯; +var 𗻰; +var 𗻱; +var 𗻲; +var 𗻳; +var 𗻴; +var 𗻵; +var 𗻶; +var 𗻷; +var 𗻸; +var 𗻹; +var 𗻺; +var 𗻻; +var 𗻼; +var 𗻽; +var 𗻾; +var 𗻿; +var 𗼀; +var 𗼁; +var 𗼂; +var 𗼃; +var 𗼄; +var 𗼅; +var 𗼆; +var 𗼇; +var 𗼈; +var 𗼉; +var 𗼊; +var 𗼋; +var 𗼌; +var 𗼍; +var 𗼎; +var 𗼏; +var 𗼐; +var 𗼑; +var 𗼒; +var 𗼓; +var 𗼔; +var 𗼕; +var 𗼖; +var 𗼗; +var 𗼘; +var 𗼙; +var 𗼚; +var 𗼛; +var 𗼜; +var 𗼝; +var 𗼞; +var 𗼟; +var 𗼠; +var 𗼡; +var 𗼢; +var 𗼣; +var 𗼤; +var 𗼥; +var 𗼦; +var 𗼧; +var 𗼨; +var 𗼩; +var 𗼪; +var 𗼫; +var 𗼬; +var 𗼭; +var 𗼮; +var 𗼯; +var 𗼰; +var 𗼱; +var 𗼲; +var 𗼳; +var 𗼴; +var 𗼵; +var 𗼶; +var 𗼷; +var 𗼸; +var 𗼹; +var 𗼺; +var 𗼻; +var 𗼼; +var 𗼽; +var 𗼾; +var 𗼿; +var 𗽀; +var 𗽁; +var 𗽂; +var 𗽃; +var 𗽄; +var 𗽅; +var 𗽆; +var 𗽇; +var 𗽈; +var 𗽉; +var 𗽊; +var 𗽋; +var 𗽌; +var 𗽍; +var 𗽎; +var 𗽏; +var 𗽐; +var 𗽑; +var 𗽒; +var 𗽓; +var 𗽔; +var 𗽕; +var 𗽖; +var 𗽗; +var 𗽘; +var 𗽙; +var 𗽚; +var 𗽛; +var 𗽜; +var 𗽝; +var 𗽞; +var 𗽟; +var 𗽠; +var 𗽡; +var 𗽢; +var 𗽣; +var 𗽤; +var 𗽥; +var 𗽦; +var 𗽧; +var 𗽨; +var 𗽩; +var 𗽪; +var 𗽫; +var 𗽬; +var 𗽭; +var 𗽮; +var 𗽯; +var 𗽰; +var 𗽱; +var 𗽲; +var 𗽳; +var 𗽴; +var 𗽵; +var 𗽶; +var 𗽷; +var 𗽸; +var 𗽹; +var 𗽺; +var 𗽻; +var 𗽼; +var 𗽽; +var 𗽾; +var 𗽿; +var 𗾀; +var 𗾁; +var 𗾂; +var 𗾃; +var 𗾄; +var 𗾅; +var 𗾆; +var 𗾇; +var 𗾈; +var 𗾉; +var 𗾊; +var 𗾋; +var 𗾌; +var 𗾍; +var 𗾎; +var 𗾏; +var 𗾐; +var 𗾑; +var 𗾒; +var 𗾓; +var 𗾔; +var 𗾕; +var 𗾖; +var 𗾗; +var 𗾘; +var 𗾙; +var 𗾚; +var 𗾛; +var 𗾜; +var 𗾝; +var 𗾞; +var 𗾟; +var 𗾠; +var 𗾡; +var 𗾢; +var 𗾣; +var 𗾤; +var 𗾥; +var 𗾦; +var 𗾧; +var 𗾨; +var 𗾩; +var 𗾪; +var 𗾫; +var 𗾬; +var 𗾭; +var 𗾮; +var 𗾯; +var 𗾰; +var 𗾱; +var 𗾲; +var 𗾳; +var 𗾴; +var 𗾵; +var 𗾶; +var 𗾷; +var 𗾸; +var 𗾹; +var 𗾺; +var 𗾻; +var 𗾼; +var 𗾽; +var 𗾾; +var 𗾿; +var 𗿀; +var 𗿁; +var 𗿂; +var 𗿃; +var 𗿄; +var 𗿅; +var 𗿆; +var 𗿇; +var 𗿈; +var 𗿉; +var 𗿊; +var 𗿋; +var 𗿌; +var 𗿍; +var 𗿎; +var 𗿏; +var 𗿐; +var 𗿑; +var 𗿒; +var 𗿓; +var 𗿔; +var 𗿕; +var 𗿖; +var 𗿗; +var 𗿘; +var 𗿙; +var 𗿚; +var 𗿛; +var 𗿜; +var 𗿝; +var 𗿞; +var 𗿟; +var 𗿠; +var 𗿡; +var 𗿢; +var 𗿣; +var 𗿤; +var 𗿥; +var 𗿦; +var 𗿧; +var 𗿨; +var 𗿩; +var 𗿪; +var 𗿫; +var 𗿬; +var 𗿭; +var 𗿮; +var 𗿯; +var 𗿰; +var 𗿱; +var 𗿲; +var 𗿳; +var 𗿴; +var 𗿵; +var 𗿶; +var 𗿷; +var 𗿸; +var 𗿹; +var 𗿺; +var 𗿻; +var 𗿼; +var 𗿽; +var 𗿾; +var 𗿿; +var 𘀀; +var 𘀁; +var 𘀂; +var 𘀃; +var 𘀄; +var 𘀅; +var 𘀆; +var 𘀇; +var 𘀈; +var 𘀉; +var 𘀊; +var 𘀋; +var 𘀌; +var 𘀍; +var 𘀎; +var 𘀏; +var 𘀐; +var 𘀑; +var 𘀒; +var 𘀓; +var 𘀔; +var 𘀕; +var 𘀖; +var 𘀗; +var 𘀘; +var 𘀙; +var 𘀚; +var 𘀛; +var 𘀜; +var 𘀝; +var 𘀞; +var 𘀟; +var 𘀠; +var 𘀡; +var 𘀢; +var 𘀣; +var 𘀤; +var 𘀥; +var 𘀦; +var 𘀧; +var 𘀨; +var 𘀩; +var 𘀪; +var 𘀫; +var 𘀬; +var 𘀭; +var 𘀮; +var 𘀯; +var 𘀰; +var 𘀱; +var 𘀲; +var 𘀳; +var 𘀴; +var 𘀵; +var 𘀶; +var 𘀷; +var 𘀸; +var 𘀹; +var 𘀺; +var 𘀻; +var 𘀼; +var 𘀽; +var 𘀾; +var 𘀿; +var 𘁀; +var 𘁁; +var 𘁂; +var 𘁃; +var 𘁄; +var 𘁅; +var 𘁆; +var 𘁇; +var 𘁈; +var 𘁉; +var 𘁊; +var 𘁋; +var 𘁌; +var 𘁍; +var 𘁎; +var 𘁏; +var 𘁐; +var 𘁑; +var 𘁒; +var 𘁓; +var 𘁔; +var 𘁕; +var 𘁖; +var 𘁗; +var 𘁘; +var 𘁙; +var 𘁚; +var 𘁛; +var 𘁜; +var 𘁝; +var 𘁞; +var 𘁟; +var 𘁠; +var 𘁡; +var 𘁢; +var 𘁣; +var 𘁤; +var 𘁥; +var 𘁦; +var 𘁧; +var 𘁨; +var 𘁩; +var 𘁪; +var 𘁫; +var 𘁬; +var 𘁭; +var 𘁮; +var 𘁯; +var 𘁰; +var 𘁱; +var 𘁲; +var 𘁳; +var 𘁴; +var 𘁵; +var 𘁶; +var 𘁷; +var 𘁸; +var 𘁹; +var 𘁺; +var 𘁻; +var 𘁼; +var 𘁽; +var 𘁾; +var 𘁿; +var 𘂀; +var 𘂁; +var 𘂂; +var 𘂃; +var 𘂄; +var 𘂅; +var 𘂆; +var 𘂇; +var 𘂈; +var 𘂉; +var 𘂊; +var 𘂋; +var 𘂌; +var 𘂍; +var 𘂎; +var 𘂏; +var 𘂐; +var 𘂑; +var 𘂒; +var 𘂓; +var 𘂔; +var 𘂕; +var 𘂖; +var 𘂗; +var 𘂘; +var 𘂙; +var 𘂚; +var 𘂛; +var 𘂜; +var 𘂝; +var 𘂞; +var 𘂟; +var 𘂠; +var 𘂡; +var 𘂢; +var 𘂣; +var 𘂤; +var 𘂥; +var 𘂦; +var 𘂧; +var 𘂨; +var 𘂩; +var 𘂪; +var 𘂫; +var 𘂬; +var 𘂭; +var 𘂮; +var 𘂯; +var 𘂰; +var 𘂱; +var 𘂲; +var 𘂳; +var 𘂴; +var 𘂵; +var 𘂶; +var 𘂷; +var 𘂸; +var 𘂹; +var 𘂺; +var 𘂻; +var 𘂼; +var 𘂽; +var 𘂾; +var 𘂿; +var 𘃀; +var 𘃁; +var 𘃂; +var 𘃃; +var 𘃄; +var 𘃅; +var 𘃆; +var 𘃇; +var 𘃈; +var 𘃉; +var 𘃊; +var 𘃋; +var 𘃌; +var 𘃍; +var 𘃎; +var 𘃏; +var 𘃐; +var 𘃑; +var 𘃒; +var 𘃓; +var 𘃔; +var 𘃕; +var 𘃖; +var 𘃗; +var 𘃘; +var 𘃙; +var 𘃚; +var 𘃛; +var 𘃜; +var 𘃝; +var 𘃞; +var 𘃟; +var 𘃠; +var 𘃡; +var 𘃢; +var 𘃣; +var 𘃤; +var 𘃥; +var 𘃦; +var 𘃧; +var 𘃨; +var 𘃩; +var 𘃪; +var 𘃫; +var 𘃬; +var 𘃭; +var 𘃮; +var 𘃯; +var 𘃰; +var 𘃱; +var 𘃲; +var 𘃳; +var 𘃴; +var 𘃵; +var 𘃶; +var 𘃷; +var 𘃸; +var 𘃹; +var 𘃺; +var 𘃻; +var 𘃼; +var 𘃽; +var 𘃾; +var 𘃿; +var 𘄀; +var 𘄁; +var 𘄂; +var 𘄃; +var 𘄄; +var 𘄅; +var 𘄆; +var 𘄇; +var 𘄈; +var 𘄉; +var 𘄊; +var 𘄋; +var 𘄌; +var 𘄍; +var 𘄎; +var 𘄏; +var 𘄐; +var 𘄑; +var 𘄒; +var 𘄓; +var 𘄔; +var 𘄕; +var 𘄖; +var 𘄗; +var 𘄘; +var 𘄙; +var 𘄚; +var 𘄛; +var 𘄜; +var 𘄝; +var 𘄞; +var 𘄟; +var 𘄠; +var 𘄡; +var 𘄢; +var 𘄣; +var 𘄤; +var 𘄥; +var 𘄦; +var 𘄧; +var 𘄨; +var 𘄩; +var 𘄪; +var 𘄫; +var 𘄬; +var 𘄭; +var 𘄮; +var 𘄯; +var 𘄰; +var 𘄱; +var 𘄲; +var 𘄳; +var 𘄴; +var 𘄵; +var 𘄶; +var 𘄷; +var 𘄸; +var 𘄹; +var 𘄺; +var 𘄻; +var 𘄼; +var 𘄽; +var 𘄾; +var 𘄿; +var 𘅀; +var 𘅁; +var 𘅂; +var 𘅃; +var 𘅄; +var 𘅅; +var 𘅆; +var 𘅇; +var 𘅈; +var 𘅉; +var 𘅊; +var 𘅋; +var 𘅌; +var 𘅍; +var 𘅎; +var 𘅏; +var 𘅐; +var 𘅑; +var 𘅒; +var 𘅓; +var 𘅔; +var 𘅕; +var 𘅖; +var 𘅗; +var 𘅘; +var 𘅙; +var 𘅚; +var 𘅛; +var 𘅜; +var 𘅝; +var 𘅞; +var 𘅟; +var 𘅠; +var 𘅡; +var 𘅢; +var 𘅣; +var 𘅤; +var 𘅥; +var 𘅦; +var 𘅧; +var 𘅨; +var 𘅩; +var 𘅪; +var 𘅫; +var 𘅬; +var 𘅭; +var 𘅮; +var 𘅯; +var 𘅰; +var 𘅱; +var 𘅲; +var 𘅳; +var 𘅴; +var 𘅵; +var 𘅶; +var 𘅷; +var 𘅸; +var 𘅹; +var 𘅺; +var 𘅻; +var 𘅼; +var 𘅽; +var 𘅾; +var 𘅿; +var 𘆀; +var 𘆁; +var 𘆂; +var 𘆃; +var 𘆄; +var 𘆅; +var 𘆆; +var 𘆇; +var 𘆈; +var 𘆉; +var 𘆊; +var 𘆋; +var 𘆌; +var 𘆍; +var 𘆎; +var 𘆏; +var 𘆐; +var 𘆑; +var 𘆒; +var 𘆓; +var 𘆔; +var 𘆕; +var 𘆖; +var 𘆗; +var 𘆘; +var 𘆙; +var 𘆚; +var 𘆛; +var 𘆜; +var 𘆝; +var 𘆞; +var 𘆟; +var 𘆠; +var 𘆡; +var 𘆢; +var 𘆣; +var 𘆤; +var 𘆥; +var 𘆦; +var 𘆧; +var 𘆨; +var 𘆩; +var 𘆪; +var 𘆫; +var 𘆬; +var 𘆭; +var 𘆮; +var 𘆯; +var 𘆰; +var 𘆱; +var 𘆲; +var 𘆳; +var 𘆴; +var 𘆵; +var 𘆶; +var 𘆷; +var 𘆸; +var 𘆹; +var 𘆺; +var 𘆻; +var 𘆼; +var 𘆽; +var 𘆾; +var 𘆿; +var 𘇀; +var 𘇁; +var 𘇂; +var 𘇃; +var 𘇄; +var 𘇅; +var 𘇆; +var 𘇇; +var 𘇈; +var 𘇉; +var 𘇊; +var 𘇋; +var 𘇌; +var 𘇍; +var 𘇎; +var 𘇏; +var 𘇐; +var 𘇑; +var 𘇒; +var 𘇓; +var 𘇔; +var 𘇕; +var 𘇖; +var 𘇗; +var 𘇘; +var 𘇙; +var 𘇚; +var 𘇛; +var 𘇜; +var 𘇝; +var 𘇞; +var 𘇟; +var 𘇠; +var 𘇡; +var 𘇢; +var 𘇣; +var 𘇤; +var 𘇥; +var 𘇦; +var 𘇧; +var 𘇨; +var 𘇩; +var 𘇪; +var 𘇫; +var 𘇬; +var 𘇭; +var 𘇮; +var 𘇯; +var 𘇰; +var 𘇱; +var 𘇲; +var 𘇳; +var 𘇴; +var 𘇵; +var 𘇶; +var 𘇷; +var 𘇸; +var 𘇹; +var 𘇺; +var 𘇻; +var 𘇼; +var 𘇽; +var 𘇾; +var 𘇿; +var 𘈀; +var 𘈁; +var 𘈂; +var 𘈃; +var 𘈄; +var 𘈅; +var 𘈆; +var 𘈇; +var 𘈈; +var 𘈉; +var 𘈊; +var 𘈋; +var 𘈌; +var 𘈍; +var 𘈎; +var 𘈏; +var 𘈐; +var 𘈑; +var 𘈒; +var 𘈓; +var 𘈔; +var 𘈕; +var 𘈖; +var 𘈗; +var 𘈘; +var 𘈙; +var 𘈚; +var 𘈛; +var 𘈜; +var 𘈝; +var 𘈞; +var 𘈟; +var 𘈠; +var 𘈡; +var 𘈢; +var 𘈣; +var 𘈤; +var 𘈥; +var 𘈦; +var 𘈧; +var 𘈨; +var 𘈩; +var 𘈪; +var 𘈫; +var 𘈬; +var 𘈭; +var 𘈮; +var 𘈯; +var 𘈰; +var 𘈱; +var 𘈲; +var 𘈳; +var 𘈴; +var 𘈵; +var 𘈶; +var 𘈷; +var 𘈸; +var 𘈹; +var 𘈺; +var 𘈻; +var 𘈼; +var 𘈽; +var 𘈾; +var 𘈿; +var 𘉀; +var 𘉁; +var 𘉂; +var 𘉃; +var 𘉄; +var 𘉅; +var 𘉆; +var 𘉇; +var 𘉈; +var 𘉉; +var 𘉊; +var 𘉋; +var 𘉌; +var 𘉍; +var 𘉎; +var 𘉏; +var 𘉐; +var 𘉑; +var 𘉒; +var 𘉓; +var 𘉔; +var 𘉕; +var 𘉖; +var 𘉗; +var 𘉘; +var 𘉙; +var 𘉚; +var 𘉛; +var 𘉜; +var 𘉝; +var 𘉞; +var 𘉟; +var 𘉠; +var 𘉡; +var 𘉢; +var 𘉣; +var 𘉤; +var 𘉥; +var 𘉦; +var 𘉧; +var 𘉨; +var 𘉩; +var 𘉪; +var 𘉫; +var 𘉬; +var 𘉭; +var 𘉮; +var 𘉯; +var 𘉰; +var 𘉱; +var 𘉲; +var 𘉳; +var 𘉴; +var 𘉵; +var 𘉶; +var 𘉷; +var 𘉸; +var 𘉹; +var 𘉺; +var 𘉻; +var 𘉼; +var 𘉽; +var 𘉾; +var 𘉿; +var 𘊀; +var 𘊁; +var 𘊂; +var 𘊃; +var 𘊄; +var 𘊅; +var 𘊆; +var 𘊇; +var 𘊈; +var 𘊉; +var 𘊊; +var 𘊋; +var 𘊌; +var 𘊍; +var 𘊎; +var 𘊏; +var 𘊐; +var 𘊑; +var 𘊒; +var 𘊓; +var 𘊔; +var 𘊕; +var 𘊖; +var 𘊗; +var 𘊘; +var 𘊙; +var 𘊚; +var 𘊛; +var 𘊜; +var 𘊝; +var 𘊞; +var 𘊟; +var 𘊠; +var 𘊡; +var 𘊢; +var 𘊣; +var 𘊤; +var 𘊥; +var 𘊦; +var 𘊧; +var 𘊨; +var 𘊩; +var 𘊪; +var 𘊫; +var 𘊬; +var 𘊭; +var 𘊮; +var 𘊯; +var 𘊰; +var 𘊱; +var 𘊲; +var 𘊳; +var 𘊴; +var 𘊵; +var 𘊶; +var 𘊷; +var 𘊸; +var 𘊹; +var 𘊺; +var 𘊻; +var 𘊼; +var 𘊽; +var 𘊾; +var 𘊿; +var 𘋀; +var 𘋁; +var 𘋂; +var 𘋃; +var 𘋄; +var 𘋅; +var 𘋆; +var 𘋇; +var 𘋈; +var 𘋉; +var 𘋊; +var 𘋋; +var 𘋌; +var 𘋍; +var 𘋎; +var 𘋏; +var 𘋐; +var 𘋑; +var 𘋒; +var 𘋓; +var 𘋔; +var 𘋕; +var 𘋖; +var 𘋗; +var 𘋘; +var 𘋙; +var 𘋚; +var 𘋛; +var 𘋜; +var 𘋝; +var 𘋞; +var 𘋟; +var 𘋠; +var 𘋡; +var 𘋢; +var 𘋣; +var 𘋤; +var 𘋥; +var 𘋦; +var 𘋧; +var 𘋨; +var 𘋩; +var 𘋪; +var 𘋫; +var 𘋬; +var 𘋭; +var 𘋮; +var 𘋯; +var 𘋰; +var 𘋱; +var 𘋲; +var 𘋳; +var 𘋴; +var 𘋵; +var 𘋶; +var 𘋷; +var 𘋸; +var 𘋹; +var 𘋺; +var 𘋻; +var 𘋼; +var 𘋽; +var 𘋾; +var 𘋿; +var 𘌀; +var 𘌁; +var 𘌂; +var 𘌃; +var 𘌄; +var 𘌅; +var 𘌆; +var 𘌇; +var 𘌈; +var 𘌉; +var 𘌊; +var 𘌋; +var 𘌌; +var 𘌍; +var 𘌎; +var 𘌏; +var 𘌐; +var 𘌑; +var 𘌒; +var 𘌓; +var 𘌔; +var 𘌕; +var 𘌖; +var 𘌗; +var 𘌘; +var 𘌙; +var 𘌚; +var 𘌛; +var 𘌜; +var 𘌝; +var 𘌞; +var 𘌟; +var 𘌠; +var 𘌡; +var 𘌢; +var 𘌣; +var 𘌤; +var 𘌥; +var 𘌦; +var 𘌧; +var 𘌨; +var 𘌩; +var 𘌪; +var 𘌫; +var 𘌬; +var 𘌭; +var 𘌮; +var 𘌯; +var 𘌰; +var 𘌱; +var 𘌲; +var 𘌳; +var 𘌴; +var 𘌵; +var 𘌶; +var 𘌷; +var 𘌸; +var 𘌹; +var 𘌺; +var 𘌻; +var 𘌼; +var 𘌽; +var 𘌾; +var 𘌿; +var 𘍀; +var 𘍁; +var 𘍂; +var 𘍃; +var 𘍄; +var 𘍅; +var 𘍆; +var 𘍇; +var 𘍈; +var 𘍉; +var 𘍊; +var 𘍋; +var 𘍌; +var 𘍍; +var 𘍎; +var 𘍏; +var 𘍐; +var 𘍑; +var 𘍒; +var 𘍓; +var 𘍔; +var 𘍕; +var 𘍖; +var 𘍗; +var 𘍘; +var 𘍙; +var 𘍚; +var 𘍛; +var 𘍜; +var 𘍝; +var 𘍞; +var 𘍟; +var 𘍠; +var 𘍡; +var 𘍢; +var 𘍣; +var 𘍤; +var 𘍥; +var 𘍦; +var 𘍧; +var 𘍨; +var 𘍩; +var 𘍪; +var 𘍫; +var 𘍬; +var 𘍭; +var 𘍮; +var 𘍯; +var 𘍰; +var 𘍱; +var 𘍲; +var 𘍳; +var 𘍴; +var 𘍵; +var 𘍶; +var 𘍷; +var 𘍸; +var 𘍹; +var 𘍺; +var 𘍻; +var 𘍼; +var 𘍽; +var 𘍾; +var 𘍿; +var 𘎀; +var 𘎁; +var 𘎂; +var 𘎃; +var 𘎄; +var 𘎅; +var 𘎆; +var 𘎇; +var 𘎈; +var 𘎉; +var 𘎊; +var 𘎋; +var 𘎌; +var 𘎍; +var 𘎎; +var 𘎏; +var 𘎐; +var 𘎑; +var 𘎒; +var 𘎓; +var 𘎔; +var 𘎕; +var 𘎖; +var 𘎗; +var 𘎘; +var 𘎙; +var 𘎚; +var 𘎛; +var 𘎜; +var 𘎝; +var 𘎞; +var 𘎟; +var 𘎠; +var 𘎡; +var 𘎢; +var 𘎣; +var 𘎤; +var 𘎥; +var 𘎦; +var 𘎧; +var 𘎨; +var 𘎩; +var 𘎪; +var 𘎫; +var 𘎬; +var 𘎭; +var 𘎮; +var 𘎯; +var 𘎰; +var 𘎱; +var 𘎲; +var 𘎳; +var 𘎴; +var 𘎵; +var 𘎶; +var 𘎷; +var 𘎸; +var 𘎹; +var 𘎺; +var 𘎻; +var 𘎼; +var 𘎽; +var 𘎾; +var 𘎿; +var 𘏀; +var 𘏁; +var 𘏂; +var 𘏃; +var 𘏄; +var 𘏅; +var 𘏆; +var 𘏇; +var 𘏈; +var 𘏉; +var 𘏊; +var 𘏋; +var 𘏌; +var 𘏍; +var 𘏎; +var 𘏏; +var 𘏐; +var 𘏑; +var 𘏒; +var 𘏓; +var 𘏔; +var 𘏕; +var 𘏖; +var 𘏗; +var 𘏘; +var 𘏙; +var 𘏚; +var 𘏛; +var 𘏜; +var 𘏝; +var 𘏞; +var 𘏟; +var 𘏠; +var 𘏡; +var 𘏢; +var 𘏣; +var 𘏤; +var 𘏥; +var 𘏦; +var 𘏧; +var 𘏨; +var 𘏩; +var 𘏪; +var 𘏫; +var 𘏬; +var 𘏭; +var 𘏮; +var 𘏯; +var 𘏰; +var 𘏱; +var 𘏲; +var 𘏳; +var 𘏴; +var 𘏵; +var 𘏶; +var 𘏷; +var 𘏸; +var 𘏹; +var 𘏺; +var 𘏻; +var 𘏼; +var 𘏽; +var 𘏾; +var 𘏿; +var 𘐀; +var 𘐁; +var 𘐂; +var 𘐃; +var 𘐄; +var 𘐅; +var 𘐆; +var 𘐇; +var 𘐈; +var 𘐉; +var 𘐊; +var 𘐋; +var 𘐌; +var 𘐍; +var 𘐎; +var 𘐏; +var 𘐐; +var 𘐑; +var 𘐒; +var 𘐓; +var 𘐔; +var 𘐕; +var 𘐖; +var 𘐗; +var 𘐘; +var 𘐙; +var 𘐚; +var 𘐛; +var 𘐜; +var 𘐝; +var 𘐞; +var 𘐟; +var 𘐠; +var 𘐡; +var 𘐢; +var 𘐣; +var 𘐤; +var 𘐥; +var 𘐦; +var 𘐧; +var 𘐨; +var 𘐩; +var 𘐪; +var 𘐫; +var 𘐬; +var 𘐭; +var 𘐮; +var 𘐯; +var 𘐰; +var 𘐱; +var 𘐲; +var 𘐳; +var 𘐴; +var 𘐵; +var 𘐶; +var 𘐷; +var 𘐸; +var 𘐹; +var 𘐺; +var 𘐻; +var 𘐼; +var 𘐽; +var 𘐾; +var 𘐿; +var 𘑀; +var 𘑁; +var 𘑂; +var 𘑃; +var 𘑄; +var 𘑅; +var 𘑆; +var 𘑇; +var 𘑈; +var 𘑉; +var 𘑊; +var 𘑋; +var 𘑌; +var 𘑍; +var 𘑎; +var 𘑏; +var 𘑐; +var 𘑑; +var 𘑒; +var 𘑓; +var 𘑔; +var 𘑕; +var 𘑖; +var 𘑗; +var 𘑘; +var 𘑙; +var 𘑚; +var 𘑛; +var 𘑜; +var 𘑝; +var 𘑞; +var 𘑟; +var 𘑠; +var 𘑡; +var 𘑢; +var 𘑣; +var 𘑤; +var 𘑥; +var 𘑦; +var 𘑧; +var 𘑨; +var 𘑩; +var 𘑪; +var 𘑫; +var 𘑬; +var 𘑭; +var 𘑮; +var 𘑯; +var 𘑰; +var 𘑱; +var 𘑲; +var 𘑳; +var 𘑴; +var 𘑵; +var 𘑶; +var 𘑷; +var 𘑸; +var 𘑹; +var 𘑺; +var 𘑻; +var 𘑼; +var 𘑽; +var 𘑾; +var 𘑿; +var 𘒀; +var 𘒁; +var 𘒂; +var 𘒃; +var 𘒄; +var 𘒅; +var 𘒆; +var 𘒇; +var 𘒈; +var 𘒉; +var 𘒊; +var 𘒋; +var 𘒌; +var 𘒍; +var 𘒎; +var 𘒏; +var 𘒐; +var 𘒑; +var 𘒒; +var 𘒓; +var 𘒔; +var 𘒕; +var 𘒖; +var 𘒗; +var 𘒘; +var 𘒙; +var 𘒚; +var 𘒛; +var 𘒜; +var 𘒝; +var 𘒞; +var 𘒟; +var 𘒠; +var 𘒡; +var 𘒢; +var 𘒣; +var 𘒤; +var 𘒥; +var 𘒦; +var 𘒧; +var 𘒨; +var 𘒩; +var 𘒪; +var 𘒫; +var 𘒬; +var 𘒭; +var 𘒮; +var 𘒯; +var 𘒰; +var 𘒱; +var 𘒲; +var 𘒳; +var 𘒴; +var 𘒵; +var 𘒶; +var 𘒷; +var 𘒸; +var 𘒹; +var 𘒺; +var 𘒻; +var 𘒼; +var 𘒽; +var 𘒾; +var 𘒿; +var 𘓀; +var 𘓁; +var 𘓂; +var 𘓃; +var 𘓄; +var 𘓅; +var 𘓆; +var 𘓇; +var 𘓈; +var 𘓉; +var 𘓊; +var 𘓋; +var 𘓌; +var 𘓍; +var 𘓎; +var 𘓏; +var 𘓐; +var 𘓑; +var 𘓒; +var 𘓓; +var 𘓔; +var 𘓕; +var 𘓖; +var 𘓗; +var 𘓘; +var 𘓙; +var 𘓚; +var 𘓛; +var 𘓜; +var 𘓝; +var 𘓞; +var 𘓟; +var 𘓠; +var 𘓡; +var 𘓢; +var 𘓣; +var 𘓤; +var 𘓥; +var 𘓦; +var 𘓧; +var 𘓨; +var 𘓩; +var 𘓪; +var 𘓫; +var 𘓬; +var 𘓭; +var 𘓮; +var 𘓯; +var 𘓰; +var 𘓱; +var 𘓲; +var 𘓳; +var 𘓴; +var 𘓵; +var 𘓶; +var 𘓷; +var 𘓸; +var 𘓹; +var 𘓺; +var 𘓻; +var 𘓼; +var 𘓽; +var 𘓾; +var 𘓿; +var 𘔀; +var 𘔁; +var 𘔂; +var 𘔃; +var 𘔄; +var 𘔅; +var 𘔆; +var 𘔇; +var 𘔈; +var 𘔉; +var 𘔊; +var 𘔋; +var 𘔌; +var 𘔍; +var 𘔎; +var 𘔏; +var 𘔐; +var 𘔑; +var 𘔒; +var 𘔓; +var 𘔔; +var 𘔕; +var 𘔖; +var 𘔗; +var 𘔘; +var 𘔙; +var 𘔚; +var 𘔛; +var 𘔜; +var 𘔝; +var 𘔞; +var 𘔟; +var 𘔠; +var 𘔡; +var 𘔢; +var 𘔣; +var 𘔤; +var 𘔥; +var 𘔦; +var 𘔧; +var 𘔨; +var 𘔩; +var 𘔪; +var 𘔫; +var 𘔬; +var 𘔭; +var 𘔮; +var 𘔯; +var 𘔰; +var 𘔱; +var 𘔲; +var 𘔳; +var 𘔴; +var 𘔵; +var 𘔶; +var 𘔷; +var 𘔸; +var 𘔹; +var 𘔺; +var 𘔻; +var 𘔼; +var 𘔽; +var 𘔾; +var 𘔿; +var 𘕀; +var 𘕁; +var 𘕂; +var 𘕃; +var 𘕄; +var 𘕅; +var 𘕆; +var 𘕇; +var 𘕈; +var 𘕉; +var 𘕊; +var 𘕋; +var 𘕌; +var 𘕍; +var 𘕎; +var 𘕏; +var 𘕐; +var 𘕑; +var 𘕒; +var 𘕓; +var 𘕔; +var 𘕕; +var 𘕖; +var 𘕗; +var 𘕘; +var 𘕙; +var 𘕚; +var 𘕛; +var 𘕜; +var 𘕝; +var 𘕞; +var 𘕟; +var 𘕠; +var 𘕡; +var 𘕢; +var 𘕣; +var 𘕤; +var 𘕥; +var 𘕦; +var 𘕧; +var 𘕨; +var 𘕩; +var 𘕪; +var 𘕫; +var 𘕬; +var 𘕭; +var 𘕮; +var 𘕯; +var 𘕰; +var 𘕱; +var 𘕲; +var 𘕳; +var 𘕴; +var 𘕵; +var 𘕶; +var 𘕷; +var 𘕸; +var 𘕹; +var 𘕺; +var 𘕻; +var 𘕼; +var 𘕽; +var 𘕾; +var 𘕿; +var 𘖀; +var 𘖁; +var 𘖂; +var 𘖃; +var 𘖄; +var 𘖅; +var 𘖆; +var 𘖇; +var 𘖈; +var 𘖉; +var 𘖊; +var 𘖋; +var 𘖌; +var 𘖍; +var 𘖎; +var 𘖏; +var 𘖐; +var 𘖑; +var 𘖒; +var 𘖓; +var 𘖔; +var 𘖕; +var 𘖖; +var 𘖗; +var 𘖘; +var 𘖙; +var 𘖚; +var 𘖛; +var 𘖜; +var 𘖝; +var 𘖞; +var 𘖟; +var 𘖠; +var 𘖡; +var 𘖢; +var 𘖣; +var 𘖤; +var 𘖥; +var 𘖦; +var 𘖧; +var 𘖨; +var 𘖩; +var 𘖪; +var 𘖫; +var 𘖬; +var 𘖭; +var 𘖮; +var 𘖯; +var 𘖰; +var 𘖱; +var 𘖲; +var 𘖳; +var 𘖴; +var 𘖵; +var 𘖶; +var 𘖷; +var 𘖸; +var 𘖹; +var 𘖺; +var 𘖻; +var 𘖼; +var 𘖽; +var 𘖾; +var 𘖿; +var 𘗀; +var 𘗁; +var 𘗂; +var 𘗃; +var 𘗄; +var 𘗅; +var 𘗆; +var 𘗇; +var 𘗈; +var 𘗉; +var 𘗊; +var 𘗋; +var 𘗌; +var 𘗍; +var 𘗎; +var 𘗏; +var 𘗐; +var 𘗑; +var 𘗒; +var 𘗓; +var 𘗔; +var 𘗕; +var 𘗖; +var 𘗗; +var 𘗘; +var 𘗙; +var 𘗚; +var 𘗛; +var 𘗜; +var 𘗝; +var 𘗞; +var 𘗟; +var 𘗠; +var 𘗡; +var 𘗢; +var 𘗣; +var 𘗤; +var 𘗥; +var 𘗦; +var 𘗧; +var 𘗨; +var 𘗩; +var 𘗪; +var 𘗫; +var 𘗬; +var 𘗭; +var 𘗮; +var 𘗯; +var 𘗰; +var 𘗱; +var 𘗲; +var 𘗳; +var 𘗴; +var 𘗵; +var 𘗶; +var 𘗷; +var 𘗸; +var 𘗹; +var 𘗺; +var 𘗻; +var 𘗼; +var 𘗽; +var 𘗾; +var 𘗿; +var 𘘀; +var 𘘁; +var 𘘂; +var 𘘃; +var 𘘄; +var 𘘅; +var 𘘆; +var 𘘇; +var 𘘈; +var 𘘉; +var 𘘊; +var 𘘋; +var 𘘌; +var 𘘍; +var 𘘎; +var 𘘏; +var 𘘐; +var 𘘑; +var 𘘒; +var 𘘓; +var 𘘔; +var 𘘕; +var 𘘖; +var 𘘗; +var 𘘘; +var 𘘙; +var 𘘚; +var 𘘛; +var 𘘜; +var 𘘝; +var 𘘞; +var 𘘟; +var 𘘠; +var 𘘡; +var 𘘢; +var 𘘣; +var 𘘤; +var 𘘥; +var 𘘦; +var 𘘧; +var 𘘨; +var 𘘩; +var 𘘪; +var 𘘫; +var 𘘬; +var 𘘭; +var 𘘮; +var 𘘯; +var 𘘰; +var 𘘱; +var 𘘲; +var 𘘳; +var 𘘴; +var 𘘵; +var 𘘶; +var 𘘷; +var 𘘸; +var 𘘹; +var 𘘺; +var 𘘻; +var 𘘼; +var 𘘽; +var 𘘾; +var 𘘿; +var 𘙀; +var 𘙁; +var 𘙂; +var 𘙃; +var 𘙄; +var 𘙅; +var 𘙆; +var 𘙇; +var 𘙈; +var 𘙉; +var 𘙊; +var 𘙋; +var 𘙌; +var 𘙍; +var 𘙎; +var 𘙏; +var 𘙐; +var 𘙑; +var 𘙒; +var 𘙓; +var 𘙔; +var 𘙕; +var 𘙖; +var 𘙗; +var 𘙘; +var 𘙙; +var 𘙚; +var 𘙛; +var 𘙜; +var 𘙝; +var 𘙞; +var 𘙟; +var 𘙠; +var 𘙡; +var 𘙢; +var 𘙣; +var 𘙤; +var 𘙥; +var 𘙦; +var 𘙧; +var 𘙨; +var 𘙩; +var 𘙪; +var 𘙫; +var 𘙬; +var 𘙭; +var 𘙮; +var 𘙯; +var 𘙰; +var 𘙱; +var 𘙲; +var 𘙳; +var 𘙴; +var 𘙵; +var 𘙶; +var 𘙷; +var 𘙸; +var 𘙹; +var 𘙺; +var 𘙻; +var 𘙼; +var 𘙽; +var 𘙾; +var 𘙿; +var 𘚀; +var 𘚁; +var 𘚂; +var 𘚃; +var 𘚄; +var 𘚅; +var 𘚆; +var 𘚇; +var 𘚈; +var 𘚉; +var 𘚊; +var 𘚋; +var 𘚌; +var 𘚍; +var 𘚎; +var 𘚏; +var 𘚐; +var 𘚑; +var 𘚒; +var 𘚓; +var 𘚔; +var 𘚕; +var 𘚖; +var 𘚗; +var 𘚘; +var 𘚙; +var 𘚚; +var 𘚛; +var 𘚜; +var 𘚝; +var 𘚞; +var 𘚟; +var 𘚠; +var 𘚡; +var 𘚢; +var 𘚣; +var 𘚤; +var 𘚥; +var 𘚦; +var 𘚧; +var 𘚨; +var 𘚩; +var 𘚪; +var 𘚫; +var 𘚬; +var 𘚭; +var 𘚮; +var 𘚯; +var 𘚰; +var 𘚱; +var 𘚲; +var 𘚳; +var 𘚴; +var 𘚵; +var 𘚶; +var 𘚷; +var 𘚸; +var 𘚹; +var 𘚺; +var 𘚻; +var 𘚼; +var 𘚽; +var 𘚾; +var 𘚿; +var 𘛀; +var 𘛁; +var 𘛂; +var 𘛃; +var 𘛄; +var 𘛅; +var 𘛆; +var 𘛇; +var 𘛈; +var 𘛉; +var 𘛊; +var 𘛋; +var 𘛌; +var 𘛍; +var 𘛎; +var 𘛏; +var 𘛐; +var 𘛑; +var 𘛒; +var 𘛓; +var 𘛔; +var 𘛕; +var 𘛖; +var 𘛗; +var 𘛘; +var 𘛙; +var 𘛚; +var 𘛛; +var 𘛜; +var 𘛝; +var 𘛞; +var 𘛟; +var 𘛠; +var 𘛡; +var 𘛢; +var 𘛣; +var 𘛤; +var 𘛥; +var 𘛦; +var 𘛧; +var 𘛨; +var 𘛩; +var 𘛪; +var 𘛫; +var 𘛬; +var 𘛭; +var 𘛮; +var 𘛯; +var 𘛰; +var 𘛱; +var 𘛲; +var 𘛳; +var 𘛴; +var 𘛵; +var 𘛶; +var 𘛷; +var 𘛸; +var 𘛹; +var 𘛺; +var 𘛻; +var 𘛼; +var 𘛽; +var 𘛾; +var 𘛿; +var 𘜀; +var 𘜁; +var 𘜂; +var 𘜃; +var 𘜄; +var 𘜅; +var 𘜆; +var 𘜇; +var 𘜈; +var 𘜉; +var 𘜊; +var 𘜋; +var 𘜌; +var 𘜍; +var 𘜎; +var 𘜏; +var 𘜐; +var 𘜑; +var 𘜒; +var 𘜓; +var 𘜔; +var 𘜕; +var 𘜖; +var 𘜗; +var 𘜘; +var 𘜙; +var 𘜚; +var 𘜛; +var 𘜜; +var 𘜝; +var 𘜞; +var 𘜟; +var 𘜠; +var 𘜡; +var 𘜢; +var 𘜣; +var 𘜤; +var 𘜥; +var 𘜦; +var 𘜧; +var 𘜨; +var 𘜩; +var 𘜪; +var 𘜫; +var 𘜬; +var 𘜭; +var 𘜮; +var 𘜯; +var 𘜰; +var 𘜱; +var 𘜲; +var 𘜳; +var 𘜴; +var 𘜵; +var 𘜶; +var 𘜷; +var 𘜸; +var 𘜹; +var 𘜺; +var 𘜻; +var 𘜼; +var 𘜽; +var 𘜾; +var 𘜿; +var 𘝀; +var 𘝁; +var 𘝂; +var 𘝃; +var 𘝄; +var 𘝅; +var 𘝆; +var 𘝇; +var 𘝈; +var 𘝉; +var 𘝊; +var 𘝋; +var 𘝌; +var 𘝍; +var 𘝎; +var 𘝏; +var 𘝐; +var 𘝑; +var 𘝒; +var 𘝓; +var 𘝔; +var 𘝕; +var 𘝖; +var 𘝗; +var 𘝘; +var 𘝙; +var 𘝚; +var 𘝛; +var 𘝜; +var 𘝝; +var 𘝞; +var 𘝟; +var 𘝠; +var 𘝡; +var 𘝢; +var 𘝣; +var 𘝤; +var 𘝥; +var 𘝦; +var 𘝧; +var 𘝨; +var 𘝩; +var 𘝪; +var 𘝫; +var 𘝬; +var 𘝭; +var 𘝮; +var 𘝯; +var 𘝰; +var 𘝱; +var 𘝲; +var 𘝳; +var 𘝴; +var 𘝵; +var 𘝶; +var 𘝷; +var 𘝸; +var 𘝹; +var 𘝺; +var 𘝻; +var 𘝼; +var 𘝽; +var 𘝾; +var 𘝿; +var 𘞀; +var 𘞁; +var 𘞂; +var 𘞃; +var 𘞄; +var 𘞅; +var 𘞆; +var 𘞇; +var 𘞈; +var 𘞉; +var 𘞊; +var 𘞋; +var 𘞌; +var 𘞍; +var 𘞎; +var 𘞏; +var 𘞐; +var 𘞑; +var 𘞒; +var 𘞓; +var 𘞔; +var 𘞕; +var 𘞖; +var 𘞗; +var 𘞘; +var 𘞙; +var 𘞚; +var 𘞛; +var 𘞜; +var 𘞝; +var 𘞞; +var 𘞟; +var 𘞠; +var 𘞡; +var 𘞢; +var 𘞣; +var 𘞤; +var 𘞥; +var 𘞦; +var 𘞧; +var 𘞨; +var 𘞩; +var 𘞪; +var 𘞫; +var 𘞬; +var 𘞭; +var 𘞮; +var 𘞯; +var 𘞰; +var 𘞱; +var 𘞲; +var 𘞳; +var 𘞴; +var 𘞵; +var 𘞶; +var 𘞷; +var 𘞸; +var 𘞹; +var 𘞺; +var 𘞻; +var 𘞼; +var 𘞽; +var 𘞾; +var 𘞿; +var 𘟀; +var 𘟁; +var 𘟂; +var 𘟃; +var 𘟄; +var 𘟅; +var 𘟆; +var 𘟇; +var 𘟈; +var 𘟉; +var 𘟊; +var 𘟋; +var 𘟌; +var 𘟍; +var 𘟎; +var 𘟏; +var 𘟐; +var 𘟑; +var 𘟒; +var 𘟓; +var 𘟔; +var 𘟕; +var 𘟖; +var 𘟗; +var 𘟘; +var 𘟙; +var 𘟚; +var 𘟛; +var 𘟜; +var 𘟝; +var 𘟞; +var 𘟟; +var 𘟠; +var 𘟡; +var 𘟢; +var 𘟣; +var 𘟤; +var 𘟥; +var 𘟦; +var 𘟧; +var 𘟨; +var 𘟩; +var 𘟪; +var 𘟫; +var 𘟬; +var 𘠀; +var 𘠁; +var 𘠂; +var 𘠃; +var 𘠄; +var 𘠅; +var 𘠆; +var 𘠇; +var 𘠈; +var 𘠉; +var 𘠊; +var 𘠋; +var 𘠌; +var 𘠍; +var 𘠎; +var 𘠏; +var 𘠐; +var 𘠑; +var 𘠒; +var 𘠓; +var 𘠔; +var 𘠕; +var 𘠖; +var 𘠗; +var 𘠘; +var 𘠙; +var 𘠚; +var 𘠛; +var 𘠜; +var 𘠝; +var 𘠞; +var 𘠟; +var 𘠠; +var 𘠡; +var 𘠢; +var 𘠣; +var 𘠤; +var 𘠥; +var 𘠦; +var 𘠧; +var 𘠨; +var 𘠩; +var 𘠪; +var 𘠫; +var 𘠬; +var 𘠭; +var 𘠮; +var 𘠯; +var 𘠰; +var 𘠱; +var 𘠲; +var 𘠳; +var 𘠴; +var 𘠵; +var 𘠶; +var 𘠷; +var 𘠸; +var 𘠹; +var 𘠺; +var 𘠻; +var 𘠼; +var 𘠽; +var 𘠾; +var 𘠿; +var 𘡀; +var 𘡁; +var 𘡂; +var 𘡃; +var 𘡄; +var 𘡅; +var 𘡆; +var 𘡇; +var 𘡈; +var 𘡉; +var 𘡊; +var 𘡋; +var 𘡌; +var 𘡍; +var 𘡎; +var 𘡏; +var 𘡐; +var 𘡑; +var 𘡒; +var 𘡓; +var 𘡔; +var 𘡕; +var 𘡖; +var 𘡗; +var 𘡘; +var 𘡙; +var 𘡚; +var 𘡛; +var 𘡜; +var 𘡝; +var 𘡞; +var 𘡟; +var 𘡠; +var 𘡡; +var 𘡢; +var 𘡣; +var 𘡤; +var 𘡥; +var 𘡦; +var 𘡧; +var 𘡨; +var 𘡩; +var 𘡪; +var 𘡫; +var 𘡬; +var 𘡭; +var 𘡮; +var 𘡯; +var 𘡰; +var 𘡱; +var 𘡲; +var 𘡳; +var 𘡴; +var 𘡵; +var 𘡶; +var 𘡷; +var 𘡸; +var 𘡹; +var 𘡺; +var 𘡻; +var 𘡼; +var 𘡽; +var 𘡾; +var 𘡿; +var 𘢀; +var 𘢁; +var 𘢂; +var 𘢃; +var 𘢄; +var 𘢅; +var 𘢆; +var 𘢇; +var 𘢈; +var 𘢉; +var 𘢊; +var 𘢋; +var 𘢌; +var 𘢍; +var 𘢎; +var 𘢏; +var 𘢐; +var 𘢑; +var 𘢒; +var 𘢓; +var 𘢔; +var 𘢕; +var 𘢖; +var 𘢗; +var 𘢘; +var 𘢙; +var 𘢚; +var 𘢛; +var 𘢜; +var 𘢝; +var 𘢞; +var 𘢟; +var 𘢠; +var 𘢡; +var 𘢢; +var 𘢣; +var 𘢤; +var 𘢥; +var 𘢦; +var 𘢧; +var 𘢨; +var 𘢩; +var 𘢪; +var 𘢫; +var 𘢬; +var 𘢭; +var 𘢮; +var 𘢯; +var 𘢰; +var 𘢱; +var 𘢲; +var 𘢳; +var 𘢴; +var 𘢵; +var 𘢶; +var 𘢷; +var 𘢸; +var 𘢹; +var 𘢺; +var 𘢻; +var 𘢼; +var 𘢽; +var 𘢾; +var 𘢿; +var 𘣀; +var 𘣁; +var 𘣂; +var 𘣃; +var 𘣄; +var 𘣅; +var 𘣆; +var 𘣇; +var 𘣈; +var 𘣉; +var 𘣊; +var 𘣋; +var 𘣌; +var 𘣍; +var 𘣎; +var 𘣏; +var 𘣐; +var 𘣑; +var 𘣒; +var 𘣓; +var 𘣔; +var 𘣕; +var 𘣖; +var 𘣗; +var 𘣘; +var 𘣙; +var 𘣚; +var 𘣛; +var 𘣜; +var 𘣝; +var 𘣞; +var 𘣟; +var 𘣠; +var 𘣡; +var 𘣢; +var 𘣣; +var 𘣤; +var 𘣥; +var 𘣦; +var 𘣧; +var 𘣨; +var 𘣩; +var 𘣪; +var 𘣫; +var 𘣬; +var 𘣭; +var 𘣮; +var 𘣯; +var 𘣰; +var 𘣱; +var 𘣲; +var 𘣳; +var 𘣴; +var 𘣵; +var 𘣶; +var 𘣷; +var 𘣸; +var 𘣹; +var 𘣺; +var 𘣻; +var 𘣼; +var 𘣽; +var 𘣾; +var 𘣿; +var 𘤀; +var 𘤁; +var 𘤂; +var 𘤃; +var 𘤄; +var 𘤅; +var 𘤆; +var 𘤇; +var 𘤈; +var 𘤉; +var 𘤊; +var 𘤋; +var 𘤌; +var 𘤍; +var 𘤎; +var 𘤏; +var 𘤐; +var 𘤑; +var 𘤒; +var 𘤓; +var 𘤔; +var 𘤕; +var 𘤖; +var 𘤗; +var 𘤘; +var 𘤙; +var 𘤚; +var 𘤛; +var 𘤜; +var 𘤝; +var 𘤞; +var 𘤟; +var 𘤠; +var 𘤡; +var 𘤢; +var 𘤣; +var 𘤤; +var 𘤥; +var 𘤦; +var 𘤧; +var 𘤨; +var 𘤩; +var 𘤪; +var 𘤫; +var 𘤬; +var 𘤭; +var 𘤮; +var 𘤯; +var 𘤰; +var 𘤱; +var 𘤲; +var 𘤳; +var 𘤴; +var 𘤵; +var 𘤶; +var 𘤷; +var 𘤸; +var 𘤹; +var 𘤺; +var 𘤻; +var 𘤼; +var 𘤽; +var 𘤾; +var 𘤿; +var 𘥀; +var 𘥁; +var 𘥂; +var 𘥃; +var 𘥄; +var 𘥅; +var 𘥆; +var 𘥇; +var 𘥈; +var 𘥉; +var 𘥊; +var 𘥋; +var 𘥌; +var 𘥍; +var 𘥎; +var 𘥏; +var 𘥐; +var 𘥑; +var 𘥒; +var 𘥓; +var 𘥔; +var 𘥕; +var 𘥖; +var 𘥗; +var 𘥘; +var 𘥙; +var 𘥚; +var 𘥛; +var 𘥜; +var 𘥝; +var 𘥞; +var 𘥟; +var 𘥠; +var 𘥡; +var 𘥢; +var 𘥣; +var 𘥤; +var 𘥥; +var 𘥦; +var 𘥧; +var 𘥨; +var 𘥩; +var 𘥪; +var 𘥫; +var 𘥬; +var 𘥭; +var 𘥮; +var 𘥯; +var 𘥰; +var 𘥱; +var 𘥲; +var 𘥳; +var 𘥴; +var 𘥵; +var 𘥶; +var 𘥷; +var 𘥸; +var 𘥹; +var 𘥺; +var 𘥻; +var 𘥼; +var 𘥽; +var 𘥾; +var 𘥿; +var 𘦀; +var 𘦁; +var 𘦂; +var 𘦃; +var 𘦄; +var 𘦅; +var 𘦆; +var 𘦇; +var 𘦈; +var 𘦉; +var 𘦊; +var 𘦋; +var 𘦌; +var 𘦍; +var 𘦎; +var 𘦏; +var 𘦐; +var 𘦑; +var 𘦒; +var 𘦓; +var 𘦔; +var 𘦕; +var 𘦖; +var 𘦗; +var 𘦘; +var 𘦙; +var 𘦚; +var 𘦛; +var 𘦜; +var 𘦝; +var 𘦞; +var 𘦟; +var 𘦠; +var 𘦡; +var 𘦢; +var 𘦣; +var 𘦤; +var 𘦥; +var 𘦦; +var 𘦧; +var 𘦨; +var 𘦩; +var 𘦪; +var 𘦫; +var 𘦬; +var 𘦭; +var 𘦮; +var 𘦯; +var 𘦰; +var 𘦱; +var 𘦲; +var 𘦳; +var 𘦴; +var 𘦵; +var 𘦶; +var 𘦷; +var 𘦸; +var 𘦹; +var 𘦺; +var 𘦻; +var 𘦼; +var 𘦽; +var 𘦾; +var 𘦿; +var 𘧀; +var 𘧁; +var 𘧂; +var 𘧃; +var 𘧄; +var 𘧅; +var 𘧆; +var 𘧇; +var 𘧈; +var 𘧉; +var 𘧊; +var 𘧋; +var 𘧌; +var 𘧍; +var 𘧎; +var 𘧏; +var 𘧐; +var 𘧑; +var 𘧒; +var 𘧓; +var 𘧔; +var 𘧕; +var 𘧖; +var 𘧗; +var 𘧘; +var 𘧙; +var 𘧚; +var 𘧛; +var 𘧜; +var 𘧝; +var 𘧞; +var 𘧟; +var 𘧠; +var 𘧡; +var 𘧢; +var 𘧣; +var 𘧤; +var 𘧥; +var 𘧦; +var 𘧧; +var 𘧨; +var 𘧩; +var 𘧪; +var 𘧫; +var 𘧬; +var 𘧭; +var 𘧮; +var 𘧯; +var 𘧰; +var 𘧱; +var 𘧲; +var 𘧳; +var 𘧴; +var 𘧵; +var 𘧶; +var 𘧷; +var 𘧸; +var 𘧹; +var 𘧺; +var 𘧻; +var 𘧼; +var 𘧽; +var 𘧾; +var 𘧿; +var 𘨀; +var 𘨁; +var 𘨂; +var 𘨃; +var 𘨄; +var 𘨅; +var 𘨆; +var 𘨇; +var 𘨈; +var 𘨉; +var 𘨊; +var 𘨋; +var 𘨌; +var 𘨍; +var 𘨎; +var 𘨏; +var 𘨐; +var 𘨑; +var 𘨒; +var 𘨓; +var 𘨔; +var 𘨕; +var 𘨖; +var 𘨗; +var 𘨘; +var 𘨙; +var 𘨚; +var 𘨛; +var 𘨜; +var 𘨝; +var 𘨞; +var 𘨟; +var 𘨠; +var 𘨡; +var 𘨢; +var 𘨣; +var 𘨤; +var 𘨥; +var 𘨦; +var 𘨧; +var 𘨨; +var 𘨩; +var 𘨪; +var 𘨫; +var 𘨬; +var 𘨭; +var 𘨮; +var 𘨯; +var 𘨰; +var 𘨱; +var 𘨲; +var 𘨳; +var 𘨴; +var 𘨵; +var 𘨶; +var 𘨷; +var 𘨸; +var 𘨹; +var 𘨺; +var 𘨻; +var 𘨼; +var 𘨽; +var 𘨾; +var 𘨿; +var 𘩀; +var 𘩁; +var 𘩂; +var 𘩃; +var 𘩄; +var 𘩅; +var 𘩆; +var 𘩇; +var 𘩈; +var 𘩉; +var 𘩊; +var 𘩋; +var 𘩌; +var 𘩍; +var 𘩎; +var 𘩏; +var 𘩐; +var 𘩑; +var 𘩒; +var 𘩓; +var 𘩔; +var 𘩕; +var 𘩖; +var 𘩗; +var 𘩘; +var 𘩙; +var 𘩚; +var 𘩛; +var 𘩜; +var 𘩝; +var 𘩞; +var 𘩟; +var 𘩠; +var 𘩡; +var 𘩢; +var 𘩣; +var 𘩤; +var 𘩥; +var 𘩦; +var 𘩧; +var 𘩨; +var 𘩩; +var 𘩪; +var 𘩫; +var 𘩬; +var 𘩭; +var 𘩮; +var 𘩯; +var 𘩰; +var 𘩱; +var 𘩲; +var 𘩳; +var 𘩴; +var 𘩵; +var 𘩶; +var 𘩷; +var 𘩸; +var 𘩹; +var 𘩺; +var 𘩻; +var 𘩼; +var 𘩽; +var 𘩾; +var 𘩿; +var 𘪀; +var 𘪁; +var 𘪂; +var 𘪃; +var 𘪄; +var 𘪅; +var 𘪆; +var 𘪇; +var 𘪈; +var 𘪉; +var 𘪊; +var 𘪋; +var 𘪌; +var 𘪍; +var 𘪎; +var 𘪏; +var 𘪐; +var 𘪑; +var 𘪒; +var 𘪓; +var 𘪔; +var 𘪕; +var 𘪖; +var 𘪗; +var 𘪘; +var 𘪙; +var 𘪚; +var 𘪛; +var 𘪜; +var 𘪝; +var 𘪞; +var 𘪟; +var 𘪠; +var 𘪡; +var 𘪢; +var 𘪣; +var 𘪤; +var 𘪥; +var 𘪦; +var 𘪧; +var 𘪨; +var 𘪩; +var 𘪪; +var 𘪫; +var 𘪬; +var 𘪭; +var 𘪮; +var 𘪯; +var 𘪰; +var 𘪱; +var 𘪲; +var 𘪳; +var 𘪴; +var 𘪵; +var 𘪶; +var 𘪷; +var 𘪸; +var 𘪹; +var 𘪺; +var 𘪻; +var 𘪼; +var 𘪽; +var 𘪾; +var 𘪿; +var 𘫀; +var 𘫁; +var 𘫂; +var 𘫃; +var 𘫄; +var 𘫅; +var 𘫆; +var 𘫇; +var 𘫈; +var 𘫉; +var 𘫊; +var 𘫋; +var 𘫌; +var 𘫍; +var 𘫎; +var 𘫏; +var 𘫐; +var 𘫑; +var 𘫒; +var 𘫓; +var 𘫔; +var 𘫕; +var 𘫖; +var 𘫗; +var 𘫘; +var 𘫙; +var 𘫚; +var 𘫛; +var 𘫜; +var 𘫝; +var 𘫞; +var 𘫟; +var 𘫠; +var 𘫡; +var 𘫢; +var 𘫣; +var 𘫤; +var 𘫥; +var 𘫦; +var 𘫧; +var 𘫨; +var 𘫩; +var 𘫪; +var 𘫫; +var 𘫬; +var 𘫭; +var 𘫮; +var 𘫯; +var 𘫰; +var 𘫱; +var 𘫲; +var 𞤀; +var 𞤁; +var 𞤂; +var 𞤃; +var 𞤄; +var 𞤅; +var 𞤆; +var 𞤇; +var 𞤈; +var 𞤉; +var 𞤊; +var 𞤋; +var 𞤌; +var 𞤍; +var 𞤎; +var 𞤏; +var 𞤐; +var 𞤑; +var 𞤒; +var 𞤓; +var 𞤔; +var 𞤕; +var 𞤖; +var 𞤗; +var 𞤘; +var 𞤙; +var 𞤚; +var 𞤛; +var 𞤜; +var 𞤝; +var 𞤞; +var 𞤟; +var 𞤠; +var 𞤡; +var 𞤢; +var 𞤣; +var 𞤤; +var 𞤥; +var 𞤦; +var 𞤧; +var 𞤨; +var 𞤩; +var 𞤪; +var 𞤫; +var 𞤬; +var 𞤭; +var 𞤮; +var 𞤯; +var 𞤰; +var 𞤱; +var 𞤲; +var 𞤳; +var 𞤴; +var 𞤵; +var 𞤶; +var 𞤷; +var 𞤸; +var 𞤹; +var 𞤺; +var 𞤻; +var 𞤼; +var 𞤽; +var 𞤾; +var 𞤿; +var 𞥀; +var 𞥁; +var 𞥂; +var 𞥃; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-ltr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-ltr.js new file mode 100644 index 000000000..af7651c8c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-unicode-ltr.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierPart :: IdentifierStart" +es5id: 7.6_A2.1_T1 +description: "IdentifierStart :: UnicodeLetter" +---*/ + +var x = 1; +assert.sameValue(x, 1); + +var xx = 2; +assert.sameValue(xx, 2); + +var x$ = 3; +assert.sameValue(x$, 3); + +var x_ = 4; +assert.sameValue(x_, 4); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-zwj-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-zwj-escaped.js new file mode 100644 index 000000000..a677eddcf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-zwj-escaped.js @@ -0,0 +1,15 @@ +// Copyright (C) 2020 Adam Kluball. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Adam Kluball +esid: sec-names-and-keywords +description: zero width joiner is not a valid identifier start +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u200D; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-zwnj-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-zwnj-escaped.js new file mode 100644 index 000000000..ae8c92089 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/start-zwnj-escaped.js @@ -0,0 +1,15 @@ +// Copyright (C) 2020 Adam Kluball. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Adam Kluball +esid: sec-names-and-keywords +description: zero width non-joiner is not a valid identifier start +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u200C; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/unicode-escape-nls-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/unicode-escape-nls-err.js new file mode 100644 index 000000000..599553517 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/unicode-escape-nls-err.js @@ -0,0 +1,48 @@ +// Copyright (C) 2014 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: prod-Identifier +description: NumericLiteralSeperator disallowed in unicode CodePoint escape sequence +info: | + Identifier: + IdentifierName but not ReservedWord + + IdentifierName :: + IdentifierStart + IdentifierNameIdentifierPart + + IdentifierStart :: + UnicodeIDStart + $ + _ + \UnicodeEscapeSequence + + IdentifierPart :: + UnicodeIDContinue + $ + \UnicodeEscapeSequence + + UnicodeEscapeSequence :: + uHex4Digits + u{CodePoint} + + CodePoint :: + HexDigit but only if MV of HexDigits ≤ 0x10FFFF + CodePointDigits but only if MV of HexDigits ≤ 0x10FFFF + + CodePointDigits :: + HexDigit + CodePointDigitsHexDigit + + HexDigit :: one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{00_76} = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-break-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-break-via-escape-hex.js new file mode 100644 index 000000000..cbcc1e2fc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-break-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: break +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{62}\u{72}\u{65}\u{61}\u{6b} = 123;; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-break-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-break-via-escape-hex4.js new file mode 100644 index 000000000..dc912f000 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-break-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-4 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: break (break) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0062\u0072\u0065\u0061\u006b = 123;; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-break.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-break.js new file mode 100644 index 000000000..63245c571 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-break.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var break = 123;; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-case-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-case-via-escape-hex.js new file mode 100644 index 000000000..a64dc36d2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-case-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: case +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{63}ase = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-case-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-case-via-escape-hex4.js new file mode 100644 index 000000000..af1305028 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-case-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-5 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: case (case) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0063ase = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-case.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-case.js new file mode 100644 index 000000000..e33501f3e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-case.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var case = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-catch-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-catch-via-escape-hex.js new file mode 100644 index 000000000..1feabad24 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-catch-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: catch +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{63}atch = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-catch-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-catch-via-escape-hex4.js new file mode 100644 index 000000000..c6d5a8e70 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-catch-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-13 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: catch (catch) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0063atch = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-catch.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-catch.js new file mode 100644 index 000000000..da3290b5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-catch.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var catch = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-class-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-class-via-escape-hex.js new file mode 100644 index 000000000..ad9c9fbcf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-class-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: class +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var cla\u{73}s = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-class-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-class-via-escape-hex4.js new file mode 100644 index 000000000..b9a86fe0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-class-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-30 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: class (class) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var cla\u0073s = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-class.js new file mode 100644 index 000000000..523e45e9d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-class.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var class = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-const-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-const-via-escape-hex.js new file mode 100644 index 000000000..16a81b93e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-const-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: const +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var co\u{6e}st = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-const-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-const-via-escape-hex4.js new file mode 100644 index 000000000..9dc1fefcb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-const-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-34 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: const (const) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var co\u006est = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-const.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-const.js new file mode 100644 index 000000000..1026f6347 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-const.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var const = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-continue-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-continue-via-escape-hex.js new file mode 100644 index 000000000..3c6b60a37 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-continue-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: continue +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{63}ontinue = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-continue-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-continue-via-escape-hex4.js new file mode 100644 index 000000000..d39c1d756 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-continue-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-17 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: continue (continue) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0063ontinue = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-continue.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-continue.js new file mode 100644 index 000000000..99e97f00c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-continue.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var continue = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-debugger-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-debugger-via-escape-hex.js new file mode 100644 index 000000000..572946203 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-debugger-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: debugger +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{64}ebugger = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-debugger-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-debugger-via-escape-hex4.js new file mode 100644 index 000000000..b1e7b1038 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-debugger-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-21 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: debugger (debugger) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0064ebugger = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-debugger.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-debugger.js new file mode 100644 index 000000000..887ff1156 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-debugger.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var debugger = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-default-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-default-via-escape-hex.js new file mode 100644 index 000000000..e3f51cb73 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-default-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: default +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var def\u{61}ult = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-default-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-default-via-escape-hex4.js new file mode 100644 index 000000000..e55e7613c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-default-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-26 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: default (default) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var def\u0061ult = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-default.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-default.js new file mode 100644 index 000000000..0362c98e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-default.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var default = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-delete-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-delete-via-escape-hex.js new file mode 100644 index 000000000..6aee51962 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-delete-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: delete +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{64}elete = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-delete-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-delete-via-escape-hex4.js new file mode 100644 index 000000000..3a0ec4aac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-delete-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-29 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: delete (delete) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0064elete = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-delete.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-delete.js new file mode 100644 index 000000000..ea6d6e8a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-delete.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var delete = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-do-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-do-via-escape-hex.js new file mode 100644 index 000000000..57737dd3a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-do-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: do +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{64}\u{6f} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-do-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-do-via-escape-hex4.js new file mode 100644 index 000000000..5dda96dae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-do-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-8 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: do (do) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0064\u006f = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-do.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-do.js new file mode 100644 index 000000000..5e39924aa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-do.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var do = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-dollar-sign-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-dollar-sign-via-escape-hex.js new file mode 100644 index 000000000..08d4c67fa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-dollar-sign-via-escape-hex.js @@ -0,0 +1,12 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierStart :: $" +es6id: 11.6 +description: The $ as unicode character \u{24} +---*/ + +var \u{24} = 1; + +assert.sameValue($, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-dollar-sign-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-dollar-sign-via-escape-hex4.js new file mode 100644 index 000000000..4e3e701d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-dollar-sign-via-escape-hex4.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierStart :: $" +es5id: 7.6_A1.2_T2 +description: The $ as unicode character \u0024 +---*/ + +var \u0024 = 1; + +assert.sameValue($, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-dollar-sign.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-dollar-sign.js new file mode 100644 index 000000000..979525829 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-dollar-sign.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierStart :: $" +es5id: 7.6_A1.2_T1 +description: Create variable $ +---*/ + +//CHECK#1 +var $ = 1; + +assert.sameValue($, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-else-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-else-via-escape-hex.js new file mode 100644 index 000000000..15aa60b3d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-else-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: else (else) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{65}lse = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-else-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-else-via-escape-hex4.js new file mode 100644 index 000000000..242d3f40d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-else-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-9 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: else (else) (null) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0065lse = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-else.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-else.js new file mode 100644 index 000000000..85bb6cf95 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-else.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var else = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-enum-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-enum-via-escape-hex.js new file mode 100644 index 000000000..8e5b69d96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-enum-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: enum +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{65}\u{6e}\u{75}\u{6d} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-enum-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-enum-via-escape-hex4.js new file mode 100644 index 000000000..6b0fe1c79 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-enum-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-32 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: enum (enum) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0065\u006e\u0075\u006d = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-enum.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-enum.js new file mode 100644 index 000000000..6021eebaf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-enum.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var enum = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-export-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-export-via-escape-hex.js new file mode 100644 index 000000000..6df8f9a00 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-export-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: export +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var expor\u{74} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-export-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-export-via-escape-hex4.js new file mode 100644 index 000000000..a7e65aff3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-export-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-35 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: export (export) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var expor\u0074 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-export.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-export.js new file mode 100644 index 000000000..7353bc17c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-export.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var export = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-extends-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-extends-via-escape-hex.js new file mode 100644 index 000000000..0eebd7a78 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-extends-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: extends +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var extend\u{73} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-extends-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-extends-via-escape-hex4.js new file mode 100644 index 000000000..ec2902f72 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-extends-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-31 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: extends (extends) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var extend\u0073 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-extends.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-extends.js new file mode 100644 index 000000000..f90534e94 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-extends.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var extends = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-false-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-false-via-escape-hex.js new file mode 100644 index 000000000..1072b5f32 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-false-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: false +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var fals\u{65} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-false-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-false-via-escape-hex4.js new file mode 100644 index 000000000..5689a2aa6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-false-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-3 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: false (false) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var fals\u0065 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-false.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-false.js new file mode 100644 index 000000000..5ac71043b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-false.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var false = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-finally-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-finally-via-escape-hex.js new file mode 100644 index 000000000..71cf88f51 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-finally-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: finally +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var fina\u{6c}ly = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-finally-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-finally-via-escape-hex4.js new file mode 100644 index 000000000..6601e830e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-finally-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-14 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: finally (finally) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var fina\u006cly = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-finally.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-finally.js new file mode 100644 index 000000000..789804f5d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-finally.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var finally = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-for-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-for-via-escape-hex.js new file mode 100644 index 000000000..2c29a6ab0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-for-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: for +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var f\u{6f}r = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-for-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-for-via-escape-hex4.js new file mode 100644 index 000000000..b7bc7093c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-for-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-18 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: for (for) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var f\u006fr = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-for.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-for.js new file mode 100644 index 000000000..1f2ff856b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-for.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var for = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-function-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-function-via-escape-hex.js new file mode 100644 index 000000000..250a5fd48 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-function-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: function +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var func\u{74}ion = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-function-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-function-via-escape-hex4.js new file mode 100644 index 000000000..710c6340f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-function-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-22 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: function (function) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var func\u0074ion = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-function.js new file mode 100644 index 000000000..471ee03d7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-function.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var function = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-if-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-if-via-escape-hex.js new file mode 100644 index 000000000..80d33f6e3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-if-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: if +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{69}\u{66} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-if-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-if-via-escape-hex4.js new file mode 100644 index 000000000..69ef0882d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-if-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-24 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: if (if) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0069\u0066 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-if.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-if.js new file mode 100644 index 000000000..2bd0e031e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-if.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var if = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-import-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-import-via-escape-hex.js new file mode 100644 index 000000000..a40c4772f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-import-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: import +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{69}\u{6d}\u{70}\u{6f}\u{72}\u{74} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-import-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-import-via-escape-hex4.js new file mode 100644 index 000000000..b18c523cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-import-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-36 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: import (import) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0069\u006d\u0070\u006f\u0072\u0074 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-import.js new file mode 100644 index 000000000..b10f54f0a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-import.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var import = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-in-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-in-via-escape-hex.js new file mode 100644 index 000000000..ed656698b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-in-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: in +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{69}\u{6e} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-in-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-in-via-escape-hex4.js new file mode 100644 index 000000000..f3b1b260b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-in-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-28 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: in (in) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0069\u006e = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-in.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-in.js new file mode 100644 index 000000000..1600a074b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-in.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var in = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-instanceof-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-instanceof-via-escape-hex.js new file mode 100644 index 000000000..4caa3fbd8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-instanceof-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: instanceof +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var insta\u{6e}ceof = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-instanceof-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-instanceof-via-escape-hex4.js new file mode 100644 index 000000000..14942260e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-instanceof-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-6 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: instanceof (instanceof) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var insta\u006eceof = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-instanceof.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-instanceof.js new file mode 100644 index 000000000..c6f5f35b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-instanceof.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var instanceof = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-new-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-new-via-escape-hex.js new file mode 100644 index 000000000..38df80753 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-new-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: new +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var n\u{65}w = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-new-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-new-via-escape-hex4.js new file mode 100644 index 000000000..e19d75bcc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-new-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-10 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: new (new) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var n\u0065w = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-new.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-new.js new file mode 100644 index 000000000..2c7a12fbe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-new.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var new = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-null-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-null-via-escape-hex.js new file mode 100644 index 000000000..7afad5d9c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-null-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: null +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{6e}ull = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-null-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-null-via-escape-hex4.js new file mode 100644 index 000000000..aab4dbff8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-null-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-1 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: null (null) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u006eull = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-null.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-null.js new file mode 100644 index 000000000..2edc6fef5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-null.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var null = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-return-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-return-via-escape-hex.js new file mode 100644 index 000000000..584d234ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-return-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: return +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var retur\u{6e} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-return-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-return-via-escape-hex4.js new file mode 100644 index 000000000..39b71e495 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-return-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-15 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: return (return) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var retur\u006e = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-return.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-return.js new file mode 100644 index 000000000..1937772c0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-return.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var return = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-super-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-super-via-escape-hex.js new file mode 100644 index 000000000..e36fa5bb4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-super-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: super +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{73}uper = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-super-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-super-via-escape-hex4.js new file mode 100644 index 000000000..57b5f61b3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-super-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-33 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: super (super) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0073uper = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-super.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-super.js new file mode 100644 index 000000000..12b0527a3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-super.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var super = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-switch-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-switch-via-escape-hex.js new file mode 100644 index 000000000..c3bf37a25 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-switch-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: switch +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var switc\u{68} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-switch-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-switch-via-escape-hex4.js new file mode 100644 index 000000000..c142b0390 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-switch-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-19 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: switch (switch) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var switc\u0068 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-switch.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-switch.js new file mode 100644 index 000000000..2d8283661 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-switch.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var switch = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-this-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-this-via-escape-hex.js new file mode 100644 index 000000000..ceea7c660 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-this-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: this +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var thi\u{73} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-this-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-this-via-escape-hex4.js new file mode 100644 index 000000000..a68c8f7e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-this-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-23 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: this (this) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var thi\u0073 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-this.js new file mode 100644 index 000000000..1f6851fcd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-this.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var this = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-throw-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-throw-via-escape-hex.js new file mode 100644 index 000000000..b039bee2b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-throw-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: throw +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var thro\u{77} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-throw-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-throw-via-escape-hex4.js new file mode 100644 index 000000000..00bab2fee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-throw-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-27 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: throw (throw) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var thro\u0077 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-throw.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-throw.js new file mode 100644 index 000000000..84cdadbe3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-throw.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var throw = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-true-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-true-via-escape-hex.js new file mode 100644 index 000000000..f85838afb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-true-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: true +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var tr\u{75}e = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-true-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-true-via-escape-hex4.js new file mode 100644 index 000000000..7908c4c02 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-true-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-2 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: true (true) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var tr\u0075e = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-true.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-true.js new file mode 100644 index 000000000..14f00afdb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-true.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var true = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-try-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-try-via-escape-hex.js new file mode 100644 index 000000000..02ae56508 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-try-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: try +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{74}\u{72}\u{79} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-try-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-try-via-escape-hex4.js new file mode 100644 index 000000000..d581fc0e0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-try-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-12 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: try (try) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0074\u0072\u0079 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-try.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-try.js new file mode 100644 index 000000000..fae1ea310 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-try.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var try = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-typeof-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-typeof-via-escape-hex.js new file mode 100644 index 000000000..a828fc202 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-typeof-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: typeof +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var typeo\u{66} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-typeof-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-typeof-via-escape-hex4.js new file mode 100644 index 000000000..6dbd86d36 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-typeof-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-7 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: typeof (typeof) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var typeo\u0066 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-typeof.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-typeof.js new file mode 100644 index 000000000..20276745d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-typeof.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var typeof = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-underscore-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-underscore-via-escape-hex.js new file mode 100644 index 000000000..62c358aeb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-underscore-via-escape-hex.js @@ -0,0 +1,12 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierStart :: _" +es6id: 11.6 +description: The _ as unicode character \u{5F} +---*/ + +var \u{5F} = 1; + +assert.sameValue(_, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-underscore-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-underscore-via-escape-hex4.js new file mode 100644 index 000000000..23dbe11c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-underscore-via-escape-hex4.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierStart :: _" +es5id: 7.6_A1.3_T2 +description: The _ as unicode character \u005F +---*/ + +var \u005F = 1; + +assert.sameValue(_, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-underscore.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-underscore.js new file mode 100644 index 000000000..19f04879f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-underscore.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "IdentifierStart :: _" +es5id: 7.6_A1.3_T1 +description: Create variable _ +---*/ + +//CHECK#1 +var _ = 1; + +assert.sameValue(_, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-var-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-var-via-escape-hex.js new file mode 100644 index 000000000..ced646a0e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-var-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: var +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var va\u{72} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-var-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-var-via-escape-hex4.js new file mode 100644 index 000000000..0044f1582 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-var-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-11 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: var (var) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var va\u0072 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-var.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-var.js new file mode 100644 index 000000000..35d87e846 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-var.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var var = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-void-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-void-via-escape-hex.js new file mode 100644 index 000000000..397fc54c3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-void-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: void +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{76}\u{6f}\u{69}\u{64} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-void-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-void-via-escape-hex4.js new file mode 100644 index 000000000..cc6e90617 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-void-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-16 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: void (void) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0076\u006f\u0069\u0064 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-void.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-void.js new file mode 100644 index 000000000..97761147d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-void.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var void = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-while-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-while-via-escape-hex.js new file mode 100644 index 000000000..08f305dc4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-while-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: while +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{77}\u{68}\u{69}\u{6c}\u{65} = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-while-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-while-via-escape-hex4.js new file mode 100644 index 000000000..084bfb135 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-while-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-20 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: while (while) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0077\u0068\u0069\u006c\u0065 = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-while.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-while.js new file mode 100644 index 000000000..632a2960b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-while.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var while = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-with-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-with-via-escape-hex.js new file mode 100644 index 000000000..eb8fe6e23 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-with-via-escape-hex.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier + Names in UTF8: with +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u{77}ith = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-with-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-with-via-escape-hex4.js new file mode 100644 index 000000000..caaed2719 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-with-via-escape-hex4.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.6-25 +description: > + 7.6 - SyntaxError expected: reserved words used as Identifier + Names in UTF8: with (with) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u0077ith = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-with.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-with.js new file mode 100644 index 000000000..514c776dc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-with.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.6 +description: > + SyntaxError expected: reserved words used as Identifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var with = 123; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-yield-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-yield-strict.js new file mode 100644 index 000000000..a4cc49667 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/val-yield-strict.js @@ -0,0 +1,17 @@ +// Copyright (C) 2013 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + `yield` is a reserved identifier in strict mode code and may not be used + as an identifier. +es6id: 12.1.1 +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var yield = 13; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-cjk-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-cjk-escaped.js new file mode 100644 index 000000000..1270cf142 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-cjk-escaped.js @@ -0,0 +1,36 @@ +// Copyright (C) 2019 Student Main. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +info: | + IdentifierName and ReservedWord are tokens that are interpreted according to the + Default Identifier Syntax given in Unicode Standard Annex #31, + Identifier and Pattern Syntax, with some small modifications. +esid: sec-names-and-keywords +description: Check CJK UNIFIED IDEOGRAPH range is correct. +---*/ + +// CJK UNIFIED IDEOGRAPH 4e00-9fff +// u4e00 +var \u4e00 = 1; +assert.sameValue(一, 1); + +// u6c5f, check parser included all CJK range not only first and last +var \u6c5f = 1; +assert.sameValue(江, 1); + +// u9fa5, last character in CJK UNIFIED IDEOGRAPH as for 2019 +var \u9fa5 = 1; +assert.sameValue(龥, 1); + +// CJK UNIFIED IDEOGRAPH EXTENDED A 3400-4dbf +// u3400 +var \u3400 = 1; +assert.sameValue(㐀, 1); + +// u362e +var \u362e = 1; +assert.sameValue(㘮, 1); + +// u4db5, last in CJK UNIFIED IDEOGRAPH EXTENDED A +var \u4db5 = 1; +assert.sameValue(䶵, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-cjk.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-cjk.js new file mode 100644 index 000000000..819d0b780 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-cjk.js @@ -0,0 +1,36 @@ +// Copyright (C) 2019 Student Main. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +info: | + IdentifierName and ReservedWord are tokens that are interpreted according to the + Default Identifier Syntax given in Unicode Standard Annex #31, + Identifier and Pattern Syntax, with some small modifications. +esid: sec-names-and-keywords +description: Check CJK UNIFIED IDEOGRAPH range is correct. +---*/ + +// CJK UNIFIED IDEOGRAPH 4e00-9fff +// u4e00 +var 一 = 1; +assert.sameValue(一, 1); + +// u6c5f, check parser included all CJK range not only first and last character +var 江 = 1; +assert.sameValue(江, 1); + +// u9fa5, last character in CJK UNIFIED IDEOGRAPH as for 2019 +var 龥 = 1; +assert.sameValue(龥, 1); + +// CJK UNIFIED IDEOGRAPH EXTENDED A 3400-4dbf +// u3400 +var 㐀 = 1; +assert.sameValue(㐀, 1); + +// u362e +var 㘮 = 1; +assert.sameValue(㘮, 1); + +// u4db5, last in CJK UNIFIED IDEOGRAPH EXTENDED A +var 䶵 = 1; +assert.sameValue(䶵, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-lower-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-lower-via-escape-hex.js new file mode 100644 index 000000000..d94f1d435 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-lower-via-escape-hex.js @@ -0,0 +1,86 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of ENGLISH ALPHABET +es6id: 11.6 +description: Check ENGLISH SMALL ALPHABET +---*/ + +var \u{61} = 1; +assert.sameValue(a, 1); + +var \u{62} = 1; +assert.sameValue(b, 1); + +var \u{63} = 1; +assert.sameValue(c, 1); + +var \u{64} = 1; +assert.sameValue(d, 1); + +var \u{65} = 1; +assert.sameValue(e, 1); + +var \u{66} = 1; +assert.sameValue(f, 1); + +var \u{67} = 1; +assert.sameValue(g, 1); + +var \u{68} = 1; +assert.sameValue(h, 1); + +var \u{69} = 1; +assert.sameValue(i, 1); + +var \u{6A} = 1; +assert.sameValue(j, 1); + +var \u{6B} = 1; +assert.sameValue(k, 1); + +var \u{6C} = 1; +assert.sameValue(l, 1); + +var \u{6D} = 1; +assert.sameValue(m, 1); + +var \u{6E} = 1; +assert.sameValue(n, 1); + +var \u{6F} = 1; +assert.sameValue(o, 1); + +var \u{70} = 1; +assert.sameValue(p, 1); + +var \u{71} = 1; +assert.sameValue(q, 1); + +var \u{72} = 1; +assert.sameValue(r, 1); + +var \u{73} = 1; +assert.sameValue(s, 1); + +var \u{74} = 1; +assert.sameValue(t, 1); + +var \u{75} = 1; +assert.sameValue(u, 1); + +var \u{76} = 1; +assert.sameValue(v, 1); + +var \u{77} = 1; +assert.sameValue(w, 1); + +var \u{78} = 1; +assert.sameValue(x, 1); + +var \u{79} = 1; +assert.sameValue(y, 1); + +var \u{7A} = 1; +assert.sameValue(z, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-lower-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-lower-via-escape-hex4.js new file mode 100644 index 000000000..62b93a8c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-lower-via-escape-hex4.js @@ -0,0 +1,86 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of ENGLISH ALPHABET +es5id: 7.6_A4.1_T2 +description: Check ENGLISH SMALL ALPHABET +---*/ + +var \u0061 = 1; +assert.sameValue(a, 1); + +var \u0062 = 1; +assert.sameValue(b, 1); + +var \u0063 = 1; +assert.sameValue(c, 1); + +var \u0064 = 1; +assert.sameValue(d, 1); + +var \u0065 = 1; +assert.sameValue(e, 1); + +var \u0066 = 1; +assert.sameValue(f, 1); + +var \u0067 = 1; +assert.sameValue(g, 1); + +var \u0068 = 1; +assert.sameValue(h, 1); + +var \u0069 = 1; +assert.sameValue(i, 1); + +var \u006A = 1; +assert.sameValue(j, 1); + +var \u006B = 1; +assert.sameValue(k, 1); + +var \u006C = 1; +assert.sameValue(l, 1); + +var \u006D = 1; +assert.sameValue(m, 1); + +var \u006E = 1; +assert.sameValue(n, 1); + +var \u006F = 1; +assert.sameValue(o, 1); + +var \u0070 = 1; +assert.sameValue(p, 1); + +var \u0071 = 1; +assert.sameValue(q, 1); + +var \u0072 = 1; +assert.sameValue(r, 1); + +var \u0073 = 1; +assert.sameValue(s, 1); + +var \u0074 = 1; +assert.sameValue(t, 1); + +var \u0075 = 1; +assert.sameValue(u, 1); + +var \u0076 = 1; +assert.sameValue(v, 1); + +var \u0077 = 1; +assert.sameValue(w, 1); + +var \u0078 = 1; +assert.sameValue(x, 1); + +var \u0079 = 1; +assert.sameValue(y, 1); + +var \u007A = 1; +assert.sameValue(z, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-lower.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-lower.js new file mode 100644 index 000000000..703e9a653 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-lower.js @@ -0,0 +1,113 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of ENGLISH ALPHABET +es6id: 11.6 +description: Check ENGLISH SMALL ALPHABET +---*/ + +var a = 1; +if (a !== 1) { + throw new Test262Error('#a'); +} +var b = 1; +if (b !== 1) { + throw new Test262Error('#b'); +} +var c = 1; +if (c !== 1) { + throw new Test262Error('#c'); +} +var d = 1; +if (d !== 1) { + throw new Test262Error('#d'); +} +var e = 1; +if (e !== 1) { + throw new Test262Error('#e'); +} +var f = 1; +if (f !== 1) { + throw new Test262Error('#f'); +} +var g = 1; +if (g !== 1) { + throw new Test262Error('#g'); +} +var h = 1; +if (h !== 1) { + throw new Test262Error('#h'); +} +var i = 1; +if (i !== 1) { + throw new Test262Error('#i'); +} +var j = 1; +if (j !== 1) { + throw new Test262Error('#j'); +} +var k = 1; +if (k !== 1) { + throw new Test262Error('#k'); +} +var l = 1; +if (l !== 1) { + throw new Test262Error('#l'); +} +var m = 1; +if (m !== 1) { + throw new Test262Error('#m'); +} +var n = 1; +if (n !== 1) { + throw new Test262Error('#n'); +} +var o = 1; +if (o !== 1) { + throw new Test262Error('#o'); +} +var p = 1; +if (p !== 1) { + throw new Test262Error('#p'); +} +var q = 1; +if (q !== 1) { + throw new Test262Error('#q'); +} +var r = 1; +if (r !== 1) { + throw new Test262Error('#r'); +} +var s = 1; +if (s !== 1) { + throw new Test262Error('#s'); +} +var t = 1; +if (t !== 1) { + throw new Test262Error('#t'); +} +var u = 1; +if (u !== 1) { + throw new Test262Error('#u'); +} +var v = 1; +if (v !== 1) { + throw new Test262Error('#v'); +} +var w = 1; +if (w !== 1) { + throw new Test262Error('#w'); +} +var x = 1; +if (x !== 1) { + throw new Test262Error('#x'); +} +var y = 1; +if (y !== 1) { + throw new Test262Error('#y'); +} +var z = 1; +if (z !== 1) { + throw new Test262Error('#z'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-upper-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-upper-via-escape-hex.js new file mode 100644 index 000000000..55ad78d16 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-upper-via-escape-hex.js @@ -0,0 +1,86 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of ENGLISH ALPHABET +es6id: 11.6 +description: Check ENGLISH CAPITAL ALPHABET +---*/ + +var \u{41} = 1; +assert.sameValue(A, 1); + +var \u{42} = 1; +assert.sameValue(B, 1); + +var \u{43} = 1; +assert.sameValue(C, 1); + +var \u{44} = 1; +assert.sameValue(D, 1); + +var \u{45} = 1; +assert.sameValue(E, 1); + +var \u{46} = 1; +assert.sameValue(F, 1); + +var \u{47} = 1; +assert.sameValue(G, 1); + +var \u{48} = 1; +assert.sameValue(H, 1); + +var \u{49} = 1; +assert.sameValue(I, 1); + +var \u{4A} = 1; +assert.sameValue(J, 1); + +var \u{4B} = 1; +assert.sameValue(K, 1); + +var \u{4C} = 1; +assert.sameValue(L, 1); + +var \u{4D} = 1; +assert.sameValue(M, 1); + +var \u{4E} = 1; +assert.sameValue(N, 1); + +var \u{4F} = 1; +assert.sameValue(O, 1); + +var \u{50} = 1; +assert.sameValue(P, 1); + +var \u{51} = 1; +assert.sameValue(Q, 1); + +var \u{52} = 1; +assert.sameValue(R, 1); + +var \u{53} = 1; +assert.sameValue(S, 1); + +var \u{54} = 1; +assert.sameValue(T, 1); + +var \u{55} = 1; +assert.sameValue(U, 1); + +var \u{56} = 1; +assert.sameValue(V, 1); + +var \u{57} = 1; +assert.sameValue(W, 1); + +var \u{58} = 1; +assert.sameValue(X, 1); + +var \u{59} = 1; +assert.sameValue(Y, 1); + +var \u{5A} = 1; +assert.sameValue(Z, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-upper-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-upper-via-escape-hex4.js new file mode 100644 index 000000000..20a55d49a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-upper-via-escape-hex4.js @@ -0,0 +1,86 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of ENGLISH ALPHABET +es5id: 7.6_A4.1_T1 +description: Check ENGLISH CAPITAL ALPHABET +---*/ + +var \u0041 = 1; +assert.sameValue(A, 1); + +var \u0042 = 1; +assert.sameValue(B, 1); + +var \u0043 = 1; +assert.sameValue(C, 1); + +var \u0044 = 1; +assert.sameValue(D, 1); + +var \u0045 = 1; +assert.sameValue(E, 1); + +var \u0046 = 1; +assert.sameValue(F, 1); + +var \u0047 = 1; +assert.sameValue(G, 1); + +var \u0048 = 1; +assert.sameValue(H, 1); + +var \u0049 = 1; +assert.sameValue(I, 1); + +var \u004A = 1; +assert.sameValue(J, 1); + +var \u004B = 1; +assert.sameValue(K, 1); + +var \u004C = 1; +assert.sameValue(L, 1); + +var \u004D = 1; +assert.sameValue(M, 1); + +var \u004E = 1; +assert.sameValue(N, 1); + +var \u004F = 1; +assert.sameValue(O, 1); + +var \u0050 = 1; +assert.sameValue(P, 1); + +var \u0051 = 1; +assert.sameValue(Q, 1); + +var \u0052 = 1; +assert.sameValue(R, 1); + +var \u0053 = 1; +assert.sameValue(S, 1); + +var \u0054 = 1; +assert.sameValue(T, 1); + +var \u0055 = 1; +assert.sameValue(U, 1); + +var \u0056 = 1; +assert.sameValue(V, 1); + +var \u0057 = 1; +assert.sameValue(W, 1); + +var \u0058 = 1; +assert.sameValue(X, 1); + +var \u0059 = 1; +assert.sameValue(Y, 1); + +var \u005A = 1; +assert.sameValue(Z, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-upper.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-upper.js new file mode 100644 index 000000000..41ae9013f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-eng-alpha-upper.js @@ -0,0 +1,86 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of ENGLISH ALPHABET +es6id: 11.6 +description: Check ENGLISH CAPITAL ALPHABET +---*/ + +var A = 1; +assert.sameValue(A, 1); + +var B = 1; +assert.sameValue(B, 1); + +var C = 1; +assert.sameValue(C, 1); + +var D = 1; +assert.sameValue(D, 1); + +var E = 1; +assert.sameValue(E, 1); + +var F = 1; +assert.sameValue(F, 1); + +var G = 1; +assert.sameValue(G, 1); + +var H = 1; +assert.sameValue(H, 1); + +var I = 1; +assert.sameValue(I, 1); + +var J = 1; +assert.sameValue(J, 1); + +var K = 1; +assert.sameValue(K, 1); + +var L = 1; +assert.sameValue(L, 1); + +var M = 1; +assert.sameValue(M, 1); + +var N = 1; +assert.sameValue(N, 1); + +var O = 1; +assert.sameValue(O, 1); + +var P = 1; +assert.sameValue(P, 1); + +var Q = 1; +assert.sameValue(Q, 1); + +var R = 1; +assert.sameValue(R, 1); + +var S = 1; +assert.sameValue(S, 1); + +var T = 1; +assert.sameValue(T, 1); + +var U = 1; +assert.sameValue(U, 1); + +var V = 1; +assert.sameValue(V, 1); + +var W = 1; +assert.sameValue(W, 1); + +var X = 1; +assert.sameValue(X, 1); + +var Y = 1; +assert.sameValue(Y, 1); + +var Z = 1; +assert.sameValue(Z, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-lower-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-lower-via-escape-hex.js new file mode 100644 index 000000000..16b1dfbdb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-lower-via-escape-hex.js @@ -0,0 +1,107 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of RUSSIAN ALPHABET +es6id: 11.6 +description: Check RUSSIAN SMALL ALPHABET +---*/ + +var \u{430} = 1; +assert.sameValue(а, 1); + +var \u{431} = 1; +assert.sameValue(б, 1); + +var \u{432} = 1; +assert.sameValue(в, 1); + +var \u{433} = 1; +assert.sameValue(г, 1); + +var \u{434} = 1; +assert.sameValue(д, 1); + +var \u{435} = 1; +assert.sameValue(е, 1); + +var \u{436} = 1; +assert.sameValue(ж, 1); + +var \u{437} = 1; +assert.sameValue(з, 1); + +var \u{438} = 1; +assert.sameValue(и, 1); + +var \u{439} = 1; +assert.sameValue(й, 1); + +var \u{43A} = 1; +assert.sameValue(к, 1); + +var \u{43B} = 1; +assert.sameValue(л, 1); + +var \u{43C} = 1; +assert.sameValue(м, 1); + +var \u{43D} = 1; +assert.sameValue(н, 1); + +var \u{43E} = 1; +assert.sameValue(о, 1); + +var \u{43F} = 1; +assert.sameValue(п, 1); + +var \u{440} = 1; +assert.sameValue(р, 1); + +var \u{441} = 1; +assert.sameValue(с, 1); + +var \u{442} = 1; +assert.sameValue(т, 1); + +var \u{443} = 1; +assert.sameValue(у, 1); + +var \u{444} = 1; +assert.sameValue(ф, 1); + +var \u{445} = 1; +assert.sameValue(х, 1); + +var \u{446} = 1; +assert.sameValue(ц, 1); + +var \u{447} = 1; +assert.sameValue(ч, 1); + +var \u{448} = 1; +assert.sameValue(ш, 1); + +var \u{449} = 1; +assert.sameValue(щ, 1); + +var \u{44A} = 1; +assert.sameValue(ъ, 1); + +var \u{44B} = 1; +assert.sameValue(ы, 1); + +var \u{44C} = 1; +assert.sameValue(ь, 1); + +var \u{44D} = 1; +assert.sameValue(э, 1); + +var \u{44E} = 1; +assert.sameValue(ю, 1); + +var \u{44F} = 1; +assert.sameValue(я, 1); + +var \u{451} = 1; +assert.sameValue(ё, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-lower-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-lower-via-escape-hex4.js new file mode 100644 index 000000000..b46c1bab1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-lower-via-escape-hex4.js @@ -0,0 +1,107 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of RUSSIAN ALPHABET +es5id: 7.6_A4.2_T2 +description: Check RUSSIAN SMALL ALPHABET +---*/ + +var \u0430 = 1; +assert.sameValue(а, 1); + +var \u0431 = 1; +assert.sameValue(б, 1); + +var \u0432 = 1; +assert.sameValue(в, 1); + +var \u0433 = 1; +assert.sameValue(г, 1); + +var \u0434 = 1; +assert.sameValue(д, 1); + +var \u0435 = 1; +assert.sameValue(е, 1); + +var \u0436 = 1; +assert.sameValue(ж, 1); + +var \u0437 = 1; +assert.sameValue(з, 1); + +var \u0438 = 1; +assert.sameValue(и, 1); + +var \u0439 = 1; +assert.sameValue(й, 1); + +var \u043A = 1; +assert.sameValue(к, 1); + +var \u043B = 1; +assert.sameValue(л, 1); + +var \u043C = 1; +assert.sameValue(м, 1); + +var \u043D = 1; +assert.sameValue(н, 1); + +var \u043E = 1; +assert.sameValue(о, 1); + +var \u043F = 1; +assert.sameValue(п, 1); + +var \u0440 = 1; +assert.sameValue(р, 1); + +var \u0441 = 1; +assert.sameValue(с, 1); + +var \u0442 = 1; +assert.sameValue(т, 1); + +var \u0443 = 1; +assert.sameValue(у, 1); + +var \u0444 = 1; +assert.sameValue(ф, 1); + +var \u0445 = 1; +assert.sameValue(х, 1); + +var \u0446 = 1; +assert.sameValue(ц, 1); + +var \u0447 = 1; +assert.sameValue(ч, 1); + +var \u0448 = 1; +assert.sameValue(ш, 1); + +var \u0449 = 1; +assert.sameValue(щ, 1); + +var \u044A = 1; +assert.sameValue(ъ, 1); + +var \u044B = 1; +assert.sameValue(ы, 1); + +var \u044C = 1; +assert.sameValue(ь, 1); + +var \u044D = 1; +assert.sameValue(э, 1); + +var \u044E = 1; +assert.sameValue(ю, 1); + +var \u044F = 1; +assert.sameValue(я, 1); + +var \u0451 = 1; +assert.sameValue(ё, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-lower.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-lower.js new file mode 100644 index 000000000..b190abeff --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-lower.js @@ -0,0 +1,107 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of RUSSIAN ALPHABET +es6id: 11.6 +description: Check RUSSIAN SMALL ALPHABET +---*/ + +var а = 1; +assert.sameValue(а, 1); + +var б = 1; +assert.sameValue(б, 1); + +var в = 1; +assert.sameValue(в, 1); + +var г = 1; +assert.sameValue(г, 1); + +var д = 1; +assert.sameValue(д, 1); + +var е = 1; +assert.sameValue(е, 1); + +var ж = 1; +assert.sameValue(ж, 1); + +var з = 1; +assert.sameValue(з, 1); + +var и = 1; +assert.sameValue(и, 1); + +var й = 1; +assert.sameValue(й, 1); + +var к = 1; +assert.sameValue(к, 1); + +var л = 1; +assert.sameValue(л, 1); + +var м = 1; +assert.sameValue(м, 1); + +var н = 1; +assert.sameValue(н, 1); + +var о = 1; +assert.sameValue(о, 1); + +var п = 1; +assert.sameValue(п, 1); + +var р = 1; +assert.sameValue(р, 1); + +var с = 1; +assert.sameValue(с, 1); + +var т = 1; +assert.sameValue(т, 1); + +var у = 1; +assert.sameValue(у, 1); + +var ф = 1; +assert.sameValue(ф, 1); + +var х = 1; +assert.sameValue(х, 1); + +var ц = 1; +assert.sameValue(ц, 1); + +var ч = 1; +assert.sameValue(ч, 1); + +var ш = 1; +assert.sameValue(ш, 1); + +var щ = 1; +assert.sameValue(щ, 1); + +var ъ = 1; +assert.sameValue(ъ, 1); + +var ы = 1; +assert.sameValue(ы, 1); + +var ь = 1; +assert.sameValue(ь, 1); + +var э = 1; +assert.sameValue(э, 1); + +var ю = 1; +assert.sameValue(ю, 1); + +var я = 1; +assert.sameValue(я, 1); + +var ё = 1; +assert.sameValue(ё, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-upper-via-escape-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-upper-via-escape-hex.js new file mode 100644 index 000000000..828334fac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-upper-via-escape-hex.js @@ -0,0 +1,107 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of RUSSIAN ALPHABET +es6id: 11.6 +description: Check RUSSIAN CAPITAL ALPHABET +---*/ + +var \u{410} = 1; +assert.sameValue(А, 1); + +var \u{411} = 1; +assert.sameValue(Б, 1); + +var \u{412} = 1; +assert.sameValue(В, 1); + +var \u{413} = 1; +assert.sameValue(Г, 1); + +var \u{414} = 1; +assert.sameValue(Д, 1); + +var \u{415} = 1; +assert.sameValue(Е, 1); + +var \u{416} = 1; +assert.sameValue(Ж, 1); + +var \u{417} = 1; +assert.sameValue(З, 1); + +var \u{418} = 1; +assert.sameValue(И, 1); + +var \u{419} = 1; +assert.sameValue(Й, 1); + +var \u{41A} = 1; +assert.sameValue(К, 1); + +var \u{41B} = 1; +assert.sameValue(Л, 1); + +var \u{41C} = 1; +assert.sameValue(М, 1); + +var \u{41D} = 1; +assert.sameValue(Н, 1); + +var \u{41E} = 1; +assert.sameValue(О, 1); + +var \u{41F} = 1; +assert.sameValue(П, 1); + +var \u{420} = 1; +assert.sameValue(Р, 1); + +var \u{421} = 1; +assert.sameValue(С, 1); + +var \u{422} = 1; +assert.sameValue(Т, 1); + +var \u{423} = 1; +assert.sameValue(У, 1); + +var \u{424} = 1; +assert.sameValue(Ф, 1); + +var \u{425} = 1; +assert.sameValue(Х, 1); + +var \u{426} = 1; +assert.sameValue(Ц, 1); + +var \u{427} = 1; +assert.sameValue(Ч, 1); + +var \u{428} = 1; +assert.sameValue(Ш, 1); + +var \u{429} = 1; +assert.sameValue(Щ, 1); + +var \u{42A} = 1; +assert.sameValue(Ъ, 1); + +var \u{42B} = 1; +assert.sameValue(Ы, 1); + +var \u{42C} = 1; +assert.sameValue(Ь, 1); + +var \u{42D} = 1; +assert.sameValue(Э, 1); + +var \u{42E} = 1; +assert.sameValue(Ю, 1); + +var \u{42F} = 1; +assert.sameValue(Я, 1); + +var \u{401} = 1; +assert.sameValue(Ё, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-upper-via-escape-hex4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-upper-via-escape-hex4.js new file mode 100644 index 000000000..f3e1645fa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-upper-via-escape-hex4.js @@ -0,0 +1,107 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of RUSSIAN ALPHABET +es5id: 7.6_A4.2_T1 +description: Check RUSSIAN CAPITAL ALPHABET +---*/ + +var \u0410 = 1; +assert.sameValue(А, 1); + +var \u0411 = 1; +assert.sameValue(Б, 1); + +var \u0412 = 1; +assert.sameValue(В, 1); + +var \u0413 = 1; +assert.sameValue(Г, 1); + +var \u0414 = 1; +assert.sameValue(Д, 1); + +var \u0415 = 1; +assert.sameValue(Е, 1); + +var \u0416 = 1; +assert.sameValue(Ж, 1); + +var \u0417 = 1; +assert.sameValue(З, 1); + +var \u0418 = 1; +assert.sameValue(И, 1); + +var \u0419 = 1; +assert.sameValue(Й, 1); + +var \u041A = 1; +assert.sameValue(К, 1); + +var \u041B = 1; +assert.sameValue(Л, 1); + +var \u041C = 1; +assert.sameValue(М, 1); + +var \u041D = 1; +assert.sameValue(Н, 1); + +var \u041E = 1; +assert.sameValue(О, 1); + +var \u041F = 1; +assert.sameValue(П, 1); + +var \u0420 = 1; +assert.sameValue(Р, 1); + +var \u0421 = 1; +assert.sameValue(С, 1); + +var \u0422 = 1; +assert.sameValue(Т, 1); + +var \u0423 = 1; +assert.sameValue(У, 1); + +var \u0424 = 1; +assert.sameValue(Ф, 1); + +var \u0425 = 1; +assert.sameValue(Х, 1); + +var \u0426 = 1; +assert.sameValue(Ц, 1); + +var \u0427 = 1; +assert.sameValue(Ч, 1); + +var \u0428 = 1; +assert.sameValue(Ш, 1); + +var \u0429 = 1; +assert.sameValue(Щ, 1); + +var \u042A = 1; +assert.sameValue(Ъ, 1); + +var \u042B = 1; +assert.sameValue(Ы, 1); + +var \u042C = 1; +assert.sameValue(Ь, 1); + +var \u042D = 1; +assert.sameValue(Э, 1); + +var \u042E = 1; +assert.sameValue(Ю, 1); + +var \u042F = 1; +assert.sameValue(Я, 1); + +var \u0401 = 1; +assert.sameValue(Ё, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-upper.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-upper.js new file mode 100644 index 000000000..0b4e5d102 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vals-rus-alpha-upper.js @@ -0,0 +1,107 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of RUSSIAN ALPHABET +es6id: 11.6 +description: Check RUSSIAN CAPITAL ALPHABET +---*/ + +var А = 1; +assert.sameValue(А, 1); + +var Б = 1; +assert.sameValue(Б, 1); + +var В = 1; +assert.sameValue(В, 1); + +var Г = 1; +assert.sameValue(Г, 1); + +var Д = 1; +assert.sameValue(Д, 1); + +var Е = 1; +assert.sameValue(Е, 1); + +var Ж = 1; +assert.sameValue(Ж, 1); + +var З = 1; +assert.sameValue(З, 1); + +var И = 1; +assert.sameValue(И, 1); + +var Й = 1; +assert.sameValue(Й, 1); + +var К = 1; +assert.sameValue(К, 1); + +var Л = 1; +assert.sameValue(Л, 1); + +var М = 1; +assert.sameValue(М, 1); + +var Н = 1; +assert.sameValue(Н, 1); + +var О = 1; +assert.sameValue(О, 1); + +var П = 1; +assert.sameValue(П, 1); + +var Р = 1; +assert.sameValue(Р, 1); + +var С = 1; +assert.sameValue(С, 1); + +var Т = 1; +assert.sameValue(Т, 1); + +var У = 1; +assert.sameValue(У, 1); + +var Ф = 1; +assert.sameValue(Ф, 1); + +var Х = 1; +assert.sameValue(Х, 1); + +var Ц = 1; +assert.sameValue(Ц, 1); + +var Ч = 1; +assert.sameValue(Ч, 1); + +var Ш = 1; +assert.sameValue(Ш, 1); + +var Щ = 1; +assert.sameValue(Щ, 1); + +var Ъ = 1; +assert.sameValue(Ъ, 1); + +var Ы = 1; +assert.sameValue(Ы, 1); + +var Ь = 1; +assert.sameValue(Ь, 1); + +var Э = 1; +assert.sameValue(Э, 1); + +var Ю = 1; +assert.sameValue(Ю, 1); + +var Я = 1; +assert.sameValue(Я, 1); + +var Ё = 1; +assert.sameValue(Ё, 1); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-continue-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-continue-escaped.js new file mode 100644 index 000000000..96ac5c3e4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-continue-escaped.js @@ -0,0 +1,16 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-names-and-keywords +description: Test VERTICAL TILDE (U+2E2F) is not recognized as ID_Continue character. +info: | + VERTICAL TILDE is in General Category 'Lm' and [:Pattern_Syntax:]. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var a\u2E2F; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-continue.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-continue.js new file mode 100644 index 000000000..96f8dcd95 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-continue.js @@ -0,0 +1,16 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-names-and-keywords +description: Test VERTICAL TILDE (U+2E2F) is not recognized as ID_Continue character. +info: | + VERTICAL TILDE is in General Category 'Lm' and [:Pattern_Syntax:]. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var aⸯ; // U+2E2F diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-start-escaped.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-start-escaped.js new file mode 100644 index 000000000..cf2ec8277 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-start-escaped.js @@ -0,0 +1,16 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-names-and-keywords +description: Test VERTICAL TILDE (U+2E2F) is not recognized as ID_Start character. +info: | + VERTICAL TILDE is in General Category 'Lm' and [:Pattern_Syntax:]. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var \u2E2F; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-start.js b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-start.js new file mode 100644 index 000000000..1b64ef6fa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/identifiers/vertical-tilde-start.js @@ -0,0 +1,16 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-names-and-keywords +description: Test VERTICAL TILDE (U+2E2F) is not recognized as ID_Start character. +info: | + VERTICAL TILDE is in General Category 'Lm' and [:Pattern_Syntax:]. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var ⸯ; // U+2E2F diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/dup-bound-names.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/dup-bound-names.js new file mode 100644 index 000000000..56f3cc2c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/dup-bound-names.js @@ -0,0 +1,16 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 15.2.1.1 +description: > + It is a Syntax Error if the BoundNames of ImportDeclaration contains any + duplicate entries. +flags: [module] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +import { x, y as x } from 'z'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/escaped-as-import-specifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/escaped-as-import-specifier.js new file mode 100644 index 000000000..92b2d1c6d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/escaped-as-import-specifier.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `as` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +export var a = 0; + +import {a \u0061s b} from "./escaped-as-import-specifier.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/escaped-as-namespace-import.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/escaped-as-namespace-import.js new file mode 100644 index 000000000..78225fc5b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/escaped-as-namespace-import.js @@ -0,0 +1,24 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `as` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +import* \u0061s self from "./escaped-as-namespace-import.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/escaped-from.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/escaped-from.js new file mode 100644 index 000000000..123702fe4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/escaped-from.js @@ -0,0 +1,24 @@ +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-grammar-notation +description: > + The `from` contextual keyword must not contain Unicode escape sequences. +info: | + Terminal symbols are shown + in fixed width font, both in the productions of the grammars and throughout this + specification whenever the text directly refers to such a terminal symbol. These + are to appear in a script exactly as written. All terminal symbol code points + specified in this way are to be understood as the appropriate Unicode code points + from the Basic Latin range, as opposed to any similar-looking code points from + other Unicode ranges. +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +import {} \u0066rom "./escaped-from.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-idempotency-indirect_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-idempotency-indirect_FIXTURE.js new file mode 100644 index 000000000..15f28b68b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-idempotency-indirect_FIXTURE.js @@ -0,0 +1,6 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +import value from './json-idempotency_FIXTURE.json' with { type: 'json' }; + +globalThis.viaSecondModule = value; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-idempotency_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-idempotency_FIXTURE.json new file mode 100644 index 000000000..0967ef424 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-idempotency_FIXTURE.json @@ -0,0 +1 @@ +{} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-invalid.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-invalid.js new file mode 100644 index 000000000..3c4256448 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-invalid.js @@ -0,0 +1,23 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-parse-json-module +description: Does not define +info: | + # 1.4 ParseJSONModule ( source ) + + The abstract operation ParseJSONModule takes a single argument source which + is a String representing the contents of a module. + + 1. Let json be ? Call(%JSON.parse%, undefined, « source »). + 2. Return CreateDefaultExportSyntheticModule(json). +flags: [module] +features: [import-attributes, json-modules] +negative: + phase: resolution + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +import value from './json-invalid_FIXTURE.json' with { type: 'json' }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-invalid_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-invalid_FIXTURE.json new file mode 100644 index 000000000..64809bccc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-invalid_FIXTURE.json @@ -0,0 +1,3 @@ +{ + notJson: 0 +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-named-bindings.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-named-bindings.js new file mode 100644 index 000000000..9d2ec8a6b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-named-bindings.js @@ -0,0 +1,20 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-parse-json-module +description: Does not define named bindings +info: | + In the early design of JSON modules, contributors considered allowing the + properties of object values in JSON modules to be imported directly by name. + This was ultimately rejected, so attempting to import in this way should + produce a SyntaxError. +flags: [module] +features: [import-attributes, json-modules] +negative: + phase: resolution + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +import {name} from './json-named-bindings_FIXTURE.json' with { type: 'json' }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-named-bindings_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-named-bindings_FIXTURE.json new file mode 100644 index 000000000..ead2bb7c6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-named-bindings_FIXTURE.json @@ -0,0 +1,3 @@ +{ + "name": 0 +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-array_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-array_FIXTURE.json new file mode 100644 index 000000000..952004879 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-array_FIXTURE.json @@ -0,0 +1,10 @@ + + [ + -1234.500e-003, + true, + "a string value", + null, + {}, + [] +] + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-boolean_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-boolean_FIXTURE.json new file mode 100644 index 000000000..27ba77dda --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-boolean_FIXTURE.json @@ -0,0 +1 @@ +true diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-null_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-null_FIXTURE.json new file mode 100644 index 000000000..19765bd50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-null_FIXTURE.json @@ -0,0 +1 @@ +null diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-number_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-number_FIXTURE.json new file mode 100644 index 000000000..859603bae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-number_FIXTURE.json @@ -0,0 +1 @@ +-1234.500e-003 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-object_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-object_FIXTURE.json new file mode 100644 index 000000000..814ec45e4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-object_FIXTURE.json @@ -0,0 +1,10 @@ + + { + "number": -1234.500e-003, + "boolean": true, + "string": "a string value", + "null": null, + "object": {}, + "array": [] +} + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-string_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-string_FIXTURE.json new file mode 100644 index 000000000..d98e33314 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-value-string_FIXTURE.json @@ -0,0 +1 @@ +"a string value" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-via-namespace_FIXTURE.json b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-via-namespace_FIXTURE.json new file mode 100644 index 000000000..5484d8291 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/json-via-namespace_FIXTURE.json @@ -0,0 +1 @@ +262 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-empty_FIXTURE b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-empty_FIXTURE new file mode 100644 index 000000000..e69de29bb diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-javascript_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-javascript_FIXTURE.js new file mode 100644 index 000000000..b8b84b608 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-javascript_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2025 Mozilla Foundation. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +invalid { javascript diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-string_FIXTURE b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-string_FIXTURE new file mode 100644 index 000000000..2a2e2100e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-string_FIXTURE @@ -0,0 +1 @@ +a string value diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-via-namespace_FIXTURE b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-via-namespace_FIXTURE new file mode 100644 index 000000000..5484d8291 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-attributes/text-via-namespace_FIXTURE @@ -0,0 +1 @@ +262 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/errors/syntax-error/import-defer-of-syntax-error-fails.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/errors/syntax-error/import-defer-of-syntax-error-fails.js new file mode 100644 index 000000000..9ee96b6e3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/errors/syntax-error/import-defer-of-syntax-error-fails.js @@ -0,0 +1,22 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-module-namespace-exotic-objects-get-p-receiver-EnsureDeferredNamespaceEvaluation +description: > + Syntax errors in deferred modules are reported eagerly +info: | + LoadRequestedModules ([ _hostDefined_ ]) + - just notice that it does not check if the module is deferred + +flags: [module] +features: [import-defer] + +negative: + phase: resolution + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +import defer * as ns from "./syntax-error_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/errors/syntax-error/syntax-error_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/errors/syntax-error/syntax-error_FIXTURE.js new file mode 100644 index 000000000..b7d221754 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/errors/syntax-error/syntax-error_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +invalid syntax! diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/dep_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/dep_FIXTURE.js new file mode 100644 index 000000000..c0a2af180 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/dep_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export default 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-default-and-defer-namespace.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-default-and-defer-namespace.js new file mode 100644 index 000000000..5a33f20e7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-default-and-defer-namespace.js @@ -0,0 +1,33 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-imports +description: > + `import defer` cannot be used if there are both a default and namespace bindings +info: | + ImportDeclaration : + `import` ImportClause FromClause `;` + `import` `defer` NameSpaceImport FromClause `;` + `import` ModuleSpecifier `;` + + ImportClause : + ImportedDefaultBinding + NameSpaceImport + NamedImports + ImportedDefaultBinding `,` NameSpaceImport + ImportedDefaultBinding `,` NamedImports + + NameSpaceImport : + `*` `as` ImportedBinding + +features: [import-defer] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +import defer x, * as ns from "./dep_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-as-with-no-asterisk.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-as-with-no-asterisk.js new file mode 100644 index 000000000..008108dee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-as-with-no-asterisk.js @@ -0,0 +1,33 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-imports +description: > + `import defer` must be followed by `*` +info: | + ImportDeclaration : + `import` ImportClause FromClause `;` + `import` `defer` NameSpaceImport FromClause `;` + `import` ModuleSpecifier `;` + + ImportClause : + ImportedDefaultBinding + NameSpaceImport + NamedImports + ImportedDefaultBinding `,` NameSpaceImport + ImportedDefaultBinding `,` NamedImports + + NameSpaceImport : + `*` `as` ImportedBinding + +features: [import-defer] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +import defer as ns from "./dep_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-default-and-namespace.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-default-and-namespace.js new file mode 100644 index 000000000..b7ba83936 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-default-and-namespace.js @@ -0,0 +1,33 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-imports +description: > + `import defer` cannot be used if there are both a default and namespace bindings +info: | + ImportDeclaration : + `import` ImportClause FromClause `;` + `import` `defer` NameSpaceImport FromClause `;` + `import` ModuleSpecifier `;` + + ImportClause : + ImportedDefaultBinding + NameSpaceImport + NamedImports + ImportedDefaultBinding `,` NameSpaceImport + ImportedDefaultBinding `,` NamedImports + + NameSpaceImport : + `*` `as` ImportedBinding + +features: [import-defer] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +import x, defer * as ns from "./dep_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-default.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-default.js new file mode 100644 index 000000000..e3af0bf78 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-default.js @@ -0,0 +1,33 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-imports +description: > + `import defer` cannot be used with default imports +info: | + ImportDeclaration : + `import` ImportClause FromClause `;` + `import` `defer` NameSpaceImport FromClause `;` + `import` ModuleSpecifier `;` + + ImportClause : + ImportedDefaultBinding + NameSpaceImport + NamedImports + ImportedDefaultBinding `,` NameSpaceImport + ImportedDefaultBinding `,` NamedImports + + NameSpaceImport : + `*` `as` ImportedBinding + +features: [import-defer] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +import defer x from "./dep_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-named.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-named.js new file mode 100644 index 000000000..6f94674db --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-defer-named.js @@ -0,0 +1,33 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-imports +description: > + `import defer` cannot be used with named imports +info: | + ImportDeclaration : + `import` ImportClause FromClause `;` + `import` `defer` NameSpaceImport FromClause `;` + `import` ModuleSpecifier `;` + + ImportClause : + ImportedDefaultBinding + NameSpaceImport + NamedImports + ImportedDefaultBinding `,` NameSpaceImport + ImportedDefaultBinding `,` NamedImports + + NameSpaceImport : + `*` `as` ImportedBinding + +features: [import-defer] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +import defer { default as x } from "./dep_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-export-defer-namespace.js b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-export-defer-namespace.js new file mode 100644 index 000000000..ff797659d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/import/import-defer/syntax/invalid-export-defer-namespace.js @@ -0,0 +1,32 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-exports +description: > + `export defer` is not valid +info: | + ExportDeclaration : + `export` ExportFromClause FromClause `;` + `export` NamedExports `;` + `export` VariableStatement + `export` Declaration + `export` `default` HoistableDeclaration + `export` `default` ClassDeclaration + `export` `default` [lookahead ∉ { function, async [no LineTerminator here] function, class }] AssignmentExpression `;` + + ExportFromClause : + `*` + `*` `as` ModuleExportName + NamedExports + +features: [import-defer] + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +export defer * as ns from "./dep_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-break.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-break.js new file mode 100644 index 000000000..04bb6104f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-break.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.1 +description: Checking if execution of "break=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +break = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-case.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-case.js new file mode 100644 index 000000000..41a6a34fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-case.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.2 +description: Checking if execution of "case=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +case = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-catch.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-catch.js new file mode 100644 index 000000000..e347ae88f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-catch.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.3 +description: Checking if execution of "catch=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +catch = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-continue.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-continue.js new file mode 100644 index 000000000..b373619fd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-continue.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.4 +description: Checking if execution of "contunue=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +continue = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-default.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-default.js new file mode 100644 index 000000000..0bbb8a978 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-default.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.5 +description: Checking if execution of "default=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +default = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-delete.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-delete.js new file mode 100644 index 000000000..72d49c245 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-delete.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.6 +description: Checking if execution of "delete=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +delete = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-do.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-do.js new file mode 100644 index 000000000..430281ffc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-do.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.7 +description: Checking if execution of "do=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +do = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-else.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-else.js new file mode 100644 index 000000000..6535671c6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-else.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.8 +description: Checking if execution of "else=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +else = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-finally.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-finally.js new file mode 100644 index 000000000..119d41c05 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-finally.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.9 +description: Checking if execution of "finally=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +finally = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-for.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-for.js new file mode 100644 index 000000000..25f7d3a71 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-for.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.10 +description: Checking if execution of "for=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +for = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-function.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-function.js new file mode 100644 index 000000000..7b92caa0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-function.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.11 +description: Checking if execution of "function=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-if.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-if.js new file mode 100644 index 000000000..151db6602 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-if.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.12 +description: Checking if execution of "if=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +if = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-in.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-in.js new file mode 100644 index 000000000..1ac8f2f20 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-in.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.13 +description: Checking if execution of "in=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +in = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-instanceof.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-instanceof.js new file mode 100644 index 000000000..0aecb056d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-instanceof.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.14 +description: Checking if execution of "instanceof=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +instanceof = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-new.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-new.js new file mode 100644 index 000000000..66a292477 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-new.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.15 +description: Checking if execution of "new=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +new = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-return.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-return.js new file mode 100644 index 000000000..59bd45de9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-return.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.16 +description: Checking if execution of "return=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +return = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-switch.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-switch.js new file mode 100644 index 000000000..e31f58b65 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-switch.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.17 +description: Checking if execution of "switch=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +switch = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-this.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-this.js new file mode 100644 index 000000000..b4ccdd077 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-this.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.18 +description: Checking if execution of "this=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// It's tempting to write `this = 0`, but that'd be a test to validate `this` +// is not a valid simple assignment target, cf. tests in language/expressions/assignment. +// Also see: sec-semantics-static-semantics-isvalidsimpleassignmenttarget +({this}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-throw.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-throw.js new file mode 100644 index 000000000..aea07ab1d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-throw.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.19 +description: Checking if execution of "throw=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +throw = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-try.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-try.js new file mode 100644 index 000000000..0a37439c2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-try.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.20 +description: Checking if execution of "try=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +try = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-typeof.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-typeof.js new file mode 100644 index 000000000..791f089b1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-typeof.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.21 +description: Checking if execution of "typeof=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +typeof = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-var.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-var.js new file mode 100644 index 000000000..e9e2e8336 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-var.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.22 +description: Checking if execution of "var=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-void.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-void.js new file mode 100644 index 000000000..14b8c368b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-void.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.23 +description: Checking if execution of "void=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +void = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-while.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-while.js new file mode 100644 index 000000000..8a5908bc5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-while.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.24 +description: Checking if execution of "while=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +while = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-with.js b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-with.js new file mode 100644 index 000000000..b4ae98fb7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/keywords/ident-ref-with.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-identifiers-static-semantics-early-errors +es5id: 7.6.1.1_A1.25 +description: Checking if execution of "with=1" fails +info: | + Identifier : IdentifierName but not ReservedWord + + It is a Syntax Error if StringValue of IdentifierName is the same String + value as the StringValue of any ReservedWord except for yield. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +with = 1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/7.3-15.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/7.3-15.js new file mode 100644 index 000000000..2dfc66d26 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/7.3-15.js @@ -0,0 +1,13 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.3-15 +description: 7.3 - ES5 recognize (\uFFFF) as a whitespace character +---*/ + + var prop = "a\uFFFFa"; + +assert.sameValue(prop.length, 3, 'prop.length'); +assert.notSameValue(prop, "aa", 'prop'); +assert.sameValue(prop[1], "\uFFFF", 'prop[1]'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/7.3-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/7.3-5.js new file mode 100644 index 000000000..6304cc3c2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/7.3-5.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.3-5 +description: > + 7.3 - ES5 recognizes the character (\u2028) as terminating + string literal +---*/ + + var prop = "66\u2028123"; + +assert.sameValue(prop, "66\u2028123", 'prop'); +assert.sameValue(prop[2], "\u2028", 'prop[2]'); +assert.sameValue(prop.length, 6, 'prop.length'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/7.3-6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/7.3-6.js new file mode 100644 index 000000000..45c834ee8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/7.3-6.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.3-6 +description: > + 7.3 - ES5 recognizes the character (\u2029) as terminating + string literal +---*/ + + var prop = "66\u2029123"; + +assert.sameValue(prop, "66\u2029123", 'prop'); +assert.sameValue(prop[2], "\u2029", 'prop[2]'); +assert.sameValue(prop.length, 6, 'prop.length'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A2.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A2.1_T2.js new file mode 100644 index 000000000..d6a147c4f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A2.1_T2.js @@ -0,0 +1,19 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: LINE FEED (U+000A) within strings is not allowed +es5id: 7.3_A2.1_T2 +description: Use real LINE FEED into string +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +" +str +ing +"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A2.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A2.2_T2.js new file mode 100644 index 000000000..d1224d1b1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A2.2_T2.js @@ -0,0 +1,19 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: CARRIAGE RETURN (U+000D) within strings is not allowed +es5id: 7.3_A2.2_T2 +description: Insert real CARRIAGE RETURN into string +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +" +str +ing +"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A3.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A3.2_T1.js new file mode 100644 index 000000000..4d6e18b58 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A3.2_T1.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single line comments can not contain CARRIAGE RETURN (U+000D) inside +es5id: 7.3_A3.2_T1 +description: Insert CARRIAGE RETURN (\u000D) into single line comment +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// single line comment + ??? (invalid) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A5.4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A5.4.js new file mode 100644 index 000000000..5e30f817f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A5.4.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Multi line comment can contain LINE SEPARATOR (U+2029) +es5id: 7.3_A5.4 +description: Insert PARAGRAPH SEPARATOR (U+2029) into multi line comment +---*/ + +// CHECK#1 +eval("/*\u2029 multi line \u2029 comment \u2029*/"); + +//CHECK#2 +var x = 0; +eval("/*\u2029 multi line \u2029 comment \u2029 x = 1;*/"); +if (x !== 0) { + throw new Test262Error('#1: var x = 0; eval("/*\\u2029 multi line \\u2029 comment \\u2029 x = 1;*/"); x === 0. Actual: ' + (x)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T1.js new file mode 100644 index 000000000..0e7be8984 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T1.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Line Terminator cannot be expressed as a Unicode escape sequence + consisting of six characters, namely \u plus four hexadecimal digits +es5id: 7.3_A6_T1 +description: Insert LINE FEED (U+000A) in var x +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var\u000Ax; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T2.js new file mode 100644 index 000000000..b02afee0d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T2.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Line Terminator cannot be expressed as a Unicode escape sequence + consisting of six characters, namely \u plus four hexadecimal digits +es5id: 7.3_A6_T2 +description: Insert CARRIAGE RETURN (U+000D) in var x +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var\u000Dx; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T3.js new file mode 100644 index 000000000..f75f3800d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T3.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Line Terminator cannot be expressed as a Unicode escape sequence + consisting of six characters, namely \u plus four hexadecimal digits +es5id: 7.3_A6_T3 +description: Insert LINE SEPARATOR (U+2028) in var x +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var\u2028x; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T4.js new file mode 100644 index 000000000..48968bb12 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A6_T4.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Line Terminator cannot be expressed as a Unicode escape sequence + consisting of six characters, namely \u plus four hexadecimal digits +es5id: 7.3_A6_T4 +description: Insert PARAGRAPH SEPARATOR (U+2029) in var x +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +var\u2029x; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T1.js new file mode 100644 index 000000000..75956b8ec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T1.js @@ -0,0 +1,56 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminators between operators are allowed +es5id: 7.3_A7_T1 +description: Insert Line Terminator in var x=y+z +---*/ + +// CHECK#1 +var y=2; +var z=3; +var +x += +y ++ +z +; +if (x !== 5) { + throw new Test262Error('#1: var\\nx\\n=\\ny\\n+\\nz\\n; x === 5. Actual: ' + (x)); +} +x=0; + +// CHECK#2 +var y=2; +var z=3; +var +x += +y ++ +z +; +if (x !== 5) { + throw new Test262Error('#2: var\\nx\\n=\\ny\\n+\\nz\\n; x === 5. Actual: ' + (x)); +} +x=0; + +// CHECK#3 +var result; +var y=2; +var z=3; +eval("\u2028var\u2028x\u2028=\u2028y\u2028+\u2028z\u2028; result = x;"); +if (result !== 5) { + throw new Test262Error('#3: eval("\\u2028var\\u2028x\\u2028=\\u2028y\\u2028+\\u2028z\\u2028; result = x;"); result === 5. Actual: ' + (result)); +} +result=0; + +// CHECK#4 +var y=2; +var z=3; +eval("\u2029var\u2029x\u2029=\u2029y\u2029+\u2029z\u2029; result = x;"); +if (result !== 5) { + throw new Test262Error('#4: eval("\\u2029var\\u2029x\\u2029=\\u2029y\\u2029+\\u2029z\\u2029; result = x;"); result === 5. Actual: ' + (result)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T2.js new file mode 100644 index 000000000..5c7e3ae76 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T2.js @@ -0,0 +1,56 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminators between operators are allowed +es5id: 7.3_A7_T2 +description: Insert Line Terminator in var x=y-z +---*/ + +// CHECK#1 +var y=3; +var z=2; +var +x += +y +- +z +; +if (x !== 1) { + throw new Test262Error('#1: var\\nx\\n=\\ny\\n-\\nz\\n; x === 1. Actual: ' + (x)); +} +x=0; + +// CHECK#2 +var y=3; +var z=2; +var +x += +y +- +z +; +if (x !== 1) { + throw new Test262Error('#2: var\\nx\\n=\\ny\\n-\\nz\\n; x === 1. Actual: ' + (x)); +} +x=0; + +// CHECK#3 +var result; +var y=3; +var z=2; +eval("\u2028var\u2028x\u2028=\u2028y\u2028-\u2028z\u2028; result = x;"); +if (result !== 1) { + throw new Test262Error('#3: eval("\\u2028var\\u2028x\\u2028=\\u2028y\\u2028-\\u2028z\\u2028; result = x;"); result === 1. Actual: ' + (result)); +} +result=0; + +// CHECK#4 +var y=3; +var z=2; +eval("\u2029var\u2029x\u2029=\u2029y\u2029-\u2029z\u2029; result = x;"); +if (result !== 1) { + throw new Test262Error('#4: eval("\\u2029var\\u2029x\\u2029=\\u2029y\\u2029-\\u2029z\\u2029; result = x;"); result === 1. Actual: ' + (result)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T3.js new file mode 100644 index 000000000..4599fd0ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T3.js @@ -0,0 +1,56 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminators between operators are allowed +es5id: 7.3_A7_T3 +description: Insert Line Terminator in var x=y*z +---*/ + +// CHECK#1 +var y=3; +var z=2; +var +x += +y +* +z +; +if (x !== 6) { + throw new Test262Error('#1: var\\nx\\n=\\ny\\n*\\nz\\n; x === 6. Actual: ' + (x)); +} +x=0; + +// CHECK#2 +var y=3; +var z=2; +var +x += +y +* +z +; +if (x !== 6) { + throw new Test262Error('#2: var\\nx\\n=\\ny\\n*\\nz\\n; x === 6. Actual: ' + (x)); +} +x=0; + +// CHECK#3 +var result; +var y=3; +var z=2; +eval("\u2028var\u2028x\u2028=\u2028y\u2028*\u2028z\u2028; result = x;"); +if (result !== 6) { + throw new Test262Error('#3: eval("\\u2028var\\u2028x\\u2028=\\u2028y\\u2028*\\u2028z\\u2028; result = x;"); result === 6. Actual: ' + (result)); +} +result=0; + +// CHECK#4 +var y=3; +var z=2; +eval("\u2029var\u2029x\u2029=\u2029y\u2029*\u2029z\u2029; result = x;"); +if (result !== 6) { + throw new Test262Error('#4: eval("\\u2029var\\u2029x\\u2029=\\u2029y\\u2029*\\u2029z\\u2029; result = x;"); result === 6. Actual: ' + (result)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T4.js new file mode 100644 index 000000000..1c6563599 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T4.js @@ -0,0 +1,56 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminators between operators are allowed +es5id: 7.3_A7_T4 +description: Insert Line Terminator in var x=y/z +---*/ + +// CHECK#1 +var y=12; +var z=2; +var +x += +y +/ +z +; +if (x !== 6) { + throw new Test262Error('#1: var\\nx\\n=\\ny\\n/\\nz\\n; x === 6. Actual: ' + (x)); +} +x=0; + +// CHECK#2 +var y=12; +var z=2; +var +x += +y +/ +z +; +if (x !== 6) { + throw new Test262Error('#2: var\\nx\\n=\\ny\\n/\\nz\\n; x === 6. Actual: ' + (x)); +} +x=0; + +// CHECK#3 +var result; +var y=12; +var z=2; +eval("\u2028var\u2028x\u2028=\u2028y\u2028/\u2028z\u2028; result = x;"); +if (result !== 6) { + throw new Test262Error('#3: eval("\\u2028var\\u2028x\\u2028=\\u2028y\\u2028/\\u2028z\\u2028; result = x;"); result === 6. Actual: ' + (result)); +} +result=0; + +// CHECK#4 +var y=12; +var z=2; +eval("\u2029var\u2029x\u2029=\u2029y\u2029/\u2029z\u2029; result = x;"); +if (result !== 6) { + throw new Test262Error('#4: eval("\\u2029var\\u2029x\\u2029=\\u2029y\\u2029/\\u2029z\\u2029; result = x;"); result === 6. Actual: ' + (result)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T5.js new file mode 100644 index 000000000..fc0fcf5ec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T5.js @@ -0,0 +1,56 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminators between operators are allowed +es5id: 7.3_A7_T5 +description: Insert Line Terminator in var x=y%z +---*/ + +// CHECK#1 +var y=16; +var z=10; +var +x += +y +% +z +; +if (x !== 6) { + throw new Test262Error('#1: var\\nx\\n=\\ny\\n%\\nz\\n; x === 6. Actual: ' + (x)); +} +x=0; + +// CHECK#2 +var y=16; +var z=10; +var +x += +y +% +z +; +if (x !== 6) { + throw new Test262Error('#2: var\\nx\\n=\\ny\\n%\\nz\\n; x === 6. Actual: ' + (x)); +} +x=0; + +// CHECK#3 +var result; +var y=16; +var z=10; +eval("\u2028var\u2028x\u2028=\u2028y\u2028%\u2028z\u2028; result = x;"); +if (result !== 6) { + throw new Test262Error('#3: eval("\\u2028var\\u2028x\\u2028=\\u2028y\\u2028%\\u2028z\\u2028; result = x;"); result === 6. Actual: ' + (result)); +} +result=0; + +// CHECK#4 +var y=16; +var z=10; +eval("\u2029var\u2029x\u2029=\u2029y\u2029%\u2029z\u2029; result = x;"); +if (result !== 6) { + throw new Test262Error('#4: eval("\\u2029var\\u2029x\\u2029=\\u2029y\\u2029%\\u2029z\\u2029; result = x;"); result === 6. Actual: ' + (result)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T6.js new file mode 100644 index 000000000..5e04b609f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T6.js @@ -0,0 +1,56 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminators between operators are allowed +es5id: 7.3_A7_T6 +description: Insert Line Terminator in var x=y>>z +---*/ + +// CHECK#1 +var y=16; +var z=3; +var +x += +y +>> +z +; +if (x !== 2) { + throw new Test262Error('#1: var\\nx\\n=\\ny\\n>>\\nz\\n; x === 2. Actual: ' + (x)); +} +x=0; + +// CHECK#2 +var y=16; +var z=3; +var +x += +y +>> +z +; +if (x !== 2) { + throw new Test262Error('#2: var\\nx\\n=\\ny\\n>>\\nz\\n; x === 2. Actual: ' + (x)); +} +x=0; + +// CHECK#3 +var result; +var y=16; +var z=3; +eval("\u2028var\u2028x\u2028=\u2028y\u2028>>\u2028z\u2028; result = x;"); +if (result !== 2) { + throw new Test262Error('#3: eval("\\u2028var\\u2028x\\u2028=\\u2028y\\u2028>>\\u2028z\\u2028; result = x;"); result === 2. Actual: ' + (result)); +} +result=0; + +// CHECK#4 +var y=16; +var z=3; +eval("\u2029var\u2029x\u2029=\u2029y\u2029>>\u2029z\u2029; result = x;"); +if (result !== 2) { + throw new Test262Error('#4: eval("\\u2029var\\u2029x\\u2029=\\u2029y\\u2029>>\\u2029z\\u2029; result = x;"); result === 2. Actual: ' + (result)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T7.js new file mode 100644 index 000000000..cbf60cd64 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/S7.3_A7_T7.js @@ -0,0 +1,56 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Line Terminators between operators are allowed +es5id: 7.3_A7_T7 +description: Insert Line Terminator in var x=y< + Insert PARAGRAPH SEPARATOR (U+2029) into the end of single line + comment +negative: + phase: runtime + type: Test262Error +---*/ + +// Because this test concerns the interpretation of non-executable character +// sequences within ECMAScript source code, special care must be taken to +// ensure that executable code is evaluated as expected. +// +// Express the intended behavior by intentionally throwing an error; this +// guarantees that test runners will only consider the test "passing" if +// executable sequences are correctly interpreted as such. + +// single line
throw new Test262Error(); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-cr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-cr.js new file mode 100644 index 000000000..09568f1a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-cr.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single line comments can not contain CARRIAGE RETURN (U+000D) inside +es5id: 7.3_A3.2_T2 +esid: sec-line-terminators +description: Insert CARRIAGE RETURN (\u000D) into begin of single line comment +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// this text is not included in the single-line comment that precedes it diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-lf.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-lf.js new file mode 100644 index 000000000..196f00203 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-lf.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single line comments can not contain LINE FEED (U+000A) inside +es5id: 7.3_A3.1_T3 +description: Insert real LINE FEED into single line comment +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// CHECK#1 +//single +line comment diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-ls.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-ls.js new file mode 100644 index 000000000..4405e0e73 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-ls.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Single line comments are terminated by the LINE SEPARATOR (U+2028) + character +es5id: 7.3_A3.3_T1 +description: Insert LINE SEPARATOR (\u2028) into single line comment +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// single line LS>
??? (invalid) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-ps.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-ps.js new file mode 100644 index 000000000..54ba2571c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-comment-single-ps.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Single line comments can not contain PARAGRAPH SEPARATOR (U+2029) inside +es5id: 7.3_A3.4_T1 +description: Insert PARAGRAPH SEPARATOR (\u2029) into single line comment +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// single line PS>
??? (invalid) diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-cr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-cr.js new file mode 100644 index 000000000..449ee384c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-cr.js @@ -0,0 +1,17 @@ +// Copyright 2019 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-line-terminators +es5id: 7.3-7 +description: > + 7.3 - ES5 recognizes the character (\u000D) as terminating + regular expression literals +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/ / diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-lf.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-lf.js new file mode 100644 index 000000000..82fc50eb2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-lf.js @@ -0,0 +1,18 @@ +// Copyright 2019 Mike Pennisi. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-line-terminators +es5id: 7.3-7 +description: > + 7.3 - ES5 recognizes the character (\u000A) as terminating + regular expression literals +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/ +/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-ls.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-ls.js new file mode 100644 index 000000000..9c0bab7c5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-ls.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-line-terminators +es5id: 7.3-7 +description: > + 7.3 - ES5 recognizes the character (\u2028) as terminating + regular expression literals +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/
/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-ps.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-ps.js new file mode 100644 index 000000000..edf3496af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-regexp-ps.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-line-terminators +es5id: 7.3-8 +description: > + 7.3 - ES5 recognizes the character (\u2029) as terminating + regular expression literals +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/
/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-string-cr.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-string-cr.js new file mode 100644 index 000000000..5d7c50e9c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-string-cr.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: CARRIAGE RETURN (U+000D) within strings is not allowed +es5id: 7.3_A2.2_T1 +esid: sec-line-terminators +description: Insert CARRIAGE RETURN (\u000D) into string +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +' ' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-string-lf.js b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-string-lf.js new file mode 100644 index 000000000..bd8b43310 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/line-terminators/invalid-string-lf.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: LINE FEED (U+000A) within strings is not allowed +es5id: 7.3_A2.1_T1 +esid: sec-line-terminators +description: Insert LINE FEED (\u000A) into string +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +' +' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/binary-invalid-digit.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/binary-invalid-digit.js new file mode 100644 index 000000000..46396daba --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/binary-invalid-digit.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 Robin Templeton. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Binary BigInt literal containing an invalid digit +esid: prod-NumericLiteral +info: | + NumericLiteral :: + NumericLiteralBase NumericLiteralSuffix + + NumericLiteralBase :: + DecimalLiteral + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + NumericLiteralSuffix :: n +negative: + phase: parse + type: SyntaxError +features: [BigInt] +---*/ + +$DONOTEVALUATE(); + +0b2n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/exponent-part.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/exponent-part.js new file mode 100644 index 000000000..aa2c095d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/exponent-part.js @@ -0,0 +1,16 @@ +// Copyright (C) 2017 Robin Templeton. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + It is a Syntax Error if the NumericLiteralBase contains an ExponentPart. +esid: sec-numeric-literal-static-semantics-early-errors +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0e0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/hexadecimal-invalid-digit.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/hexadecimal-invalid-digit.js new file mode 100644 index 000000000..e0e19f6cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/hexadecimal-invalid-digit.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 Robin Templeton. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Hexadecimal BigInt literal containing an invalid digit +esid: prod-NumericLiteral +info: | + NumericLiteral :: + NumericLiteralBase NumericLiteralSuffix + + NumericLiteralBase :: + DecimalLiteral + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + NumericLiteralSuffix :: n +negative: + phase: parse + type: SyntaxError +features: [BigInt] +---*/ + +$DONOTEVALUATE(); + +0xgn; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/legacy-octal-like-invalid-00n.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/legacy-octal-like-invalid-00n.js new file mode 100644 index 000000000..5c4c9bbd3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/legacy-octal-like-invalid-00n.js @@ -0,0 +1,28 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteral +description: > + The BigInt suffix is disallowed in LegacyOctalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + LegacyOctalIntegerLiteral + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +00n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/legacy-octal-like-invalid-01n.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/legacy-octal-like-invalid-01n.js new file mode 100644 index 000000000..1f406259e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/legacy-octal-like-invalid-01n.js @@ -0,0 +1,28 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteral +description: > + The BigInt suffix is disallowed in LegacyOctalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + LegacyOctalIntegerLiteral + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +01n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/legacy-octal-like-invalid-07n.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/legacy-octal-like-invalid-07n.js new file mode 100644 index 000000000..b9b962cc2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/legacy-octal-like-invalid-07n.js @@ -0,0 +1,28 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteral +description: > + The BigInt suffix is disallowed in LegacyOctalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + LegacyOctalIntegerLiteral + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +07n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/mv-is-not-integer-dil-dot-dds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/mv-is-not-integer-dil-dot-dds.js new file mode 100644 index 000000000..683e8c1b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/mv-is-not-integer-dil-dot-dds.js @@ -0,0 +1,27 @@ +// Copyright (C) 2017 The V8 Project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-numeric-literal-static-semantics-early-errors +description: > + It is a Syntax Error if the MV is not an integer. (decimalIntegerLiteral dot decimalDigits) +info: | + Static Semantics: BigInt Value + + NumericLiteral :: NumericLiteralBase NumericLiteralSuffix + + 1. Assert: NumericLiteralSuffix is n. + 2. Let the value of NumericLiteral be the MV of NumericLiteralBase represented as BigInt. + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt + . DecimalDigits +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +2017.8n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/mv-is-not-integer-dot-dds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/mv-is-not-integer-dot-dds.js new file mode 100644 index 000000000..756c5d719 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/mv-is-not-integer-dot-dds.js @@ -0,0 +1,27 @@ +// Copyright (C) 2017 The V8 Project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-numeric-literal-static-semantics-early-errors +description: > + It is a Syntax Error if the MV is not an integer. (dot decimalDigits) +info: | + Static Semantics: BigInt Value + + NumericLiteral :: NumericLiteralBase NumericLiteralSuffix + + 1. Assert: NumericLiteralSuffix is n. + 2. Let the value of NumericLiteral be the MV of NumericLiteralBase represented as BigInt. + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt + . DecimalDigits +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +.0000000001n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-0008n.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-0008n.js new file mode 100644 index 000000000..239a45dfc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-0008n.js @@ -0,0 +1,28 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteral +description: > + The BigInt suffix is disallowed in NonOctalDecimalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + + https://github.com/tc39/proposal-bigint/issues/208 + + NumericLiteral :: + DecimalBigIntegerLiteral + + DecimalBigIntegerLiteral :: + 0 BigIntLiteralSuffix + NonZeroDigit DecimalDigits_opt BigIntLiteralSuffix +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0008n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-012348n.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-012348n.js new file mode 100644 index 000000000..fbbc05312 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-012348n.js @@ -0,0 +1,28 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteral +description: > + The BigInt suffix is disallowed in NonOctalDecimalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + + https://github.com/tc39/proposal-bigint/issues/208 + + NumericLiteral :: + DecimalBigIntegerLiteral + + DecimalBigIntegerLiteral :: + 0 BigIntLiteralSuffix + NonZeroDigit DecimalDigits_opt BigIntLiteralSuffix +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +012348n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-08n.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-08n.js new file mode 100644 index 000000000..9c7b06921 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-08n.js @@ -0,0 +1,28 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteral +description: > + The BigInt suffix is disallowed in NonOctalDecimalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + + https://github.com/tc39/proposal-bigint/issues/208 + + NumericLiteral :: + DecimalBigIntegerLiteral + + DecimalBigIntegerLiteral :: + 0 BigIntLiteralSuffix + NonZeroDigit DecimalDigits_opt BigIntLiteralSuffix +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +08n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-09n.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-09n.js new file mode 100644 index 000000000..f8ef4935f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/non-octal-like-invalid-09n.js @@ -0,0 +1,28 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteral +description: > + The BigInt suffix is disallowed in NonOctalDecimalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + + https://github.com/tc39/proposal-bigint/issues/208 + + NumericLiteral :: + DecimalBigIntegerLiteral + + DecimalBigIntegerLiteral :: + 0 BigIntLiteralSuffix + NonZeroDigit DecimalDigits_opt BigIntLiteralSuffix +features: [BigInt] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +09n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js new file mode 100644 index 000000000..0a076f5d3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js @@ -0,0 +1,44 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the appear adjacent to `0b` | `0B` in a + BinaryIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0b_1n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd.js new file mode 100644 index 000000000..f284d276a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0b` | `0B` BinaryDigit NumericLiteralSeparator BinaryDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0b0_1n, 0b01n); +assert.sameValue(0B0_1n, 0B01n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bds.js new file mode 100644 index 000000000..cad1feec0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bd-nsl-bds.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0b` | `0B` BinaryDigit NumericLiteralSeparator BinaryDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0b0_10n, 0b010n); +assert.sameValue(0B0_10n, 0B010n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bds-nsl-bd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bds-nsl-bd.js new file mode 100644 index 000000000..4949452f6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bds-nsl-bd.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0b` | `0B` BinaryDigits NumericLiteralSeparator BinaryDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0b01_0n, 0b010n); +assert.sameValue(0B01_0n, 0B010n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bds-nsl-bds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bds-nsl-bds.js new file mode 100644 index 000000000..8f8bc77f2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-bds-nsl-bds.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0b` | `0B` BinaryDigits NumericLiteralSeparator BinaryDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0b01_00n, 0b0100n); +assert.sameValue(0B01_00n, 0B0100n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js new file mode 100644 index 000000000..352019f6e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js @@ -0,0 +1,44 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in a BinaryIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0b0__0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js new file mode 100644 index 000000000..8e6113be0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js @@ -0,0 +1,43 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of a + BinaryIntegerLiteral (before n) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0b0_n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dd-one-of.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dd-one-of.js new file mode 100644 index 000000000..46fda9a05 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dd-one-of.js @@ -0,0 +1,46 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + + DecimalDigits :: + DecimalDigit + ... + + DecimalDigit :: one of + 0 1 2 3 4 5 6 7 8 9 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(1_0n, 10n); +assert.sameValue(1_1n, 11n); +assert.sameValue(1_2n, 12n); +assert.sameValue(1_3n, 13n); +assert.sameValue(1_4n, 14n); +assert.sameValue(1_5n, 15n); +assert.sameValue(1_6n, 16n); +assert.sameValue(1_7n, 17n); +assert.sameValue(1_8n, 18n); +assert.sameValue(1_9n, 19n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js new file mode 100644 index 000000000..4faf06f03 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js @@ -0,0 +1,36 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in a DecimalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +1__0123456789n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-err.js new file mode 100644 index 000000000..f3a0b2af4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dd-nsl-err.js @@ -0,0 +1,38 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +1_n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dd.js new file mode 100644 index 000000000..2ecb7a4a4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dd.js @@ -0,0 +1,38 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: DecimalDigits NumericLiteralSeparator DecimalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(123456789_0n, 1234567890n); +assert.sameValue(123456789_1n, 1234567891n); +assert.sameValue(123456789_2n, 1234567892n); +assert.sameValue(123456789_3n, 1234567893n); +assert.sameValue(123456789_4n, 1234567894n); +assert.sameValue(123456789_5n, 1234567895n); +assert.sameValue(123456789_6n, 1234567896n); +assert.sameValue(123456789_7n, 1234567897n); +assert.sameValue(123456789_8n, 1234567898n); +assert.sameValue(123456789_9n, 1234567899n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js new file mode 100644 index 000000000..7436225b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js @@ -0,0 +1,36 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in DecimalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +10__0123456789n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-err.js new file mode 100644 index 000000000..be6b56e9c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-dds-nsl-err.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of a + DecimalLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +10_n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd-err.js new file mode 100644 index 000000000..4caf506d7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd-err.js @@ -0,0 +1,44 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the appear adjacent to `0x` | `0X` in a + HexIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0x_1n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd.js new file mode 100644 index 000000000..d12a37d2f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigit NumericLiteralSeparator HexDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0x0_1n, 0x01n); +assert.sameValue(0X0_1n, 0X01n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hds.js new file mode 100644 index 000000000..bfd203a8a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hd-nsl-hds.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigit NumericLiteralSeparator HexDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0x0_10n, 0x010n); +assert.sameValue(0X0_10n, 0X010n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hds-nsl-hd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hds-nsl-hd.js new file mode 100644 index 000000000..a4fcc57a4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hds-nsl-hd.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigits NumericLiteralSeparator HexDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0x01_0n, 0x010n); +assert.sameValue(0X01_0n, 0X010n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hds-nsl-hds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hds-nsl-hds.js new file mode 100644 index 000000000..43846d880 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-hds-nsl-hds.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigits NumericLiteralSeparator HexDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0x01_00n, 0x0100n); +assert.sameValue(0X01_00n, 0X0100n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-dunder-err.js new file mode 100644 index 000000000..72b1c7ee9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-dunder-err.js @@ -0,0 +1,44 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in a HexIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0x0__0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-err.js new file mode 100644 index 000000000..f2c87cb83 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-nsl-hd-err.js @@ -0,0 +1,44 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of a + HexIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0x0_n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-od-nsl-od-one-of.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-od-nsl-od-one-of.js new file mode 100644 index 000000000..2e4b27ca3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-hil-od-nsl-od-one-of.js @@ -0,0 +1,59 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigit NumericLiteralSeparator HexDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0x0_0n, 0x00n); +assert.sameValue(0x1_1n, 0x11n); +assert.sameValue(0x2_2n, 0x22n); +assert.sameValue(0x3_3n, 0x33n); +assert.sameValue(0x4_4n, 0x44n); +assert.sameValue(0x5_5n, 0x55n); +assert.sameValue(0x6_6n, 0x66n); +assert.sameValue(0x7_7n, 0x77n); +assert.sameValue(0x8_8n, 0x88n); +assert.sameValue(0x9_9n, 0x99n); +assert.sameValue(0xa_a, 0xaa); +assert.sameValue(0xb_b, 0xbb); +assert.sameValue(0xc_c, 0xcc); +assert.sameValue(0xd_d, 0xdd); +assert.sameValue(0xe_e, 0xee); +assert.sameValue(0xf_f, 0xff); +assert.sameValue(0xA_A, 0xAA); +assert.sameValue(0xB_B, 0xBB); +assert.sameValue(0xC_C, 0xCC); +assert.sameValue(0xD_D, 0xDD); +assert.sameValue(0xE_E, 0xEE); +assert.sameValue(0xF_F, 0xFF); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-00-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-00-err.js new file mode 100644 index 000000000..33c7116ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-00-err.js @@ -0,0 +1,52 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (00_0) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +00_0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-01-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-01-err.js new file mode 100644 index 000000000..58d16fe1d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-01-err.js @@ -0,0 +1,52 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (01_0) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +01_0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-07-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-07-err.js new file mode 100644 index 000000000..85e65fd90 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-07-err.js @@ -0,0 +1,54 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (07_0) + ) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +07_0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_0-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_0-err.js new file mode 100644 index 000000000..899d939af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_0-err.js @@ -0,0 +1,52 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (0_0) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_1-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_1-err.js new file mode 100644 index 000000000..4e03c7cea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_1-err.js @@ -0,0 +1,52 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (0_1) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_1n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_7-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_7-err.js new file mode 100644 index 000000000..8abc8c282 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-lol-0_7-err.js @@ -0,0 +1,53 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (0_7) + ) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_7n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-08-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-08-err.js new file mode 100644 index 000000000..73dc74079 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-08-err.js @@ -0,0 +1,49 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a NonOctalDecimalIntegerLiteral (08) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +08_0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-09-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-09-err.js new file mode 100644 index 000000000..3b15ee9f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-09-err.js @@ -0,0 +1,49 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a NonOctalDecimalIntegerLiteral (09) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +09_0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_8-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_8-err.js new file mode 100644 index 000000000..d338c2406 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_8-err.js @@ -0,0 +1,49 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a NonOctalDecimalIntegerLiteral (0_8) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_8n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_9-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_9-err.js new file mode 100644 index 000000000..6f35f3a3f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nonoctal-0_9-err.js @@ -0,0 +1,49 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a NonOctalDecimalIntegerLiteral (0_9) +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_9n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dd-one-of.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dd-one-of.js new file mode 100644 index 000000000..a60c20281 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dd-one-of.js @@ -0,0 +1,50 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + + DecimalDigits :: + DecimalDigit + ... + + DecimalDigit :: one of + 0 1 2 3 4 5 6 7 8 9 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(1_0n, 10n); +assert.sameValue(1_1n, 11n); +assert.sameValue(2_2n, 22n); +assert.sameValue(3_3n, 33n); +assert.sameValue(4_4n, 44n); +assert.sameValue(5_5n, 55n); +assert.sameValue(6_6n, 66n); +assert.sameValue(7_7n, 77n); +assert.sameValue(8_8n, 88n); +assert.sameValue(9_9n, 99n); + + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dd.js new file mode 100644 index 000000000..151619477 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dd.js @@ -0,0 +1,37 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + + DecimalDigits :: + ... + DecimalDigits DecimalDigit + ... + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(1_1n, 11n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-dunder-err.js new file mode 100644 index 000000000..be881a011 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-dunder-err.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in DecimalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0__0123456789n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-leading-zero-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-leading-zero-err.js new file mode 100644 index 000000000..c04c929a4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds-leading-zero-err.js @@ -0,0 +1,37 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigits +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_0123456789n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds.js new file mode 100644 index 000000000..a732cefc3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-nzd-nsl-dds.js @@ -0,0 +1,37 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigits +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + + DecimalDigits :: + ... + DecimalDigits DecimalDigit + ... + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(1_0123456789n, 10123456789n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-dunder-err.js new file mode 100644 index 000000000..3718509af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-dunder-err.js @@ -0,0 +1,44 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in a OctalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0o0__0n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-err.js new file mode 100644 index 000000000..58c7cefa8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-nsl-od-err.js @@ -0,0 +1,44 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of an + OctalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0o0_n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od-err.js new file mode 100644 index 000000000..0a9e2bcc6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od-err.js @@ -0,0 +1,44 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the appear adjacent to `0o` | `0O` in a + OctalIntegerLiteral +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0o_1n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od-one-of.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od-one-of.js new file mode 100644 index 000000000..f7972983a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od-one-of.js @@ -0,0 +1,45 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigit NumericLiteralSeparator OctalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0o0_0n, 0o00n); +assert.sameValue(0o1_1n, 0o11n); +assert.sameValue(0o2_2n, 0o22n); +assert.sameValue(0o3_3n, 0o33n); +assert.sameValue(0o4_4n, 0o44n); +assert.sameValue(0o5_5n, 0o55n); +assert.sameValue(0o6_6n, 0o66n); +assert.sameValue(0o7_7n, 0o77n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od.js new file mode 100644 index 000000000..5e1239335 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-od.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigit NumericLiteralSeparator OctalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0o0_1n, 0o01n); +assert.sameValue(0O0_1n, 0O01n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-ods.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-ods.js new file mode 100644 index 000000000..9478005ab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-od-nsl-ods.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigit NumericLiteralSeparator OctalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0o0_10n, 0o010n); +assert.sameValue(0O0_10n, 0O010n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-ods-nsl-od.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-ods-nsl-od.js new file mode 100644 index 000000000..70b433e66 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-ods-nsl-od.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigits NumericLiteralSeparator OctalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0o01_0n, 0o010n); +assert.sameValue(0O01_0n, 0O010n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-ods-nsl-ods.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-ods-nsl-ods.js new file mode 100644 index 000000000..2b2ce4848 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-oil-ods-nsl-ods.js @@ -0,0 +1,39 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigits NumericLiteralSeparator OctalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(0o01_00n, 0o0100n); +assert.sameValue(0O01_00n, 0O0100n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-sign-minus-dds-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-sign-minus-dds-nsl-dd.js new file mode 100644 index 000000000..3453f115a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-sign-minus-dds-nsl-dd.js @@ -0,0 +1,38 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: DecimalDigits NumericLiteralSeparator DecimalDigit +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator :: + _ + + SignedInteger :: + ... + - DecimalDigits + +features: [BigInt, numeric-separator-literal] +---*/ + +assert.sameValue(-123456789_0n, -1234567890n); +assert.sameValue(-123456789_1n, -1234567891n); +assert.sameValue(-123456789_2n, -1234567892n); +assert.sameValue(-123456789_3n, -1234567893n); +assert.sameValue(-123456789_4n, -1234567894n); +assert.sameValue(-123456789_5n, -1234567895n); +assert.sameValue(-123456789_6n, -1234567896n); +assert.sameValue(-123456789_7n, -1234567897n); +assert.sameValue(-123456789_8n, -1234567898n); +assert.sameValue(-123456789_9n, -1234567899n); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-unicode-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-unicode-err.js new file mode 100644 index 000000000..3ae1602e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/numeric-separators/numeric-separator-literal-unicode-err.js @@ -0,0 +1,36 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NonZeroDigit NumericLiteralSeparator DecimalDigits sequence expressed with + unicode escape sequence +info: | + NumericLiteral :: + DecimalIntegerLiteral BigIntLiteralSuffix + NumericLiteralBase BigIntLiteralSuffix + + NumericLiteralBase :: + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + BigIntLiteralSuffix :: n + + NumericLiteralSeparator:: + _ + + DecimalIntegerLiteral:: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + +negative: + phase: parse + type: SyntaxError +features: [BigInt, numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +1\u005F0123456789n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/octal-invalid-digit.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/octal-invalid-digit.js new file mode 100644 index 000000000..13a345c15 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/bigint/octal-invalid-digit.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 Robin Templeton. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Octal BigInt literal containing an invalid digit +esid: prod-NumericLiteral +info: | + NumericLiteral :: + NumericLiteralBase NumericLiteralSuffix + + NumericLiteralBase :: + DecimalLiteral + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + + NumericLiteralSuffix :: n +negative: + phase: parse + type: SyntaxError +features: [BigInt] +---*/ + +$DONOTEVALUATE(); + +0o9n; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/S7.8.2_A1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/S7.8.2_A1_T1.js new file mode 100644 index 000000000..889f9150d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/S7.8.2_A1_T1.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "Literal :: BooleanLiteral" +es5id: 7.8.2_A1_T1 +description: "BooleanLiteral :: true" +---*/ + +//CHECK#1 +if (Boolean(true) !== true) { + throw new Test262Error('#1: Boolean(true) === true. Actual: Boolean(true) === ' + (Boolean(true))); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/S7.8.2_A1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/S7.8.2_A1_T2.js new file mode 100644 index 000000000..05a80fc50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/S7.8.2_A1_T2.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "Literal :: BooleanLiteral" +es5id: 7.8.2_A1_T2 +description: "BooleanLiteral :: false" +---*/ + +//CHECK#1 +if (Boolean(false) !== false) { + throw new Test262Error('#1: Boolean(false) === false. Actual: Boolean(false) === ' + (Boolean(false))); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/false-with-unicode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/false-with-unicode.js new file mode 100644 index 000000000..8f0c7085b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/false-with-unicode.js @@ -0,0 +1,20 @@ +// Copyright (C) 2023 Veera Sivarajan. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-keywords-and-reserved-words +description: > + ReservedWord (false) cannot contain UnicodeEscapeSequence. +info: | + Note 1 + + Per 5.1.5, keywords in the grammar match literal sequences of specific SourceCharacter elements. + A code point in a keyword cannot be expressed by a \ UnicodeEscapeSequence. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +f\u{61}lse; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/true-with-unicode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/true-with-unicode.js new file mode 100644 index 000000000..7e76c8081 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/boolean/true-with-unicode.js @@ -0,0 +1,20 @@ +// Copyright (C) 2023 Veera Sivarajan. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-keywords-and-reserved-words +description: > + ReservedWord (true) cannot contain UnicodeEscapeSequence. +info: | + Note 1 + + Per 5.1.5, keywords in the grammar match literal sequences of specific SourceCharacter elements. + A code point in a keyword cannot be expressed by a \ UnicodeEscapeSequence. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +tru\u{65}; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/null/S7.8.1_A1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/null/S7.8.1_A1_T1.js new file mode 100644 index 000000000..8313a22bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/null/S7.8.1_A1_T1.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "Literal :: NullLiteral" +es5id: 7.8.1_A1_T1 +description: Check null === null +---*/ + +//CHECK#1 +if (null !== null) { + throw new Test262Error('#1: null === null'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/null/S7.8.1_A1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/null/S7.8.1_A1_T2.js new file mode 100644 index 000000000..9f21a775f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/null/S7.8.1_A1_T2.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "Literal :: NullLiteral" +es5id: 7.8.1_A1_T2 +description: Check RegExp("0").exec("1") === null +---*/ + +//CHECK#1 +if (RegExp("0").exec("1") !== null) { + throw new Test262Error('#1: RegExp("0").exec("1") === null'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/null/null-with-unicode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/null/null-with-unicode.js new file mode 100644 index 000000000..e517220a1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/null/null-with-unicode.js @@ -0,0 +1,20 @@ +// Copyright (C) 2023 Veera Sivarajan. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-keywords-and-reserved-words +description: > + ReservedWord (null) cannot contain UnicodeEscapeSequence. +info: | + Note 1 + + Per 5.1.5, keywords in the grammar match literal sequences of specific SourceCharacter elements. + A code point in a keyword cannot be expressed by a \ UnicodeEscapeSequence. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +n\u{75}ll; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/7.8.3-1gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/7.8.3-1gs.js new file mode 100644 index 000000000..9e509faa0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/7.8.3-1gs.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.3-1gs +description: Strict Mode - octal extension(010) is forbidden in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var y = 010; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/7.8.3-2gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/7.8.3-2gs.js new file mode 100644 index 000000000..32cc0b7f4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/7.8.3-2gs.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.3-2gs +description: > + Strict Mode - octal extension is forbidden in strict mode (after a + hex number is assigned to a variable) +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +var a; +a = 0x1; +a = 01; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/7.8.3-3gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/7.8.3-3gs.js new file mode 100644 index 000000000..e82e6cffe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/7.8.3-3gs.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.3-3gs +description: > + Strict Mode - octal extension is forbidden in strict mode (after a + hex number is assigned to a variable from an eval) +flags: [onlyStrict] +---*/ + +var a; +assert.throws(SyntaxError, function() { + eval("a = 0x1;a = 01;"); +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.1_T1.js new file mode 100644 index 000000000..462b597cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.1_T1.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral" +es5id: 7.8.3_A1.1_T1 +description: "DecimalIntegerLiteral :: 0, NoNZeroDigit" +---*/ + +//CHECK#0 +if (0 !== 0) { + throw new Test262Error('#0: 0 === 0'); +} + +//CHECK#1 +if (1 !== 1) { + throw new Test262Error('#1: 1 === 1'); +} + +//CHECK#2 +if (2 !== 2) { + throw new Test262Error('#2: 2 === 2'); +} + +//CHECK#3 +if (3 !== 3) { + throw new Test262Error('#3: 3 === 3'); +} + +//CHECK#4 +if (4 !== 4) { + throw new Test262Error('#4: 4 === 4'); +} + +//CHECK#5 +if (5 !== 5) { + throw new Test262Error('#5: 5 === 5'); +} + +//CHECK#6 +if (6 !== 6) { + throw new Test262Error('#6: 6 === 6'); +} + +//CHECK#7 +if (7 !== 7) { + throw new Test262Error('#7: 7 === 7'); +} + +//CHECK#8 +if (8 !== 8) { + throw new Test262Error('#8: 8 === 8'); +} + +//CHECK#9 +if (9 !== 9) { + throw new Test262Error('#9: 9 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.1_T2.js new file mode 100644 index 000000000..c52e17cec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.1_T2.js @@ -0,0 +1,53 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral" +es5id: 7.8.3_A1.1_T2 +description: "DecimalIntegerLiteral :: NoNZeroDigit DecimalDigits" +---*/ + +//CHECK#1 +if (11 !== 11) { + throw new Test262Error('#1: 11 === 11'); +} + +//CHECK#2 +if (22 !== 22) { + throw new Test262Error('#2: 22 === 22'); +} + +//CHECK#3 +if (33 !== 33) { + throw new Test262Error('#3: 33 === 33'); +} + +//CHECK#4 +if (44 !== 44) { + throw new Test262Error('#4: 44 === 44'); +} + +//CHECK#5 +if (55 !== 55) { + throw new Test262Error('#5: 55 === 55'); +} + +//CHECK#6 +if (66 !== 66) { + throw new Test262Error('#6: 66 === 66'); +} + +//CHECK#7 +if (77 !== 77) { + throw new Test262Error('#7: 77 === 77'); +} + +//CHECK#8 +if (88 !== 88) { + throw new Test262Error('#8: 88 === 88'); +} + +//CHECK#9 +if (99 !== 99) { + throw new Test262Error('#9: 99 === 99'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T1.js new file mode 100644 index 000000000..b2889b403 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T1.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral ExponentPart" +es5id: 7.8.3_A1.2_T1 +description: "ExponentPart :: e DecimalDigits" +---*/ + +//CHECK#0 +if (0e1 !== 0) { + throw new Test262Error('#0: 0e1 === 0'); +} + +//CHECK#1 +if (1e1 !== 10) { + throw new Test262Error('#1: 1e1 === 10'); +} + +//CHECK#2 +if (2e1 !== 20) { + throw new Test262Error('#2: 2e1 === 20'); +} + +//CHECK#3 +if (3e1 !== 30) { + throw new Test262Error('#3: 3e1 === 30'); +} + +//CHECK#4 +if (4e1 !== 40) { + throw new Test262Error('#4: 4e1 === 40'); +} + +//CHECK#5 +if (5e1 !== 50) { + throw new Test262Error('#5: 5e1 === 50'); +} + +//CHECK#6 +if (6e1 !== 60) { + throw new Test262Error('#6: 6e1 === 60'); +} + +//CHECK#7 +if (7e1 !== 70) { + throw new Test262Error('#7: 7e1 === 70'); +} + +//CHECK#8 +if (8e1 !== 80) { + throw new Test262Error('#8: 8e1 === 80'); +} + +//CHECK#9 +if (9e1 !== 90) { + throw new Test262Error('#9: 9e1 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T2.js new file mode 100644 index 000000000..2f73ec9a9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T2.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral ExponentPart" +es5id: 7.8.3_A1.2_T2 +description: "ExponentPart :: E DecimalDigits" +---*/ + +//CHECK#0 +if (0E1 !== 0) { + throw new Test262Error('#0: 0E1 === 0'); +} + +//CHECK#1 +if (1E1 !== 10) { + throw new Test262Error('#1: 1E1 === 1'); +} + +//CHECK#2 +if (2E1 !== 20) { + throw new Test262Error('#2: 2E1 === 20'); +} + +//CHECK#3 +if (3E1 !== 30) { + throw new Test262Error('#3: 3E1 === 30'); +} + +//CHECK#4 +if (4E1 !== 40) { + throw new Test262Error('#4: 4E1 === 40'); +} + +//CHECK#5 +if (5E1 !== 50) { + throw new Test262Error('#5: 5E1 === 50'); +} + +//CHECK#6 +if (6E1 !== 60) { + throw new Test262Error('#6: 6E1 === 60'); +} + +//CHECK#7 +if (7E1 !== 70) { + throw new Test262Error('#7: 7E1 === 70'); +} + +//CHECK#8 +if (8E1 !== 80) { + throw new Test262Error('#8: 8E1 === 80'); +} + +//CHECK#9 +if (9E1 !== 90) { + throw new Test262Error('#9: 9E1 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T3.js new file mode 100644 index 000000000..05777aecd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T3.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral ExponentPart" +es5id: 7.8.3_A1.2_T3 +description: "ExponentPart :: e -DecimalDigits" +---*/ + +//CHECK#0 +if (0e-1 !== 0) { + throw new Test262Error('#0: 0e-1 === 0'); +} + +//CHECK#1 +if (1e-1 !== 0.1) { + throw new Test262Error('#1: 1e-1 === 0.1'); +} + +//CHECK#2 +if (2e-1 !== 0.2) { + throw new Test262Error('#2: 2e-1 === 0.2'); +} + +//CHECK#3 +if (3e-1 !== 0.3) { + throw new Test262Error('#3: 3e-1 === 0.3'); +} + +//CHECK#4 +if (4e-1 !== 0.4) { + throw new Test262Error('#4: 4e-1 === 0.4'); +} + +//CHECK#5 +if (5e-1 !== 0.5) { + throw new Test262Error('#5: 5e-1 === 0.5'); +} + +//CHECK#6 +if (6e-1 !== 0.6) { + throw new Test262Error('#6: 6e-1 === 0.6'); +} + +//CHECK#7 +if (7e-1 !== 0.7) { + throw new Test262Error('#7: 7e-1 === 0.7'); +} + +//CHECK#8 +if (8e-1 !== 0.8) { + throw new Test262Error('#8: 8e-1 === 0.8'); +} + +//CHECK#9 +if (9e-1 !== 0.9) { + throw new Test262Error('#9: 9e-1 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T4.js new file mode 100644 index 000000000..7be554686 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T4.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral ExponentPart" +es5id: 7.8.3_A1.2_T4 +description: "ExponentPart :: E -DecimalDigits" +---*/ + +//CHECK#0 +if (0E-1 !== 0) { + throw new Test262Error('#0: 0E-1 === 0'); +} + +//CHECK#1 +if (1E-1 !== 0.1) { + throw new Test262Error('#1: 1E-1 === 0.1'); +} + +//CHECK#2 +if (2E-1 !== 0.2) { + throw new Test262Error('#2: 2E-1 === 0.2'); +} + +//CHECK#3 +if (3E-1 !== 0.3) { + throw new Test262Error('#3: 3E-1 === 0.3'); +} + +//CHECK#4 +if (4E-1 !== 0.4) { + throw new Test262Error('#4: 4E-1 === 0.4'); +} + +//CHECK#5 +if (5E-1 !== 0.5) { + throw new Test262Error('#5: 5E-1 === 0.5'); +} + +//CHECK#6 +if (6E-1 !== 0.6) { + throw new Test262Error('#6: 6E-1 === 0.6'); +} + +//CHECK#7 +if (7E-1 !== 0.7) { + throw new Test262Error('#7: 7E-1 === 0.7'); +} + +//CHECK#8 +if (8E-1 !== 0.8) { + throw new Test262Error('#8: 8E-1 === 0.8'); +} + +//CHECK#9 +if (9E-1 !== 0.9) { + throw new Test262Error('#9: 9E-1 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T5.js new file mode 100644 index 000000000..c1e1b2ff8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T5.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral ExponentPart" +es5id: 7.8.3_A1.2_T5 +description: "ExponentPart :: e +DecimalDigits" +---*/ + +//CHECK#0 +if (0e+1 !== 0) { + throw new Test262Error('#0: 0e+1 === 0'); +} + +//CHe+CK#1 +if (1e+1 !== 10) { + throw new Test262Error('#1: 1e+1 === 10'); +} + +//CHe+CK#2 +if (2e+1 !== 20) { + throw new Test262Error('#2: 2e+1 === 20'); +} + +//CHe+CK#3 +if (3e+1 !== 30) { + throw new Test262Error('#3: 3e+1 === 30'); +} + +//CHe+CK#4 +if (4e+1 !== 40) { + throw new Test262Error('#4: 4e+1 === 40'); +} + +//CHe+CK#5 +if (5e+1 !== 50) { + throw new Test262Error('#5: 5e+1 === 50'); +} + +//CHe+CK#6 +if (6e+1 !== 60) { + throw new Test262Error('#6: 6e+1 === 60'); +} + +//CHe+CK#7 +if (7e+1 !== 70) { + throw new Test262Error('#7: 7e+1 === 70'); +} + +//CHe+CK#8 +if (8e+1 !== 80) { + throw new Test262Error('#8: 8e+1 === 80'); +} + +//CHe+CK#9 +if (9e+1 !== 90) { + throw new Test262Error('#9: 9e+1 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T6.js new file mode 100644 index 000000000..c6f5688d2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T6.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral ExponentPart" +es5id: 7.8.3_A1.2_T6 +description: "ExponentPart :: E +DecimalDigits" +---*/ + +//CHECK#0 +if (0E+1 !== 0) { + throw new Test262Error('#0: 0E+1 === 0'); +} + +//CHE+CK#1 +if (1E+1 !== 10) { + throw new Test262Error('#1: 1E+1 === 10'); +} + +//CHE+CK#2 +if (2E+1 !== 20) { + throw new Test262Error('#2: 2E+1 === 20'); +} + +//CHE+CK#3 +if (3E+1 !== 30) { + throw new Test262Error('#3: 3E+1 === 30'); +} + +//CHE+CK#4 +if (4E+1 !== 40) { + throw new Test262Error('#4: 4E+1 === 40'); +} + +//CHE+CK#5 +if (5E+1 !== 50) { + throw new Test262Error('#5: 5E+1 === 50'); +} + +//CHE+CK#6 +if (6E+1 !== 60) { + throw new Test262Error('#6: 6E+1 === 60'); +} + +//CHE+CK#7 +if (7E+1 !== 70) { + throw new Test262Error('#7: 7E+1 === 70'); +} + +//CHE+CK#8 +if (8E+1 !== 80) { + throw new Test262Error('#8: 8E+1 === 80'); +} + +//CHE+CK#9 +if (9E+1 !== 90) { + throw new Test262Error('#9: 9E+1 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T7.js new file mode 100644 index 000000000..8db338071 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T7.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral ExponentPart" +es5id: 7.8.3_A1.2_T7 +description: "ExponentPart :: e 0" +---*/ + +//CHECK#0 +if (0e0 !== 0) { + throw new Test262Error('#0: 0e0 === 0'); +} + +//CHECK#1 +if (1e0 !== 1) { + throw new Test262Error('#1: 1e0 === 1'); +} + +//CHECK#2 +if (2e0 !== 2) { + throw new Test262Error('#2: 2e0 === 2'); +} + +//CHECK#3 +if (3e0 !== 3) { + throw new Test262Error('#3: 3e0 === 3'); +} + +//CHECK#4 +if (4e0 !== 4) { + throw new Test262Error('#4: 4e0 === 4'); +} + +//CHECK#5 +if (5e0 !== 5) { + throw new Test262Error('#5: 5e0 === 5'); +} + +//CHECK#6 +if (6e0 !== 6) { + throw new Test262Error('#6: 6e0 === 6'); +} + +//CHECK#7 +if (7e0 !== 7) { + throw new Test262Error('#7: 7e0 === 7'); +} + +//CHECK#8 +if (8e0 !== 8) { + throw new Test262Error('#8: 8e0 === 8'); +} + +//CHECK#9 +if (9e0 !== 9) { + throw new Test262Error('#9: 9e0 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T8.js new file mode 100644 index 000000000..be6181387 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A1.2_T8.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral ExponentPart" +es5id: 7.8.3_A1.2_T8 +description: "ExponentPart :: E 0" +---*/ + +//CHECK#0 +if (0E0 !== 0) { + throw new Test262Error('#0: 0E0 === 0'); +} + +//CHECK#1 +if (1E0 !== 1) { + throw new Test262Error('#1: 1E0 === 1'); +} + +//CHECK#2 +if (2E0 !== 2) { + throw new Test262Error('#2: 2E0 === 2'); +} + +//CHECK#3 +if (3E0 !== 3) { + throw new Test262Error('#3: 3E0 === 3'); +} + +//CHECK#4 +if (4E0 !== 4) { + throw new Test262Error('#4: 4E0 === 4'); +} + +//CHECK#5 +if (5E0 !== 5) { + throw new Test262Error('#5: 5E0 === 5'); +} + +//CHECK#6 +if (6E0 !== 6) { + throw new Test262Error('#6: 6E0 === 6'); +} + +//CHECK#7 +if (7E0 !== 7) { + throw new Test262Error('#7: 7E0 === 7'); +} + +//CHECK#8 +if (8E0 !== 8) { + throw new Test262Error('#8: 8E0 === 8'); +} + +//CHECK#9 +if (9E0 !== 9) { + throw new Test262Error('#9: 9E0 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.1_T1.js new file mode 100644 index 000000000..e935e67fe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.1_T1.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits" +es5id: 7.8.3_A2.1_T1 +description: Use .DecimalDigit +---*/ + +//CHECK#0 +if (.0 !== 0.0) { + throw new Test262Error('#0: .0 === 0.0'); +} + +//CHECK#1 +if (.1 !== 0.1) { + throw new Test262Error('#1: .1 === 0.1'); +} + +//CHECK#2 +if (.2 !== 0.2) { + throw new Test262Error('#2: .2 === 0.2'); +} + +//CHECK#3 +if (.3 !== 0.3) { + throw new Test262Error('#3: .3 === 0.3'); +} + +//CHECK#4 +if (.4 !== 0.4) { + throw new Test262Error('#4: .4 === 0.4'); +} + +//CHECK#5 +if (.5 !== 0.5) { + throw new Test262Error('#5: .5 === 0.5'); +} + +//CHECK#6 +if (.6 !== 0.6) { + throw new Test262Error('#6: .6 === 0.6'); +} + +//CHECK#7 +if (.7 !== 0.7) { + throw new Test262Error('#7: .7 === 0.7'); +} + +//CHECK#8 +if (.8 !== 0.8) { + throw new Test262Error('#8: .8 === 0.8'); +} + +//CHECK#9 +if (.9 !== 0.9) { + throw new Test262Error('#9: .9 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.1_T2.js new file mode 100644 index 000000000..f0dd605f2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.1_T2.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits" +es5id: 7.8.3_A2.1_T2 +description: Use .DecimalDigits +---*/ + +//CHECK#0 +if (.00 !== 0.00) { + throw new Test262Error('#0: .00 === 0.00'); +} + +//CHECK#1 +if (.11 !== 0.11) { + throw new Test262Error('#1: .11 === 0.11'); +} + +//CHECK#2 +if (.22 !== 0.22) { + throw new Test262Error('#2: .22 === 0.22'); +} + +//CHECK#3 +if (.33 !== 0.33) { + throw new Test262Error('#3: .33 === 0.33'); +} + +//CHECK#4 +if (.44 !== 0.44) { + throw new Test262Error('#4: .44 === 0.44'); +} + +//CHECK#5 +if (.55 !== 0.55) { + throw new Test262Error('#5: .55 === 0.55'); +} + +//CHECK#6 +if (.66 !== 0.66) { + throw new Test262Error('#6: .66 === 0.66'); +} + +//CHECK#7 +if (.77 !== 0.77) { + throw new Test262Error('#7: .77 === 0.77'); +} + +//CHECK#8 +if (.88 !== 0.88) { + throw new Test262Error('#8: .88 === 0.88'); +} + +//CHECK#9 +if (.99 !== 0.99) { + throw new Test262Error('#9: .99 === 0.99'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.1_T3.js new file mode 100644 index 000000000..f0999a50d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.1_T3.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits" +es5id: 7.8.3_A2.1_T3 +description: Use .DecimalDigits that have at the end zeros +---*/ + +//CHECK#0 +if (.00 !== 0.0) { + throw new Test262Error('#0: .0 === 0.0'); +} + +//CHECK#1 +if (.10 !== 0.1) { + throw new Test262Error('#1: .1 === 0.1'); +} + +//CHECK#2 +if (.20 !== 0.2) { + throw new Test262Error('#2: .2 === 0.2'); +} + +//CHECK#3 +if (.30 !== 0.3) { + throw new Test262Error('#3: .3 === 0.3'); +} + +//CHECK#4 +if (.40 !== 0.4) { + throw new Test262Error('#4: .4 === 0.4'); +} + +//CHECK#5 +if (.50 !== 0.5) { + throw new Test262Error('#5: .5 === 0.5'); +} + +//CHECK#6 +if (.60 !== 0.6) { + throw new Test262Error('#6: .6 === 0.6'); +} + +//CHECK#7 +if (.70 !== 0.7) { + throw new Test262Error('#7: .7 === 0.7'); +} + +//CHECK#8 +if (.80 !== 0.8) { + throw new Test262Error('#8: .8 === 0.8'); +} + +//CHECK#9 +if (.90 !== 0.9) { + throw new Test262Error('#9: .9 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T1.js new file mode 100644 index 000000000..ee314c88d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T1.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits ExponentPart" +es5id: 7.8.3_A2.2_T1 +description: "ExponentPart :: e DecimalDigits" +---*/ + +//CHECK#0 +if (.0e1 !== 0) { + throw new Test262Error('#0: .0e1 === 0'); +} + +//CHECK#1 +if (.1e1 !== 1) { + throw new Test262Error('#1: .1e1 === 1'); +} + +//CHECK#2 +if (.2e1 !== 2) { + throw new Test262Error('#2: .2e1 === 2'); +} + +//CHECK#3 +if (.3e1 !== 3) { + throw new Test262Error('#3: .3e1 === 3'); +} + +//CHECK#4 +if (.4e1 !== 4) { + throw new Test262Error('#4: .4e1 === 4'); +} + +//CHECK#5 +if (.5e1 !== 5) { + throw new Test262Error('#5: .5e1 === 5'); +} + +//CHECK#6 +if (.6e1 !== 6) { + throw new Test262Error('#6: .6e1 === 6'); +} + +//CHECK#7 +if (.7e1 !== 7) { + throw new Test262Error('#7: .7e1 === 7'); +} + +//CHECK#8 +if (.8e1 !== 8) { + throw new Test262Error('#8: .8e1 === 8'); +} + +//CHECK#9 +if (.9e1 !== 9) { + throw new Test262Error('#9: .9e1 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T2.js new file mode 100644 index 000000000..6acc3b226 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T2.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits ExponentPart" +es5id: 7.8.3_A2.2_T2 +description: "ExponentPart :: E DecimalDigits" +---*/ + +//CHECK#0 +if (.0E1 !== 0) { + throw new Test262Error('#0: .0E1 === 0'); +} + +//CHECK#1 +if (.1E1 !== 1) { + throw new Test262Error('#1: .1E1 === 1'); +} + +//CHECK#2 +if (.2E1 !== 2) { + throw new Test262Error('#2: .2E1 === 2'); +} + +//CHECK#3 +if (.3E1 !== 3) { + throw new Test262Error('#3: .3E1 === 3'); +} + +//CHECK#4 +if (.4E1 !== 4) { + throw new Test262Error('#4: .4E1 === 4'); +} + +//CHECK#5 +if (.5E1 !== 5) { + throw new Test262Error('#5: .5E1 === 5'); +} + +//CHECK#6 +if (.6E1 !== 6) { + throw new Test262Error('#6: .6E1 === 6'); +} + +//CHECK#7 +if (.7E1 !== 7) { + throw new Test262Error('#7: .7E1 === 7'); +} + +//CHECK#8 +if (.8E1 !== 8) { + throw new Test262Error('#8: .8E1 === 8'); +} + +//CHECK#9 +if (.9E1 !== 9) { + throw new Test262Error('#9: .9E1 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T3.js new file mode 100644 index 000000000..48fa8b7ed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T3.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits ExponentPart" +es5id: 7.8.3_A2.2_T3 +description: "ExponentPart :: e +DecimalDigits" +---*/ + +//CHECK#0 +if (.0e-1 !== 0) { + throw new Test262Error('#0: .0e-1 === 0'); +} + +//CHECK#1 +if (.1e-1 !== 0.01) { + throw new Test262Error('#1: .1e-1 === 0.01'); +} + +//CHECK#2 +if (.2e-1 !== 0.02) { + throw new Test262Error('#2: .2e-1 === 0.02'); +} + +//CHECK#3 +if (.3e-1 !== 0.03) { + throw new Test262Error('#3: .3e-1 === 0.03'); +} + +//CHECK#4 +if (.4e-1 !== 0.04) { + throw new Test262Error('#4: .4e-1 === 0.04'); +} + +//CHECK#5 +if (.5e-1 !== 0.05) { + throw new Test262Error('#5: .5e-1 === 0.05'); +} + +//CHECK#6 +if (.6e-1 !== 0.06) { + throw new Test262Error('#6: .6e-1 === 0.06'); +} + +//CHECK#7 +if (.7e-1 !== 0.07) { + throw new Test262Error('#7: .7e-1 === 0.07'); +} + +//CHECK#8 +if (.8e-1 !== 0.08) { + throw new Test262Error('#8: .8e-1 === 0.08'); +} + +//CHECK#9 +if (.9e-1 !== 0.09) { + throw new Test262Error('#9: .9e-1 === 0.09'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T4.js new file mode 100644 index 000000000..90e0c5681 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T4.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits ExponentPart" +es5id: 7.8.3_A2.2_T4 +description: "ExponentPart :: E +DecimalDigits" +---*/ + +//CHECK#0 +if (.0E-1 !== 0) { + throw new Test262Error('#0: .0E-1 === 0'); +} + +//CHECK#1 +if (.1E-1 !== 0.01) { + throw new Test262Error('#1: .1E-1 === 0.01'); +} + +//CHECK#2 +if (.2E-1 !== 0.02) { + throw new Test262Error('#2: .2E-1 === 0.02'); +} + +//CHECK#3 +if (.3E-1 !== 0.03) { + throw new Test262Error('#3: .3E-1 === 0.03'); +} + +//CHECK#4 +if (.4E-1 !== 0.04) { + throw new Test262Error('#4: .4E-1 === 0.04'); +} + +//CHECK#5 +if (.5E-1 !== 0.05) { + throw new Test262Error('#5: .5E-1 === 0.05'); +} + +//CHECK#6 +if (.6E-1 !== 0.06) { + throw new Test262Error('#6: .6E-1 === 0.06'); +} + +//CHECK#7 +if (.7E-1 !== 0.07) { + throw new Test262Error('#7: .7E-1 === 0.07'); +} + +//CHECK#8 +if (.8E-1 !== 0.08) { + throw new Test262Error('#8: .8E-1 === 0.08'); +} + +//CHECK#9 +if (.9E-1 !== 0.09) { + throw new Test262Error('#9: .9E-1 === 0.09'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T5.js new file mode 100644 index 000000000..cb372d26f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T5.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits ExponentPart" +es5id: 7.8.3_A2.2_T5 +description: "ExponentPart :: e +DecimalDigits" +---*/ + +//CHECK#0 +if (.0e+1 !== 0) { + throw new Test262Error('#0: .0e+1 === 0'); +} + +//CHECK#1 +if (.1e+1 !== 1) { + throw new Test262Error('#1: .1e+1 === 1'); +} + +//CHECK#2 +if (.2e+1 !== 2) { + throw new Test262Error('#2: .2e+1 === 2'); +} + +//CHECK#3 +if (.3e+1 !== 3) { + throw new Test262Error('#3: .3e+1 === 3'); +} + +//CHECK#4 +if (.4e+1 !== 4) { + throw new Test262Error('#4: .4e+1 === 4'); +} + +//CHECK#5 +if (.5e+1 !== 5) { + throw new Test262Error('#5: .5e+1 === 5'); +} + +//CHECK#6 +if (.6e+1 !== 6) { + throw new Test262Error('#6: .6e+1 === 6'); +} + +//CHECK#7 +if (.7e+1 !== 7) { + throw new Test262Error('#7: .7e+1 === 7'); +} + +//CHECK#8 +if (.8e+1 !== 8) { + throw new Test262Error('#8: .8e+1 === 8'); +} + +//CHECK#9 +if (.9e+1 !== 9) { + throw new Test262Error('#9: .9e+1 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T6.js new file mode 100644 index 000000000..0e1143108 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T6.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits ExponentPart" +es5id: 7.8.3_A2.2_T6 +description: "ExponentPart :: E +DecimalDigits" +---*/ + +//CHECK#0 +if (.0E+1 !== 0) { + throw new Test262Error('#0: .0E+1 === 0'); +} + +//CHECK#1 +if (.1E+1 !== 1) { + throw new Test262Error('#1: .1E+1 === 1'); +} + +//CHECK#2 +if (.2E+1 !== 2) { + throw new Test262Error('#2: .2E+1 === 2'); +} + +//CHECK#3 +if (.3E+1 !== 3) { + throw new Test262Error('#3: .3E+1 === 3'); +} + +//CHECK#4 +if (.4E+1 !== 4) { + throw new Test262Error('#4: .4E+1 === 4'); +} + +//CHECK#5 +if (.5E+1 !== 5) { + throw new Test262Error('#5: .5E+1 === 5'); +} + +//CHECK#6 +if (.6E+1 !== 6) { + throw new Test262Error('#6: .6E+1 === 6'); +} + +//CHECK#7 +if (.7E+1 !== 7) { + throw new Test262Error('#7: .7E+1 === 7'); +} + +//CHECK#8 +if (.8E+1 !== 8) { + throw new Test262Error('#8: .8E+1 === 8'); +} + +//CHECK#9 +if (.9E+1 !== 9) { + throw new Test262Error('#9: .9E+1 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T7.js new file mode 100644 index 000000000..5db5062e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T7.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits ExponentPart" +es5id: 7.8.3_A2.2_T7 +description: "ExponentPart :: e 0" +---*/ + +//CHECK#0 +if (.0e0 !== 0.0) { + throw new Test262Error('#0: .0e0 === 0.0'); +} + +//CHECK#1 +if (.1e0 !== 0.1) { + throw new Test262Error('#1: .1e0 === 0.1'); +} + +//CHECK#2 +if (.2e0 !== 0.2) { + throw new Test262Error('#2: .2e0 === 0.2'); +} + +//CHECK#3 +if (.3e0 !== 0.3) { + throw new Test262Error('#3: .3e0 === 0.3'); +} + +//CHECK#4 +if (.4e0 !== 0.4) { + throw new Test262Error('#4: .4e0 === 0.4'); +} + +//CHECK#5 +if (.5e0 !== 0.5) { + throw new Test262Error('#5: .5e0 === 0.5'); +} + +//CHECK#6 +if (.6e0 !== 0.6) { + throw new Test262Error('#6: .6e0 === 0.6'); +} + +//CHECK#7 +if (.7e0 !== 0.7) { + throw new Test262Error('#7: .7e0 === 0.7'); +} + +//CHECK#8 +if (.8e0 !== 0.8) { + throw new Test262Error('#8: .8e0 === 0.8'); +} + +//CHECK#9 +if (.9e0 !== 0.9) { + throw new Test262Error('#9: .9e0 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T8.js new file mode 100644 index 000000000..8e599d0f3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A2.2_T8.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: .DecimalDigits ExponentPart" +es5id: 7.8.3_A2.2_T8 +description: "ExponentPart :: E 0" +---*/ + +//CHECK#0 +if (.0E0 !== 0.0) { + throw new Test262Error('#0: .0E0 === 0.0'); +} + +//CHECK#1 +if (.1E0 !== 0.1) { + throw new Test262Error('#1: .1E0 === 0.1'); +} + +//CHECK#2 +if (.2E0 !== 0.2) { + throw new Test262Error('#2: .2E0 === 0.2'); +} + +//CHECK#3 +if (.3E0 !== 0.3) { + throw new Test262Error('#3: .3E0 === 0.3'); +} + +//CHECK#4 +if (.4E0 !== 0.4) { + throw new Test262Error('#4: .4E0 === 0.4'); +} + +//CHECK#5 +if (.5E0 !== 0.5) { + throw new Test262Error('#5: .5E0 === 0.5'); +} + +//CHECK#6 +if (.6E0 !== 0.6) { + throw new Test262Error('#6: .6E0 === 0.6'); +} + +//CHECK#7 +if (.7E0 !== 0.7) { + throw new Test262Error('#7: .7E0 === 0.7'); +} + +//CHECK#8 +if (.8E0 !== 0.8) { + throw new Test262Error('#8: .8E0 === 0.8'); +} + +//CHECK#9 +if (.9E0 !== 0.9) { + throw new Test262Error('#9: .9E0 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.1_T1.js new file mode 100644 index 000000000..a908f70bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.1_T1.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral." +es5id: 7.8.3_A3.1_T1 +description: "DecimalIntegerLiteral :: 0, NoNZeroDigit" +---*/ + +//CHECK#0 +if (0. !== 0) { + throw new Test262Error('#0: 0. === 0'); +} + +//CHECK#1 +if (1. !== 1) { + throw new Test262Error('#1: 1. === 1'); +} + +//CHECK#2 +if (2. !== 2) { + throw new Test262Error('#2: 2. === 2'); +} + +//CHECK#3 +if (3. !== 3) { + throw new Test262Error('#3: 3. === 3'); +} + +//CHECK#4 +if (4. !== 4) { + throw new Test262Error('#4: 4. === 4'); +} + +//CHECK#5 +if (5. !== 5) { + throw new Test262Error('#5: 5. === 5'); +} + +//CHECK#6 +if (6. !== 6) { + throw new Test262Error('#6: 6. === 6'); +} + +//CHECK#7 +if (7. !== 7) { + throw new Test262Error('#7: 7. === 7'); +} + +//CHECK#8 +if (8. !== 8) { + throw new Test262Error('#8: 8. === 8'); +} + +//CHECK#9 +if (9. !== 9) { + throw new Test262Error('#9: 9. === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.1_T2.js new file mode 100644 index 000000000..53625ee2f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.1_T2.js @@ -0,0 +1,53 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral." +es5id: 7.8.3_A3.1_T2 +description: "DecimalIntegerLiteral :: NoNZeroDigit DecimalDigigts" +---*/ + +//CHECK#1 +if (11. !== 11) { + throw new Test262Error('#1: 11. === 11'); +} + +//CHECK#2 +if (22. !== 22) { + throw new Test262Error('#2: 22. === 22'); +} + +//CHECK#3 +if (33. !== 33) { + throw new Test262Error('#3: 33. === 33'); +} + +//CHECK#4 +if (44. !== 44) { + throw new Test262Error('#4: 44. === 44'); +} + +//CHECK#5 +if (55. !== 55) { + throw new Test262Error('#5: 55. === 55'); +} + +//CHECK#6 +if (66. !== 66) { + throw new Test262Error('#6: 66. === 66'); +} + +//CHECK#7 +if (77. !== 77) { + throw new Test262Error('#7: 77. === 77'); +} + +//CHECK#8 +if (88. !== 88) { + throw new Test262Error('#8: 88. === 88'); +} + +//CHECK#9 +if (99. !== 99) { + throw new Test262Error('#9: 99. === 99'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.2_T1.js new file mode 100644 index 000000000..646a36668 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.2_T1.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigits" +es5id: 7.8.3_A3.2_T1 +description: After DecimalIntegerLiteral. used ZeroDigit +---*/ + +//CHECK#0 +if (0.0 !== 0) { + throw new Test262Error('#0: 0.0 === 0'); +} + +//CHECK#1 +if (1.0 !== 1) { + throw new Test262Error('#1: 1.0 === 1'); +} + +//CHECK#2 +if (2.0 !== 2) { + throw new Test262Error('#2: 2.0 === 2'); +} + +//CHECK#3 +if (3.0 !== 3) { + throw new Test262Error('#3: 3.0 === 3'); +} + +//CHECK#4 +if (4.0 !== 4) { + throw new Test262Error('#4: 4.0 === 4'); +} + +//CHECK#5 +if (5.0 !== 5) { + throw new Test262Error('#5: 5.0 === 5'); +} + +//CHECK#6 +if (6.0 !== 6) { + throw new Test262Error('#6: 6.0 === 6'); +} + +//CHECK#7 +if (7.0 !== 7) { + throw new Test262Error('#7: 7.0 === 7'); +} + +//CHECK#8 +if (8.0 !== 8) { + throw new Test262Error('#8: 8.0 === 8'); +} + +//CHECK#9 +if (9.0 !== 9) { + throw new Test262Error('#9: 9.0 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.2_T2.js new file mode 100644 index 000000000..4798f35f8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.2_T2.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigits" +es5id: 7.8.3_A3.2_T2 +description: After DecimalIntegerLiteral. used ZeroDigits +---*/ + +//CHECK#0 +if (0.00 !== 0) { + throw new Test262Error('#0: 0.00 === 0'); +} + +//CHECK#1 +if (1.00 !== 1) { + throw new Test262Error('#1: 1.00 === 1'); +} + +//CHECK#2 +if (2.00 !== 2) { + throw new Test262Error('#2: 2.00 === 2'); +} + +//CHECK#3 +if (3.00 !== 3) { + throw new Test262Error('#3: 3.00 === 3'); +} + +//CHECK#4 +if (4.00 !== 4) { + throw new Test262Error('#4: 4.00 === 4'); +} + +//CHECK#5 +if (5.00 !== 5) { + throw new Test262Error('#5: 5.00 === 5'); +} + +//CHECK#6 +if (6.00 !== 6) { + throw new Test262Error('#6: 6.00 === 6'); +} + +//CHECK#7 +if (7.00 !== 7) { + throw new Test262Error('#7: 7.00 === 7'); +} + +//CHECK#8 +if (8.00 !== 8) { + throw new Test262Error('#8: 8.00 === 8'); +} + +//CHECK#9 +if (9.00 !== 9) { + throw new Test262Error('#9: 9.00 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.2_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.2_T3.js new file mode 100644 index 000000000..904a5c5b8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.2_T3.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigits" +es5id: 7.8.3_A3.2_T3 +description: After DecimalIntegerLiteral. used NoNZeroDigit +---*/ + +//CHECK#0 +if (0.0 !== 0.0) { + throw new Test262Error('#0: 0.0 === 0.0'); +} + +//CHECK#1 +if (1.1 !== 1.1) { + throw new Test262Error('#1: 1.1 === 1.1'); +} + +//CHECK#2 +if (2.2 !== 2.2) { + throw new Test262Error('#2: 2.2 === 2.2'); +} + +//CHECK#3 +if (3.3 !== 3.3) { + throw new Test262Error('#3: 3.3 === 3.3'); +} + +//CHECK#4 +if (4.4 !== 4.4) { + throw new Test262Error('#4: 4.4 === 4.4'); +} + +//CHECK#5 +if (5.5 !== 5.5) { + throw new Test262Error('#5: 5.5 === 5.5'); +} + +//CHECK#6 +if (6.6 !== 6.6) { + throw new Test262Error('#6: 6.6 === 6.6'); +} + +//CHECK#7 +if (7.7 !== 7.7) { + throw new Test262Error('#7: 7.7 === 7.7'); +} + +//CHECK#8 +if (8.8 !== 8.8) { + throw new Test262Error('#8: 8..8 === 8.8'); +} + +//CHECK#9 +if (9.9 !== 9.9) { + throw new Test262Error('#9: 9.9 === 9.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T1.js new file mode 100644 index 000000000..820fb9543 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T1.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. ExponentPart" +es5id: 7.8.3_A3.3_T1 +description: "ExponentPart :: e DecimalDigits" +---*/ + +//CHECK#0 +if (0.e1 !== 0) { + throw new Test262Error('#0: 0.e1 === 0'); +} + +//CHECK#1 +if (1.e1 !== 10) { + throw new Test262Error('#1: 1.e1 === 10'); +} + +//CHECK#2 +if (2.e1 !== 20) { + throw new Test262Error('#2: 2.e1 === 20'); +} + +//CHECK#3 +if (3.e1 !== 30) { + throw new Test262Error('#3: 3.e1 === 30'); +} + +//CHECK#4 +if (4.e1 !== 40) { + throw new Test262Error('#4: 4.e1 === 40'); +} + +//CHECK#5 +if (5.e1 !== 50) { + throw new Test262Error('#5: 5.e1 === 50'); +} + +//CHECK#6 +if (6.e1 !== 60) { + throw new Test262Error('#6: 6.e1 === 60'); +} + +//CHECK#7 +if (7.e1 !== 70) { + throw new Test262Error('#7: 7.e1 === 70'); +} + +//CHECK#8 +if (8.e1 !== 80) { + throw new Test262Error('#8: 8.e1 === 80'); +} + +//CHECK#9 +if (9.e1 !== 90) { + throw new Test262Error('#9: 9.e1 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T2.js new file mode 100644 index 000000000..ffc4ce595 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T2.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. ExponentPart" +es5id: 7.8.3_A3.3_T2 +description: "ExponentPart :: E DecimalDigits" +---*/ + +//CHECK#0 +if (0.E1 !== 0) { + throw new Test262Error('#0: 0.E1 === 0'); +} + +//CHECK#1 +if (1.E1 !== 10) { + throw new Test262Error('#1: 1.E1 === 10'); +} + +//CHECK#2 +if (2.E1 !== 20) { + throw new Test262Error('#2: 2.E1 === 20'); +} + +//CHECK#3 +if (3.E1 !== 30) { + throw new Test262Error('#3: 3.E1 === 30'); +} + +//CHECK#4 +if (4.E1 !== 40) { + throw new Test262Error('#4: 4.E1 === 40'); +} + +//CHECK#5 +if (5.E1 !== 50) { + throw new Test262Error('#5: 5.E1 === 50'); +} + +//CHECK#6 +if (6.E1 !== 60) { + throw new Test262Error('#6: 6.E1 === 60'); +} + +//CHECK#7 +if (7.E1 !== 70) { + throw new Test262Error('#7: 7.E1 === 70'); +} + +//CHECK#8 +if (8.E1 !== 80) { + throw new Test262Error('#8: 8.E1 === 80'); +} + +//CHECK#9 +if (9.E1 !== 90) { + throw new Test262Error('#9: 9.E1 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T3.js new file mode 100644 index 000000000..99331eb33 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T3.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. ExponentPart" +es5id: 7.8.3_A3.3_T3 +description: "ExponentPart :: e -DecimalDigits" +---*/ + +//CHECK#0 +if (0.e-1 !== 0) { + throw new Test262Error('#0: 0.e-1 === 0'); +} + +//CHECK#1 +if (1.e-1 !== 0.1) { + throw new Test262Error('#1: 1.e-1 === 0.1'); +} + +//CHECK#2 +if (2.e-1 !== 0.2) { + throw new Test262Error('#2: 2.e-1 === 0.2'); +} + +//CHECK#3 +if (3.e-1 !== 0.3) { + throw new Test262Error('#3: 3.e-1 === 0.3'); +} + +//CHECK#4 +if (4.e-1 !== 0.4) { + throw new Test262Error('#4: 4.e-1 === 0.4'); +} + +//CHECK#5 +if (5.e-1 !== 0.5) { + throw new Test262Error('#5: 5.e-1 === 0.5'); +} + +//CHECK#6 +if (6.e-1 !== 0.6) { + throw new Test262Error('#6: 6.e-1 === 0.6'); +} + +//CHECK#7 +if (7.e-1 !== 0.7) { + throw new Test262Error('#7: 7.e-1 === 0.7'); +} + +//CHECK#8 +if (8.e-1 !== 0.8) { + throw new Test262Error('#8: 8.e-1 === 0.8'); +} + +//CHECK#9 +if (9.e-1 !== 0.9) { + throw new Test262Error('#9: 9.e-1 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T4.js new file mode 100644 index 000000000..5051de64b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T4.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. ExponentPart" +es5id: 7.8.3_A3.3_T4 +description: "ExponentPart :: E -DecimalDigits" +---*/ + +//CHECK#0 +if (0.E-1 !== 0) { + throw new Test262Error('#0: 0.E-1 === 0'); +} + +//CHECK#1 +if (1.E-1 !== 0.1) { + throw new Test262Error('#1: 1.E-1 === 0.1'); +} + +//CHECK#2 +if (2.E-1 !== 0.2) { + throw new Test262Error('#2: 2.E-1 === 0.2'); +} + +//CHECK#3 +if (3.E-1 !== 0.3) { + throw new Test262Error('#3: 3.E-1 === 0.3'); +} + +//CHECK#4 +if (4.E-1 !== 0.4) { + throw new Test262Error('#4: 4.E-1 === 0.4'); +} + +//CHECK#5 +if (5.E-1 !== 0.5) { + throw new Test262Error('#5: 5.E-1 === 0.5'); +} + +//CHECK#6 +if (6.E-1 !== 0.6) { + throw new Test262Error('#6: 6.E-1 === 0.6'); +} + +//CHECK#7 +if (7.E-1 !== 0.7) { + throw new Test262Error('#7: 7.E-1 === 0.7'); +} + +//CHECK#8 +if (8.E-1 !== 0.8) { + throw new Test262Error('#8: 8.E-1 === 0.8'); +} + +//CHECK#9 +if (9.E-1 !== 0.9) { + throw new Test262Error('#9: 9.E-1 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T5.js new file mode 100644 index 000000000..26c26ef3d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T5.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. ExponentPart" +es5id: 7.8.3_A3.3_T5 +description: "ExponentPart :: e +DecimalDigits" +---*/ + +//CHECK#0 +if (0.e+1 !== 0) { + throw new Test262Error('#0: 0.e+1 === 0'); +} + +//CHECK#1 +if (1.e+1 !== 10) { + throw new Test262Error('#1: 1.e+1 === 10'); +} + +//CHECK#2 +if (2.e+1 !== 20) { + throw new Test262Error('#2: 2.e+1 === 20'); +} + +//CHECK#3 +if (3.e+1 !== 30) { + throw new Test262Error('#3: 3.e+1 === 30'); +} + +//CHECK#4 +if (4.e+1 !== 40) { + throw new Test262Error('#4: 4.e+1 === 40'); +} + +//CHECK#5 +if (5.e+1 !== 50) { + throw new Test262Error('#5: 5.e+1 === 50'); +} + +//CHECK#6 +if (6.e+1 !== 60) { + throw new Test262Error('#6: 6.e+1 === 60'); +} + +//CHECK#7 +if (7.e+1 !== 70) { + throw new Test262Error('#7: 7.e+1 === 70'); +} + +//CHECK#8 +if (8.e+1 !== 80) { + throw new Test262Error('#8: 8.e+1 === 80'); +} + +//CHECK#9 +if (9.e+1 !== 90) { + throw new Test262Error('#9: 9.e+1 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T6.js new file mode 100644 index 000000000..83c49cc21 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T6.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. ExponentPart" +es5id: 7.8.3_A3.3_T6 +description: "ExponentPart :: E +DecimalDigits" +---*/ + +//CHECK#0 +if (0.E+1 !== 0) { + throw new Test262Error('#0: 0.E+1 === 0'); +} + +//CHECK#1 +if (1.E+1 !== 10) { + throw new Test262Error('#1: 1.E+1 === 10'); +} + +//CHECK#2 +if (2.E+1 !== 20) { + throw new Test262Error('#2: 2.E+1 === 20'); +} + +//CHECK#3 +if (3.E+1 !== 30) { + throw new Test262Error('#3: 3.E+1 === 30'); +} + +//CHECK#4 +if (4.E+1 !== 40) { + throw new Test262Error('#4: 4.E+1 === 40'); +} + +//CHECK#5 +if (5.E+1 !== 50) { + throw new Test262Error('#5: 5.E+1 === 50'); +} + +//CHECK#6 +if (6.E+1 !== 60) { + throw new Test262Error('#6: 6.E+1 === 60'); +} + +//CHECK#7 +if (7.E+1 !== 70) { + throw new Test262Error('#7: 7.E+1 === 70'); +} + +//CHECK#8 +if (8.E+1 !== 80) { + throw new Test262Error('#8: 8.E+1 === 80'); +} + +//CHECK#9 +if (9.E+1 !== 90) { + throw new Test262Error('#9: 9.E+1 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T7.js new file mode 100644 index 000000000..9fb069844 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T7.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. ExponentPart" +es5id: 7.8.3_A3.3_T7 +description: "ExponentPart :: e 0" +---*/ + +//CHECK#0 +if (0.e0 !== 0) { + throw new Test262Error('#0: 0.e0 === 0'); +} + +//CHECK#1 +if (1.e0 !== 1) { + throw new Test262Error('#1: 1.e0 === 1'); +} + +//CHECK#2 +if (2.e0 !== 2) { + throw new Test262Error('#2: 2.e0 === 2'); +} + +//CHECK#3 +if (3.e0 !== 3) { + throw new Test262Error('#3: 3.e0 === 3'); +} + +//CHECK#4 +if (4.e0 !== 4) { + throw new Test262Error('#4: 4.e0 === 4'); +} + +//CHECK#5 +if (5.e0 !== 5) { + throw new Test262Error('#5: 5.e0 === 5'); +} + +//CHECK#6 +if (6.e0 !== 6) { + throw new Test262Error('#6: 6.e0 === 6'); +} + +//CHECK#7 +if (7.e0 !== 7) { + throw new Test262Error('#7: 7.e0 === 7'); +} + +//CHECK#8 +if (8.e0 !== 8) { + throw new Test262Error('#8: 8.e0 === 8'); +} + +//CHECK#9 +if (9.e0 !== 9) { + throw new Test262Error('#9: 9.e0 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T8.js new file mode 100644 index 000000000..b5ef8d631 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.3_T8.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. ExponentPart" +es5id: 7.8.3_A3.3_T8 +description: "ExponentPart :: E 0" +---*/ + +//CHECK#0 +if (0.E0 !== 0) { + throw new Test262Error('#0: 0.E0 === 0'); +} + +//CHECK#1 +if (1.E0 !== 1) { + throw new Test262Error('#1: 1.E0 === 1'); +} + +//CHECK#2 +if (2.E0 !== 2) { + throw new Test262Error('#2: 2.E0 === 2'); +} + +//CHECK#3 +if (3.E0 !== 3) { + throw new Test262Error('#3: 3.E0 === 3'); +} + +//CHECK#4 +if (4.E0 !== 4) { + throw new Test262Error('#4: 4.E0 === 4'); +} + +//CHECK#5 +if (5.E0 !== 5) { + throw new Test262Error('#5: 5.E0 === 5'); +} + +//CHECK#6 +if (6.E0 !== 6) { + throw new Test262Error('#6: 6.E0 === 6'); +} + +//CHECK#7 +if (7.E0 !== 7) { + throw new Test262Error('#7: 7.E0 === 7'); +} + +//CHECK#8 +if (8.E0 !== 8) { + throw new Test262Error('#8: 8.E0 === 8'); +} + +//CHECK#9 +if (9.E0 !== 9) { + throw new Test262Error('#9: 9.E0 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T1.js new file mode 100644 index 000000000..27a639ee0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T1.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigigts ExponentPart" +es5id: 7.8.3_A3.4_T1 +description: "ExponentPart :: e DecimalDigits" +---*/ + +//CHECK#0 +if (0.0e1 !== 0) { + throw new Test262Error('#0: 0.0e1 === 0'); +} + +//CHECK#1 +if (1.1e1 !== 11) { + throw new Test262Error('#1: 1.1e1 === 11'); +} + +//CHECK#2 +if (2.2e1 !== 22) { + throw new Test262Error('#2: 2.2e1 === 22'); +} + +//CHECK#3 +if (3.3e1 !== 33) { + throw new Test262Error('#3: 3.3e1 === 33'); +} + +//CHECK#4 +if (4.4e1 !== 44) { + throw new Test262Error('#4: 4.4e1 === 44'); +} + +//CHECK#5 +if (5.5e1 !== 55) { + throw new Test262Error('#5: 5.5e1 === 55'); +} + +//CHECK#6 +if (6.6e1 !== 66) { + throw new Test262Error('#6: 6.e1 === 66'); +} + +//CHECK#7 +if (7.7e1 !== 77) { + throw new Test262Error('#7: 7.7e1 === 77'); +} + +//CHECK#8 +if (8.8e1 !== 88) { + throw new Test262Error('#8: 8.8e1 === 88'); +} + +//CHECK#9 +if (9.9e1 !== 99) { + throw new Test262Error('#9: 9.9e1 === 99'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T2.js new file mode 100644 index 000000000..f9fa81d0e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T2.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigigts ExponentPart" +es5id: 7.8.3_A3.4_T2 +description: "ExponentPart :: E DecimalDigits" +---*/ + +//CHECK#0 +if (0.0E1 !== 0) { + throw new Test262Error('#0: 0.0E1 === 0'); +} + +//CHECK#1 +if (1.1E1 !== 11) { + throw new Test262Error('#1: 1.1E1 === 11'); +} + +//CHECK#2 +if (2.2E1 !== 22) { + throw new Test262Error('#2: 2.2E1 === 22'); +} + +//CHECK#3 +if (3.3E1 !== 33) { + throw new Test262Error('#3: 3.3E1 === 33'); +} + +//CHECK#4 +if (4.4E1 !== 44) { + throw new Test262Error('#4: 4.4E1 === 44'); +} + +//CHECK#5 +if (5.5E1 !== 55) { + throw new Test262Error('#5: 5.5E1 === 55'); +} + +//CHECK#6 +if (6.6E1 !== 66) { + throw new Test262Error('#6: 6.E1 === 66'); +} + +//CHECK#7 +if (7.7E1 !== 77) { + throw new Test262Error('#7: 7.7E1 === 77'); +} + +//CHECK#8 +if (8.8E1 !== 88) { + throw new Test262Error('#8: 8.8E1 === 88'); +} + +//CHECK#9 +if (9.9E1 !== 99) { + throw new Test262Error('#9: 9.9E1 === 99'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T3.js new file mode 100644 index 000000000..bc50ce825 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T3.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigigts ExponentPart" +es5id: 7.8.3_A3.4_T3 +description: "ExponentPart :: e -DecimalDigits" +---*/ + +//CHECK#0 +if (0.0e-1 !== 0) { + throw new Test262Error('#0: 0.0e-1 === 0'); +} + +//CHECK#1 +if (1.1e-1 !== 0.11) { + throw new Test262Error('#1: 1.1e-1 === 0.11'); +} + +//CHECK#2 +if (2.2e-1 !== 0.22) { + throw new Test262Error('#2: 2.2e-1 === 0.22'); +} + +//CHECK#3 +if (3.3e-1 !== 0.33) { + throw new Test262Error('#3: 3.3e-1 === 0.33'); +} + +//CHECK#4 +if (4.4e-1 !== 0.44) { + throw new Test262Error('#4: 4.4e-1 === 0.44'); +} + +//CHECK#5 +if (5.5e-1 !== 0.55) { + throw new Test262Error('#5: 5.5e-1 === 0.55'); +} + +//CHECK#6 +if (6.6e-1 !== 0.66) { + throw new Test262Error('#6: 6.e-1 === 0.66'); +} + +//CHECK#7 +if (7.7e-1 !== 0.77) { + throw new Test262Error('#7: 7.7e-1 === 0.77'); +} + +//CHECK#8 +if (8.8e-1 !== 0.88) { + throw new Test262Error('#8: 8.8e-1 === 0.88'); +} + +//CHECK#9 +if (9.9e-1 !== 0.99) { + throw new Test262Error('#9: 9.9e-1 === 0.99'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T4.js new file mode 100644 index 000000000..a5a929655 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T4.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigigts ExponentPart" +es5id: 7.8.3_A3.4_T4 +description: "ExponentPart :: E -DecimalDigits" +---*/ + +//CHECK#0 +if (0.0E-1 !== 0) { + throw new Test262Error('#0: 0.0E-1 === 0'); +} + +//CHECK#1 +if (1.1E-1 !== 0.11) { + throw new Test262Error('#1: 1.1E-1 === 0.11'); +} + +//CHECK#2 +if (2.2E-1 !== 0.22) { + throw new Test262Error('#2: 2.2E-1 === 0.22'); +} + +//CHECK#3 +if (3.3E-1 !== 0.33) { + throw new Test262Error('#3: 3.3E-1 === 0.33'); +} + +//CHECK#4 +if (4.4E-1 !== 0.44) { + throw new Test262Error('#4: 4.4E-1 === 0.44'); +} + +//CHECK#5 +if (5.5E-1 !== 0.55) { + throw new Test262Error('#5: 5.5E-1 === 0.55'); +} + +//CHECK#6 +if (6.6E-1 !== 0.66) { + throw new Test262Error('#6: 6.E-1 === 0.66'); +} + +//CHECK#7 +if (7.7E-1 !== 0.77) { + throw new Test262Error('#7: 7.7E-1 === 0.77'); +} + +//CHECK#8 +if (8.8E-1 !== 0.88) { + throw new Test262Error('#8: 8.8E-1 === 0.88'); +} + +//CHECK#9 +if (9.9E-1 !== 0.99) { + throw new Test262Error('#9: 9.9E-1 === 0.99'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T5.js new file mode 100644 index 000000000..92a21b3c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T5.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigigts ExponentPart" +es5id: 7.8.3_A3.4_T5 +description: "ExponentPart :: e +DecimalDigits" +---*/ + +//CHECK#0 +if (0.0e+1 !== 0) { + throw new Test262Error('#0: 0.0e+1 === 0'); +} + +//CHECK#1 +if (1.1e+1 !== 11) { + throw new Test262Error('#1: 1.1e+1 === 11'); +} + +//CHECK#2 +if (2.2e+1 !== 22) { + throw new Test262Error('#2: 2.2e+1 === 22'); +} + +//CHECK#3 +if (3.3e+1 !== 33) { + throw new Test262Error('#3: 3.3e+1 === 33'); +} + +//CHECK#4 +if (4.4e+1 !== 44) { + throw new Test262Error('#4: 4.4e+1 === 44'); +} + +//CHECK#5 +if (5.5e+1 !== 55) { + throw new Test262Error('#5: 5.5e+1 === 55'); +} + +//CHECK#6 +if (6.6e+1 !== 66) { + throw new Test262Error('#6: 6.e+1 === 66'); +} + +//CHECK#7 +if (7.7e+1 !== 77) { + throw new Test262Error('#7: 7.7e+1 === 77'); +} + +//CHECK#8 +if (8.8e+1 !== 88) { + throw new Test262Error('#8: 8.8e+1 === 88'); +} + +//CHECK#9 +if (9.9e+1 !== 99) { + throw new Test262Error('#9: 9.9e+1 === 99'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T6.js new file mode 100644 index 000000000..ace8940ae --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T6.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigigts ExponentPart" +es5id: 7.8.3_A3.4_T6 +description: "ExponentPart :: E +DecimalDigits" +---*/ + +//CHECK#0 +if (0.0E+1 !== 0) { + throw new Test262Error('#0: 0.0E+1 === 0'); +} + +//CHECK#1 +if (1.1E+1 !== 11) { + throw new Test262Error('#1: 1.1E+1 === 11'); +} + +//CHECK#2 +if (2.2E+1 !== 22) { + throw new Test262Error('#2: 2.2E+1 === 22'); +} + +//CHECK#3 +if (3.3E+1 !== 33) { + throw new Test262Error('#3: 3.3E+1 === 33'); +} + +//CHECK#4 +if (4.4E+1 !== 44) { + throw new Test262Error('#4: 4.4E+1 === 44'); +} + +//CHECK#5 +if (5.5E+1 !== 55) { + throw new Test262Error('#5: 5.5E+1 === 55'); +} + +//CHECK#6 +if (6.6E+1 !== 66) { + throw new Test262Error('#6: 6.E+1 === 66'); +} + +//CHECK#7 +if (7.7E+1 !== 77) { + throw new Test262Error('#7: 7.7E+1 === 77'); +} + +//CHECK#8 +if (8.8E+1 !== 88) { + throw new Test262Error('#8: 8.8E+1 === 88'); +} + +//CHECK#9 +if (9.9E+1 !== 99) { + throw new Test262Error('#9: 9.9E+1 === 99'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T7.js new file mode 100644 index 000000000..6568d5691 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T7.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigigts ExponentPart" +es5id: 7.8.3_A3.4_T7 +description: "ExponentPart :: e 0" +---*/ + +//CHECK#0 +if (0.0e0 !== 0.0) { + throw new Test262Error('#0: 0.0e0 === 0.0'); +} + +//CHECK#1 +if (1.1e0 !== 1.1) { + throw new Test262Error('#1: 1.1e0 === 1.1'); +} + +//CHECK#2 +if (2.2e0 !== 2.2) { + throw new Test262Error('#2: 2.2e0 === 2.2'); +} + +//CHECK#3 +if (3.3e0 !== 3.3) { + throw new Test262Error('#3: 3.3e0 === 3.3'); +} + +//CHECK#4 +if (4.4e0 !== 4.4) { + throw new Test262Error('#4: 4.4e0 === 4.4'); +} + +//CHECK#5 +if (5.5e0 !== 5.5) { + throw new Test262Error('#5: 5.5e0 === 5.5'); +} + +//CHECK#6 +if (6.6e0 !== 6.6) { + throw new Test262Error('#6: 6.e0 === 6.6'); +} + +//CHECK#7 +if (7.7e0 !== 7.7) { + throw new Test262Error('#7: 7.7e0 === 7.7'); +} + +//CHECK#8 +if (8.8e0 !== 8.8) { + throw new Test262Error('#8: 8.8e0 === 8.8'); +} + +//CHECK#9 +if (9.9e0 !== 9.9) { + throw new Test262Error('#9: 9.9e0 === 9.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T8.js new file mode 100644 index 000000000..e13faf56d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A3.4_T8.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: DecimalIntegerLiteral. DecimalDigigts ExponentPart" +es5id: 7.8.3_A3.4_T8 +description: "ExponentPart :: E 0" +---*/ + +//CHECK#0 +if (0.0E0 !== 0.0) { + throw new Test262Error('#0: 0.0E0 === 0.0'); +} + +//CHECK#1 +if (1.1E0 !== 1.1) { + throw new Test262Error('#1: 1.1E0 === 1.1'); +} + +//CHECK#2 +if (2.2E0 !== 2.2) { + throw new Test262Error('#2: 2.2E0 === 2.2'); +} + +//CHECK#3 +if (3.3E0 !== 3.3) { + throw new Test262Error('#3: 3.3E0 === 3.3'); +} + +//CHECK#4 +if (4.4E0 !== 4.4) { + throw new Test262Error('#4: 4.4E0 === 4.4'); +} + +//CHECK#5 +if (5.5E0 !== 5.5) { + throw new Test262Error('#5: 5.5E0 === 5.5'); +} + +//CHECK#6 +if (6.6E0 !== 6.6) { + throw new Test262Error('#6: 6.E0 === 6.6'); +} + +//CHECK#7 +if (7.7E0 !== 7.7) { + throw new Test262Error('#7: 7.7E0 === 7.7'); +} + +//CHECK#8 +if (8.8E0 !== 8.8) { + throw new Test262Error('#8: 8.8E0 === 8.8'); +} + +//CHECK#9 +if (9.9E0 !== 9.9) { + throw new Test262Error('#9: 9.9E0 === 9.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T1.js new file mode 100644 index 000000000..bc06c1d1b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T1.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: ExponentPart is incorrect" +es5id: 7.8.3_A4.1_T1 +description: "ExponentPart :: e DecimalDigits" +---*/ + +assert.throws(ReferenceError, function() { + e1 +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T2.js new file mode 100644 index 000000000..7f380c77c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T2.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: ExponentPart is incorrect" +es5id: 7.8.3_A4.1_T2 +description: "ExponentPart :: E DecimalDigits" +---*/ + +assert.throws(ReferenceError, function() { + E1 +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T3.js new file mode 100644 index 000000000..d409549e6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T3.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: ExponentPart is incorrect" +es5id: 7.8.3_A4.1_T3 +description: "ExponentPart :: e DecimalDigits" +---*/ + +assert.throws(ReferenceError, function() { + e-1 +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T4.js new file mode 100644 index 000000000..bc52c5248 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T4.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: ExponentPart is incorrect" +es5id: 7.8.3_A4.1_T4 +description: "ExponentPart :: E DecimalDigits" +---*/ + +assert.throws(ReferenceError, function() { + E-1 +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T5.js new file mode 100644 index 000000000..b27832b83 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T5.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: ExponentPart is incorrect" +es5id: 7.8.3_A4.1_T5 +description: "ExponentPart :: e DecimalDigits" +---*/ + +assert.throws(ReferenceError, function() { + e+1 +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T6.js new file mode 100644 index 000000000..0ec20924b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T6.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: ExponentPart is incorrect" +es5id: 7.8.3_A4.1_T6 +description: "ExponentPart :: E DecimalDigits" +---*/ + +assert.throws(ReferenceError, function() { + E+1 +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T7.js new file mode 100644 index 000000000..38e2db4d0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T7.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: ExponentPart is incorrect" +es5id: 7.8.3_A4.1_T7 +description: "ExponentPart :: e 0" +---*/ + +assert.throws(ReferenceError, function() { + e0 +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T8.js new file mode 100644 index 000000000..c90de6057 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.1_T8.js @@ -0,0 +1,12 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: ExponentPart is incorrect" +es5id: 7.8.3_A4.1_T8 +description: "ExponentPart :: E 0" +---*/ + +assert.throws(ReferenceError, function() { + E0 +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T1.js new file mode 100644 index 000000000..c7c6cd3f4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T1.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "ExponentPart :: ExponentIndicator ( /+/-) 0 DecimalDigits is allowed" +es5id: 7.8.3_A4.2_T1 +description: "ExponentIndicator :: e" +---*/ + +//CHECK#0 +if (0e01 !== 0) { + throw new Test262Error('#0: 0e01 === 0'); +} + +//CHECK#1 +if (1e01 !== 10) { + throw new Test262Error('#1: 1e01 === 10'); +} + +//CHECK#2 +if (2e01 !== 20) { + throw new Test262Error('#2: 2e01 === 20'); +} + +//CHECK#3 +if (3e01 !== 30) { + throw new Test262Error('#3: 3e01 === 30'); +} + +//CHECK#4 +if (4e01 !== 40) { + throw new Test262Error('#4: 4e01 === 40'); +} + +//CHECK#5 +if (5e01 !== 50) { + throw new Test262Error('#5: 5e01 === 50'); +} + +//CHECK#6 +if (6e01 !== 60) { + throw new Test262Error('#6: 6e01 === 60'); +} + +//CHECK#7 +if (7e01 !== 70) { + throw new Test262Error('#7: 7e01 === 70'); +} + +//CHECK#8 +if (8e01 !== 80) { + throw new Test262Error('#8: 8e01 === 80'); +} + +//CHECK#9 +if (9e01 !== 90) { + throw new Test262Error('#9: 9e01 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T2.js new file mode 100644 index 000000000..c7da13963 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T2.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "ExponentPart :: ExponentIndicator ( /+/-) 0 DecimalDigits is allowed" +es5id: 7.8.3_A4.2_T2 +description: "ExponentIndicator :: E" +---*/ + +//CHECK#0 +if (0E01 !== 0) { + throw new Test262Error('#0: 0E01 === 0'); +} + +//CHECK#1 +if (1E01 !== 10) { + throw new Test262Error('#1: 1E01 === 10'); +} + +//CHECK#2 +if (2E01 !== 20) { + throw new Test262Error('#2: 2E01 === 20'); +} + +//CHECK#3 +if (3E01 !== 30) { + throw new Test262Error('#3: 3E01 === 30'); +} + +//CHECK#4 +if (4E01 !== 40) { + throw new Test262Error('#4: 4E01 === 40'); +} + +//CHECK#5 +if (5E01 !== 50) { + throw new Test262Error('#5: 5E01 === 50'); +} + +//CHECK#6 +if (6E01 !== 60) { + throw new Test262Error('#6: 6E01 === 60'); +} + +//CHECK#7 +if (7E01 !== 70) { + throw new Test262Error('#7: 7E01 === 70'); +} + +//CHECK#8 +if (8E01 !== 80) { + throw new Test262Error('#8: 8E01 === 80'); +} + +//CHECK#9 +if (9E01 !== 90) { + throw new Test262Error('#9: 9E01 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T3.js new file mode 100644 index 000000000..7167bb226 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T3.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "ExponentPart :: ExponentIndicator ( /+/-) 0 DecimalDigits is allowed" +es5id: 7.8.3_A4.2_T3 +description: "ExponentIndicator :: e" +---*/ + +//CHECK#0 +if (0e-01 !== 0) { + throw new Test262Error('#0: 0e-01 === 0'); +} + +//CHECK#1 +if (1e-01 !== 0.1) { + throw new Test262Error('#1: 1e-01 === 0.1'); +} + +//CHECK#2 +if (2e-01 !== 0.2) { + throw new Test262Error('#2: 2e-01 === 0.2'); +} + +//CHECK#3 +if (3e-01 !== 0.3) { + throw new Test262Error('#3: 3e-01 === 0.3'); +} + +//CHECK#4 +if (4e-01 !== 0.4) { + throw new Test262Error('#4: 4e-01 === 0.4'); +} + +//CHECK#5 +if (5e-01 !== 0.5) { + throw new Test262Error('#5: 5e-01 === 0.5'); +} + +//CHECK#6 +if (6e-01 !== 0.6) { + throw new Test262Error('#6: 6e-01 === 0.6'); +} + +//CHECK#7 +if (7e-01 !== 0.7) { + throw new Test262Error('#7: 7e-01 === 0.7'); +} + +//CHECK#8 +if (8e-01 !== 0.8) { + throw new Test262Error('#8: 8e-01 === 0.8'); +} + +//CHECK#9 +if (9e-01 !== 0.9) { + throw new Test262Error('#9: 9e-01 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T4.js new file mode 100644 index 000000000..e4fc9eb71 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T4.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "ExponentPart :: ExponentIndicator ( /+/-) 0 DecimalDigits is allowed" +es5id: 7.8.3_A4.2_T4 +description: "ExponentIndicator :: E" +---*/ + +//CHECK#0 +if (0E-01 !== 0) { + throw new Test262Error('#0: 0E-01 === 0'); +} + +//CHECK#1 +if (1E-01 !== 0.1) { + throw new Test262Error('#1: 1E-01 === 0.1'); +} + +//CHECK#2 +if (2E-01 !== 0.2) { + throw new Test262Error('#2: 2E-01 === 0.2'); +} + +//CHECK#3 +if (3E-01 !== 0.3) { + throw new Test262Error('#3: 3E-01 === 0.3'); +} + +//CHECK#4 +if (4E-01 !== 0.4) { + throw new Test262Error('#4: 4E-01 === 0.4'); +} + +//CHECK#5 +if (5E-01 !== 0.5) { + throw new Test262Error('#5: 5E-01 === 0.5'); +} + +//CHECK#6 +if (6E-01 !== 0.6) { + throw new Test262Error('#6: 6E-01 === 0.6'); +} + +//CHECK#7 +if (7E-01 !== 0.7) { + throw new Test262Error('#7: 7E-01 === 0.7'); +} + +//CHECK#8 +if (8E-01 !== 0.8) { + throw new Test262Error('#8: 8E-01 === 0.8'); +} + +//CHECK#9 +if (9E-01 !== 0.9) { + throw new Test262Error('#9: 9E-01 === 0.9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T5.js new file mode 100644 index 000000000..5db506881 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T5.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "ExponentPart :: ExponentIndicator ( /+/-) 0 DecimalDigits is allowed" +es5id: 7.8.3_A4.2_T5 +description: "ExponentIndicator :: e" +---*/ + +//CHECK#0 +if (0e+01 !== 0) { + throw new Test262Error('#0: 0e+01 === 0'); +} + +//CHECK#1 +if (1e+01 !== 10) { + throw new Test262Error('#1: 1e+01 === 10'); +} + +//CHECK#2 +if (2e+01 !== 20) { + throw new Test262Error('#2: 2e+01 === 20'); +} + +//CHECK#3 +if (3e+01 !== 30) { + throw new Test262Error('#3: 3e+01 === 30'); +} + +//CHECK#4 +if (4e+01 !== 40) { + throw new Test262Error('#4: 4e+01 === 40'); +} + +//CHECK#5 +if (5e+01 !== 50) { + throw new Test262Error('#5: 5e+01 === 50'); +} + +//CHECK#6 +if (6e+01 !== 60) { + throw new Test262Error('#6: 6e+01 === 60'); +} + +//CHECK#7 +if (7e+01 !== 70) { + throw new Test262Error('#7: 7e+01 === 70'); +} + +//CHECK#8 +if (8e+01 !== 80) { + throw new Test262Error('#8: 8e+01 === 80'); +} + +//CHECK#9 +if (9e+01 !== 90) { + throw new Test262Error('#9: 9e+01 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T6.js new file mode 100644 index 000000000..992befbfb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T6.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "ExponentPart :: ExponentIndicator ( /+/-) 0 DecimalDigits is allowed" +es5id: 7.8.3_A4.2_T6 +description: "ExponentIndicator :: E" +---*/ + +//CHECK#0 +if (0E+01 !== 0) { + throw new Test262Error('#0: 0E+01 === 0'); +} + +//CHECK#1 +if (1E+01 !== 10) { + throw new Test262Error('#1: 1E+01 === 10'); +} + +//CHECK#2 +if (2E+01 !== 20) { + throw new Test262Error('#2: 2E+01 === 20'); +} + +//CHECK#3 +if (3E+01 !== 30) { + throw new Test262Error('#3: 3E+01 === 30'); +} + +//CHECK#4 +if (4E+01 !== 40) { + throw new Test262Error('#4: 4E+01 === 40'); +} + +//CHECK#5 +if (5E+01 !== 50) { + throw new Test262Error('#5: 5E+01 === 50'); +} + +//CHECK#6 +if (6E+01 !== 60) { + throw new Test262Error('#6: 6E+01 === 60'); +} + +//CHECK#7 +if (7E+01 !== 70) { + throw new Test262Error('#7: 7E+01 === 70'); +} + +//CHECK#8 +if (8E+01 !== 80) { + throw new Test262Error('#8: 8E+01 === 80'); +} + +//CHECK#9 +if (9E+01 !== 90) { + throw new Test262Error('#9: 9E+01 === 90'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T7.js new file mode 100644 index 000000000..32b43b6a1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T7.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "ExponentPart :: ExponentIndicator ( /+/-) 0 DecimalDigits is allowed" +es5id: 7.8.3_A4.2_T7 +description: "ExponentIndicator :: e" +---*/ + +//CHECK#0 +if (0e00 !== 0) { + throw new Test262Error('#0: 0e00 === 0'); +} + +//CHECK#1 +if (1e00 !== 1) { + throw new Test262Error('#1: 1e00 === 1'); +} + +//CHECK#2 +if (2e00 !== 2) { + throw new Test262Error('#2: 2e00 === 2'); +} + +//CHECK#3 +if (3e00 !== 3) { + throw new Test262Error('#3: 3e00 === 3'); +} + +//CHECK#4 +if (4e00 !== 4) { + throw new Test262Error('#4: 4e00 === 4'); +} + +//CHECK#5 +if (5e00 !== 5) { + throw new Test262Error('#5: 5e00 === 5'); +} + +//CHECK#6 +if (6e00 !== 6) { + throw new Test262Error('#6: 6e00 === 6'); +} + +//CHECK#7 +if (7e00 !== 7) { + throw new Test262Error('#7: 7e00 === 7'); +} + +//CHECK#8 +if (8e00 !== 8) { + throw new Test262Error('#8: 8e00 === 8'); +} + +//CHECK#9 +if (9e00 !== 9) { + throw new Test262Error('#9: 9e00 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T8.js new file mode 100644 index 000000000..8c9c4a296 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A4.2_T8.js @@ -0,0 +1,58 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "ExponentPart :: ExponentIndicator ( /+/-) 0 DecimalDigits is allowed" +es5id: 7.8.3_A4.2_T8 +description: "ExponentIndicator :: E" +---*/ + +//CHECK#0 +if (0E00 !== 0) { + throw new Test262Error('#0: 0E00 === 0'); +} + +//CHECK#1 +if (1E00 !== 1) { + throw new Test262Error('#1: 1E00 === 1'); +} + +//CHECK#2 +if (2E00 !== 2) { + throw new Test262Error('#2: 2E00 === 2'); +} + +//CHECK#3 +if (3E00 !== 3) { + throw new Test262Error('#3: 3E00 === 3'); +} + +//CHECK#4 +if (4E00 !== 4) { + throw new Test262Error('#4: 4E00 === 4'); +} + +//CHECK#5 +if (5E00 !== 5) { + throw new Test262Error('#5: 5E00 === 5'); +} + +//CHECK#6 +if (6E00 !== 6) { + throw new Test262Error('#6: 6E00 === 6'); +} + +//CHECK#7 +if (7E00 !== 7) { + throw new Test262Error('#7: 7E00 === 7'); +} + +//CHECK#8 +if (8E00 !== 8) { + throw new Test262Error('#8: 8E00 === 8'); +} + +//CHECK#9 +if (9E00 !== 9) { + throw new Test262Error('#9: 9E00 === 9'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T1.js new file mode 100644 index 000000000..6e595de9e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T1.js @@ -0,0 +1,88 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: HexIntegerLiteral" +es5id: 7.8.3_A5.1_T1 +description: "HexIntegerLiteral :: 0x Digit" +---*/ + +//CHECK#0 +if (0x0 !== 0) { + throw new Test262Error('#0: 0x0 === 0'); +} + +//CHECK#1 +if (0x1 !== 1) { + throw new Test262Error('#1: 0x1 === 1'); +} + +//CHECK#2 +if (0x2 !== 2) { + throw new Test262Error('#2: 0x2 === 2'); +} + +//CHECK#3 +if (0x3 !== 3) { + throw new Test262Error('#3: 0x3 === 3'); +} + +//CHECK#4 +if (0x4 !== 4) { + throw new Test262Error('#4: 0x4 === 4'); +} + +//CHECK#5 +if (0x5 !== 5) { + throw new Test262Error('#5: 0x5 === 5'); +} + +//CHECK#6 +if (0x6 !== 6) { + throw new Test262Error('#6: 0x6 === 6'); +} + +//CHECK#7 +if (0x7 !== 7) { + throw new Test262Error('#7: 0x7 === 7'); +} + +//CHECK#8 +if (0x8 !== 8) { + throw new Test262Error('#8: 0x8 === 8'); +} + +//CHECK#9 +if (0x9 !== 9) { + throw new Test262Error('#9: 0x9 === 9'); +} + +//CHECK#A +if (0xA !== 10) { + throw new Test262Error('#A: 0xA === 10'); +} + +//CHECK#B +if (0xB !== 11) { + throw new Test262Error('#B: 0xB === 11'); +} + +//CHECK#C +if (0xC !== 12) { + throw new Test262Error('#C: 0xC === 12'); +} + +//CHECK#D +if (0xD !== 13) { + throw new Test262Error('#D: 0xD === 13'); +} + +//CHECK#E +if (0xE !== 14) { + throw new Test262Error('#E: 0xE === 14'); +} + +//CHECK#F +if (0xF !== 15) { + throw new Test262Error('#F: 0xF === 15'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T2.js new file mode 100644 index 000000000..52f2de09d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T2.js @@ -0,0 +1,88 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: HexIntegerLiteral" +es5id: 7.8.3_A5.1_T2 +description: "HexIntegerLiteral :: 0X Digit" +---*/ + +//CHECK#0 +if (0X0 !== 0) { + throw new Test262Error('#0: 0X0 === 0'); +} + +//CHECK#1 +if (0X1 !== 1) { + throw new Test262Error('#1: 0X1 === 1'); +} + +//CHECK#2 +if (0X2 !== 2) { + throw new Test262Error('#2: 0X2 === 2'); +} + +//CHECK#3 +if (0X3 !== 3) { + throw new Test262Error('#3: 0X3 === 3'); +} + +//CHECK#4 +if (0X4 !== 4) { + throw new Test262Error('#4: 0X4 === 4'); +} + +//CHECK#5 +if (0X5 !== 5) { + throw new Test262Error('#5: 0X5 === 5'); +} + +//CHECK#6 +if (0X6 !== 6) { + throw new Test262Error('#6: 0X6 === 6'); +} + +//CHECK#7 +if (0X7 !== 7) { + throw new Test262Error('#7: 0X7 === 7'); +} + +//CHECK#8 +if (0X8 !== 8) { + throw new Test262Error('#8: 0X8 === 8'); +} + +//CHECK#9 +if (0X9 !== 9) { + throw new Test262Error('#9: 0X9 === 9'); +} + +//CHECK#A +if (0XA !== 10) { + throw new Test262Error('#A: 0XA === 10'); +} + +//CHECK#B +if (0XB !== 11) { + throw new Test262Error('#B: 0XB === 11'); +} + +//CHECK#C +if (0XC !== 12) { + throw new Test262Error('#C: 0XC === 12'); +} + +//CHECK#D +if (0XD !== 13) { + throw new Test262Error('#D: 0XD === 13'); +} + +//CHECK#E +if (0XE !== 14) { + throw new Test262Error('#E: 0XE === 14'); +} + +//CHECK#F +if (0XF !== 15) { + throw new Test262Error('#F: 0XF === 15'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T3.js new file mode 100644 index 000000000..46f3bdcdb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T3.js @@ -0,0 +1,53 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: HexIntegerLiteral" +es5id: 7.8.3_A5.1_T3 +description: "HexIntegerLiteral :: 0x NonZeroDigit Digits" +---*/ + +//CHECK#0 +if (0x0 !== 0) { + throw new Test262Error('#0: 0x0 === 0'); +} + +//CHECK#1 +if (0x1 !== 1) { + throw new Test262Error('#1: 0x1 === 1'); +} + +//CHECK#2 +if (0x10 !== 16) { + throw new Test262Error('#2: 0x10 === 16'); +} + +//CHECK3 +if (0x100 !== 256) { + throw new Test262Error('3: 0x100 === 256'); +} + +//CHECK#4 +if (0x1000 !== 4096) { + throw new Test262Error('#4: 0x1000 === 4096'); +} + +//CHECK#5 +if (0x10000 !== 65536) { + throw new Test262Error('#5: 0x10000 === 65536'); +} + +//CHECK#6 +if (0x100000 !== 1048576) { + throw new Test262Error('#6: 0x100000 === 1048576'); +} + +//CHECK#7 +if (0x1000000 !== 16777216) { + throw new Test262Error('#7: 0x1000000 === 16777216'); +} + +//CHECK#8 +if (0x10000000 !== 268435456) { + throw new Test262Error('#8: 0x10000000 === 268435456'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T4.js new file mode 100644 index 000000000..d9a93d517 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T4.js @@ -0,0 +1,53 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: HexIntegerLiteral" +es5id: 7.8.3_A5.1_T4 +description: "HexIntegerLiteral :: 0X NonZeroDigit Digits" +---*/ + +//CHECK#0 +if (0X0 !== 0) { + throw new Test262Error('#0: 0X0 === 0'); +} + +//CHECK#1 +if (0X1 !== 1) { + throw new Test262Error('#1: 0X1 === 1'); +} + +//CHECK#2 +if (0X10 !== 16) { + throw new Test262Error('#2: 0X10 === 16'); +} + +//CHECK3 +if (0X100 !== 256) { + throw new Test262Error('3: 0X100 === 256'); +} + +//CHECK#4 +if (0X1000 !== 4096) { + throw new Test262Error('#4: 0X1000 === 4096'); +} + +//CHECK#5 +if (0X10000 !== 65536) { + throw new Test262Error('#5: 0X10000 === 65536'); +} + +//CHECK#6 +if (0X100000 !== 1048576) { + throw new Test262Error('#6: 0X100000 === 1048576'); +} + +//CHECK#7 +if (0X1000000 !== 16777216) { + throw new Test262Error('#7: 0X1000000 === 16777216'); +} + +//CHECK#8 +if (0X10000000 !== 268435456) { + throw new Test262Error('#8: 0X10000000 === 268435456'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T5.js new file mode 100644 index 000000000..112210527 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T5.js @@ -0,0 +1,53 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: HexIntegerLiteral" +es5id: 7.8.3_A5.1_T5 +description: "HexIntegerLiteral :: 0x0 Digits" +---*/ + +//CHECK#0 +if (0x00 !== 0) { + throw new Test262Error('#0: 0x00 === 0'); +} + +//CHECK#1 +if (0x01 !== 1) { + throw new Test262Error('#1: 0x01 === 1'); +} + +//CHECK#2 +if (0x010 !== 16) { + throw new Test262Error('#2: 0x010 === 16'); +} + +//CHECK3 +if (0x0100 !== 256) { + throw new Test262Error('3: 0x0100 === 256'); +} + +//CHECK#4 +if (0x01000 !== 4096) { + throw new Test262Error('#4: 0x01000 === 4096'); +} + +//CHECK#5 +if (0x010000 !== 65536) { + throw new Test262Error('#5: 0x010000 === 65536'); +} + +//CHECK#6 +if (0x0100000 !== 1048576) { + throw new Test262Error('#6: 0x0100000 === 1048576'); +} + +//CHECK#7 +if (0x01000000 !== 16777216) { + throw new Test262Error('#7: 0x01000000 === 16777216'); +} + +//CHECK#8 +if (0x010000000 !== 268435456) { + throw new Test262Error('#8: 0x010000000 === 268435456'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T6.js new file mode 100644 index 000000000..fdc911286 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T6.js @@ -0,0 +1,53 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: HexIntegerLiteral" +es5id: 7.8.3_A5.1_T6 +description: "HexIntegerLiteral :: 0X0 Digits" +---*/ + +//CHECK#0 +if (0X00 !== 0) { + throw new Test262Error('#0: 0X00 === 0'); +} + +//CHECK#1 +if (0X01 !== 1) { + throw new Test262Error('#1: 0X01 === 1'); +} + +//CHECK#2 +if (0X010 !== 16) { + throw new Test262Error('#2: 0X010 === 16'); +} + +//CHECK3 +if (0X0100 !== 256) { + throw new Test262Error('3: 0X0100 === 256'); +} + +//CHECK#4 +if (0X01000 !== 4096) { + throw new Test262Error('#4: 0X01000 === 4096'); +} + +//CHECK#5 +if (0X010000 !== 65536) { + throw new Test262Error('#5: 0X010000 === 65536'); +} + +//CHECK#6 +if (0X0100000 !== 1048576) { + throw new Test262Error('#6: 0X0100000 === 1048576'); +} + +//CHECK#7 +if (0X01000000 !== 16777216) { + throw new Test262Error('#7: 0X01000000 === 16777216'); +} + +//CHECK#8 +if (0X010000000 !== 268435456) { + throw new Test262Error('#8: 0X010000000 === 268435456'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T7.js new file mode 100644 index 000000000..829cbc2ab --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T7.js @@ -0,0 +1,38 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: HexIntegerLiteral" +es5id: 7.8.3_A5.1_T7 +description: "HexIntegerLiteral :: 0x one of a, b, c, d, e, f" +---*/ + +//CHECK#a +if (0xa !== 10) { + throw new Test262Error('#a: 0xa === 10'); +} + +//CHECK#b +if (0xb !== 11) { + throw new Test262Error('#b: 0xb === 11'); +} + +//CHECK#c +if (0xc !== 12) { + throw new Test262Error('#c: 0xc === 12'); +} + +//CHECK#d +if (0xd !== 13) { + throw new Test262Error('#d: 0xd === 13'); +} + +//CHECK#e +if (0xe !== 14) { + throw new Test262Error('#e: 0xe === 14'); +} + +//CHECK#f +if (0xf !== 15) { + throw new Test262Error('#f: 0xf === 15'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T8.js new file mode 100644 index 000000000..21a786e84 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A5.1_T8.js @@ -0,0 +1,38 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "DecimalLiteral :: HexIntegerLiteral" +es5id: 7.8.3_A5.1_T8 +description: "HexIntegerLiteral :: 0X one of a, b, c, d, e, f" +---*/ + +//CHECK#a +if (0Xa !== 10) { + throw new Test262Error('#a: 0Xa === 10'); +} + +//CHECK#b +if (0Xb !== 11) { + throw new Test262Error('#b: 0Xb === 11'); +} + +//CHECK#c +if (0Xc !== 12) { + throw new Test262Error('#c: 0Xc === 12'); +} + +//CHECK#d +if (0Xd !== 13) { + throw new Test262Error('#d: 0Xd === 13'); +} + +//CHECK#e +if (0Xe !== 14) { + throw new Test262Error('#e: 0Xe === 14'); +} + +//CHECK#f +if (0Xf !== 15) { + throw new Test262Error('#f: 0Xf === 15'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.1_T1.js new file mode 100644 index 000000000..7eb030f0b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.1_T1.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "HexIntegerLiteral :: 0(x/X) is incorrect" +es5id: 7.8.3_A6.1_T1 +description: Checking if execution of "0x" passes +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +0x diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.1_T2.js new file mode 100644 index 000000000..63fd69057 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.1_T2.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "HexIntegerLiteral :: 0(x/X) is incorrect" +es5id: 7.8.3_A6.1_T2 +description: Checking if execution of "0X" passes +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +0X diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.2_T1.js new file mode 100644 index 000000000..cec76f6c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.2_T1.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: 0xG is incorrect +es5id: 7.8.3_A6.2_T1 +description: Checking if execution of "0xG" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +0xG diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.2_T2.js new file mode 100644 index 000000000..7d1b29a03 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/S7.8.3_A6.2_T2.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: 0xG is incorrect +es5id: 7.8.3_A6.2_T2 +description: Checking if execution of "0xg" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +0xg diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-digit.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-digit.js new file mode 100644 index 000000000..7fab44619 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-digit.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3 +description: Binary-integer-literal-like sequence containing an invalid digit +info: | + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigit :: one of + 0 1 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0b2; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-leading.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-leading.js new file mode 100644 index 000000000..c594c24cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-leading.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3 +description: Binary-integer-literal-like sequence with a leading 0 +info: | + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigit :: one of + 0 1 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +00b0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-truncated.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-truncated.js new file mode 100644 index 000000000..bbd1a5ee0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-truncated.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3 +description: Binary-integer-literal-like sequence without any digits +info: | + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigit :: one of + 0 1 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0b; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-unicode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-unicode.js new file mode 100644 index 000000000..fefe59b23 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary-invalid-unicode.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3 +description: Binary-integer-literal-like sequence expressed with unicode escape sequence +info: | + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigit :: one of + 0 1 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0\u00620; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary.js new file mode 100644 index 000000000..f871184bd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/binary.js @@ -0,0 +1,35 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3.1 +description: Mathematical value of valid binary integer literals +info: | + The MV of BinaryIntegerLiteral :: 0b BinaryDigits is the MV of + BinaryDigits. + The MV of BinaryIntegerLiteral :: 0B BinaryDigits is the MV of + BinaryDigits. + The MV of BinaryDigits :: BinaryDigit is the MV of BinaryDigit. + The MV of BinaryDigits :: BinaryDigits BinaryDigit is (the MV of + BinaryDigits × 2) plus the MV of BinaryDigit. +---*/ + +assert.sameValue(0b0, 0, 'lower-case head'); +assert.sameValue(0B0, 0, 'upper-case head'); +assert.sameValue(0b00, 0, 'lower-case head with leading zeros'); +assert.sameValue(0B00, 0, 'upper-case head with leading zeros'); + +assert.sameValue(0b1, 1, 'lower-case head'); +assert.sameValue(0B1, 1, 'upper-case head'); +assert.sameValue(0b01, 1, 'lower-case head with leading zeros'); +assert.sameValue(0B01, 1, 'upper-case head with leading zeros'); + +assert.sameValue(0b10, 2, 'lower-case head'); +assert.sameValue(0B10, 2, 'upper-case head'); +assert.sameValue(0b010, 2, 'lower-case head with leading zeros'); +assert.sameValue(0B010, 2, 'upper-case head with leading zeros'); + +assert.sameValue(0b11, 3, 'lower-case head'); +assert.sameValue(0B11, 3, 'upper-case head'); +assert.sameValue(0b011, 3, 'lower-case head with leading zeros'); +assert.sameValue(0B011, 3, 'upper-case head with leading zeros'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integer-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integer-strict.js new file mode 100644 index 000000000..f8f9c02aa --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integer-strict.js @@ -0,0 +1,33 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-numeric-literals +description: LegacyOctalIntegerLiteral is not enabled in strict mode code +info: | + NumericLiteral :: + DecimalLiteral + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + LegacyOctalIntegerLiteral + + LegacyOctalIntegerLiteral :: + 0 OctalDigit + LegacyOctalIntegerLiteral OctalDigit + + ## 12.8.3.1 Static Semantics: Early Errors + + NumericLiteral :: LegacyOctalIntegerLiteral + DecimalIntegerLiteral :: NonOctalDecimalIntegerLiteral + + - It is a Syntax Error if the source code matching this production is + strict mode code. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +00; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integer.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integer.js new file mode 100644 index 000000000..cd3be3b11 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integer.js @@ -0,0 +1,49 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-numeric-literals +description: Mathematical value for LegacyOctalIntegerLiteral +info: | + NumericLiteral :: + DecimalLiteral + BinaryIntegerLiteral + OctalIntegerLiteral + HexIntegerLiteral + LegacyOctalIntegerLiteral + + LegacyOctalIntegerLiteral :: + 0 OctalDigit + LegacyOctalIntegerLiteral OctalDigit +flags: [noStrict] +---*/ + +// LegacyOctalIntegerLiteral :: +// 0 OctalDigit +assert.sameValue(00, 0, '00'); +assert.sameValue(01, 1, '01'); +assert.sameValue(02, 2, '02'); +assert.sameValue(03, 3, '03'); +assert.sameValue(04, 4, '04'); +assert.sameValue(05, 5, '05'); +assert.sameValue(06, 6, '06'); +assert.sameValue(07, 7, '07'); + +// LegacyOctalIntegerLiteral :: +// LegacyOctalIntegerLiteral OctalDigit +assert.sameValue(000, 0, '000'); +assert.sameValue(001, 1, '001'); +assert.sameValue(002, 2, '002'); +assert.sameValue(003, 3, '003'); +assert.sameValue(004, 4, '004'); +assert.sameValue(005, 5, '005'); +assert.sameValue(006, 6, '006'); +assert.sameValue(007, 7, '007'); + +assert.sameValue(070, 56); +assert.sameValue(071, 57); +assert.sameValue(072, 58); +assert.sameValue(073, 59); +assert.sameValue(074, 60); +assert.sameValue(075, 61); +assert.sameValue(076, 62); +assert.sameValue(077, 63); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-000-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-000-strict.js new file mode 100644 index 000000000..a62ef52b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-000-strict.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.3-6-s +description: Strict Mode - octal extension (000) is forbidden in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +000; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-005-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-005-strict.js new file mode 100644 index 000000000..f32c08233 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-005-strict.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.3-7-s +description: Strict Mode - octal extension (005) is forbidden in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +005; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-01-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-01-strict.js new file mode 100644 index 000000000..fc89b50f4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-01-strict.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.3-3-s +description: Strict Mode - octal extension (01) is forbidden in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +01; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-010-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-010-strict.js new file mode 100644 index 000000000..7bb23e259 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-010-strict.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.3-1-s +description: Strict Mode - octal extension (010) is forbidden in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +010; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-06-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-06-strict.js new file mode 100644 index 000000000..ac6eab9cf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-06-strict.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.3-4-s +description: Strict Mode - octal extension (06) is forbidden in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +06; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-07-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-07-strict.js new file mode 100644 index 000000000..ac5c6bd3f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/legacy-octal-integery-07-strict.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.3-5-s +description: Strict Mode - octal extension (07) is forbidden in strict mode +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +07; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/non-octal-decimal-integer-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/non-octal-decimal-integer-strict.js new file mode 100644 index 000000000..446f88530 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/non-octal-decimal-integer-strict.js @@ -0,0 +1,39 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-numeric-literals +description: NonOctalDecimalIntegerLiteral is not enabled in strict mode code +info: | + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigits[opt] + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit :: one of + 8 9 + + ## 12.8.3.1 Static Semantics: Early Errors + + NumericLiteral :: LegacyOctalIntegerLiteral + DecimalIntegerLiteral :: NonOctalDecimalIntegerLiteral + + - It is a Syntax Error if the source code matching this production is + strict mode code. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +08; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/non-octal-decimal-integer.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/non-octal-decimal-integer.js new file mode 100644 index 000000000..6905ba987 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/non-octal-decimal-integer.js @@ -0,0 +1,119 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-numeric-literals +description: Mathematical value for NonOctalDecimalIntegerLiteral +info: | + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigits[opt] + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit :: one of + 8 9 +flags: [noStrict] +---*/ + +// NonOctalDecimalIntegerLiteral :: +// 0 NonOctalDigit +assert.sameValue(08, 8, '08'); +assert.sameValue(09, 9, '09'); + +// NonOctalDecimalIntegerLiteral :: +// LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit +assert.sameValue(008, 8, '008'); +assert.sameValue(018, 18, '018'); +assert.sameValue(028, 28, '028'); +assert.sameValue(038, 38, '038'); +assert.sameValue(048, 48, '048'); +assert.sameValue(058, 58, '058'); +assert.sameValue(068, 68, '068'); +assert.sameValue(078, 78, '078'); +assert.sameValue(088, 88, '088'); +assert.sameValue(098, 98, '098'); +assert.sameValue(0708, 708, '708'); +assert.sameValue(0718, 718, '718'); +assert.sameValue(0728, 728, '728'); +assert.sameValue(0738, 738, '738'); +assert.sameValue(0748, 748, '748'); +assert.sameValue(0758, 758, '758'); +assert.sameValue(0768, 768, '768'); +assert.sameValue(0778, 778, '778'); +assert.sameValue(0788, 788, '788'); +assert.sameValue(0798, 798, '798'); + +assert.sameValue(009, 9, '009'); +assert.sameValue(019, 19, '019'); +assert.sameValue(029, 29, '029'); +assert.sameValue(039, 39, '039'); +assert.sameValue(049, 49, '049'); +assert.sameValue(059, 59, '059'); +assert.sameValue(069, 69, '069'); +assert.sameValue(079, 79, '079'); +assert.sameValue(089, 89, '089'); +assert.sameValue(099, 99, '099'); +assert.sameValue(0709, 709, '0709'); +assert.sameValue(0719, 719, '0719'); +assert.sameValue(0729, 729, '0729'); +assert.sameValue(0739, 739, '0739'); +assert.sameValue(0749, 749, '0749'); +assert.sameValue(0759, 759, '0759'); +assert.sameValue(0769, 769, '0769'); +assert.sameValue(0779, 779, '0779'); +assert.sameValue(0789, 789, '0789'); +assert.sameValue(0799, 799, '0799'); + +// NonOctalDecimalIntegerLiteral :: +// NonOctalDecimalIntegerLiteral DecimalDigit +assert.sameValue(080, 80, '080'); +assert.sameValue(081, 81, '081'); +assert.sameValue(082, 82, '082'); +assert.sameValue(083, 83, '083'); +assert.sameValue(084, 84, '084'); +assert.sameValue(085, 85, '085'); +assert.sameValue(086, 86, '086'); +assert.sameValue(087, 87, '087'); +assert.sameValue(088, 88, '088'); +assert.sameValue(089, 89, '089'); + +assert.sameValue(0780, 780, '0780'); +assert.sameValue(0781, 781, '0781'); +assert.sameValue(0782, 782, '0782'); +assert.sameValue(0783, 783, '0783'); +assert.sameValue(0784, 784, '0784'); +assert.sameValue(0785, 785, '0785'); +assert.sameValue(0786, 786, '0786'); +assert.sameValue(0787, 787, '0787'); +assert.sameValue(0788, 788, '0788'); +assert.sameValue(0789, 789, '0789'); + +assert.sameValue(090, 90, '090'); +assert.sameValue(091, 91, '091'); +assert.sameValue(092, 92, '092'); +assert.sameValue(093, 93, '093'); +assert.sameValue(094, 94, '094'); +assert.sameValue(095, 95, '095'); +assert.sameValue(096, 96, '096'); +assert.sameValue(097, 97, '097'); +assert.sameValue(098, 98, '098'); +assert.sameValue(099, 99, '099'); + +assert.sameValue(0790, 790, '0790'); +assert.sameValue(0791, 791, '0791'); +assert.sameValue(0792, 792, '0792'); +assert.sameValue(0793, 793, '0793'); +assert.sameValue(0794, 794, '0794'); +assert.sameValue(0795, 795, '0795'); +assert.sameValue(0796, 796, '0796'); +assert.sameValue(0797, 797, '0797'); +assert.sameValue(0798, 798, '0798'); +assert.sameValue(0799, 799, '0799'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-followed-by-ident.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-followed-by-ident.js new file mode 100644 index 000000000..7bd59bf20 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-followed-by-ident.js @@ -0,0 +1,18 @@ +// Copyright (C) 2018 Mozilla. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-numeric-literals +description: > + NumericLiteral followed by IdentifierStart +info: | + The source character immediately following a NumericLiteral must not be an IdentifierStart or DecimalDigit. + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +3in [] diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js new file mode 100644 index 000000000..7f968de9b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd-err.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the appear adjacent to `0b` | `0B` in a + BinaryIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0b_1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd.js new file mode 100644 index 000000000..36129c5f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bd.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0b` | `0B` BinaryDigit NumericLiteralSeparator BinaryDigit +info: | + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0b0_1, 0b01); +assert.sameValue(0B0_1, 0B01); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bds.js new file mode 100644 index 000000000..84037cc66 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bd-nsl-bds.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0b` | `0B` BinaryDigit NumericLiteralSeparator BinaryDigit +info: | + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0b0_10, 0b010); +assert.sameValue(0B0_10, 0B010); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bds-nsl-bd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bds-nsl-bd.js new file mode 100644 index 000000000..0c964795d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bds-nsl-bd.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0b` | `0B` BinaryDigits NumericLiteralSeparator BinaryDigit +info: | + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0b01_0, 0b010); +assert.sameValue(0B01_0, 0B010); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bds-nsl-bds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bds-nsl-bds.js new file mode 100644 index 000000000..c7237b2b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-bds-nsl-bds.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0b` | `0B` BinaryDigits NumericLiteralSeparator BinaryDigit +info: | + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0b01_00, 0b0100); +assert.sameValue(0B01_00, 0B0100); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js new file mode 100644 index 000000000..eaa7eb697 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-dunder-err.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in a BinaryIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0b0__0 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js new file mode 100644 index 000000000..68d3a578c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-bil-nsl-bd-err.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of a + BinaryIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + BinaryIntegerLiteral :: + 0b BinaryDigits + 0B BinaryDigits + + BinaryDigits :: + BinaryDigit + BinaryDigits BinaryDigit + BinaryDigits NumericLiteralSeparator BinaryDigit + + BinaryDigit :: one of + 0 1 + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0b0_ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-minus-dd-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-minus-dd-nsl-dd.js new file mode 100644 index 000000000..f606a7a93 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-minus-dd-nsl-dd.js @@ -0,0 +1,27 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + DecimalDigits `.` DecimalDigits ExponentPart_opt `-` DecimalDigits +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + SignedInteger :: + ... + - DecimalDigits + ... + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(1.0e-1_0, 1.0e-10); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-minus-dds-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-minus-dds-nsl-dd.js new file mode 100644 index 000000000..11d1fbff0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-minus-dds-nsl-dd.js @@ -0,0 +1,27 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + DecimalDigits `.` DecimalDigits ExponentPart_opt `-` DecimalDigits +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + SignedInteger :: + ... + - DecimalDigits + ... + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(1.0e-10_0, 1.0e-100); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-plus-dd-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-plus-dd-nsl-dd.js new file mode 100644 index 000000000..a81aa0642 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-plus-dd-nsl-dd.js @@ -0,0 +1,27 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + DecimalDigits `.` DecimalDigits ExponentPart_opt `+` DecimalDigits +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + SignedInteger :: + ... + + DecimalDigits + ... + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(1.0e+1_0, 1.0e+10); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-plus-dds-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-plus-dds-nsl-dd.js new file mode 100644 index 000000000..fb1d3301a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-dot-dd-ep-sign-plus-dds-nsl-dd.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + DecimalDigits `.` DecimalDigits ExponentPart_opt `+` DecimalDigits +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + SignedInteger :: + ... + + DecimalDigits + ... + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(1.0e+10_0, 1.0e+100); + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dd-one-of.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dd-one-of.js new file mode 100644 index 000000000..72d0b9785 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dd-one-of.js @@ -0,0 +1,35 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigit +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + + DecimalDigits :: + DecimalDigit + ... + + DecimalDigit :: one of + 0 1 2 3 4 5 6 7 8 9 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(1_0, 10); +assert.sameValue(1_1, 11); +assert.sameValue(1_2, 12); +assert.sameValue(1_3, 13); +assert.sameValue(1_4, 14); +assert.sameValue(1_5, 15); +assert.sameValue(1_6, 16); +assert.sameValue(1_7, 17); +assert.sameValue(1_8, 18); +assert.sameValue(1_9, 19); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js new file mode 100644 index 000000000..0ab8add16 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-dds-dunder-err.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in a DecimalIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +1__0123456789 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-err.js new file mode 100644 index 000000000..1c59fa79d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dd-nsl-err.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +1_ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-dot-dd-nsl-dd-ep-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-dot-dd-nsl-dd-ep-dd.js new file mode 100644 index 000000000..290f67bb3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-dot-dd-nsl-dd-ep-dd.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + DecimalDigits `.` DecimalDigits NumericLiteralSeparator DecimalDigits + ExponentPart SignedInteger +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + . DecimalDigits ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + ExponentIndicator :: one of + e E + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(10.00_01e2, 10.0001e2); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dd.js new file mode 100644 index 000000000..30591b3de --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dd.js @@ -0,0 +1,27 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: DecimalDigits NumericLiteralSeparator DecimalDigit +info: | + NumericLiteralSeparator :: + _ + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(123456789_0, 1234567890); +assert.sameValue(123456789_1, 1234567891); +assert.sameValue(123456789_2, 1234567892); +assert.sameValue(123456789_3, 1234567893); +assert.sameValue(123456789_4, 1234567894); +assert.sameValue(123456789_5, 1234567895); +assert.sameValue(123456789_6, 1234567896); +assert.sameValue(123456789_7, 1234567897); +assert.sameValue(123456789_8, 1234567898); +assert.sameValue(123456789_9, 1234567899); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js new file mode 100644 index 000000000..73cf0028d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-dds-dunder-err.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in DecimalIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +10__0123456789 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-err.js new file mode 100644 index 000000000..1f581b673 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dds-nsl-err.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of a + DecimalLiteral +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +10_ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-dds-nsl-ep-dd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-dds-nsl-ep-dd-err.js new file mode 100644 index 000000000..6d0901626 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-dds-nsl-ep-dd-err.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to ExponentPart +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +10.0_e1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-dd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-dd-err.js new file mode 100644 index 000000000..f7c32700e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-dd-err.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be adjacent to `.` +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +10._1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-ep-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-ep-err.js new file mode 100644 index 000000000..be031987d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-ep-err.js @@ -0,0 +1,31 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear between `.` and ExponentPart +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + ExponentIndicator :: one of + e E + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +10._e1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-err.js new file mode 100644 index 000000000..513efd5c3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dil-dot-nsl-err.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of a + DecimalLiteral +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + DecimalIntegerLiteral . DecimalDigits_opt ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +10._ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dd-nsl-dd-ep.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dd-nsl-dd-ep.js new file mode 100644 index 000000000..04f1b644d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dd-nsl-dd-ep.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `.` DecimalDigit NumericLiteralSeparator DecimalDigit ExponentPart +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + . DecimalDigits ExponentPart_opt + + DecimalDigits :: + DecimalDigit + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + ExponentIndicator :: one of + e E + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(.0_1e2, .01e2); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dd-nsl-dds-ep.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dd-nsl-dds-ep.js new file mode 100644 index 000000000..37180f459 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dd-nsl-dds-ep.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `.` DecimalDigit NumericLiteralSeparator DecimalDigits ExponentPart +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + . DecimalDigits ExponentPart_opt + + DecimalDigits :: + DecimalDigit + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + ExponentIndicator :: one of + e E + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(.1_01e2, .101e2); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-dd-ep.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-dd-ep.js new file mode 100644 index 000000000..4dee9bb10 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-dd-ep.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `.` DecimalDigits NumericLiteralSeparator DecimalDigit ExponentPart +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + . DecimalDigits ExponentPart_opt + + DecimalDigits :: + DecimalDigit + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + ExponentIndicator :: one of + e E + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(.10_1e2, .101e2); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-dds-ep.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-dds-ep.js new file mode 100644 index 000000000..7365bd7af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-dds-ep.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `.` DecimalDigits NumericLiteralSeparator DecimalDigits ExponentPart +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + . DecimalDigits ExponentPart_opt + + DecimalDigits :: + DecimalDigit + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + ExponentIndicator :: one of + e E + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(.00_01e2, .0001e2); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-ep-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-ep-err.js new file mode 100644 index 000000000..503c49ca7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-dds-nsl-ep-err.js @@ -0,0 +1,30 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NumericLiteralSeparator may not appear adjacent to ExponentPart +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + . DecimalDigits ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + ExponentIndicator :: one of + e E + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +.0_e1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-nsl-ep-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-nsl-ep-err.js new file mode 100644 index 000000000..ec7f92ab1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-nsl-ep-err.js @@ -0,0 +1,31 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear between `.` and ExponentPart +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + . DecimalDigits ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + + ExponentIndicator :: one of + e E + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +._e1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-nsl-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-nsl-err.js new file mode 100644 index 000000000..63c7ed429 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-dot-nsl-err.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of a + DecimalLiteral, nor adjacent to `.` +info: | + NumericLiteralSeparator :: + _ + + DecimalLiteral :: + . DecimalDigits ExponentPart_opt + + DecimalDigits :: + ... + DecimalDigits NumericLiteralSeparator DecimalDigit + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +._ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd-err.js new file mode 100644 index 000000000..6dbca041e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd-err.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the appear adjacent to `0x` | `0X` in a + HexIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0x_1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd.js new file mode 100644 index 000000000..0b931cff0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hd.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigit NumericLiteralSeparator HexDigit +info: | + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0x0_1, 0x01); +assert.sameValue(0X0_1, 0X01); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hds.js new file mode 100644 index 000000000..b277fde04 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hd-nsl-hds.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigit NumericLiteralSeparator HexDigit +info: | + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0x0_10, 0x010); +assert.sameValue(0X0_10, 0X010); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hds-nsl-hd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hds-nsl-hd.js new file mode 100644 index 000000000..fe6b3199a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hds-nsl-hd.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigits NumericLiteralSeparator HexDigit +info: | + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0x01_0, 0x010); +assert.sameValue(0X01_0, 0X010); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hds-nsl-hds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hds-nsl-hds.js new file mode 100644 index 000000000..f44d6ae82 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-hds-nsl-hds.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigits NumericLiteralSeparator HexDigit +info: | + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0x01_00, 0x0100); +assert.sameValue(0X01_00, 0X0100); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-nsl-hd-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-nsl-hd-dunder-err.js new file mode 100644 index 000000000..baa5bad9b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-nsl-hd-dunder-err.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in a HexIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0x0__0 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-nsl-hd-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-nsl-hd-err.js new file mode 100644 index 000000000..db4aa2995 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-nsl-hd-err.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of a + HexIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0x0_ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-od-nsl-od-one-of.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-od-nsl-od-one-of.js new file mode 100644 index 000000000..8650c06fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-hil-od-nsl-od-one-of.js @@ -0,0 +1,48 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0x` | `0X` HexDigit NumericLiteralSeparator HexDigit +info: | + NumericLiteralSeparator :: + _ + + HexIntegerLiteral :: + 0x HexDigits + 0X HexDigits + + HexDigits :: + HexDigit + HexDigits HexDigit + HexDigits NumericLiteralSeparator HexDigit + + HexDigit::one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0x0_0, 0x00); +assert.sameValue(0x1_1, 0x11); +assert.sameValue(0x2_2, 0x22); +assert.sameValue(0x3_3, 0x33); +assert.sameValue(0x4_4, 0x44); +assert.sameValue(0x5_5, 0x55); +assert.sameValue(0x6_6, 0x66); +assert.sameValue(0x7_7, 0x77); +assert.sameValue(0x8_8, 0x88); +assert.sameValue(0x9_9, 0x99); +assert.sameValue(0xa_a, 0xaa); +assert.sameValue(0xb_b, 0xbb); +assert.sameValue(0xc_c, 0xcc); +assert.sameValue(0xd_d, 0xdd); +assert.sameValue(0xe_e, 0xee); +assert.sameValue(0xf_f, 0xff); +assert.sameValue(0xA_A, 0xAA); +assert.sameValue(0xB_B, 0xBB); +assert.sameValue(0xC_C, 0xCC); +assert.sameValue(0xD_D, 0xDD); +assert.sameValue(0xE_E, 0xEE); +assert.sameValue(0xF_F, 0xFF); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-00-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-00-err.js new file mode 100644 index 000000000..3c3f3c62e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-00-err.js @@ -0,0 +1,41 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (00_0) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +00_0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-01-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-01-err.js new file mode 100644 index 000000000..fa206dba0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-01-err.js @@ -0,0 +1,41 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (01_0) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +01_0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-07-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-07-err.js new file mode 100644 index 000000000..0af908368 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-07-err.js @@ -0,0 +1,43 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (07_0) + ) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +07_0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_0-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_0-err.js new file mode 100644 index 000000000..6998cb03e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_0-err.js @@ -0,0 +1,41 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (0_0) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_1-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_1-err.js new file mode 100644 index 000000000..4932da69e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_1-err.js @@ -0,0 +1,41 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (0_1) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_1; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_7-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_7-err.js new file mode 100644 index 000000000..6b81733f1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-lol-0_7-err.js @@ -0,0 +1,42 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a LegacyOctalLikeDecimalIntegerLiteral (0_7) + ) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 + + OctalDigit::one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_7; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-08-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-08-err.js new file mode 100644 index 000000000..d70a87fc8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-08-err.js @@ -0,0 +1,38 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a NonOctalDecimalIntegerLiteral (08) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +08_0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-09-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-09-err.js new file mode 100644 index 000000000..258b9e9a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-09-err.js @@ -0,0 +1,38 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a NonOctalDecimalIntegerLiteral (09) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +09_0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-0_8-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-0_8-err.js new file mode 100644 index 000000000..745e4544f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-0_8-err.js @@ -0,0 +1,38 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a NonOctalDecimalIntegerLiteral (0_8) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_8; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-0_9-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-0_9-err.js new file mode 100644 index 000000000..708d350e4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nonoctal-0_9-err.js @@ -0,0 +1,38 @@ +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator must not be in a NonOctalDecimalIntegerLiteral (0_9) +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + 0 + NonZeroDigit DecimalDigitsopt + NonZeroDigit + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + NonOctalDecimalIntegerLiteral + + NonOctalDecimalIntegerLiteral :: + 0 NonOctalDigit + LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit + NonOctalDecimalIntegerLiteral DecimalDigit + + LegacyOctalLikeDecimalIntegerLiteral :: + 0 OctalDigit + LegacyOctalLikeDecimalIntegerLiteral OctalDigit + + NonOctalDigit::one of + 8 9 +negative: + phase: parse + type: SyntaxError +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_9; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dd-one-of.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dd-one-of.js new file mode 100644 index 000000000..39d0db0c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dd-one-of.js @@ -0,0 +1,39 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigit +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + + DecimalDigits :: + DecimalDigit + ... + + DecimalDigit :: one of + 0 1 2 3 4 5 6 7 8 9 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(1_0, 10); +assert.sameValue(1_1, 11); +assert.sameValue(2_2, 22); +assert.sameValue(3_3, 33); +assert.sameValue(4_4, 44); +assert.sameValue(5_5, 55); +assert.sameValue(6_6, 66); +assert.sameValue(7_7, 77); +assert.sameValue(8_8, 88); +assert.sameValue(9_9, 99); + + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dd.js new file mode 100644 index 000000000..f274b19ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dd.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigit +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + + DecimalDigits :: + ... + DecimalDigits DecimalDigit + ... + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(1_1, 11); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds-dunder-err.js new file mode 100644 index 000000000..779f9d9b8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds-dunder-err.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in DecimalIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0__0123456789 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds-leading-zero-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds-leading-zero-err.js new file mode 100644 index 000000000..03ba35733 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds-leading-zero-err.js @@ -0,0 +1,27 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigits +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0_0123456789 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds.js new file mode 100644 index 000000000..dcd6de071 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-nzd-nsl-dds.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: NonZeroDigit NumericLiteralSeparator DecimalDigits +info: | + NumericLiteralSeparator :: + _ + + DecimalIntegerLiteral :: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + + NonZeroDigit :: one of + 1 2 3 4 5 6 7 8 9 + + DecimalDigits :: + ... + DecimalDigits DecimalDigit + ... + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(1_0123456789, 10123456789); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-nsl-od-dunder-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-nsl-od-dunder-err.js new file mode 100644 index 000000000..d43bf3a23 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-nsl-od-dunder-err.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not appear adjacent to another + NumericLiteralSeparator in a OctalIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0o0__0 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-nsl-od-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-nsl-od-err.js new file mode 100644 index 000000000..f93df5221 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-nsl-od-err.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the last digit character of an + OctalIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0o0_ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od-err.js new file mode 100644 index 000000000..57d0a50d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od-err.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NumericLiteralSeparator may not be the appear adjacent to `0o` | `0O` in a + OctalIntegerLiteral +info: | + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +0o_1 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od-one-of.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od-one-of.js new file mode 100644 index 000000000..181850503 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od-one-of.js @@ -0,0 +1,34 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigit NumericLiteralSeparator OctalDigit +info: | + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0o0_0, 0o00); +assert.sameValue(0o1_1, 0o11); +assert.sameValue(0o2_2, 0o22); +assert.sameValue(0o3_3, 0o33); +assert.sameValue(0o4_4, 0o44); +assert.sameValue(0o5_5, 0o55); +assert.sameValue(0o6_6, 0o66); +assert.sameValue(0o7_7, 0o77); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od.js new file mode 100644 index 000000000..7c3952d19 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-od.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigit NumericLiteralSeparator OctalDigit +info: | + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0o0_1, 0o01); +assert.sameValue(0O0_1, 0O01); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-ods.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-ods.js new file mode 100644 index 000000000..44e888aa8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-od-nsl-ods.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigit NumericLiteralSeparator OctalDigit +info: | + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0o0_10, 0o010); +assert.sameValue(0O0_10, 0O010); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-ods-nsl-od.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-ods-nsl-od.js new file mode 100644 index 000000000..a87372e3f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-ods-nsl-od.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigits NumericLiteralSeparator OctalDigit +info: | + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0o01_0, 0o010); +assert.sameValue(0O01_0, 0O010); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-ods-nsl-ods.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-ods-nsl-ods.js new file mode 100644 index 000000000..d64977299 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-oil-ods-nsl-ods.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + `0o` | `0O` OctalDigits NumericLiteralSeparator OctalDigit +info: | + NumericLiteralSeparator :: + _ + + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigits NumericLiteralSeparator OctalDigit + + OctalDigit :: one of + 0 1 2 3 4 5 6 7 + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(0o01_00, 0o0100); +assert.sameValue(0O01_00, 0O0100); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-sign-minus-dds-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-sign-minus-dds-nsl-dd.js new file mode 100644 index 000000000..bf01b6a13 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-sign-minus-dds-nsl-dd.js @@ -0,0 +1,27 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: DecimalDigits NumericLiteralSeparator DecimalDigit +info: | + NumericLiteralSeparator :: + _ + + SignedInteger :: + ... + - DecimalDigits + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(-123456789_0, -1234567890); +assert.sameValue(-123456789_1, -1234567891); +assert.sameValue(-123456789_2, -1234567892); +assert.sameValue(-123456789_3, -1234567893); +assert.sameValue(-123456789_4, -1234567894); +assert.sameValue(-123456789_5, -1234567895); +assert.sameValue(-123456789_6, -1234567896); +assert.sameValue(-123456789_7, -1234567897); +assert.sameValue(-123456789_8, -1234567898); +assert.sameValue(-123456789_9, -1234567899); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-sign-plus-dds-nsl-dd.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-sign-plus-dds-nsl-dd.js new file mode 100644 index 000000000..25c78243f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-sign-plus-dds-nsl-dd.js @@ -0,0 +1,28 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: DecimalDigits NumericLiteralSeparator DecimalDigit +info: | + NumericLiteralSeparator :: + _ + + SignedInteger :: + ... + + DecimalDigits + ... + +features: [numeric-separator-literal] +---*/ + +assert.sameValue(+123456789_0, 1234567890); +assert.sameValue(+123456789_1, 1234567891); +assert.sameValue(+123456789_2, 1234567892); +assert.sameValue(+123456789_3, 1234567893); +assert.sameValue(+123456789_4, 1234567894); +assert.sameValue(+123456789_5, 1234567895); +assert.sameValue(+123456789_6, 1234567896); +assert.sameValue(+123456789_7, 1234567897); +assert.sameValue(+123456789_8, 1234567898); +assert.sameValue(+123456789_9, 1234567899); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-unicode-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-unicode-err.js new file mode 100644 index 000000000..84f0629a5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/numeric-separators/numeric-separator-literal-unicode-err.js @@ -0,0 +1,26 @@ +// Copyright (C) 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-NumericLiteralSeparator +description: > + NonZeroDigit NumericLiteralSeparator DecimalDigits sequence expressed with + unicode escape sequence +info: | + NumericLiteralSeparator:: + _ + + DecimalIntegerLiteral:: + ... + NonZeroDigit NumericLiteralSeparator_opt DecimalDigits + +negative: + phase: parse + type: SyntaxError + +features: [numeric-separator-literal] +---*/ + +$DONOTEVALUATE(); + +1\u005F0123456789 diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-digit.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-digit.js new file mode 100644 index 000000000..08651cddd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-digit.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3 +description: Octal-integer-literal-like sequence containing an invalid digit +info: | + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigit :: one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0o8; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-leading.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-leading.js new file mode 100644 index 000000000..68b27eb97 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-leading.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3 +description: Octal-integer-literal-like sequence with a leading 0 +info: | + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigit :: one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +00o0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-truncated.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-truncated.js new file mode 100644 index 000000000..1de190703 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-truncated.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3 +description: Octal-integer-literal-like sequence without any digits +info: | + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigit :: one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0o; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-unicode.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-unicode.js new file mode 100644 index 000000000..38aa32896 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal-invalid-unicode.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3 +description: Octal-integer-literal-like sequence expressed with unicode escape sequence +info: | + OctalIntegerLiteral :: + 0o OctalDigits + 0O OctalDigits + OctalDigits :: + OctalDigit + OctalDigits OctalDigit + OctalDigit :: one of + 0 1 2 3 4 5 6 7 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +0\u006f0; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal.js new file mode 100644 index 000000000..3fb577fe6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/numeric/octal.js @@ -0,0 +1,45 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es6id: 11.8.3.1 +description: Mathematical value of valid octal integer literals +info: | + The MV of StrNumericLiteral ::: OctalIntegerLiteral is the MV of + OctalIntegerLiteral. + The MV of OctalIntegerLiteral :: 0o OctalDigits is the MV of OctalDigits. + The MV of OctalIntegerLiteral :: 0O OctalDigits is the MV of OctalDigits. + The MV of OctalDigits :: OctalDigit is the MV of OctalDigit. + The MV of OctalDigits :: OctalDigits OctalDigit is (the MV of OctalDigits × + 8) plus the MV of OctalDigit. +---*/ + +assert.sameValue(0o0, 0, 'lower-case head'); +assert.sameValue(0O0, 0, 'upper-case head'); +assert.sameValue(0o00, 0, 'lower-case head with leading zeros'); +assert.sameValue(0O00, 0, 'upper-case head with leading zeros'); + +assert.sameValue(0o1, 1, 'lower-case head'); +assert.sameValue(0O1, 1, 'upper-case head'); +assert.sameValue(0o01, 1, 'lower-case head with leading zeros'); +assert.sameValue(0O01, 1, 'upper-case head with leading zeros'); + +assert.sameValue(0o7, 7, 'lower-case head'); +assert.sameValue(0O7, 7, 'upper-case head'); +assert.sameValue(0o07, 7, 'lower-case head with leading zeros'); +assert.sameValue(0O07, 7, 'upper-case head with leading zeros'); + +assert.sameValue(0o10, 8, 'lower-case head'); +assert.sameValue(0O10, 8, 'upper-case head'); +assert.sameValue(0o010, 8, 'lower-case head with leading zeros'); +assert.sameValue(0O010, 8, 'upper-case head with leading zeros'); + +assert.sameValue(0o11, 9, 'lower-case head'); +assert.sameValue(0O11, 9, 'upper-case head'); +assert.sameValue(0o011, 9, 'lower-case head with leading zeros'); +assert.sameValue(0O011, 9, 'upper-case head with leading zeros'); + +assert.sameValue(0o77, 63, 'lower-case head'); +assert.sameValue(0O77, 63, 'upper-case head'); +assert.sameValue(0o077, 63, 'lower-case head with leading zeros'); +assert.sameValue(0O077, 63, 'upper-case head with leading zeros'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/7.8.5-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/7.8.5-1.js new file mode 100644 index 000000000..4b76d6adf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/7.8.5-1.js @@ -0,0 +1,29 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + SyntaxError exception is thrown if the RegularExpressionNonTerminator position of a + RegularExpressionBackslashSequence is a LineTerminator. +description: > + A RegularExpressionBackslashSequence may not contain a LineTerminator. +---*/ + +assert.throws(SyntaxError, function() { + eval("/\\\rn/;"); +/* + +The result of this string is: + +"/\ +n/;" + +*/ +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/7.8.5-1gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/7.8.5-1gs.js new file mode 100644 index 000000000..345042142 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/7.8.5-1gs.js @@ -0,0 +1,35 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionLiteral :: + / RegularExpressionBody / RegularExpressionFlags + + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + SourceCharacter :: + any Unicode code point + + RegularExpressionNonTerminator:: + SourceCharacter but not LineTerminator + +description: > + RegularExpressionBody will never be empty, because RegularExpressionFirstChar must always be _something_. // is a comment. +---*/ + +var y = 42; +var x = //.source; +y; + +assert.sameValue(x, y); + diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/7.8.5-2gs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/7.8.5-2gs.js new file mode 100644 index 000000000..5b9c14967 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/7.8.5-2gs.js @@ -0,0 +1,9 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.5-2gs +description: Empty dynamic RegExp should not result in a SyntaxError +---*/ + +var re = new RegExp(""); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.1_T1.js new file mode 100644 index 000000000..f7cf8837d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.1_T1.js @@ -0,0 +1,35 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + RegularExpressionFirstChar :: NonTerminator but not * or \ or /, + RegularExpressionChars :: [empty], RegularExpressionFlags :: [empty] +es5id: 7.8.5_A1.1_T1 +description: Without eval +---*/ + +//CHECK#1 +if (/1/.source !== "1") { + throw new Test262Error('#1: /1/'); +} + +//CHECK#2 +if (/a/.source !== "a") { + throw new Test262Error('#2: /a/'); +} + +//CHECK#3 +if (/;/.source !== ";") { + throw new Test262Error('#3: /;/'); +} + +//CHECK#4 +if (/ /.source !== " ") { + throw new Test262Error('#4: / /'); +} + +//CHECK#5 +if (/\u0041/.source !== "\\u0041") { + throw new Test262Error('#5: /\\u0041/'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.1_T2.js new file mode 100644 index 000000000..8a2c3113b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.1_T2.js @@ -0,0 +1,28 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + RegularExpressionFirstChar :: NonTerminator but not * or \ or /, + RegularExpressionChars :: [empty], RegularExpressionFlags :: [empty] +es5id: 7.8.5_A1.1_T2 +description: Complex test with eval, using syntax pattern +---*/ + +for (var cu = 0; cu <= 0xffff; ++cu) { + var Elimination = + ((cu === 0x002A) || (cu === 0x002F) || (cu === 0x005C) || (cu === 0x002B) || + (cu === 0x003F) || (cu === 0x0028) || (cu === 0x0029) || + (cu === 0x005B) || (cu === 0x005D) || (cu === 0x007B) || (cu === 0x007D)); + /* + * \u002A / \u002F \ \u005C + \u002B + ? \u003F ( \u0028 ) \u0029 + [ \u005B ] \u005D { \u007B } \u007D + */ + var LineTerminator = ((cu === 0x000A) || (cu === 0x000D) || (cu === 0x2028) || (cu === 0x2029)); + if ((Elimination || LineTerminator ) === false) { + var xx = String.fromCharCode(cu); + var pattern = eval("/" + xx + "/"); + assert.sameValue(pattern.source, xx, "Code unit: " + cu.toString(16)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T1.js new file mode 100644 index 000000000..e21e23cf3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T1.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionFirstChar +info: | + RegularExpressionChars :: + [empty] + RegularExpressionCharsRegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + +description: > + The first character of a regular expression may not be "*" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T2.js new file mode 100644 index 000000000..2cf22c2ca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T2.js @@ -0,0 +1,26 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-regular-expression-literals +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + +description: > + The first character of a regular expression may not be "\" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T3.js new file mode 100644 index 000000000..2b6ff6d77 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T3.js @@ -0,0 +1,27 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-regular-expression-literals +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + +description: > + The first character of a regular expression may not be "/" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/// +.source; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T4.js new file mode 100644 index 000000000..a3c394fce --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.2_T4.js @@ -0,0 +1,27 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-regular-expression-literals +info: | + RegularExpressionLiteral:: + / RegularExpressionBody / RegularExpressionFlags + + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars:: + [empty] + + MemberExpression . IdentifierName + +description: A regular expression may not be empty. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +// +.source; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T1.js new file mode 100644 index 000000000..f0be68d2b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T1.js @@ -0,0 +1,30 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + The first character of a regular expression may not be a (\u000A) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/ +/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T2.js new file mode 100644 index 000000000..b0a8cb12a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T2.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + The first character of a regular expression may not be a (\u000A), evaluated +---*/ + +//CHECK#1 +try { + eval("/\u000A/").source; + throw new Test262Error('#1.1: RegularExpressionFirstChar :: Line Feed is incorrect. Actual: ' + (eval("/\u000A/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionFirstChar :: Line Feed is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T3.js new file mode 100644 index 000000000..009060de8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T3.js @@ -0,0 +1,30 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + The first character of a regular expression may not be a , (\u000D) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/ +/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T4.js new file mode 100644 index 000000000..d9116f0d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T4.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + The first character of a regular expression may not be a , (\u000D), evaluated +---*/ + +//CHECK#1 +try { + eval("/\u000D/").source; + throw new Test262Error('#1.1: RegularExpressionFirstChar :: Carriage Return is incorrect. Actual: ' + (eval("/\u000D/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionFirstChar :: Carriage Return is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T5.js new file mode 100644 index 000000000..69a9aa5b6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T5.js @@ -0,0 +1,34 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + The first character of a regular expression may not be a , (\u2028), evaluated + +---*/ + +//CHECK#1 +try { + eval("/\u2028/").source; + throw new Test262Error('#1.1: RegularExpressionFirstChar :: Line separator is incorrect. Actual: ' + (eval("/\u2028/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionFirstChar :: Line separator is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T6.js new file mode 100644 index 000000000..395877613 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.3_T6.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + The first character of a regular expression may not be a , (\u2028), evaluated +---*/ + +//CHECK#1 +try { + eval("/\u2029/").source; + throw new Test262Error('#1.1: RegularExpressionFirstChar :: Paragraph separator is incorrect. Actual: ' + (eval("/\u2029/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionFirstChar :: Paragraph separator is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.4_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.4_T1.js new file mode 100644 index 000000000..d0cf513ad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.4_T1.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + RegularExpressionFirstChar :: BackslashSequence :: \NonTerminator, + RegularExpressionChars :: [empty], RegularExpressionFlags :: [empty] +es5id: 7.8.5_A1.4_T1 +description: Check similar to (/\;/.source === "\\;") +---*/ + +//CHECK#1 +if (/\;/.source !== "\\;") { + throw new Test262Error('#1: /\\;/'); +} + +//CHECK#2 +if (/\ /.source !== "\\ ") { + throw new Test262Error('#2: /\\ /'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.4_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.4_T2.js new file mode 100644 index 000000000..73b8475cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.4_T2.js @@ -0,0 +1,40 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + RegularExpressionFirstChar :: BackslashSequence :: \NonTerminator, + RegularExpressionChars :: [empty], RegularExpressionFlags :: [empty] +es5id: 7.8.5_A1.4_T2 +description: Complex test with eval, using syntax pattern +---*/ + +for (var cu = 0; cu <= 0xffff; ++cu) { + var Elimination = + ((cu === 0x002A) || (cu === 0x002F) || (cu === 0x005C) || (cu === 0x002B) || + (cu === 0x003F) || (cu === 0x0028) || (cu === 0x0029) || + (cu === 0x005B) || (cu === 0x005D) || (cu === 0x007B) || (cu === 0x007D)); + /* + * \u002A / \u002F \ \u005C + \u002B + ? \u003F ( \u0028 ) \u0029 + [ \u005B ] \u005D { \u007B } \u007D + */ + var LineTerminator = ((cu === 0x000A) || (cu === 0x000D) || (cu === 0x2028) || (cu === 0x2029)); + if ((Elimination || LineTerminator ) === false) { + var xx = "\\" + String.fromCharCode(cu); + try { + var pattern = eval("/" + xx + "/"); + } catch (e) { + var identifierPartNotUnicodeIDContinue = ((cu === 0x0024) || (cu === 0x200C) || (cu === 0x200D)); + if (e instanceof SyntaxError && !identifierPartNotUnicodeIDContinue) { + // Use eval with var-declaration to check if `cu` is in UnicodeIDContinue. + try { + eval("var _" + String.fromCharCode(cu)); + continue; + } catch (ignore) { } + } + throw e; + } + assert.sameValue(pattern.source, xx, "Code unit: " + cu.toString(16)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T1.js new file mode 100644 index 000000000..12f5e7aac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T1.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + A RegularExpressionBackslashSequence may not contain a + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\ +/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T2.js new file mode 100644 index 000000000..85bc60f44 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T2.js @@ -0,0 +1,27 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + A RegularExpressionBackslashSequence may not contain a , evaluated + +---*/ + +//CHECK#1 +try { + eval("/\\\u000A/").source; + throw new Test262Error('#1.1: RegularExpressionFirstChar :: BackslashSequence :: \\Line Feed is incorrect. Actual: ' + (eval("/\\\u000A/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionFirstChar :: BackslashSequence :: \\Line Feed is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T3.js new file mode 100644 index 000000000..b62a5f359 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T3.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + A RegularExpressionBackslashSequence may not contain a +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\ +/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T4.js new file mode 100644 index 000000000..92ab28be2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T4.js @@ -0,0 +1,26 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + A RegularExpressionBackslashSequence may not contain a , evaluated +---*/ + +//CHECK#1 +try { + eval("/\\\u000D/").source; + throw new Test262Error('#1.1: RegularExpressionFirstChar :: BackslashSequence :: \\Carriage Return is incorrect. Actual: ' + (eval("/\\\u000D/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionFirstChar :: BackslashSequence :: \\Carriage Return is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T5.js new file mode 100644 index 000000000..eebb1583b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T5.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + The first character of a regular expression may not be a , (\u2028), evaluated +---*/ + +//CHECK#1 +try { + eval("/\\\u2028/").source; + throw new Test262Error('#1.1: RegularExpressionFirstChar :: BackslashSequence :: \\Line separator is incorrect. Actual: ' + (eval("/\\\u2028/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionFirstChar :: BackslashSequence :: \\Line separator is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T6.js new file mode 100644 index 000000000..834e2c9a1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A1.5_T6.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + The first character of a regular expression may not be a , (\u2029), evaluated +---*/ + +//CHECK#1 +try { + eval("/\\\u2029/").source; + throw new Test262Error('#1.1: RegularExpressionFirstChar :: BackslashSequence :: \\Paragraph separator is incorrect. Actual: ' + (eval("/\\\u2029/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionFirstChar :: BackslashSequence :: \\Paragraph separator is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.1_T1.js new file mode 100644 index 000000000..9f86ee734 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.1_T1.js @@ -0,0 +1,35 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + RegularExpressionChar :: NonTerminator but not \ or /, + RegularExpressionFlags :: [empty] +es5id: 7.8.5_A2.1_T1 +description: Without eval +---*/ + +//CHECK#1 +if (/1a/.source !== "1a") { + throw new Test262Error('#1: /1a/'); +} + +//CHECK#2 +if (/aa/.source !== "aa") { + throw new Test262Error('#2: /aa/'); +} + +//CHECK#3 +if (/,;/.source !== ",;") { + throw new Test262Error('#3: /,;/'); +} + +//CHECK#4 +if (/ /.source !== " ") { + throw new Test262Error('#4: / /'); +} + +//CHECK#5 +if (/a\u0041/.source !== "a\\u0041") { + throw new Test262Error('#5: /a\\u0041/'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.1_T2.js new file mode 100644 index 000000000..e55e2bfaf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.1_T2.js @@ -0,0 +1,28 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + RegularExpressionChar :: NonTerminator but not \ or /, + RegularExpressionFlags :: [empty] +es5id: 7.8.5_A2.1_T2 +description: Complex test with eval, using syntax pattern +---*/ + +for (var cu = 0; cu <= 0xffff; ++cu) { + var Elimination = + ((cu === 0x002A) || (cu === 0x002F) || (cu === 0x005C) || (cu === 0x002B) || + (cu === 0x003F) || (cu === 0x0028) || (cu === 0x0029) || + (cu === 0x005B) || (cu === 0x005D) || (cu === 0x007B) || (cu === 0x007D)); + /* + * \u002A / \u002F \ \u005C + \u002B + ? \u003F ( \u0028 ) \u0029 + [ \u005B ] \u005D { \u007B } \u007D + */ + var LineTerminator = ((cu === 0x000A) || (cu === 0x000D) || (cu === 0x2028) || (cu === 0x2029)); + if ((Elimination || LineTerminator ) === false) { + var xx = "nnnn" + String.fromCharCode(cu); + var pattern = eval("/" + xx + "/"); + assert.sameValue(pattern.source, xx, "Code unit: " + cu.toString(16)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.2_T1.js new file mode 100644 index 000000000..d88e36cad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.2_T1.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionChar +info: | + RegularExpressionChar :: + RegularExpressionNonTerminator but not one of \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + A regular express may not contain a "\" as a SourceCharacter + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/a\/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.2_T2.js new file mode 100644 index 000000000..4c2aa4771 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.2_T2.js @@ -0,0 +1,23 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionChar +info: | + RegularExpressionChar :: + RegularExpressionNonTerminator but not one of \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + A regular expression may not contain a "/" as a SourceCharacter + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/a//.source; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T1.js new file mode 100644 index 000000000..8174680ea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T1.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-regular-expression-literals +info: | + RegularExpressionChar :: + RegularExpressionBackslashSequence + + + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/a +/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T2.js new file mode 100644 index 000000000..fc076bd41 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T2.js @@ -0,0 +1,36 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-regular-expression-literals +info: | + RegularExpressionChar :: + RegularExpressionBackslashSequence + + + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter, evaluated +---*/ + +//CHECK#1 +try { + eval("/a\u000A/").source; + throw new Test262Error('#1.1: RegularExpressionChar :: Line Feedis incorrect. Actual: ' + (eval("/a\u000A/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionChar :: Line Feed is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T3.js new file mode 100644 index 000000000..69125e55a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T3.js @@ -0,0 +1,34 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-regular-expression-literals +info: | + RegularExpressionChar :: + RegularExpressionBackslashSequence + + + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/a +/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T4.js new file mode 100644 index 000000000..bb8325bc9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T4.js @@ -0,0 +1,36 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-regular-expression-literals +info: | + RegularExpressionChar :: + RegularExpressionBackslashSequence + + + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter, evaluated +---*/ + +//CHECK#1 +try { + eval("/a\u000D/").source; + throw new Test262Error('#1.1: RegularExpressionChar :: Carriage Retur is incorrect. Actual: ' + (eval("/a\u000D/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionChar :: Carriage Retur is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T5.js new file mode 100644 index 000000000..daf2caea7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T5.js @@ -0,0 +1,34 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + A regular expression may not contain a as a SourceCharacter, evaluated + +---*/ + +//CHECK#1 +try { + eval("/a\u2028/").source; + throw new Test262Error('#1.1: RegularExpressionChar :: Line separator is incorrect. Actual: ' + (eval("/a\u2028/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionChar :: Line separator is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T6.js new file mode 100644 index 000000000..7e1efbb5f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.3_T6.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + A regular expression may not contain a as a SourceCharacter, evaluated + +---*/ + +try { + eval("/s\u2029/").source; + throw new Test262Error('#1.1: RegularExpressionChar :: Paragraph separator is incorrect. Actual: ' + (eval("/s\u2029/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionChar :: Paragraph separator is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.4_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.4_T1.js new file mode 100644 index 000000000..a2d16a04f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.4_T1.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + RegularExpressionChar :: BackslashSequence :: \NonTerminator, + RegularExpressionFlags :: [empty] +es5id: 7.8.5_A2.4_T1 +description: Check similar to (/,\;/.source === ",\\;") +---*/ + +//CHECK#1 +if (/,\;/.source !== ",\\;") { + throw new Test262Error('#1: /,\\;/'); +} + +//CHECK#2 +if (/ \ /.source !== " \\ ") { + throw new Test262Error('#2: / \\ /'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.4_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.4_T2.js new file mode 100644 index 000000000..169d9b176 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.4_T2.js @@ -0,0 +1,40 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + RegularExpressionChar :: BackslashSequence :: \NonTerminator, + RegularExpressionFlags :: [empty] +es5id: 7.8.5_A2.4_T2 +description: Complex test with eval, using syntax pattern +---*/ + +for (var cu = 0; cu <= 0xffff; ++cu) { + var Elimination = + ((cu === 0x002A) || (cu === 0x002F) || (cu === 0x005C) || (cu === 0x002B) || + (cu === 0x003F) || (cu === 0x0028) || (cu === 0x0029) || + (cu === 0x005B) || (cu === 0x005D) || (cu === 0x007B) || (cu === 0x007D)); + /* + * \u002A / \u002F \ \u005C + \u002B + ? \u003F ( \u0028 ) \u0029 + [ \u005B ] \u005D { \u007B } \u007D + */ + var LineTerminator = ((cu === 0x000A) || (cu === 0x000D) || (cu === 0x2028) || (cu === 0x2029)); + if ((Elimination || LineTerminator ) === false) { + var xx = "a\\" + String.fromCharCode(cu); + try { + var pattern = eval("/" + xx + "/"); + } catch (e) { + var identifierPartNotUnicodeIDContinue = ((cu === 0x0024) || (cu === 0x200C) || (cu === 0x200D)); + if (e instanceof SyntaxError && !identifierPartNotUnicodeIDContinue) { + // Use eval with var-declaration to check if `cu` is in UnicodeIDContinue. + try { + eval("var _" + String.fromCharCode(cu)); + continue; + } catch (ignore) { } + } + throw e; + } + assert.sameValue(pattern.source, xx, "Code unit: " + cu.toString(16)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T1.js new file mode 100644 index 000000000..f365bdda7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T1.js @@ -0,0 +1,29 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/a\ +/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T2.js new file mode 100644 index 000000000..827cd5c14 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T2.js @@ -0,0 +1,32 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter, evaluated +---*/ + +//CHECK#1 +try { + eval("/a\\\u000A/").source; + throw new Test262Error('#1.1: RegularExpressionChar :: BackslashSequence :: \\Line Feed is incorrect. Actual: ' + (eval("/a\\\u000A/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionChar :: BackslashSequence :: \\Line Feed is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T3.js new file mode 100644 index 000000000..cff0d72e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T3.js @@ -0,0 +1,29 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/a\ +/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T4.js new file mode 100644 index 000000000..7e5480e5d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T4.js @@ -0,0 +1,32 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter, evaluated +---*/ + +//CHECK#1 +try { + eval("/a\\\u000D/").source; + throw new Test262Error('#1.1: RegularExpressionChar :: BackslashSequence :: \\Carriage Return is incorrect. Actual: ' + (eval("/a\\\u000D/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionChar :: BackslashSequence :: \\Carriage Return is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T5.js new file mode 100644 index 000000000..8a330e3ec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T5.js @@ -0,0 +1,32 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter, evaluated +---*/ + +//CHECK#1 +try { + eval("/a\\\u2028/").source; + throw new Test262Error('#1.1: RegularExpressionChar :: BackslashSequence :: \\Line separator is incorrect. Actual: ' + (eval("/a\\\u2028/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionChar :: BackslashSequence :: \\Line separator is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T6.js new file mode 100644 index 000000000..ae7cb9dfc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A2.5_T6.js @@ -0,0 +1,32 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter, evaluated +---*/ + +//CHECK#1 +try { + eval("/a\\\u2029/").source; + throw new Test262Error('#1.1: RegularExpressionChar :: BackslashSequence :: \\Paragraph separator is incorrect. Actual: ' + (eval("/a\\\u2029/").source)); +} +catch (e) { + if ((e instanceof SyntaxError) !== true) { + throw new Test262Error('#1.2: RegularExpressionChar :: BackslashSequence :: \\Paragraph separator is incorrect. Actual: ' + (e)); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T1.js new file mode 100644 index 000000000..07a777b63 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T1.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "RegularExpressionFlags :: IdentifierPart" +es5id: 7.8.5_A3.1_T1 +description: "IdentifierPart :: g" +---*/ + +//CHECK#1 +var regexp = /(?:)/g; +if (regexp.global !== true) { + throw new Test262Error('#1: var regexp = /(?:)/g; regexp.global === true. Actual: ' + (regexp.global)); +} + +//CHECK#2 +if (regexp.ignoreCase !== false) { + throw new Test262Error('#2: var regexp = /(?:)/g; regexp.ignoreCase === false. Actual: ' + (regexp.ignoreCase)); +} + +//CHECK#3 +if (regexp.multiline !== false) { + throw new Test262Error('#3: var regexp = /(?:)/g; regexp.multiline === false. Actual: ' + (regexp.multiline)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T2.js new file mode 100644 index 000000000..f678a8579 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T2.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "RegularExpressionFlags :: IdentifierPart" +es5id: 7.8.5_A3.1_T2 +description: "IdentifierPart :: i" +---*/ + +//CHECK#1 +var regexp = /(?:)/i; +if (regexp.global !== false) { + throw new Test262Error('#1: var regexp = /(?:)/g; regexp.global === false. Actual: ' + (regexp.global)); +} + +//CHECK#2 +if (regexp.ignoreCase !== true) { + throw new Test262Error('#2: var regexp = /(?:)/g; regexp.ignoreCase === true. Actual: ' + (regexp.ignoreCase)); +} + +//CHECK#3 +if (regexp.multiline !== false) { + throw new Test262Error('#3: var regexp = /(?:)/g; regexp.multiline === false. Actual: ' + (regexp.multiline)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T3.js new file mode 100644 index 000000000..45c927ec5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T3.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "RegularExpressionFlags :: IdentifierPart" +es5id: 7.8.5_A3.1_T3 +description: "IdentifierPart :: m" +---*/ + +//CHECK#1 +var regexp = /(?:)/m; +if (regexp.global !== false) { + throw new Test262Error('#1: var regexp = /(?:)/g; regexp.global === false. Actual: ' + (regexp.global)); +} + +//CHECK#2 +if (regexp.ignoreCase !== false) { + throw new Test262Error('#2: var regexp = /(?:)/g; regexp.ignoreCase === false. Actual: ' + (regexp.ignoreCase)); +} + +//CHECK#3 +if (regexp.multiline !== true) { + throw new Test262Error('#3: var regexp = /(?:)/g; regexp.multiline === true. Actual: ' + (regexp.multiline)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T4.js new file mode 100644 index 000000000..a0a1a9b90 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T4.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "RegularExpressionFlags :: IdentifierPart" +es5id: 7.8.5_A3.1_T4 +description: "IdentifierPart :: gi" +---*/ + +//CHECK#1 +var regexp = /(?:)/gi; +if (regexp.global !== true) { + throw new Test262Error('#1: var regexp = /(?:)/g; regexp.global === true. Actual: ' + (regexp.global)); +} + +//CHECK#2 +if (regexp.ignoreCase !== true) { + throw new Test262Error('#2: var regexp = /(?:)/g; regexp.ignoreCase === true. Actual: ' + (regexp.ignoreCase)); +} + +//CHECK#3 +if (regexp.multiline !== false) { + throw new Test262Error('#3: var regexp = /(?:)/g; regexp.multiline === false. Actual: ' + (regexp.multiline)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T5.js new file mode 100644 index 000000000..eaa51a4bb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T5.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "RegularExpressionFlags :: IdentifierPart" +es5id: 7.8.5_A3.1_T5 +description: "IdentifierPart :: mg" +---*/ + +//CHECK#1 +var regexp = /(?:)/mg; +if (regexp.global !== true) { + throw new Test262Error('#1: var regexp = /(?:)/g; regexp.global === true. Actual: ' + (regexp.global)); +} + +//CHECK#2 +if (regexp.ignoreCase !== false) { + throw new Test262Error('#2: var regexp = /(?:)/g; regexp.ignoreCase === false. Actual: ' + (regexp.ignoreCase)); +} + +//CHECK#3 +if (regexp.multiline !== true) { + throw new Test262Error('#3: var regexp = /(?:)/g; regexp.multiline === true. Actual: ' + (regexp.multiline)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T6.js new file mode 100644 index 000000000..76bd1f98c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A3.1_T6.js @@ -0,0 +1,24 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "RegularExpressionFlags :: IdentifierPart" +es5id: 7.8.5_A3.1_T6 +description: "IdentifierPart :: mig" +---*/ + +//CHECK#1 +var regexp = /(?:)/mig; +if (regexp.global !== true) { + throw new Test262Error('#1: var regexp = /(?:)/g; regexp.global === true. Actual: ' + (regexp.global)); +} + +//CHECK#2 +if (regexp.ignoreCase !== true) { + throw new Test262Error('#2: var regexp = /(?:)/g; regexp.ignoreCase === true. Actual: ' + (regexp.ignoreCase)); +} + +//CHECK#3 +if (regexp.multiline !== true) { + throw new Test262Error('#3: var regexp = /(?:)/g; regexp.multiline === true. Actual: ' + (regexp.multiline)); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A4.1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A4.1.js new file mode 100644 index 000000000..f8cdcc597 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A4.1.js @@ -0,0 +1,15 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + A regular expression literal is an input element that is converted to + a RegExp object when it is scanned +es5id: 7.8.5_A4.1 +description: "Check ((/(?:)/ instanceof RegExp) === true)" +---*/ + +//CHECK#1 +if ((/(?:)/ instanceof RegExp) !== true) { + throw new Test262Error('#1: (/(?:)/ instanceof RegExp) === true. Actual: ' + ((/(?:)/ instanceof RegExp))); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A4.2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A4.2.js new file mode 100644 index 000000000..a1044b7dd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/S7.8.5_A4.2.js @@ -0,0 +1,19 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + Two regular expression literals in a program evaluate to + regular expression objects that never compare as === to each other even + if the two literals' contents are identical +es5id: 7.8.5_A4.2 +description: Check equality two regular expression literals +---*/ + +var regexp1 = /(?:)/; +var regexp2 = /(?:)/; +assert.notSameValue( + regexp1, + regexp2, + "var regexp1 = /(?:)/; var regexp2 = /(?:)/; regexp1 !== regexp2" +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-i.js new file mode 100644 index 000000000..ec9451c9d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?i-i:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-m.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-m.js new file mode 100644 index 000000000..cd21baa13 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-m.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?m-m:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-multi-duplicate.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-multi-duplicate.js new file mode 100644 index 000000000..1380146f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-multi-duplicate.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?ims-m:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s-escape.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s-escape.js new file mode 100644 index 000000000..de7a50ec7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s-escape.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?\u{0073}-s:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s.js new file mode 100644 index 000000000..b4ad3a438 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-add-remove-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?s-s:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-both-empty.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-both-empty.js new file mode 100644 index 000000000..7beb7d9a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-both-empty.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by the first RegularExpressionFlags and the source text matched by the second RegularExpressionFlags are both empty. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-1.js new file mode 100644 index 000000000..c5dd23326 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-1.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-ii:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-2.js new file mode 100644 index 000000000..3779db063 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-code-point-repeat-i-2.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-imsi:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-1.js new file mode 100644 index 000000000..a506febbb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-1.js @@ -0,0 +1,18 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Regular expression modifiers should not parse without the colon. +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... +---*/ + +$DONOTEVALUATE(); + +/(?ms-i)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-2.js new file mode 100644 index 000000000..890fb235a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-2.js @@ -0,0 +1,18 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Regular expression modifiers should not parse without the colon. +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... +---*/ + +$DONOTEVALUATE(); + +/(?-s)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-3.js new file mode 100644 index 000000000..21cac0fdc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-no-colon-3.js @@ -0,0 +1,18 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Regular expression modifiers should not parse without the colon. +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... +---*/ + +$DONOTEVALUATE(); + +/(?i-)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-arbitrary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-arbitrary.js new file mode 100644 index 000000000..74d91a7d4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-arbitrary.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-1:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-i.js new file mode 100644 index 000000000..15ea531f6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-iͥ:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-m.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-m.js new file mode 100644 index 000000000..5fd580b27 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-m.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-mͫ:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-s.js new file mode 100644 index 000000000..cb2743e09 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-combining-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-s̀:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-d.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-d.js new file mode 100644 index 000000000..475ddfef8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-d.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-d:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-g.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-g.js new file mode 100644 index 000000000..899a2c23a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-g.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-g:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-1.js new file mode 100644 index 000000000..bcf7d7ddd Binary files /dev/null and b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-1.js differ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-2.js new file mode 100644 index 000000000..33e73f9f0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-display-2.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-s‎:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-flag.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-flag.js new file mode 100644 index 000000000..c0ca48145 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-non-flag.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-Q:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-u.js new file mode 100644 index 000000000..48827116f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-u.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-u:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-uppercase-I.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-uppercase-I.js new file mode 100644 index 000000000..768777f6a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-uppercase-I.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-I:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-y.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-y.js new file mode 100644 index 000000000..04e47aab6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-y.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-y:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwj.js new file mode 100644 index 000000000..b16e6367b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwj.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-s‍:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnbsp.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnbsp.js new file mode 100644 index 000000000..c5ed9f15c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnbsp.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-s:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnj.js new file mode 100644 index 000000000..068894fd9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-other-code-point-zwnj.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-s‌:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-i.js new file mode 100644 index 000000000..ec9451c9d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?i-i:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-m.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-m.js new file mode 100644 index 000000000..cd21baa13 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-m.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?m-m:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-multi-duplicate.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-multi-duplicate.js new file mode 100644 index 000000000..2f129ed86 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-multi-duplicate.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?m-ims:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-s-escape.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-s-escape.js new file mode 100644 index 000000000..baf393b70 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-s-escape.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?s-\u{0073}:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-s.js new file mode 100644 index 000000000..b4ad3a438 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-add-remove-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the any code point in the source text matched by the first RegularExpressionFlags is also contained in the source text matched by the second RegularExpressionFlags. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?s-s:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-1.js new file mode 100644 index 000000000..87ed37840 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-1.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?ii-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-2.js new file mode 100644 index 000000000..5677224bb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-code-point-repeat-i-2.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?imsi-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-arbitrary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-arbitrary.js new file mode 100644 index 000000000..d36e8c9cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-arbitrary.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?1-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-i.js new file mode 100644 index 000000000..6107b05c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?iͥ-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-m.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-m.js new file mode 100644 index 000000000..34f0e20d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-m.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?mͫ-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-s.js new file mode 100644 index 000000000..00b69cdbb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-combining-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?s̀-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-d.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-d.js new file mode 100644 index 000000000..5b40223d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-d.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?d-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-g.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-g.js new file mode 100644 index 000000000..59588f6ad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-g.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?g-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-1.js new file mode 100644 index 000000000..be6937a67 Binary files /dev/null and b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-1.js differ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-2.js new file mode 100644 index 000000000..2c7e79681 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-display-2.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?s‎-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-flag.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-flag.js new file mode 100644 index 000000000..6a155c358 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-non-flag.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?Q-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-u.js new file mode 100644 index 000000000..7547a55e9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-u.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?u-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-uppercase-I.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-uppercase-I.js new file mode 100644 index 000000000..43a9748d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-uppercase-I.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?I-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-y.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-y.js new file mode 100644 index 000000000..717e5d3bb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-y.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?y-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwj.js new file mode 100644 index 000000000..c6ea84d5a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwj.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?s‍-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnbsp.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnbsp.js new file mode 100644 index 000000000..3e24656e1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnbsp.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?s-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnj.js new file mode 100644 index 000000000..d6bf3a8dd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-other-code-point-zwnj.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?s‌-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-i.js new file mode 100644 index 000000000..2dfbef0f3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?I-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-m.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-m.js new file mode 100644 index 000000000..22f58a54b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-m.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?M-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-s.js new file mode 100644 index 000000000..a5a41be57 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-case-fold-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?S-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-i.js new file mode 100644 index 000000000..9bfa2e26b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case-folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?İ-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-s.js new file mode 100644 index 000000000..216d1a1d1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-reverse-should-not-unicode-case-fold-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case-folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?ſ-:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-i.js new file mode 100644 index 000000000..70861ad8c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-I:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-m.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-m.js new file mode 100644 index 000000000..4a39c3394 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-m.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-M:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-s.js new file mode 100644 index 000000000..1616aa963 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-case-fold-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-S:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-i.js new file mode 100644 index 000000000..75bcec6c1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case-folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-İ:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-s.js new file mode 100644 index 000000000..eb60a15f6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-arithmetic-modifiers-should-not-unicode-case-fold-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case-folded to "i", "m", or "s" (arithmetic regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpressionFlags - RegularExpressionFlags : Disjunction ) + ... + +---*/ + +$DONOTEVALUATE(); + +/(?-ſ:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-bad-flag.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-bad-flag.js new file mode 100644 index 000000000..9af46ef93 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-bad-flag.js @@ -0,0 +1,18 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-primary-expression-regular-expression-literals-static-semantics-early-errors +info: | + PrimaryExpression : RegularExpressionLiteral + +description: > + It is a Syntax Error if FlagText of RegularExpressionLiteral contains any code points other than "g", "i", "m", "u", or "y", ... + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/./G; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-dup-flag.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-dup-flag.js new file mode 100644 index 000000000..3d7cbaea6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-dup-flag.js @@ -0,0 +1,18 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-primary-expression-regular-expression-literals-static-semantics-early-errors +info: | + PrimaryExpression : RegularExpressionLiteral + +description: > + It is a Syntax Error if FlagText of RegularExpressionLiteral contains ... the same code point more than once. + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/./gig; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-flags-unicode-escape.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-flags-unicode-escape.js new file mode 100644 index 000000000..f990569d8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-flags-unicode-escape.js @@ -0,0 +1,18 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-regular-expression-literals-static-semantics-early-errors +info: | + RegularExpressionFlags :: + RegularExpressionFlags IdentifierPart + +description: > + It is a Syntax Error if IdentifierPart contains a Unicode escape sequence. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/./\u0067; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-code-point-repeat-i-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-code-point-repeat-i-1.js new file mode 100644 index 000000000..055cebc72 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-code-point-repeat-i-1.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?ii:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-code-point-repeat-i-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-code-point-repeat-i-2.js new file mode 100644 index 000000000..b84dc7bfc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-code-point-repeat-i-2.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?imsi:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-arbitrary.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-arbitrary.js new file mode 100644 index 000000000..8eda84761 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-arbitrary.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?1:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-combining-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-combining-i.js new file mode 100644 index 000000000..4cf9b1664 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-combining-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?iͥ:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-combining-m.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-combining-m.js new file mode 100644 index 000000000..ca5f47647 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-combining-m.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?mͫ:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-combining-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-combining-s.js new file mode 100644 index 000000000..edd6ba0b0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-combining-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?s̀:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-d.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-d.js new file mode 100644 index 000000000..0e4994a3d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-d.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?d:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-g.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-g.js new file mode 100644 index 000000000..2139eef74 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-g.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?g:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-non-display-1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-non-display-1.js new file mode 100644 index 000000000..6879864eb Binary files /dev/null and b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-non-display-1.js differ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-non-display-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-non-display-2.js new file mode 100644 index 000000000..17f1d7228 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-non-display-2.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?s‎:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-non-flag.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-non-flag.js new file mode 100644 index 000000000..75d28616f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-non-flag.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?Q:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-u.js new file mode 100644 index 000000000..f207d8cbf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-u.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?u:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-uppercase-I.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-uppercase-I.js new file mode 100644 index 000000000..73474568d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-uppercase-I.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?I:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-y.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-y.js new file mode 100644 index 000000000..d43c8c5a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-y.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?y:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-zwj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-zwj.js new file mode 100644 index 000000000..085d7887e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-zwj.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?s‍:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-zwnbsp.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-zwnbsp.js new file mode 100644 index 000000000..3d9b27c37 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-zwnbsp.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?s:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-zwnj.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-zwnj.js new file mode 100644 index 000000000..529f8718b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-other-code-point-zwnj.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code point other than i, m, or s, or if it contains the same code point more than once. (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?s‌:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-case-fold-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-case-fold-i.js new file mode 100644 index 000000000..1b281ff9c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-case-fold-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case folded to "i", "m", or "s" (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?I:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-case-fold-m.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-case-fold-m.js new file mode 100644 index 000000000..ce1be0530 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-case-fold-m.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case folded to "i", "m", or "s" (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?M:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-case-fold-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-case-fold-s.js new file mode 100644 index 000000000..89e471ee5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-case-fold-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case folded to "i", "m", or "s" (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?S:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-i.js new file mode 100644 index 000000000..d81c10e57 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case-folded to "i", "m", or "s" (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?İ:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-s.js new file mode 100644 index 000000000..8e6823feb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-case-fold-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Code points other than "i", "m", "s" should not be case-folded to "i", "m", or "s" (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?ſ:a)//*{ global-modifiers }*/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-i.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-i.js new file mode 100644 index 000000000..10e188399 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-i.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Source text cannot use unicode escape sequences to express code points "i", "m", "s" (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?\u0069:a)/u /* i */; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-m.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-m.js new file mode 100644 index 000000000..4916997fb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-m.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Source text cannot use unicode escape sequences to express code points "i", "m", "s" (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?\u006D:a)/u /* m */; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-s.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-s.js new file mode 100644 index 000000000..4e91d5bb5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-modifiers-should-not-unicode-escape-s.js @@ -0,0 +1,19 @@ +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Source text cannot use unicode escape sequences to express code points "i", "m", "s" (regular expression flags) +esid: sec-patterns-static-semantics-early-errors +features: [regexp-modifiers] +negative: + phase: parse + type: SyntaxError +info: | + Atom :: ( ? RegularExpresisonFlags : Disjunction ) + It is a Syntax Error if the source text matched by RegularExpressionFlags contains any code points other than "i", "m", "s", or if it contains the same code point more than once. + +---*/ + +$DONOTEVALUATE(); + +/(?\u0073:a)/u /* s */; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-pattern.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-pattern.js new file mode 100644 index 000000000..0ccbfc4ec --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/early-err-pattern.js @@ -0,0 +1,17 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-primary-expression-regular-expression-literals-static-semantics-early-errors +info: | + PrimaryExpression : RegularExpressionLiteral + +description: > + It is a Syntax Error if BodyText of RegularExpressionLiteral cannot be recognized using the goal symbol Pattern of the ECMAScript RegExp grammar specified in #sec-patterns. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/?/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/inequality.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/inequality.js new file mode 100644 index 000000000..2c953c8e8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/inequality.js @@ -0,0 +1,19 @@ +// Copyright (C) 2016 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: Regular expression literals should not compare as equal even if they appear in the same source position. +esid: sec-regular-expression-literals-runtime-semantics-evaluation +---*/ + +function makeRegExp() { + return /(?:)/; +} + +assert.notSameValue(makeRegExp(), makeRegExp()); + +var values = []; +for (var i = 0; i < 2; ++i) { + values[i] = /(?:)/; +} + +assert.notSameValue(values[0], values[1]); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-braced-quantifier-exact.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-braced-quantifier-exact.js new file mode 100644 index 000000000..dfcb60866 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-braced-quantifier-exact.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-patterns +es6id: 21.2.1 +description: Braced quantifier in an Atom position (exact count) +info: | + SyntaxCharacter :: one of + ^$\.*+?()[]{}| + + PatternCharacter :: + SourceCharacter but not SyntaxCharacter + + Although Annex B extends the definition of Term to include + ExtendedPatternCharacter, it also introduces the InvalidBracedQuantifier + pattern with a higher precedence. This makes the SyntaxError for such + patterns consistent between Annex-B and non-Annex-B environments. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/{2}/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-braced-quantifier-lower.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-braced-quantifier-lower.js new file mode 100644 index 000000000..eae3c8039 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-braced-quantifier-lower.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-patterns +es6id: 21.2.1 +description: Braced quantifier in an Atom position (lower-bounds) +info: | + SyntaxCharacter :: one of + ^$\.*+?()[]{}| + + PatternCharacter :: + SourceCharacter but not SyntaxCharacter + + Although Annex B extends the definition of Term to include + ExtendedPatternCharacter, it also introduces the InvalidBracedQuantifier + pattern with a higher precedence. This makes the SyntaxError for such + patterns consistent between Annex-B and non-Annex-B environments. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/{2,}/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-braced-quantifier-range.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-braced-quantifier-range.js new file mode 100644 index 000000000..4f834742e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-braced-quantifier-range.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-patterns +es6id: 21.2.1 +description: Braced quantifier in an Atom position (range) +info: | + SyntaxCharacter :: one of + ^$\.*+?()[]{}| + + PatternCharacter :: + SourceCharacter but not SyntaxCharacter + + Although Annex B extends the definition of Term to include + ExtendedPatternCharacter, it also introduces the InvalidBracedQuantifier + pattern with a higher precedence. This makes the SyntaxError for such + patterns consistent between Annex-B and non-Annex-B environments. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/{2,3}/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-optional-lookbehind.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-optional-lookbehind.js new file mode 100644 index 000000000..5d4469c89 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-optional-lookbehind.js @@ -0,0 +1,20 @@ +// Copyright (C) 2018 Igalia S. L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-regular-expressions-patterns +description: Lookbehinds are not treated as a QuantifiableAssertion +info: | + Term[U] :: + [~U] QuantifiableAssertion Quantifier + + QuantifiableAssertion[N]:: + ( ? = Disjunction[~U, ?N] ) + ( ? ! Disjunction[~U, ?N] ) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/.(?<=.)?/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-optional-negative-lookbehind.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-optional-negative-lookbehind.js new file mode 100644 index 000000000..5a4d23da0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/invalid-optional-negative-lookbehind.js @@ -0,0 +1,20 @@ +// Copyright (C) 2018 Igalia S. L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-regular-expressions-patterns +description: Lookbehinds are not treated as a QuantifiableAssertion +info: | + Term[U] :: + [~U] QuantifiableAssertion Quantifier + + QuantifiableAssertion[N]:: + ( ? = Disjunction[~U, ?N] ) + ( ? ! Disjunction[~U, ?N] ) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/.(? + Mongolian Vowel Separator can appear in regular expression literals (eval code). +info: | + 11.1 Unicode Format-Control Characters + + The Unicode format-control characters (i.e., the characters in category “Cf” + in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT + MARK) are control codes used to control the formatting of a range of text in + the absence of higher-level protocols for this (such as mark-up languages). + + It is useful to allow format-control characters in source text to facilitate + editing and display. All format control characters may be used within comments, + and within string literals, template literals, and regular expression literals. +features: [u180e] +---*/ + +assert.sameValue(eval("/\u180E/").source, "\u180E"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/mongolian-vowel-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/mongolian-vowel-separator.js new file mode 100644 index 000000000..ada45c945 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/mongolian-vowel-separator.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-unicode-format-control-characters +description: > + Mongolian Vowel Separator can appear in regular expression literals. +info: | + 11.1 Unicode Format-Control Characters + + The Unicode format-control characters (i.e., the characters in category “Cf” + in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT + MARK) are control codes used to control the formatting of a range of text in + the absence of higher-level protocols for this (such as mark-up languages). + + It is useful to allow format-control characters in source text to facilitate + editing and display. All format control characters may be used within comments, + and within string literals, template literals, and regular expression literals. +features: [u180e] +---*/ + +// U+180E in regular expressions; UTF8(0x180E) = 0xE1 0xA0 0x8E +assert.sameValue(/᠎/.source, "\u180E"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/forward-reference.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/forward-reference.js new file mode 100644 index 000000000..a6dd3c37f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/forward-reference.js @@ -0,0 +1,10 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Named groups can be forward references. +esid: sec-atomescape +features: [regexp-named-groups] +---*/ + +assert(/\k(?x)/.test("x")); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-2-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-2-u.js new file mode 100644 index 000000000..31459eae6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-2-u.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)\k/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-2.js new file mode 100644 index 000000000..8c44891d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-2.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)\k/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-3-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-3-u.js new file mode 100644 index 000000000..33a671976 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-3-u.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)\k/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-3.js new file mode 100644 index 000000000..85cdcf023 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-3.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)\k/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-4-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-4-u.js new file mode 100644 index 000000000..40bced7a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-4-u.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\k(?a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-4.js new file mode 100644 index 000000000..685cebcd3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-4.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\k(?a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-5.js new file mode 100644 index 000000000..fd3636bca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-5.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\k(?x)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-u.js new file mode 100644 index 000000000..b2f058060 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-u.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)\k/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-without-group-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-without-group-u.js new file mode 100644 index 000000000..9e2feba79 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname-without-group-u.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\k/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname.js new file mode 100644 index 000000000..97ad1dfea --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-dangling-groupname.js @@ -0,0 +1,20 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Group reference must have corresponding group. +info: | + It is a Syntax Error if the enclosing Pattern does not contain a + GroupSpecifier with an enclosed RegExpIdentifierName whose StringValue + equals the StringValue of the RegExpIdentifierName of this production's + GroupName. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)\k/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-2-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-2-u.js new file mode 100644 index 000000000..cc43f0df1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-2-u.js @@ -0,0 +1,19 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifiers within one alternative must be unique. +info: | + It is a Syntax Error if |Pattern| contains two distinct |GroupSpecifier|s + _x_ and _y_ for which CapturingGroupName(_x_) is the same as + CapturingGroupName(_y_) and such that CanBothParticipate(_x_, _y_) is *true*. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)(?b)(?a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-2.js new file mode 100644 index 000000000..21bf468cc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-2.js @@ -0,0 +1,19 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifiers within one alternative must be unique. +info: | + It is a Syntax Error if |Pattern| contains two distinct |GroupSpecifier|s + _x_ and _y_ for which CapturingGroupName(_x_) is the same as + CapturingGroupName(_y_) and such that CanBothParticipate(_x_, _y_) is *true*. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)(?b)(?a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-u.js new file mode 100644 index 000000000..41ff9f414 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier-u.js @@ -0,0 +1,19 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifiers within one alternative must be unique. +info: | + It is a Syntax Error if |Pattern| contains two distinct |GroupSpecifier|s + _x_ and _y_ for which CapturingGroupName(_x_) is the same as + CapturingGroupName(_y_) and such that CanBothParticipate(_x_, _y_) is *true*. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)(?a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier.js new file mode 100644 index 000000000..7fbd5e134 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-duplicate-groupspecifier.js @@ -0,0 +1,19 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifiers within one alternative must be unique. +info: | + It is a Syntax Error if |Pattern| contains two distinct |GroupSpecifier|s + _x_ and _y_ for which CapturingGroupName(_x_) is the same as + CapturingGroupName(_y_) and such that CanBothParticipate(_x_, _y_) is *true*. +esid: sec-patterns-static-semantics-early-errors +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)(?a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-empty-groupspecifier-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-empty-groupspecifier-u.js new file mode 100644 index 000000000..d436a6100 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-empty-groupspecifier-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<>a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-empty-groupspecifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-empty-groupspecifier.js new file mode 100644 index 000000000..b0340bd7a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-empty-groupspecifier.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<>a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-identity-escape-in-capture-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-identity-escape-in-capture-u.js new file mode 100644 index 000000000..4d37dd1f2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-identity-escape-in-capture-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?\a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-2-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-2-u.js new file mode 100644 index 000000000..40fb0dccd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-2-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)\k`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)\k`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)\k<>/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-3.js new file mode 100644 index 000000000..2eb0ba475 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-3.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)\k<>/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-4.js new file mode 100644 index 000000000..3b69d20f5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-4.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\ka)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-5.js new file mode 100644 index 000000000..a6a5252d9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-5.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\k.)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-6.js new file mode 100644 index 000000000..91b3d52be --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-6.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\k(?.)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-u.js new file mode 100644 index 000000000..0b96a800c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)\k/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-2-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-2-u.js new file mode 100644 index 000000000..6077b0b6a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-2-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\k<>/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-3-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-3-u.js new file mode 100644 index 000000000..11f80d3da --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-3-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\k/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-u.js new file mode 100644 index 000000000..2f30944f8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-incomplete-groupname-without-group-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupName is `< RegExpIdentifierName >`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/\k`. +esid: prod-GroupName +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)\k/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-lone-surrogate-groupname.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-lone-surrogate-groupname.js new file mode 100644 index 000000000..7be757996 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-lone-surrogate-groupname.js @@ -0,0 +1,13 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Lone surrogates in RegExp group names +esid: prod-GroupSpecifier +features: [regexp-named-groups] +---*/ + +assert.throws(SyntaxError, () => eval("/(?.)/"), "Lead"); +assert.throws(SyntaxError, () => eval("/(?.)/"), "Trail"); +assert.throws(SyntaxError, () => eval("/(?.)/u"), "Lead with u flag"); +assert.throws(SyntaxError, () => eval("/(?.)/u"), "Trail with u flag"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4-u.js new file mode 100644 index 000000000..f24ce8e30 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4.js new file mode 100644 index 000000000..959975878 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier-4.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier.js new file mode 100644 index 000000000..87a1c371a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-continue-groupspecifier.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<$❞>a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2-u.js new file mode 100644 index 000000000..1189dfcad --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<𐒤>a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2.js new file mode 100644 index 000000000..9c2b6e0af --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-2.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<𐒤>a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-3.js new file mode 100644 index 000000000..1983edae5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-3.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4-u.js new file mode 100644 index 000000000..b485cb65e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4.js new file mode 100644 index 000000000..77f9b4908 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-4.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5-u.js new file mode 100644 index 000000000..81684ea1b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5.js new file mode 100644 index 000000000..b92dc86f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-5.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-6.js new file mode 100644 index 000000000..372f44a3e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-6.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-7.js new file mode 100644 index 000000000..110adc649 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-7.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8-u.js new file mode 100644 index 000000000..9590153de --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<\>.)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8.js new file mode 100644 index 000000000..f50ceef2b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-8.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<\>.)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-9-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-9-u.js new file mode 100644 index 000000000..6dbfcc37c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-9-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?.)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-u.js new file mode 100644 index 000000000..b2c4a6755 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<❤>a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier.js new file mode 100644 index 000000000..21598105e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-non-id-start-groupspecifier.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<❤>a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-numeric-groupspecifier-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-numeric-groupspecifier-u.js new file mode 100644 index 000000000..1e50d5d39 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-numeric-groupspecifier-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<42a>a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-numeric-groupspecifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-numeric-groupspecifier.js new file mode 100644 index 000000000..923eb2f32 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-numeric-groupspecifier.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<42a>a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier-u.js new file mode 100644 index 000000000..160373d59 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<:a>a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier.js new file mode 100644 index 000000000..77885c936 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-starting-groupspecifier.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?<:a>a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier-u.js new file mode 100644 index 000000000..3038296a4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier.js new file mode 100644 index 000000000..276b423c9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-punctuator-within-groupspecifier.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(?a)/; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-unterminated-groupspecifier-u.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-unterminated-groupspecifier-u.js new file mode 100644 index 000000000..8a56f75a8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/named-groups/invalid-unterminated-groupspecifier-u.js @@ -0,0 +1,15 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: GroupSpecifier must be identifier-like. +esid: prod-GroupSpecifier +negative: + phase: parse + type: SyntaxError +features: [regexp-named-groups] +---*/ + +$DONOTEVALUATE(); + +/(? + The first character of a regular expression may not be a +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/
/ + +/* +There is a between the two / characters +*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/regexp-first-char-no-paragraph-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/regexp-first-char-no-paragraph-separator.js new file mode 100644 index 000000000..0a436bab4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/regexp-first-char-no-paragraph-separator.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + The first character of a regular expression may not be a +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/
/ + +/* +There is a between the two / characters +*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/regexp-source-char-no-line-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/regexp-source-char-no-line-separator.js new file mode 100644 index 000000000..aa173ec96 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/regexp-source-char-no-line-separator.js @@ -0,0 +1,32 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionBackslashSequence +info: | + RegularExpressionBackslashSequence :: + \ RegularExpressionNonTerminator + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + + LineTerminator :: + + + + + +description: > + A regular expression may not contain a as a SourceCharacter +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/a\\
/ + +/* +There is a between "a\\
" and "/" +*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/regexp-source-char-no-paragraph-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/regexp-source-char-no-paragraph-separator.js new file mode 100644 index 000000000..a970e9376 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/regexp-source-char-no-paragraph-separator.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-RegularExpressionNonTerminator +info: | + RegularExpressionBody :: + RegularExpressionFirstChar RegularExpressionChars + + RegularExpressionChars :: + [empty] + RegularExpressionChars RegularExpressionChar + + RegularExpressionFirstChar :: + RegularExpressionNonTerminator but not one of * or \ or / or [ + + RegularExpressionNonTerminator :: + SourceCharacter but not LineTerminator + +description: > + A regular expression may not contain a as a SourceCharacter +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/a\\

/ + +/* +There is a between "a\\
" and "/" +*/ diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-astral-char-class-invert.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-astral-char-class-invert.js new file mode 100644 index 000000000..cf5285bdf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-astral-char-class-invert.js @@ -0,0 +1,31 @@ +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-atom +description: > + Literal astral symbols within inverted CharacterClass. +info: | + The production Atom :: CharacterClass evaluates as follows: + + 1. Evaluate CharacterClass to obtain a CharSet A and a Boolean invert. + 2. Call CharacterSetMatcher(A, invert, direction) and return its Matcher result. + + Runtime Semantics: CharacterSetMatcher ( A, invert, direction ) + + 1. Return an internal Matcher closure that takes two arguments, a State x and + a Continuation c, and performs the following steps: + [...] + f. Let cc be Canonicalize(ch). + g. If invert is false, then + [...] + h. Else, + i. Assert: invert is true. + ii. If there exists a member a of set A such that Canonicalize(a) is cc, + return failure. +---*/ + +assert.sameValue(/^[^❤️]$/u.exec("❤️"), null); +assert.sameValue(/^[^🧡]/u.exec("🧡"), null); +assert.sameValue(/[^💛]$/u.exec("💛"), null); +assert.sameValue(/[^💚]/u.exec("💚"), null); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-astral.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-astral.js new file mode 100644 index 000000000..cd15057bf --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-astral.js @@ -0,0 +1,55 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Literal astral symbols within a pattern +es6id: 21.2.2.8.2 +info: | + 21.2.2.2 Pattern + + The production Pattern :: Disjunction evaluates as follows: + + 1. Evaluate Disjunction to obtain a Matcher m. + 2. Return an internal closure that takes two arguments, a String str + and an integer index, and performs the following steps: + 1. If Unicode is true, let Input be a List consisting of the + sequence of code points of str interpreted as a UTF-16 encoded + (6.1.4) Unicode string. Otherwise, let Input be a List consisting + of the sequence of code units that are the elements of str. Input + will be used throughout the algorithms in 21.2.2. Each element of + Input is considered to be a character. +---*/ + +assert(/𝌆{2}/u.test('𝌆𝌆'), 'quantifier application'); + +assert(/^[𝌆]$/u.test('𝌆'), 'as a ClassAtom'); + +var rangeRe = /[💩-💫]/u; +assert.sameValue( + rangeRe.test('\ud83d\udca8'), + false, + 'ClassAtom as lower range boundary, input below (U+1F4A8)' +); +assert.sameValue( + rangeRe.test('\ud83d\udca9'), + true, + 'ClassAtom as lower range boundary, input match (U+1F4A9)' +); +assert.sameValue( + rangeRe.test('\ud83d\udcaa'), + true, + 'ClassAtom as upper- and lower-range boundary, input within (U+1F4AA)' +); +assert.sameValue( + rangeRe.test('\ud83d\udcab'), + true, + 'ClassAtom as upper range boundary, input match (U+1F4AB)' +); +assert.sameValue( + rangeRe.test('\ud83d\udcac'), + false, + 'ClassAtom as upper range boundary, input above (U+1F4AC)' +); + +assert(/[^𝌆]/u.test('\ud834'), 'Negated character classes (LeadSurrogate)'); +assert(/[^𝌆]/u.test('\udf06'), 'Negated character classes (TrailSurrogate)'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-case-mapping.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-case-mapping.js new file mode 100644 index 000000000..0abea571b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-case-mapping.js @@ -0,0 +1,49 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Case mapping of astral symbols +es6id: 21.2.2.8.2 +info: | + 21.2.2.8.2 Runtime Semantics: Canonicalize ( ch ) + + The abstract operation Canonicalize takes a character parameter ch and + performs the following steps: + + 1. If IgnoreCase is false, return ch. + 2. If Unicode is true, + a. If the file CaseFolding.txt of the Unicode Character Database + provides a simple or common case folding mapping for ch, return + the result of applying that mapping to ch. + b. Else, return ch. +---*/ + +assert.sameValue( + /\u212a/i.test('k'), + false, + 'Case mapping is not applied in the absence of the `u` flag' +); +assert.sameValue( + /\u212a/i.test('K'), + false, + 'Case mapping is not applied in the absence of the `u` flag' +); +assert.sameValue( + /\u212a/u.test('k'), + false, + 'Case mapping is not applied in the absence of the `i` flag' +); +assert.sameValue( + /\u212a/u.test('K'), + false, + 'Case mapping is not applied in the absence of the `i` flag' +); + +assert( + /\u212a/iu.test('k'), + 'Case mapping is applied in the presence of the `i` and `u` flags' +); +assert( + /\u212a/iu.test('K'), + 'Case mapping is applied in the presence of the `i` and `u` flags' +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-class-escape.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-class-escape.js new file mode 100644 index 000000000..44cf36963 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-class-escape.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-patterns +es6id: 21.2.1 +description: > + ClassEscape does not recognize "class control" patterns +info: | + ClassEscape[U] :: + b + [+U] - + CharacterClassEscape + CharacterEscape[?U] + + The `u` flag precludes the Annex B extension that enables this pattern. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\c0/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-extended-pattern-char.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-extended-pattern-char.js new file mode 100644 index 000000000..cafb641cd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-extended-pattern-char.js @@ -0,0 +1,20 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-patterns +es6id: 21.2.1 +description: Quantifiable assertions disallowed with `u` flag +info: | + The `u` flag precludes the use of extended pattern characters irrespective + of the presence of Annex B extensions. + + Term[U] :: + [~U] ExtendedAtom +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/{/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-identity-escape.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-identity-escape.js new file mode 100644 index 000000000..2d88bc463 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-identity-escape.js @@ -0,0 +1,22 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-patterns +es6id: 21.2.1 +description: Support for UnicodeIDContinue in IdentityEscape +info: | + IdentityEscape[U] :: + [+U] SyntaxCharacter + [+U] / + [~U] SourceCharacter but not UnicodeIDContinue + + The `u` flag precludes the use of characters in UnicodeIDContinue + irrespective of the presence of Annex B extensions. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\M/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-legacy-octal-escape.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-legacy-octal-escape.js new file mode 100644 index 000000000..5a632914d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-legacy-octal-escape.js @@ -0,0 +1,25 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-patterns +es6id: 21.2.1 +description: Legacy Octal Escape Sequence not supported with `u` flag +info: | + The `u` flag precludes the use of LegacyOctalEscapeSequence irrespective + of the presence of Annex B extensions. + + CharacterEscape [U] :: + ControlEscape + c ControlLetter + 0[lookahead ∉ DecimalDigit] + HexEscapeSequence + RegExpUnicodeEscapeSequence[?U] + IdentityEscape[?U] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\1/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-a.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-a.js new file mode 100644 index 000000000..f09ecf157 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-a.js @@ -0,0 +1,32 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-pattern-semantics +es6id: 21.2.2 +description: > + NonEmptyClassRangesNoDash production cannot specify a multi-character set + ("A" parameter) +info: | + The production + NonemptyClassRangesNoDash::ClassAtomNoDash-ClassAtomClassRanges evaluates + as follows: + + 1. Evaluate ClassAtomNoDash to obtain a CharSet A. + 2. Evaluate ClassAtom to obtain a CharSet B. + 3. Evaluate ClassRanges to obtain a CharSet C. + 4. Call CharacterRange(A, B) and let D be the resulting CharSet. + + 21.2.2.15.1 Runtime Semantics: CharacterRange Abstract Operation + + 1. If A does not contain exactly one character or B does not contain + exactly one character, throw a SyntaxError exception. + + The `u` flag precludes the Annex B extension that enables this pattern. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/[\d-a]/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-ab.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-ab.js new file mode 100644 index 000000000..c4a238226 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-ab.js @@ -0,0 +1,32 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-pattern-semantics +es6id: 21.2.2 +description: > + NonEmptyClassRangesNoDash production cannot specify a multi-character set + (both "A" and "B" parameters) +info: | + The production + NonemptyClassRangesNoDash::ClassAtomNoDash-ClassAtomClassRanges evaluates + as follows: + + 1. Evaluate ClassAtomNoDash to obtain a CharSet A. + 2. Evaluate ClassAtom to obtain a CharSet B. + 3. Evaluate ClassRanges to obtain a CharSet C. + 4. Call CharacterRange(A, B) and let D be the resulting CharSet. + + 21.2.2.15.1 Runtime Semantics: CharacterRange Abstract Operation + + 1. If A does not contain exactly one character or B does not contain + exactly one character, throw a SyntaxError exception. + + The `u` flag precludes the Annex B extension that enables this pattern. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/[\s-\d]/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-b.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-b.js new file mode 100644 index 000000000..8c0c39cfe --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges-no-dash-b.js @@ -0,0 +1,32 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-pattern-semantics +es6id: 21.2.2 +description: > + NonEmptyClassRangesNoDash production cannot specify a multi-character set + ("B" parameter) +info: | + The production + NonemptyClassRangesNoDash::ClassAtomNoDash-ClassAtomClassRanges evaluates + as follows: + + 1. Evaluate ClassAtomNoDash to obtain a CharSet A. + 2. Evaluate ClassAtom to obtain a CharSet B. + 3. Evaluate ClassRanges to obtain a CharSet C. + 4. Call CharacterRange(A, B) and let D be the resulting CharSet. + + 21.2.2.15.1 Runtime Semantics: CharacterRange Abstract Operation + + 1. If A does not contain exactly one character or B does not contain + exactly one character, throw a SyntaxError exception. + + The `u` flag precludes the Annex B extension that enables this pattern. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/[%-\d]/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges.js new file mode 100644 index 000000000..b68fd6571 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-non-empty-class-ranges.js @@ -0,0 +1,31 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-pattern-semantics +es6id: 21.2.2 +description: > + NonEmptyClassRangesNoDash production cannot specify a multi-character set +info: | + The production + NonemptyClassRangesNoDash::ClassAtomNoDash-ClassAtomClassRanges evaluates + as follows: + + 1. Evaluate ClassAtomNoDash to obtain a CharSet A. + 2. Evaluate ClassAtom to obtain a CharSet B. + 3. Evaluate ClassRanges to obtain a CharSet C. + 4. Call CharacterRange(A, B) and let D be the resulting CharSet. + + 21.2.2.15.1 Runtime Semantics: CharacterRange Abstract Operation + + 1. If A does not contain exactly one character or B does not contain + exactly one character, throw a SyntaxError exception. + + The `u` flag precludes the Annex B extension that enables this pattern. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/[--\d]/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-oob-decimal-escape.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-oob-decimal-escape.js new file mode 100644 index 000000000..56f3727ac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-oob-decimal-escape.js @@ -0,0 +1,20 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-pattern-semantics +es6id: 21.2.2 +description: Out-of-bounds decimal escapes +info: | + 1. Evaluate DecimalEscape to obtain an integer n. + 2. If n>NcapturingParens, throw a SyntaxError exception. + + When the "unicode" flag is set, this algorithm is honored irrespective of + the presence of Annex B extensions. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\8/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-lookahead.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-lookahead.js new file mode 100644 index 000000000..59b94337e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-lookahead.js @@ -0,0 +1,20 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-regular-expressions-patterns +es6id: B.1.4 +description: Quantifiable assertions disallowed with `u` flag +info: | + The `u` flag precludes quantifiable assertions (even when Annex B is + honored) + + Term[U] :: + [~U] QuantifiableAssertion Quantifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/.(?=.)?/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-lookbehind.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-lookbehind.js new file mode 100644 index 000000000..f3a5e5c01 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-lookbehind.js @@ -0,0 +1,20 @@ +// Copyright (C) 2018 Igalia S. L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-regular-expressions-patterns +description: Lookbehinds are not treated as a QuantifiableAssertion +info: | + Term[U] :: + [~U] QuantifiableAssertion Quantifier + + QuantifiableAssertion[N]:: + ( ? = Disjunction[~U, ?N] ) + ( ? ! Disjunction[~U, ?N] ) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/.(?<=.)?/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-negative-lookahead.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-negative-lookahead.js new file mode 100644 index 000000000..136b3238d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-negative-lookahead.js @@ -0,0 +1,20 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-regular-expressions-patterns +es6id: B.1.4 +description: Quantifiable assertions disallowed with `u` flag +info: | + The `u` flag precludes quantifiable assertions (even when Annex B is + honored) + + Term[U] :: + [~U] QuantifiableAssertion Quantifier +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/.(?!.)?/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-negative-lookbehind.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-negative-lookbehind.js new file mode 100644 index 000000000..42e5bc071 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-invalid-optional-negative-lookbehind.js @@ -0,0 +1,20 @@ +// Copyright (C) 2018 Igalia S. L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-regular-expressions-patterns +description: Lookbehinds are not treated as a QuantifiableAssertion +info: | + Term[U] :: + [~U] QuantifiableAssertion Quantifier + + QuantifiableAssertion[N]:: + ( ? = Disjunction[~U, ?N] ) + ( ? ! Disjunction[~U, ?N] ) +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/.(? + Null character escape is permitted in Unicode patterns. +info: | + CharacterEscape[U] :: + ControlEscape + c ControlLetter + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + RegExpUnicodeEscapeSequence[?U] + IdentityEscape[?U] + + DecimalDigit :: one of + 0 1 2 3 4 5 6 7 8 9 +---*/ + +var nullChar = String.fromCharCode(0); +assert.sameValue(/\0/u.exec(nullChar)[0], nullChar); +assert(/^\0a$/u.test('\0a')); +assert.sameValue('\x00②'.match(/\0②/u)[0], '\x00②'); +assert.sameValue('\u0000፬'.search(/\0፬$/u), 0); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-char-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-char-class.js new file mode 100644 index 000000000..0eecdbcd3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-char-class.js @@ -0,0 +1,33 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-atom +es6id: 21.2.2.8 +description: > + Support for surrogate pairs within patterns match by the CharacterClass Atom +info: | + The production Atom :: CharacterClass evaluates as follows: + + 1. Evaluate CharacterClass to obtain a CharSet A and a Boolean invert. + 2. Call CharacterSetMatcher(A, invert) and return its Matcher result. + + Runtime Semantics: CharacterSetMatcher Abstract Operation + + 1. Return an internal Matcher closure that takes two arguments, a State x and + a Continuation c, and performs the following steps when evaluated: + [...] + d. Let cc be Canonicalize(ch). + [...] +---*/ + +assert(/^[\ud800\udc00]$/u.test('\ud800\udc00')); +assert.sameValue( + /[\ud800\udc00]/u.test('\ud800'), + false, + '\\ud800 does not qualify as a class member' +); +assert.sameValue( + /[\ud800\udc00]/u.test('\udc00'), + false, + '\\udc00 does not qualify as a class member' +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-dot.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-dot.js new file mode 100644 index 000000000..50a6c4fa9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-dot.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-atom +es6id: 21.2.2.8 +description: > + Support for surrogate pairs within patterns match by the "period" Atom +info: | + The production Atom :: . evaluates as follows: + + 1. Let A be the set of all characters except LineTerminator. + 2. Call CharacterSetMatcher(A, false) and return its Matcher result. + + Runtime Semantics: CharacterSetMatcher Abstract Operation + + 1. Return an internal Matcher closure that takes two arguments, a State x and + a Continuation c, and performs the following steps when evaluated: + [...] + d. Let cc be Canonicalize(ch). + [...] +---*/ + +assert(/^.$/u.test('\ud800\udc00')); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-escape-char-class.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-escape-char-class.js new file mode 100644 index 000000000..a509fb803 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-escape-char-class.js @@ -0,0 +1,24 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-atomescape +es6id: 21.2.2.9 +description: > + Support for surrogate pairs within patterns match by the CharacterClassEscape + AtomEscape +info: | + The production AtomEscape :: CharacterClassEscape evaluates as follows: + + 1. Evaluate CharacterClassEscape to obtain a CharSet A. + 2. Call CharacterSetMatcher(A, false) and return its Matcher result. + + Runtime Semantics: CharacterSetMatcher Abstract Operation + + 1. Return an internal Matcher closure that takes two arguments, a State x and + a Continuation c, and performs the following steps when evaluated: + [...] + d. Let cc be Canonicalize(ch). + [...] +---*/ + +assert(/^\S$/u.test('\ud800\udc00')); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-escape-decimal.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-escape-decimal.js new file mode 100644 index 000000000..6b945fc25 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs-atom-escape-decimal.js @@ -0,0 +1,29 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-atomescape +es6id: 21.2.2.9 +description: > + Support for surrogate pairs within patterns match by the DecimalEscape + AtomEscape +info: | + The production AtomEscape :: DecimalEscape evaluates as follows: + + [...] + 3. Return an internal Matcher closure that takes two arguments, a State x and + a Continuation c, and performs the following steps: + [...] + h. If there exists an integer i between 0 (inclusive) and len (exclusive) + such that Canonicalize(s[i]) is not the same character value as + Canonicalize(Input[e+i]), return failure. + + Runtime Semantics: CharacterSetMatcher Abstract Operation + + 1. Return an internal Matcher closure that takes two arguments, a State x and + a Continuation c, and performs the following steps when evaluated: + [...] + d. Let cc be Canonicalize(ch). + [...] +---*/ + +assert.sameValue(/(.+).*\1/u.test('\ud800\udc00\ud800'), false); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs.js new file mode 100644 index 000000000..5190e64b1 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-surrogate-pairs.js @@ -0,0 +1,19 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Out-of-range value of hexadecimal digits in UnicodeEscapeSequence +es6id: 21.2.2.10 +info: | + 21.2.2.10 CharacterEscape + + The production RegExpUnicodeEscapeSequence :: u LeadSurrogate \u + TrailSurrogate evaluates as follows: + + 1. Let lead be the result of evaluating LeadSurrogate. + 2. Let trail be the result of evaluating TrailSurrogate. + 3. Let cp be UTF16Decode(lead, trail). + 4. Return the character whose character value is cp. +---*/ + +assert(/^[\ud834\udf06]$/u.test('\ud834\udf06')); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-unicode-esc-bounds.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-unicode-esc-bounds.js new file mode 100644 index 000000000..48d721ad8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-unicode-esc-bounds.js @@ -0,0 +1,20 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Out-of-range value of hexadecimal digits in UnicodeEscapeSequence +es6id: 21.2.1.1 +info: | + 21.2.1.1 Static Semantics: Early Errors + + RegExpUnicodeEscapeSequence :: u{ HexDigits } + + - It is a Syntax Error if the MV of HexDigits > 1114111. +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\u{110000}/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-unicode-esc-non-hex.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-unicode-esc-non-hex.js new file mode 100644 index 000000000..bb33b9d18 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-unicode-esc-non-hex.js @@ -0,0 +1,15 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: > + Non-hexadecimal value within the delimiters of a UnicodeEscapeSequence +es6id: 21.2.1 +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\u{1,}/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-unicode-esc.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-unicode-esc.js new file mode 100644 index 000000000..a917a9a68 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/u-unicode-esc.js @@ -0,0 +1,22 @@ +// Copyright (C) 2015 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Unicode escape interpreted as the Mathematical Value of HexDigits +es6id: 21.2.2.10 +info: | + 21.2.2.10 CharacterEscape + + The production RegExpUnicodeEscapeSequence :: u{ HexDigits } evaluates as + follows: + + 1. Return the character whose code is the MV of HexDigits. +---*/ + +assert(/\u{0}/u.test('\u0000'), 'Minimum value (U+0000)'); +assert(/\u{1}/u.test('\u0001'), 'U+0001'); +assert.sameValue(/\u{1}/u.test('u'), false); +assert(/\u{3f}/u.test('?')); +assert(/\u{000000003f}/u.test('?'), 'Leading zeros'); +assert(/\u{3F}/u.test('?'), 'Case insensitivity'); +assert(/\u{10ffff}/u.test('\udbff\udfff'), 'Maxiumum value (U+10ffff)'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/unicode-escape-nls-err.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/unicode-escape-nls-err.js new file mode 100644 index 000000000..580c42bbd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/unicode-escape-nls-err.js @@ -0,0 +1,73 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-Pattern +description: NumericLiteralSeperator disallowed in unicode CodePoint sequence +info: | + Pattern[U, N]:: + Disjunction[?U, ?N] + + Disjunction[U, N]:: + Alternative[?U, ?N] + Alternative[?U, ?N]|Disjunction[?U, ?N] + + Alternative[U, N]:: + [empty] + Alternative[?U, ?N]Term[?U, ?N] + + Term[U, N]:: + Assertion[?U, ?N] + Atom[?U, ?N] + Atom[?U, ?N]Quantifier + + Atom[U, N]:: + PatternCharacter + . + \AtomEscape[?U, ?N] + CharacterClass[?U] + (GroupSpecifier[?U]Disjunction[?U, ?N]) + (?:Disjunction[?U, ?N]) + + AtomEscape[U, N]:: + DecimalEscape + CharacterClassEscape[?U] + CharacterEscape[?U] + [+N]kGroupName[?U] + + CharacterEscape[U]:: + ControlEscape + cControlLetter + 0[lookahead ∉ DecimalDigit] + HexEscapeSequence + RegExpUnicodeEscapeSequence[?U] + IdentityEscape[?U] + + RegExpUnicodeEscapeSequence[U]:: + [+U]uLeadSurrogate\uTrailSurrogate + [+U]uLeadSurrogate + [+U]uTrailSurrogate + [+U]uNonSurrogate + [~U]uHex4Digits + [+U]u{CodePoint} + + CodePoint :: + HexDigit but only if MV of HexDigits ≤ 0x10FFFF + CodePointDigits but only if MV of HexDigits ≤ 0x10FFFF + + CodePointDigits :: + HexDigit + CodePointDigitsHexDigit + + HexDigit :: one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +/\u{1F_639}/u; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/y-assertion-start.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/y-assertion-start.js new file mode 100644 index 000000000..4a9038dfc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/regexp/y-assertion-start.js @@ -0,0 +1,46 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-assertion +es6id: 21.2.2.6 +description: The `y` flag has no effect on the `^` assertion +info: | + Even when the y flag is used with a pattern, ^ always matches only at the + beginning of Input, or (if Multiline is true) at the beginning of a line. +---*/ + +var re; + +re = /^a/y; + +re.lastIndex = 0; +assert.sameValue( + re.test('a'), true, 'positive: beginning of input (without `m`)' +); + +re.lastIndex = 1; +assert.sameValue( + re.test(' a'), false, 'negative: within a line (without `m`)' +); + +re.lastIndex = 1; +assert.sameValue( + re.test('\na'), false, 'negative: beginning of line (without `m`)' +); + +re = /^a/my; + +re.lastIndex = 0; +assert.sameValue( + re.test('a'), true, 'positive: beginning of input (with `m`)' +); + +re.lastIndex = 1; +assert.sameValue( + re.test(' a'), false, 'negative: within a line (with `m`)' +); + +re.lastIndex = 1; +assert.sameValue( + re.test('\na'), true, 'positive: beginning of line (with `m`)' +); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.1_T1.js new file mode 100644 index 000000000..b056a3011 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.1_T1.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "StringLiteral :: \"DoubleStringCharacters_opt\"" +es5id: 7.8.4_A1.1_T1 +description: > + DoubleStringCharacter :: SourceCharacter but not double-quote " or + LineTerminator +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +""" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.1_T2.js new file mode 100644 index 000000000..687056b06 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.1_T2.js @@ -0,0 +1,19 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "StringLiteral :: \"DoubleStringCharacters_opt\"" +es5id: 7.8.4_A1.1_T2 +description: > + DoubleStringCharacter :: SourceCharacter but not double-quote " or + LineTerminator +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +" +" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.2_T1.js new file mode 100644 index 000000000..cf5db3fc4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.2_T1.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "StringLiteral :: 'SingleStringCharacters_opt'" +es5id: 7.8.4_A1.2_T1 +description: > + SingleStringCharacter :: SourceCharacter but not single-quote ' or + LineTerminator +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +''' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.2_T2.js new file mode 100644 index 000000000..3fa90f3ac --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A1.2_T2.js @@ -0,0 +1,19 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "StringLiteral :: 'SingleStringCharacters_opt'" +es5id: 7.8.4_A1.2_T2 +description: > + SingleStringCharacter :: SourceCharacter but not single-quote ' or + LineTerminator +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +' +' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.1_T1.js new file mode 100644 index 000000000..5c7e06493 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.1_T1.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of ENGLISH ALPHABET +es5id: 7.8.4_A2.1_T1 +description: Check ENGLISH CAPITAL ALPHABET +---*/ + +//CHECK#A-Z +var unicode = ["\u0041", "\u0042", "\u0043", "\u0044", "\u0045", "\u0046", "\u0047", "\u0048", "\u0049", "\u004A", "\u004B", "\u004C", "\u004D", "\u004E", "\u004F", "\u0050", "\u0051", "\u0052", "\u0053", "\u0054", "\u0055", "\u0056", "\u0057", "\u0058", "\u0059", "\u005A"]; +var character = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]; +for (var index = 0; index <= 25; index++) { + if (unicode[index] !== character[index]) { + throw new Test262Error('#' + character[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.1_T2.js new file mode 100644 index 000000000..b832e1a0d --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.1_T2.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of ENGLISH ALPHABET +es5id: 7.8.4_A2.1_T2 +description: Check ENGLISH SMALL ALPHABET +---*/ + +//CHECK#a-z +var hex = ["\u0061", "\u0062", "\u0063", "\u0064", "\u0065", "\u0066", "\u0067", "\u0068", "\u0069", "\u006A", "\u006B", "\u006C", "\u006D", "\u006E", "\u006F", "\u0070", "\u0071", "\u0072", "\u0073", "\u0074", "\u0075", "\u0076", "\u0077", "\u0078", "\u0079", "\u007A"]; +var character = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]; +for (var index = 0; index <= 25; index++) { + if (hex[index] !== character[index]) { + throw new Test262Error('#' + character[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.2_T1.js new file mode 100644 index 000000000..2834de83e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.2_T1.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of RUSSIAN ALPHABET +es5id: 7.8.4_A2.2_T1 +description: Check RUSSIAN CAPITAL ALPHABET +---*/ + +//CHECK#А-Я +var unicode = ["\u0410", "\u0411", "\u0412", "\u0413", "\u0414", "\u0415", "\u0416", "\u0417", "\u0418", "\u0419", "\u041A", "\u041B", "\u041C", "\u041D", "\u041E", "\u041F", "\u0420", "\u0421", "\u0422", "\u0423", "\u0424", "\u0425", "\u0426", "\u0427", "\u0428", "\u0429", "\u042A", "\u042B", "\u042C", "\u042D", "\u042E", "\u042F", "\u0401"]; +var character = ["А", "Б", "В", "Г", "Д", "Е", "Ж", "З", "И", "Й", "К", "Л", "М", "Н", "О", "П", "Р", "С", "Т", "У", "Ф", "Х", "Ц", "Ч", "Ш", "Щ", "Ъ", "Ы", "Ь", "Э", "Ю", "Я", "Ё"]; +for (var index = 0; index <= 32; index++) { + if (unicode[index] !== character[index]) { + throw new Test262Error('#' + character[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.2_T2.js new file mode 100644 index 000000000..67e8bc1e5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.2_T2.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of RUSSIAN ALPHABET +es5id: 7.8.4_A2.2_T2 +description: Check RUSSIAN SMALL ALPHABET +---*/ + +//CHECK#а-я +var unicode = ["\u0430", "\u0431", "\u0432", "\u0433", "\u0434", "\u0435", "\u0436", "\u0437", "\u0438", "\u0439", "\u043A", "\u043B", "\u043C", "\u043D", "\u043E", "\u043F", "\u0440", "\u0441", "\u0442", "\u0443", "\u0444", "\u0445", "\u0446", "\u0447", "\u0448", "\u0449", "\u044A", "\u044B", "\u044C", "\u044D", "\u044E", "\u044F", "\u0451"]; +var character = ["а", "б", "в", "г", "д", "е", "ж", "з", "и", "й", "к", "л", "м", "н", "о", "п", "р", "с", "т", "у", "ф", "х", "ц", "ч", "ш", "щ", "ъ", "ы", "ь", "э", "ю", "я", "ё"]; +for (var index = 0; index <= 32; index++) { + if (unicode[index] !== character[index]) { + throw new Test262Error('#' + character[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.3_T1.js new file mode 100644 index 000000000..8ef74b522 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A2.3_T1.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Correct interpretation of DIGITS +es5id: 7.8.4_A2.3_T1 +description: Check DIGITS +---*/ + +//CHECK#0-9 +var unicode = ["\u0030", "\u0031", "\u0032", "\u0033", "\u0034", "\u0035", "\u0036", "\u0037", "\u0038", "\u0039"]; +var character = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]; +for (var index = 0; index <= 9; index++) { + if (unicode[index] !== character[index]) { + throw new Test262Error('#' + character[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.1_T1.js new file mode 100644 index 000000000..6f00caeed --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.1_T1.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "StringLiteral :: \"\\\" or '\\' is not correct" +es5id: 7.8.4_A3.1_T1 +description: Checking if execution of "\" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +"\" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.1_T2.js new file mode 100644 index 000000000..cd99d21a6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.1_T2.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "StringLiteral :: \"\\\" or '\\' is not correct" +es5id: 7.8.4_A3.1_T2 +description: Checking if execution of "'\'" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +'\' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.2_T1.js new file mode 100644 index 000000000..8d82e5670 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.2_T1.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "StringLiteral :: \"\\\\\\\" or '\\\\\\' is not correct" +es5id: 7.8.4_A3.2_T1 +description: Checking if execution of "\\\" fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +"\\\" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.2_T2.js new file mode 100644 index 000000000..571c06929 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A3.2_T2.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "StringLiteral :: \"\\\\\\\" or '\\\\\\' is not correct" +es5id: 7.8.4_A3.2_T2 +description: Checking if execution of '\\\' fails +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +'\\\' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.1_T1.js new file mode 100644 index 000000000..9ad6ddbd4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.1_T1.js @@ -0,0 +1,38 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: SingleEscapeSequence" +es5id: 7.8.4_A4.1_T1 +description: "SingleEscapeSequence :: one of b f n r t v" +---*/ + +//CHECK#1 +if (String.fromCharCode(0x0008) !== "\b") { + throw new Test262Error('#1: String.fromCharCode(0x0008) === "\\b"'); +} + +//CHECK#2 +if (String.fromCharCode(0x0009) !== "\t") { + throw new Test262Error('#2: String.fromCharCode(0x0009) === "\\t"'); +} + +//CHECK#3 +if (String.fromCharCode(0x000A) !== "\n") { + throw new Test262Error('#3: String.fromCharCode(0x000A) === "\\n"'); +} + +//CHECK#4 +if (String.fromCharCode(0x000B) !== "\v") { + throw new Test262Error('#4: String.fromCharCode(0x000B) === "\\v"'); +} + +//CHECK#5 +if (String.fromCharCode(0x000C) !== "\f") { + throw new Test262Error('#5: String.fromCharCode(0x000C) === "\\f"'); +} + +//CHECK#6 +if (String.fromCharCode(0x000D) !== "\r") { + throw new Test262Error('#6: String.fromCharCode(0x000D) === "\\r"'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.1_T2.js new file mode 100644 index 000000000..db0f83c07 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.1_T2.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: SingleEscapeSequence" +es5id: 7.8.4_A4.1_T2 +description: "SingleEscapeSequence :: one of ' \" \\" +---*/ + +//CHECK#1 +if (String.fromCharCode(0x0027) !== "\'") { + throw new Test262Error('#1: String.fromCharCode(0x0027) === "\\\'"'); +} + +//CHECK#2 +if (String.fromCharCode(0x0022) !== '\"') { + throw new Test262Error('#2: String.fromCharCode(0x0027) === \'\\\"\''); +} + +//CHECK#3 +if (String.fromCharCode(0x005C) !== "\\") { + throw new Test262Error('#3: String.fromCharCode(0x005C) === "\\\"'); +} + +//CHECK#4 +if ("\'" !== "'") { + throw new Test262Error('#4: "\'" === "\\\'"'); +} + +//CHECK#5 +if ('\"' !== '"') { + throw new Test262Error('#5: \'\"\' === \'\\\"\''); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T1.js new file mode 100644 index 000000000..4f1575c81 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T1.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: NonEscapeSequence" +es5id: 7.8.4_A4.2_T1 +description: "NonEscapeSequence :: ENGLISH CAPITAL ALPHABET" +---*/ + +//CHECK#A-Z +var CharacterCode = [0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A]; +var NonEscapeCharacter = ["\A", "\B", "\C", "\D", "\E", "\F", "\G", "\H", "\I", "\J", "\K", "\L", "\M", "\N", "\O", "\P", "\Q", "\R", "\S", "\T", "\U", "\V", "\W", "\X", "\Y", "\Z"]; +for (var index = 0; index <= 25; index++) { + if (String.fromCharCode(CharacterCode[index]) !== NonEscapeCharacter[index]) { + throw new Test262Error('#' + NonEscapeCharacter[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T2.js new file mode 100644 index 000000000..47e89dcd7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T2.js @@ -0,0 +1,113 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: NonEscapeSequence" +es5id: 7.8.4_A4.2_T2 +description: "NonEscapeSequence :: ENGLISH CAPITAL ALPHABET" +---*/ + +//CHECK#A-Z +if ("A" !== "\A") { + throw new Test262Error('#A'); +} + +if ("B" !== "\B") { + throw new Test262Error('#B'); +} + +if ("C" !== "\C") { + throw new Test262Error('#C'); +} + +if ("D" !== "\D") { + throw new Test262Error('#D'); +} + +if ("E" !== "\E") { + throw new Test262Error('#E'); +} + +if ("F" !== "\F") { + throw new Test262Error('#F'); +} + +if ("G" !== "\G") { + throw new Test262Error('#G'); +} + +if ("H" !== "\H") { + throw new Test262Error('#H'); +} + +if ("I" !== "\I") { + throw new Test262Error('#I'); +} + +if ("J" !== "\J") { + throw new Test262Error('#J'); +} + +if ("K" !== "\K") { + throw new Test262Error('#K'); +} + +if ("L" !== "\L") { + throw new Test262Error('#L'); +} + +if ("M" !== "\M") { + throw new Test262Error('#M'); +} + +if ("N" !== "\N") { + throw new Test262Error('#N'); +} + +if ("O" !== "\O") { + throw new Test262Error('#O'); +} + +if ("P" !== "\P") { + throw new Test262Error('#P'); +} + +if ("Q" !== "\Q") { + throw new Test262Error('#Q'); +} + +if ("R" !== "\R") { + throw new Test262Error('#R'); +} + +if ("S" !== "\S") { + throw new Test262Error('#S'); +} + +if ("T" !== "\T") { + throw new Test262Error('#T'); +} + +if ("U" !== "\U") { + throw new Test262Error('#U'); +} + +if ("V" !== "\V") { + throw new Test262Error('#V'); +} + +if ("W" !== "\W") { + throw new Test262Error('#W'); +} + +if ("X" !== "\X") { + throw new Test262Error('#X'); +} + +if ("Y" !== "\Y") { + throw new Test262Error('#Y'); +} + +if ("Z" !== "\Z") { + throw new Test262Error('#Z'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T3.js new file mode 100644 index 000000000..15020248b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T3.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: NonEscapeSequence" +es5id: 7.8.4_A4.2_T3 +description: "NonEscapeSequence :: ENGLISH SMALL ALPHABET" +---*/ + +//CHECK#a-z without b, f, n, r, t, v, x, u +var CharacterCode = [0x0061, 0x0063, 0x0064, 0x0065, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006F, 0x0070, 0x0071, 0x0073, 0x0077, 0x0079, 0x007A]; +var NonEscapeCharacter = ["\a", "\c", "\d", "\e", "\g", "\h", "\i", "\j", "\k", "\l", "\m", "\o", "\p", "\q", "\s", "\w", "\y", "\z"]; +for (var index = 0; index <= 17; index++) { + if (String.fromCharCode(CharacterCode[index]) !== NonEscapeCharacter[index]) { + throw new Test262Error('#' + NonEscapeCharacter[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T4.js new file mode 100644 index 000000000..55268af35 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T4.js @@ -0,0 +1,83 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: NonEscapeSequence" +es5id: 7.8.4_A4.2_T4 +description: "NonEscapeSequence :: ENGLISH SMALL ALPHABET" +---*/ + +//CHECK#a-z without b, f, n, r, t, v, x, u + +if ("a" !== "\a") { + throw new Test262Error('#a'); +} + +if ("c" !== "\c") { + throw new Test262Error('#c'); +} + +if ("d" !== "\d") { + throw new Test262Error('#d'); +} + +if ("e" !== "\e") { + throw new Test262Error('#e'); +} + +if ("g" !== "\g") { + throw new Test262Error('#g'); +} + +if ("h" !== "\h") { + throw new Test262Error('#h'); +} + +if ("i" !== "\i") { + throw new Test262Error('#i'); +} + +if ("j" !== "\j") { + throw new Test262Error('#j'); +} + +if ("k" !== "\k") { + throw new Test262Error('#k'); +} + +if ("l" !== "\l") { + throw new Test262Error('#l'); +} + +if ("m" !== "\m") { + throw new Test262Error('#m'); +} + + +if ("o" !== "\o") { + throw new Test262Error('#o'); +} + +if ("p" !== "\p") { + throw new Test262Error('#p'); +} + +if ("q" !== "\q") { + throw new Test262Error('#q'); +} + +if ("s" !== "\s") { + throw new Test262Error('#s'); +} + +if ("w" !== "\w") { + throw new Test262Error('#w'); +} + +if ("y" !== "\y") { + throw new Test262Error('#y'); +} + +if ("z" !== "\z") { + throw new Test262Error('#z'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T5.js new file mode 100644 index 000000000..d6407af95 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T5.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: NonEscapeSequence" +es5id: 7.8.4_A4.2_T5 +description: "NonEscapeSequence :: RUSSIAN CAPITAL ALPHABET" +---*/ + +//CHECK#А-Я +var CharacterCode = [0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F, 0x0401]; +var NonEscapeCharacter = ["\А", "\Б", "\В", "\Г", "\Д", "\Е", "\Ж", "\З", "\И", "\Й", "\К", "\Л", "\М", "\Н", "\О", "\П", "\Р", "\С", "\Т", "\У", "\Ф", "\Х", "\Ц", "\Ч", "\Ш", "\Щ", "\Ъ", "\Ы", "\Ь", "\Э", "\Ю", "\Я", "\Ё"]; +for (var index = 0; index <= 32; index++) { + if (String.fromCharCode(CharacterCode[index]) !== NonEscapeCharacter[index]) { + throw new Test262Error('#' + NonEscapeCharacter[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T6.js new file mode 100644 index 000000000..ce389cc61 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T6.js @@ -0,0 +1,142 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: NonEscapeSequence" +es5id: 7.8.4_A4.2_T6 +description: "NonEscapeSequence :: RUSSIAN CAPITAL ALPHABET" +---*/ + +//CHECK#А-Я + +if ("А" !== "\А") { + throw new Test262Error('#А'); +} + +if ("Б" !== "\Б") { + throw new Test262Error('#Б'); +} + +if ("В" !== "\В") { + throw new Test262Error('#В'); +} + +if ("Г" !== "\Г") { + throw new Test262Error('#Г'); +} + +if ("Д" !== "\Д") { + throw new Test262Error('#Д'); +} + +if ("Е" !== "\Е") { + throw new Test262Error('#Е'); +} + +if ("Ж" !== "\Ж") { + throw new Test262Error('#Ж'); +} + +if ("З" !== "\З") { + throw new Test262Error('#З'); +} + +if ("И" !== "\И") { + throw new Test262Error('#И'); +} + +if ("Й" !== "\Й") { + throw new Test262Error('#Й'); +} + +if ("К" !== "\К") { + throw new Test262Error('#К'); +} + +if ("Л" !== "\Л") { + throw new Test262Error('#Л'); +} + +if ("М" !== "\М") { + throw new Test262Error('#М'); +} + +if ("Н" !== "\Н") { + throw new Test262Error('#Н'); +} + +if ("О" !== "\О") { + throw new Test262Error('#О'); +} + +if ("П" !== "\П") { + throw new Test262Error('#П'); +} + +if ("Р" !== "\Р") { + throw new Test262Error('#Р'); +} + +if ("С" !== "\С") { + throw new Test262Error('#С'); +} + +if ("Т" !== "\Т") { + throw new Test262Error('#Т'); +} + +if ("У" !== "\У") { + throw new Test262Error('#У'); +} + +if ("Ф" !== "\Ф") { + throw new Test262Error('#Ф'); +} + +if ("Х" !== "\Х") { + throw new Test262Error('#Х'); +} + +if ("Ц" !== "\Ц") { + throw new Test262Error('#Ц'); +} + +if ("Ч" !== "\Ч") { + throw new Test262Error('#Ч'); +} + +if ("Ш" !== "\Ш") { + throw new Test262Error('#Ш'); +} + +if ("Щ" !== "\Щ") { + throw new Test262Error('#Щ'); +} + +if ("Ъ" !== "\Ъ") { + throw new Test262Error('#Ъ'); +} + +if ("Ы" !== "\Ы") { + throw new Test262Error('#Ы'); +} + +if ("Ь" !== "\Ь") { + throw new Test262Error('#Ь'); +} + +if ("Э" !== "\Э") { + throw new Test262Error('#Э'); +} + +if ("Ю" !== "\Ю") { + throw new Test262Error('#Ю'); +} + +if ("Я" !== "\Я") { + throw new Test262Error('#Я'); +} + +if ("Ё" !== "\Ё") { + throw new Test262Error('#Ё'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T7.js new file mode 100644 index 000000000..22d730289 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T7.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: NonEscapeSequence" +es5id: 7.8.4_A4.2_T7 +description: "NonEscapeSequence :: RUSSIAN SMALL ALPHABET" +---*/ + +//CHECK#а-я +var CharacterCode = [0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 0x0451]; +var NonEscapeCharacter = ["\а", "\б", "\в", "\г", "\д", "\е", "\ж", "\з", "\и", "\й", "\к", "\л", "\м", "\н", "\о", "\п", "\р", "\с", "\т", "\у", "\ф", "\х", "\ц", "\ч", "\ш", "\щ", "\ъ", "\ы", "\ь", "\э", "\ю", "\я", "\ё"]; +for (var index = 0; index <= 32; index++) { + if (String.fromCharCode(CharacterCode[index]) !== NonEscapeCharacter[index]) { + throw new Test262Error('#' + NonEscapeCharacter[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T8.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T8.js new file mode 100644 index 000000000..72a518ef0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.2_T8.js @@ -0,0 +1,142 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "CharacterEscapeSequnce :: NonEscapeSequence" +es5id: 7.8.4_A4.2_T8 +description: "NonEscapeSequence :: RUSSIAN SMALL ALPHABET" +---*/ + +//CHECK#а-я + +if ("а" !== "\а") { + throw new Test262Error('#а'); +} + +if ("б" !== "\б") { + throw new Test262Error('#б'); +} + +if ("в" !== "\в") { + throw new Test262Error('#в'); +} + +if ("г" !== "\г") { + throw new Test262Error('#г'); +} + +if ("д" !== "\д") { + throw new Test262Error('#д'); +} + +if ("е" !== "\е") { + throw new Test262Error('#е'); +} + +if ("ж" !== "\ж") { + throw new Test262Error('#ж'); +} + +if ("з" !== "\з") { + throw new Test262Error('#з'); +} + +if ("и" !== "\и") { + throw new Test262Error('#и'); +} + +if ("й" !== "\й") { + throw new Test262Error('#й'); +} + +if ("к" !== "\к") { + throw new Test262Error('#к'); +} + +if ("л" !== "\л") { + throw new Test262Error('#л'); +} + +if ("м" !== "\м") { + throw new Test262Error('#м'); +} + +if ("н" !== "\н") { + throw new Test262Error('#н'); +} + +if ("о" !== "\о") { + throw new Test262Error('#о'); +} + +if ("п" !== "\п") { + throw new Test262Error('#п'); +} + +if ("р" !== "\р") { + throw new Test262Error('#р'); +} + +if ("с" !== "\с") { + throw new Test262Error('#с'); +} + +if ("т" !== "\т") { + throw new Test262Error('#т'); +} + +if ("у" !== "\у") { + throw new Test262Error('#у'); +} + +if ("ф" !== "\ф") { + throw new Test262Error('#ф'); +} + +if ("х" !== "\х") { + throw new Test262Error('#х'); +} + +if ("ц" !== "\ц") { + throw new Test262Error('#ц'); +} + +if ("ч" !== "\ч") { + throw new Test262Error('#ч'); +} + +if ("ш" !== "\ш") { + throw new Test262Error('#ш'); +} + +if ("щ" !== "\щ") { + throw new Test262Error('#щ'); +} + +if ("ъ" !== "\ъ") { + throw new Test262Error('#ъ'); +} + +if ("ы" !== "\ы") { + throw new Test262Error('#ы'); +} + +if ("ь" !== "\ь") { + throw new Test262Error('#ь'); +} + +if ("э" !== "\э") { + throw new Test262Error('#э'); +} + +if ("ю" !== "\ю") { + throw new Test262Error('#ю'); +} + +if ("я" !== "\я") { + throw new Test262Error('#я'); +} + +if ("ё" !== "\ё") { + throw new Test262Error('#ё'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.3_T1.js new file mode 100644 index 000000000..6a12fb211 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.3_T1.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: NonEscapeSequence is not EscapeCharacter +es5id: 7.8.4_A4.3_T1 +description: "EscapeCharacter :: DecimalDigits :: 1" +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +"\1" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.3_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.3_T2.js new file mode 100644 index 000000000..cd9d50a38 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.3_T2.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: NonEscapeSequence is not EscapeCharacter +es5id: 7.8.4_A4.3_T2 +description: "EscapeCharacter :: DecimalDigits :: 7" +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + +"\7" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.3_T7.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.3_T7.js new file mode 100644 index 000000000..40619d1db --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A4.3_T7.js @@ -0,0 +1,33 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: NonEscapeSequence is not EscapeCharacter +es5id: 7.8.4_A4.3_T7 +description: "EscapeCharacter :: SingleEscapeCharacter :: one of b f n r t v" +---*/ + +//CHECK#bfnrtv +if ("b" === "\b") { + throw new Test262Error('#b'); +} + +if ("f" === "\f") { + throw new Test262Error('#f'); +} + +if ("n" === "\n") { + throw new Test262Error('#n'); +} + +if ("r" === "\r") { + throw new Test262Error('#r'); +} + +if ("t" === "\t") { + throw new Test262Error('#t'); +} + +if ("v" === "\v") { + throw new Test262Error('#v'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A5.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A5.1_T1.js new file mode 100644 index 000000000..f4f7fdd29 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A5.1_T1.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "EscapeSequence :: 0" +es5id: 7.8.4_A5.1_T1 +description: String.fromCharCode(0x0000) +---*/ + +//CHECK#1 +if (String.fromCharCode(0x0000) !== "\0") { + throw new Test262Error('#1: String.fromCharCode(0x0000) === "\\0"'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A5.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A5.1_T2.js new file mode 100644 index 000000000..5289b85a7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A5.1_T2.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "EscapeSequence :: 0" +es5id: 7.8.4_A5.1_T2 +description: "\"\\u0000\"" +---*/ + +//CHECK#1 +if ("\u0000" !== "\0") { + throw new Test262Error('#1: "\\u0000" === "\\0"'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A5.1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A5.1_T3.js new file mode 100644 index 000000000..4ed8c929c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A5.1_T3.js @@ -0,0 +1,13 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "EscapeSequence :: 0" +es5id: 7.8.4_A5.1_T3 +description: "\"\\x00\"" +---*/ + +//CHECK#1 +if ("\x00" !== "\0") { + throw new Test262Error('#1: "\\x00" === "\\0"'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.1_T1.js new file mode 100644 index 000000000..fd87ce65f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.1_T1.js @@ -0,0 +1,88 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "EscapeSequence :: HexEscapeSequence :: x HexDigit HexDigit" +es5id: 7.8.4_A6.1_T1 +description: "HexEscapeSequence :: HexDigit" +---*/ + +//CHECK#0 +if ("\x00" !== String.fromCharCode("0")) { + throw new Test262Error('#0: "\\x00" === String.fromCharCode("0")'); +} + +//CHECK#1 +if ("\x01" !== String.fromCharCode("1")) { + throw new Test262Error('#1: "\\x01" === String.fromCharCode("1")'); +} + +//CHECK#2 +if ("\x02" !== String.fromCharCode("2")) { + throw new Test262Error('#2: "\\x02" === String.fromCharCode("2")'); +} + +//CHECK#3 +if ("\x03" !== String.fromCharCode("3")) { + throw new Test262Error('#3: "\\x03" === String.fromCharCode("3")'); +} + +//CHECK#4 +if ("\x04" !== String.fromCharCode("4")) { + throw new Test262Error('#4: "\\x04" === String.fromCharCode("4")'); +} + +//CHECK#5 +if ("\x05" !== String.fromCharCode("5")) { + throw new Test262Error('#5: "\\x05" === String.fromCharCode("5")'); +} + +//CHECK#6 +if ("\x06" !== String.fromCharCode("6")) { + throw new Test262Error('#6: "\\x06" === String.fromCharCode("6")'); +} + +//CHECK#7 +if ("\x07" !== String.fromCharCode("7")) { + throw new Test262Error('#7: "\\x07" === String.fromCharCode("7")'); +} + +//CHECK#8 +if ("\x08" !== String.fromCharCode("8")) { + throw new Test262Error('#8: "\\x08" === String.fromCharCode("8")'); +} + +//CHECK#9 +if ("\x09" !== String.fromCharCode("9")) { + throw new Test262Error('#9: "\\x09" === String.fromCharCode("9")'); +} + +//CHECK#A +if ("\x0A" !== String.fromCharCode("10")) { + throw new Test262Error('#A: "\\x0A" === String.fromCharCode("10")'); +} + +//CHECK#B +if ("\x0B" !== String.fromCharCode("11")) { + throw new Test262Error('#B: "\\x0B" === String.fromCharCode("11")'); +} + +//CHECK#C +if ("\x0C" !== String.fromCharCode("12")) { + throw new Test262Error('#C: "\\x0C" === String.fromCharCode("12")'); +} + +//CHECK#D +if ("\x0D" !== String.fromCharCode("13")) { + throw new Test262Error('#D: "\\x0D" === String.fromCharCode("13")'); +} + +//CHECK#E +if ("\x0E" !== String.fromCharCode("14")) { + throw new Test262Error('#E: "\\x0E" === String.fromCharCode("14")'); +} + +//CHECK#F +if ("\x0F" !== String.fromCharCode("15")) { + throw new Test262Error('#F: "\\x0F" === String.fromCharCode("15")'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.1_T2.js new file mode 100644 index 000000000..a09811278 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.1_T2.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "EscapeSequence :: HexEscapeSequence :: x HexDigit HexDigit" +es5id: 7.8.4_A6.1_T2 +description: "HexEscapeSequence :: ENGLISH CAPITAL ALPHABET" +---*/ + +//CHECK#A-Z +var hex = ["\x41", "\x42", "\x43", "\x44", "\x45", "\x46", "\x47", "\x48", "\x49", "\x4A", "\x4B", "\x4C", "\x4D", "\x4E", "\x4F", "\x50", "\x51", "\x52", "\x53", "\x54", "\x55", "\x56", "\x57", "\x58", "\x59", "\x5A"]; +var character = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]; +for (var index = 0; index <= 25; index++) { + if (hex[index] !== character[index]) { + throw new Test262Error('#' + character[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.1_T3.js new file mode 100644 index 000000000..d6429f7b2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.1_T3.js @@ -0,0 +1,17 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "EscapeSequence :: HexEscapeSequence :: x HexDigit HexDigit" +es5id: 7.8.4_A6.1_T3 +description: "HexEscapeSequence :: ENGLISH SMALL ALPHABET" +---*/ + +//CHECK#a-z +var hex = ["\x61", "\x62", "\x63", "\x64", "\x65", "\x66", "\x67", "\x68", "\x69", "\x6A", "\x6B", "\x6C", "\x6D", "\x6E", "\x6F", "\x70", "\x71", "\x72", "\x73", "\x74", "\x75", "\x76", "\x77", "\x78", "\x79", "\x7A"]; +var character = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]; +for (var index = 0; index <= 25; index++) { + if (hex[index] !== character[index]) { + throw new Test262Error('#' + character[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.3_T1.js new file mode 100644 index 000000000..af93fd90c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A6.3_T1.js @@ -0,0 +1,83 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: \x HexDigit HexDigit SingleStringCharacter +es5id: 7.8.4_A6.3_T1 +description: Check similar to ('\x01F' === String.fromCharCode('1') + 'F') +---*/ + +//CHECK#1 +if ('\x01F' !== String.fromCharCode('1') + 'F') { + throw new Test262Error("#1: '\x01F' === String.fromCharCode('1') + 'F'"); +} + +//CHECK#2 +if ('\x02E' !== String.fromCharCode('2') + 'E') { + throw new Test262Error("#2: '\x02E' === String.fromCharCode('2') + 'E'"); +} + +//CHECK#3 +if ('\x03D' !== String.fromCharCode('3') + 'D') { + throw new Test262Error("#3: '\x03D' === String.fromCharCode('3') + 'D'"); +} + +//CHECK#4 +if ('\x04C' !== String.fromCharCode('4') + 'C') { + throw new Test262Error("#4: '\x04C' === String.fromCharCode('4') + 'C'"); +} + +//CHECK#5 +if ('\x05B' !== String.fromCharCode('5') + 'B') { + throw new Test262Error("#5: '\x05B' === String.fromCharCode('5') + 'B'"); +} + +//CHECK#6 +if ('\x06A' !== String.fromCharCode('6') + 'A') { + throw new Test262Error("#6: '\x06A' === String.fromCharCode('6') + 'A'"); +} + +//CHECK#7 +if ('\x079' !== String.fromCharCode('7') + '9') { + throw new Test262Error("#7: '\x079' === String.fromCharCode('7') + '9'"); +} + +//CHECK#8 +if ('\x088' !== String.fromCharCode('8') + '8') { + throw new Test262Error("#8: '\x088' === String.fromCharCode('8') + '8'"); +} + +//CHECK#9 +if ('\x097' !== String.fromCharCode('9') + '7') { + throw new Test262Error("#9: '\x097' === String.fromCharCode('9') + '7'"); +} + +//CHECK#A +if ('\x0A6' !== String.fromCharCode('10') + '6') { + throw new Test262Error("#A: '\x0A6' === String.fromCharCode('10') + '6'"); +} + +//CHECK#B +if ('\x0B5' !== String.fromCharCode('11') + '5') { + throw new Test262Error("#B: '\x0B5' === String.fromCharCode('11') + '5'"); +} + +//CHECK#C +if ('\x0C4' !== String.fromCharCode('12') + '4') { + throw new Test262Error("#C: '\x0C4' === String.fromCharCode('12') + '4'"); +} + +//CHECK#D +if ('\x0D3' !== String.fromCharCode('13') + '3') { + throw new Test262Error("#D: '\x0D3' === String.fromCharCode('13') + '3'"); +} + +//CHECK#E +if ('\x0E2' !== String.fromCharCode('14') + '2') { + throw new Test262Error("#E: '\x0E2' === String.fromCharCode('14') + '2'"); +} + +//CHECK#F +if ('\x0F1' !== String.fromCharCode('15') + '1') { + throw new Test262Error("#F: '\x0F1' === String.fromCharCode('15') + '1'"); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T1.js new file mode 100644 index 000000000..6f2b9e492 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T1.js @@ -0,0 +1,90 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + EscapeSequence :: UnicodeEscapeSequence :: u HexDigit HexDigit HexDigit + HexDigit +es5id: 7.8.4_A7.1_T1 +description: Check similar to ("\u0000" === String.fromCharCode("0")) +---*/ + +//CHECK#0 +if ("\u0000" !== String.fromCharCode("0")) { + throw new Test262Error('#0: "\\u0000" === String.fromCharCode("0")'); +} + +//CHECK#1 +if ("\u0001" !== String.fromCharCode("1")) { + throw new Test262Error('#1: "\\u0001" === String.fromCharCode("1")'); +} + +//CHECK#2 +if ("\u0002" !== String.fromCharCode("2")) { + throw new Test262Error('#2: "\\u0002" === String.fromCharCode("2")'); +} + +//CHECK#3 +if ("\u0003" !== String.fromCharCode("3")) { + throw new Test262Error('#3: "\\u0003" === String.fromCharCode("3")'); +} + +//CHECK#4 +if ("\u0004" !== String.fromCharCode("4")) { + throw new Test262Error('#4: "\\u0004" === String.fromCharCode("4")'); +} + +//CHECK#5 +if ("\u0005" !== String.fromCharCode("5")) { + throw new Test262Error('#5: "\\u0005" === String.fromCharCode("5")'); +} + +//CHECK#6 +if ("\u0006" !== String.fromCharCode("6")) { + throw new Test262Error('#6: "\\u0006" === String.fromCharCode("6")'); +} + +//CHECK#7 +if ("\u0007" !== String.fromCharCode("7")) { + throw new Test262Error('#7: "\\u0007" === String.fromCharCode("7")'); +} + +//CHECK#8 +if ("\u0008" !== String.fromCharCode("8")) { + throw new Test262Error('#8: "\\u0008" === String.fromCharCode("8")'); +} + +//CHECK#9 +if ("\u0009" !== String.fromCharCode("9")) { + throw new Test262Error('#9: "\\u0009" === String.fromCharCode("9")'); +} + +//CHECK#A +if ("\u000A" !== String.fromCharCode("10")) { + throw new Test262Error('#A: "\\u000A" === String.fromCharCode("10")'); +} + +//CHECK#B +if ("\u000B" !== String.fromCharCode("11")) { + throw new Test262Error('#B: "\\u000B" === String.fromCharCode("11")'); +} + +//CHECK#C +if ("\u000C" !== String.fromCharCode("12")) { + throw new Test262Error('#C: "\\u000C" === String.fromCharCode("12")'); +} + +//CHECK#D +if ("\u000D" !== String.fromCharCode("13")) { + throw new Test262Error('#D: "\\u000D" === String.fromCharCode("13")'); +} + +//CHECK#E +if ("\u000E" !== String.fromCharCode("14")) { + throw new Test262Error('#E: "\\u000E" === String.fromCharCode("14")'); +} + +//CHECK#F +if ("\u000F" !== String.fromCharCode("15")) { + throw new Test262Error('#F: "\\u000F" === String.fromCharCode("15")'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T2.js new file mode 100644 index 000000000..5e299d5bd --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T2.js @@ -0,0 +1,19 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + EscapeSequence :: UnicodeEscapeSequence :: u HexDigit HexDigit HexDigit + HexDigit +es5id: 7.8.4_A7.1_T2 +description: "UnicodeEscapeSequence :: ENGLISH CAPITAL ALPHABET" +---*/ + +//CHECK#A-Z +var unicode = ["\u0041", "\u0042", "\u0043", "\u0044", "\u0045", "\u0046", "\u0047", "\u0048", "\u0049", "\u004A", "\u004B", "\u004C", "\u004D", "\u004E", "\u004F", "\u0050", "\u0051", "\u0052", "\u0053", "\u0054", "\u0055", "\u0056", "\u0057", "\u0058", "\u0059", "\u005A"]; +var character = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]; +for (var index = 0; index <= 25; index++) { + if (unicode[index] !== character[index]) { + throw new Test262Error('#' + character[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T3.js new file mode 100644 index 000000000..37b48bf2c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T3.js @@ -0,0 +1,19 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + EscapeSequence :: UnicodeEscapeSequence :: u HexDigit HexDigit HexDigit + HexDigit +es5id: 7.8.4_A7.1_T3 +description: "UnicodeEscapeSequence :: ENGLISH SMALL ALPHABET" +---*/ + +//CHECK#a-z +var unicode = ["\u0061", "\u0062", "\u0063", "\u0064", "\u0065", "\u0066", "\u0067", "\u0068", "\u0069", "\u006A", "\u006B", "\u006C", "\u006D", "\u006E", "\u006F", "\u0070", "\u0071", "\u0072", "\u0073", "\u0074", "\u0075", "\u0076", "\u0077", "\u0078", "\u0079", "\u007A"]; +var character = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]; +for (var index = 0; index <= 25; index++) { + if (unicode[index] !== character[index]) { + throw new Test262Error('#' + character[index] + ' '); + } +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T4.js new file mode 100644 index 000000000..4f1b981fc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.1_T4.js @@ -0,0 +1,18 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + EscapeSequence :: UnicodeEscapeSequence :: u HexDigit HexDigit HexDigit + HexDigit +es5id: 7.8.4_A7.1_T4 +description: "UnicodeEscapeSequence :: u000G is incorrect" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK# +"\u000G" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T1.js new file mode 100644 index 000000000..2889d90f4 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T1.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "UnicodeEscapeSequence :: u HexDigit (one, two or three time) is incorrect" +es5id: 7.8.4_A7.2_T1 +description: ":: HexDigit :: 1" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +"\u1" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T2.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T2.js new file mode 100644 index 000000000..3264200c8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T2.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "UnicodeEscapeSequence :: u HexDigit (one, two or three time) is incorrect" +es5id: 7.8.4_A7.2_T2 +description: ":: HexDigit :: A" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +"\uA" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T3.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T3.js new file mode 100644 index 000000000..d76f4c19a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T3.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "UnicodeEscapeSequence :: u HexDigit (one, two or three time) is incorrect" +es5id: 7.8.4_A7.2_T3 +description: ":: HexDigit :: 1" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +"\u11" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T4.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T4.js new file mode 100644 index 000000000..e8cbff6d5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T4.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "UnicodeEscapeSequence :: u HexDigit (one, two or three time) is incorrect" +es5id: 7.8.4_A7.2_T4 +description: ":: HexDigit :: A" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +"\uAA" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T5.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T5.js new file mode 100644 index 000000000..d68bda6ee --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T5.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "UnicodeEscapeSequence :: u HexDigit (one, two or three time) is incorrect" +es5id: 7.8.4_A7.2_T5 +description: ":: HexDigit :: 1" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +"\u111" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T6.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T6.js new file mode 100644 index 000000000..f95a3b6bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.2_T6.js @@ -0,0 +1,16 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: "UnicodeEscapeSequence :: u HexDigit (one, two or three time) is incorrect" +es5id: 7.8.4_A7.2_T6 +description: ":: HexDigit :: A" +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +//CHECK#1 +"\uAAA" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.3_T1.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.3_T1.js new file mode 100644 index 000000000..3ab4c85f7 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/S7.8.4_A7.3_T1.js @@ -0,0 +1,83 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: \u HexDigit HexDigit HexDigit HexDigit DoubleStringCharacter +es5id: 7.8.4_A7.3_T1 +description: Check similar to ("\u0001F" === String.fromCharCode("1") + "F") +---*/ + +//CHECK#1 +if ("\u0001F" !== String.fromCharCode("1") + "F") { + throw new Test262Error('#1: "\\u0001F" === String.fromCharCode("1") + "F"'); +} + +//CHECK#2 +if ("\u0002E" !== String.fromCharCode("2") + "E") { + throw new Test262Error('#2: "\\u0002E" === String.fromCharCode("2") + "E"'); +} + +//CHECK#3 +if ("\u0003D" !== String.fromCharCode("3") + "D") { + throw new Test262Error('#3: "\\u0003D" === String.fromCharCode("3") + "D"'); +} + +//CHECK#4 +if ("\u0004C" !== String.fromCharCode("4") + "C") { + throw new Test262Error('#4: "\\u0004C" === String.fromCharCode("4") + "C"'); +} + +//CHECK#5 +if ("\u0005B" !== String.fromCharCode("5") + "B") { + throw new Test262Error('#5: "\\u0005B" === String.fromCharCode("5") + "B"'); +} + +//CHECK#6 +if ("\u0006A" !== String.fromCharCode("6") + "A") { + throw new Test262Error('#6: "\\u0006A" === String.fromCharCode("6") + "A"'); +} + +//CHECK#7 +if ("\u00079" !== String.fromCharCode("7") + "9") { + throw new Test262Error('#7: "\\u00079" === String.fromCharCode("7") + "9"'); +} + +//CHECK#8 +if ("\u00088" !== String.fromCharCode("8") + "8") { + throw new Test262Error('#8: "\\u00088" === String.fromCharCode("8") + "8"'); +} + +//CHECK#9 +if ("\u00097" !== String.fromCharCode("9") + "7") { + throw new Test262Error('#9: "\\u00097" === String.fromCharCode("9") + "7"'); +} + +//CHECK#A +if ("\u000A6" !== String.fromCharCode("10") + "6") { + throw new Test262Error('#A: "\\u000A6" === String.fromCharCode("10") + "6"'); +} + +//CHECK#B +if ("\u000B5" !== String.fromCharCode("11") + "5") { + throw new Test262Error('#B: "\\u000B5" === String.fromCharCode("11") + "5"'); +} + +//CHECK#C +if ("\u000C4" !== String.fromCharCode("12") + "4") { + throw new Test262Error('#C: "\\u000C4" === String.fromCharCode("12") + "4"'); +} + +//CHECK#D +if ("\u000D3" !== String.fromCharCode("13") + "3") { + throw new Test262Error('#D: "\\u000D3" === String.fromCharCode("13") + "3"'); +} + +//CHECK#E +if ("\u000E2" !== String.fromCharCode("14") + "2") { + throw new Test262Error('#E: "\\u000E2" === String.fromCharCode("14") + "2"'); +} + +//CHECK#F +if ("\u000F1" !== String.fromCharCode("15") + "1") { + throw new Test262Error('#F: "\\u000F1" === String.fromCharCode("15") + "1"'); +} diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-1-strict-explicit-pragma.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-1-strict-explicit-pragma.js new file mode 100644 index 000000000..1ea37bb75 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-1-strict-explicit-pragma.js @@ -0,0 +1,26 @@ +// Copyright (C) 2020 Rick Waldron Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: > + String Literals extensions disallowed in strict mode; ZeroToThree 1 +info: | + It is possible for string literals to precede a Use Strict Directive that places the enclosing + code in strict mode, and implementations must take care to not use this extended definition of + EscapeSequence with such literals. For example, attempting to parse the following source text + must fail. + + Strict mode is entered via the explicit Use Strict Directive. + + ZeroToThree::one of + 0 1 2 3 + +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function invalid() { "\1"; "use strict"; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-2-strict-explicit-pragma.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-2-strict-explicit-pragma.js new file mode 100644 index 000000000..0b1462483 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-2-strict-explicit-pragma.js @@ -0,0 +1,26 @@ +// Copyright (C) 2020 Rick Waldron Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: > + String Literals extensions disallowed in strict mode; ZeroToThree 2 +info: | + It is possible for string literals to precede a Use Strict Directive that places the enclosing + code in strict mode, and implementations must take care to not use this extended definition of + EscapeSequence with such literals. For example, attempting to parse the following source text + must fail. + + Strict mode is entered via the explicit Use Strict Directive. + + ZeroToThree::one of + 0 1 2 3 + +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function invalid() { "\2"; "use strict"; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-3-strict-explicit-pragma.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-3-strict-explicit-pragma.js new file mode 100644 index 000000000..e118ba51f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-3-strict-explicit-pragma.js @@ -0,0 +1,26 @@ +// Copyright (C) 2020 Rick Waldron Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: > + String Literals extensions disallowed in strict mode; ZeroToThree 3 +info: | + It is possible for string literals to precede a Use Strict Directive that places the enclosing + code in strict mode, and implementations must take care to not use this extended definition of + EscapeSequence with such literals. For example, attempting to parse the following source text + must fail. + + Strict mode is entered via the explicit Use Strict Directive. + + ZeroToThree::one of + 0 1 2 3 + +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function invalid() { "\3"; "use strict"; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-4-strict-explicit-pragma.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-4-strict-explicit-pragma.js new file mode 100644 index 000000000..f5b004279 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-4-strict-explicit-pragma.js @@ -0,0 +1,26 @@ +// Copyright (C) 2020 Rick Waldron Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: > + String Literals extensions disallowed in strict mode; FourToSeven 4 +info: | + It is possible for string literals to precede a Use Strict Directive that places the enclosing + code in strict mode, and implementations must take care to not use this extended definition of + EscapeSequence with such literals. For example, attempting to parse the following source text + must fail. + + Strict mode is entered via the explicit Use Strict Directive. + + FourToSeven::one of + 4 5 6 7 + +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function invalid() { "\4"; "use strict"; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-5-strict-explicit-pragma.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-5-strict-explicit-pragma.js new file mode 100644 index 000000000..26e159552 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-5-strict-explicit-pragma.js @@ -0,0 +1,26 @@ +// Copyright (C) 2020 Rick Waldron Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: > + String Literals extensions disallowed in strict mode; FourToSeven 5 +info: | + It is possible for string literals to precede a Use Strict Directive that places the enclosing + code in strict mode, and implementations must take care to not use this extended definition of + EscapeSequence with such literals. For example, attempting to parse the following source text + must fail. + + Strict mode is entered via the explicit Use Strict Directive. + + FourToSeven::one of + 4 5 6 7 + +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function invalid() { "\5"; "use strict"; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-6-strict-explicit-pragma.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-6-strict-explicit-pragma.js new file mode 100644 index 000000000..ffa4d14c6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-6-strict-explicit-pragma.js @@ -0,0 +1,26 @@ +// Copyright (C) 2020 Rick Waldron Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: > + String Literals extensions disallowed in strict mode; FourToSeven 6 +info: | + It is possible for string literals to precede a Use Strict Directive that places the enclosing + code in strict mode, and implementations must take care to not use this extended definition of + EscapeSequence with such literals. For example, attempting to parse the following source text + must fail. + + Strict mode is entered via the explicit Use Strict Directive. + + FourToSeven::one of + 4 5 6 7 + +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function invalid() { "\6"; "use strict"; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-7-strict-explicit-pragma.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-7-strict-explicit-pragma.js new file mode 100644 index 000000000..981625d03 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-7-strict-explicit-pragma.js @@ -0,0 +1,26 @@ +// Copyright (C) 2020 Rick Waldron Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: > + String Literals extensions disallowed in strict mode; FourToSeven 7 +info: | + It is possible for string literals to precede a Use Strict Directive that places the enclosing + code in strict mode, and implementations must take care to not use this extended definition of + EscapeSequence with such literals. For example, attempting to parse the following source text + must fail. + + Strict mode is entered via the explicit Use Strict Directive. + + FourToSeven::one of + 4 5 6 7 + +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function invalid() { "\7"; "use strict"; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-8-non-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-8-non-strict.js new file mode 100644 index 000000000..8886317c0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-8-non-strict.js @@ -0,0 +1,19 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: LegacyOctalEscapeSequence is not available in non-strict code - 8 +info: | + EscapeSequence :: + CharacterEscapeSequence + LegacyOctalEscapeSequence + NonOctalDecimalEscapeSequence + HexEscapeSequence + UnicodeEscapeSequence + + NonOctalDecimalEscapeSequence :: one of + 8 9 +flags: [noStrict] +---*/ + +assert.sameValue('\8', '8'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-8-strict-explicit-pragma.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-8-strict-explicit-pragma.js new file mode 100644 index 000000000..35ace8328 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-8-strict-explicit-pragma.js @@ -0,0 +1,26 @@ +// Copyright (C) 2020 Rick Waldron Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: > + String Literals extensions disallowed in strict mode; NonOctalDecimalEscapeSequence 8 +info: | + It is possible for string literals to precede a Use Strict Directive that places the enclosing + code in strict mode, and implementations must take care to not use this extended definition of + EscapeSequence with such literals. For example, attempting to parse the following source text + must fail. + + Strict mode is entered via the explicit Use Strict Directive. + + NonOctalDecimalEscapeSequence::one of + 8 9 + +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function invalid() { "\8"; "use strict"; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-8-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-8-strict.js new file mode 100644 index 000000000..3917e634e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-8-strict.js @@ -0,0 +1,31 @@ +// Copyright (C) 2020 Sony Interactive Entertainment Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: LegacyOctalEscapeSequence is not enabled in strict mode code - 8 +info: | + EscapeSequence :: + CharacterEscapeSequence + LegacyOctalEscapeSequence + NonOctalDecimalEscapeSequence + HexEscapeSequence + UnicodeEscapeSequence + + NonOctalDecimalEscapeSequence :: one of + 8 9 + + ## 12.8.4.1 Static Semantics: Early Errors + + EscapeSequence :: NonOctalDecimalEscapeSequence + + - It is a Syntax Error if the source code matching this production is strict + mode code. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +'\8'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-9-non-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-9-non-strict.js new file mode 100644 index 000000000..68ad0a716 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-9-non-strict.js @@ -0,0 +1,19 @@ +// Copyright (C) 2021 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: LegacyOctalEscapeSequence is not available in non-strict code - 9 +info: | + EscapeSequence :: + CharacterEscapeSequence + LegacyOctalEscapeSequence + NonOctalDecimalEscapeSequence + HexEscapeSequence + UnicodeEscapeSequence + + NonOctalDecimalEscapeSequence :: one of + 8 9 +flags: [noStrict] +---*/ + +assert.sameValue('\9', '9'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-9-strict-explicit-pragma.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-9-strict-explicit-pragma.js new file mode 100644 index 000000000..585895013 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-9-strict-explicit-pragma.js @@ -0,0 +1,26 @@ +// Copyright (C) 2020 Rick Waldron Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: > + String Literals extensions disallowed in strict mode; NonOctalDecimalEscapeSequence 9 +info: | + It is possible for string literals to precede a Use Strict Directive that places the enclosing + code in strict mode, and implementations must take care to not use this extended definition of + EscapeSequence with such literals. For example, attempting to parse the following source text + must fail. + + Strict mode is entered via the explicit Use Strict Directive. + + NonOctalDecimalEscapeSequence::one of + 8 9 + +flags: [noStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +function invalid() { "\9"; "use strict"; } diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-9-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-9-strict.js new file mode 100644 index 000000000..c677c3c53 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-9-strict.js @@ -0,0 +1,31 @@ +// Copyright (C) 2020 Sony Interactive Entertainment Inc. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: LegacyOctalEscapeSequence is not enabled in strict mode code - 9 +info: | + EscapeSequence :: + CharacterEscapeSequence + LegacyOctalEscapeSequence + NonOctalDecimalEscapeSequence + HexEscapeSequence + UnicodeEscapeSequence + + NonOctalDecimalEscapeSequence :: one of + 8 9 + + ## 12.8.4.1 Static Semantics: Early Errors + + EscapeSequence :: NonOctalDecimalEscapeSequence + + - It is a Syntax Error if the source code matching this production is strict + mode code. +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +'\9'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-strict.js new file mode 100644 index 000000000..1743d4e26 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-non-octal-escape-sequence-strict.js @@ -0,0 +1,27 @@ +// Copyright (C) 2017 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: LegacyOctalEscapeSequence is not available in template literals +info: | + TemplateCharacter :: + $ [lookahead ≠ {] + \ TemplateEscapeSequence + \ NotEscapeSequence + LineContinuation + LineTerminatorSequence + SourceCharacter but not one of ` or \ or $ or LineTerminator + TemplateEscapeSequence :: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +'\08'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-octal-escape-sequence-prologue-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-octal-escape-sequence-prologue-strict.js new file mode 100644 index 000000000..afe403d8e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-octal-escape-sequence-prologue-strict.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 7.8.4-1-s +description: > + A directive preceding an 'use strict' directive may not contain + an OctalEscapeSequence +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +(function() { + "asterisk: \052"; + "use strict"; +}); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-octal-escape-sequence-strict.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-octal-escape-sequence-strict.js new file mode 100644 index 000000000..be603dd74 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-octal-escape-sequence-strict.js @@ -0,0 +1,27 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-template-literal-lexical-components +description: LegacyOctalEscapeSequence is not available in template literals +info: | + TemplateCharacter :: + $ [lookahead ≠ {] + \ TemplateEscapeSequence + \ NotEscapeSequence + LineContinuation + LineTerminatorSequence + SourceCharacter but not one of ` or \ or $ or LineTerminator + TemplateEscapeSequence :: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence +flags: [onlyStrict] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +'\1'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-octal-escape-sequence.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-octal-escape-sequence.js new file mode 100644 index 000000000..d25a4e57a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/legacy-octal-escape-sequence.js @@ -0,0 +1,152 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-literals-string-literals +description: String value for LegacyOctalEscapeSequence +info: | + EscapeSequence :: + CharacterEscapeSequence + LegacyOctalEscapeSequence + NonOctalDecimalEscapeSequence + HexEscapeSequence + UnicodeEscapeSequence + + LegacyOctalEscapeSequence :: + OctalDigit [lookahead ∉ OctalDigit] + ZeroToThree OctalDigit [lookahead ∉ OctalDigit] + FourToSeven OctalDigit + ZeroToThree OctalDigit OctalDigit + + ZeroToThree :: one of + 0 1 2 3 + + FourToSeven :: one of + 4 5 6 7 +flags: [noStrict] +---*/ + +// LegacyOctalEscapeSequence :: +// OctalDigit [lookahead ∉ OctalDigit] +assert.sameValue('\0', '\x00', '\\0'); +assert.sameValue('\1', '\x01', '\\1'); +assert.sameValue('\2', '\x02', '\\2'); +assert.sameValue('\3', '\x03', '\\3'); +assert.sameValue('\4', '\x04', '\\4'); +assert.sameValue('\5', '\x05', '\\5'); +assert.sameValue('\6', '\x06', '\\6'); +assert.sameValue('\7', '\x07', '\\7'); + +assert.sameValue('\08', '\x008', '\\08'); +assert.sameValue('\18', '\x018', '\\18'); +assert.sameValue('\28', '\x028', '\\28'); +assert.sameValue('\38', '\x038', '\\38'); +assert.sameValue('\48', '\x048', '\\48'); +assert.sameValue('\58', '\x058', '\\58'); +assert.sameValue('\68', '\x068', '\\68'); +assert.sameValue('\78', '\x078', '\\78'); +assert.sameValue('\08', '\x008', '\\08'); + +// LegacyOctalEscapeSequence :: +// ZeroToThree OctalDigit [lookahead ∉ OctalDigit] +assert.sameValue('\00', '\x00', '\\00'); +assert.sameValue('\01', '\x01', '\\01'); +assert.sameValue('\06', '\x06', '\\06'); +assert.sameValue('\07', '\x07', '\\07'); +assert.sameValue('\10', '\x08', '\\10'); +assert.sameValue('\11', '\x09', '\\11'); +assert.sameValue('\16', '\x0e', '\\16'); +assert.sameValue('\17', '\x0f', '\\17'); +assert.sameValue('\20', '\x10', '\\20'); +assert.sameValue('\21', '\x11', '\\21'); +assert.sameValue('\26', '\x16', '\\26'); +assert.sameValue('\27', '\x17', '\\27'); +assert.sameValue('\30', '\x18', '\\30'); +assert.sameValue('\31', '\x19', '\\31'); +assert.sameValue('\36', '\x1e', '\\36'); +assert.sameValue('\37', '\x1f', '\\37'); +assert.sameValue('\008', '\x008', '\\008'); +assert.sameValue('\018', '\x018', '\\018'); +assert.sameValue('\068', '\x068', '\\068'); +assert.sameValue('\078', '\x078', '\\078'); +assert.sameValue('\108', '\x088', '\\108'); +assert.sameValue('\118', '\x098', '\\118'); +assert.sameValue('\168', '\x0e8', '\\168'); +assert.sameValue('\178', '\x0f8', '\\178'); +assert.sameValue('\208', '\x108', '\\208'); +assert.sameValue('\218', '\x118', '\\218'); +assert.sameValue('\268', '\x168', '\\268'); +assert.sameValue('\278', '\x178', '\\278'); +assert.sameValue('\308', '\x188', '\\308'); +assert.sameValue('\318', '\x198', '\\318'); +assert.sameValue('\368', '\x1e8', '\\368'); +assert.sameValue('\378', '\x1f8', '\\378'); + +// LegacyOctalEscapeSequence :: +// FourToSeven OctalDigit +assert.sameValue('\40', '\x20', '\\40'); +assert.sameValue('\41', '\x21', '\\41'); +assert.sameValue('\46', '\x26', '\\46'); +assert.sameValue('\47', '\x27', '\\47'); +assert.sameValue('\50', '\x28', '\\50'); +assert.sameValue('\51', '\x29', '\\51'); +assert.sameValue('\56', '\x2e', '\\56'); +assert.sameValue('\57', '\x2f', '\\57'); +assert.sameValue('\60', '\x30', '\\60'); +assert.sameValue('\61', '\x31', '\\61'); +assert.sameValue('\66', '\x36', '\\66'); +assert.sameValue('\67', '\x37', '\\67'); +assert.sameValue('\70', '\x38', '\\70'); +assert.sameValue('\71', '\x39', '\\71'); +assert.sameValue('\76', '\x3e', '\\76'); +assert.sameValue('\77', '\x3f', '\\77'); +assert.sameValue('\400', '\x200', '\\400'); +assert.sameValue('\410', '\x210', '\\410'); +assert.sameValue('\460', '\x260', '\\460'); +assert.sameValue('\470', '\x270', '\\470'); +assert.sameValue('\500', '\x280', '\\500'); +assert.sameValue('\510', '\x290', '\\510'); +assert.sameValue('\560', '\x2e0', '\\560'); +assert.sameValue('\570', '\x2f0', '\\570'); +assert.sameValue('\600', '\x300', '\\600'); +assert.sameValue('\610', '\x310', '\\610'); +assert.sameValue('\660', '\x360', '\\660'); +assert.sameValue('\670', '\x370', '\\670'); +assert.sameValue('\700', '\x380', '\\700'); +assert.sameValue('\710', '\x390', '\\710'); +assert.sameValue('\760', '\x3e0', '\\760'); +assert.sameValue('\770', '\x3f0', '\\770'); + +// LegacyOctalEscapeSequence :: +// ZeroToThree OctalDigit OctalDigit +assert.sameValue('\000', '\x00', '\\000'); +assert.sameValue('\001', '\x01', '\\001'); +assert.sameValue('\010', '\x08', '\\010'); +assert.sameValue('\006', '\x06', '\\006'); +assert.sameValue('\060', '\x30', '\\060'); +assert.sameValue('\007', '\x07', '\\007'); +assert.sameValue('\070', '\x38', '\\070'); +assert.sameValue('\077', '\x3f', '\\077'); +assert.sameValue('\100', '\x40', '\\100'); +assert.sameValue('\101', '\x41', '\\101'); +assert.sameValue('\110', '\x48', '\\110'); +assert.sameValue('\106', '\x46', '\\106'); +assert.sameValue('\160', '\x70', '\\160'); +assert.sameValue('\107', '\x47', '\\107'); +assert.sameValue('\170', '\x78', '\\170'); +assert.sameValue('\177', '\x7f', '\\177'); +assert.sameValue('\200', '\x80', '\\200'); +assert.sameValue('\201', '\x81', '\\201'); +assert.sameValue('\210', '\x88', '\\210'); +assert.sameValue('\206', '\x86', '\\206'); +assert.sameValue('\260', '\xb0', '\\260'); +assert.sameValue('\207', '\x87', '\\207'); +assert.sameValue('\270', '\xb8', '\\270'); +assert.sameValue('\277', '\xbf', '\\277'); +assert.sameValue('\300', '\xc0', '\\300'); +assert.sameValue('\301', '\xc1', '\\301'); +assert.sameValue('\310', '\xc8', '\\310'); +assert.sameValue('\306', '\xc6', '\\306'); +assert.sameValue('\360', '\xf0', '\\360'); +assert.sameValue('\307', '\xc7', '\\307'); +assert.sameValue('\370', '\xf8', '\\370'); +assert.sameValue('\377', '\xff', '\\377'); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-continuation-double.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-continuation-double.js new file mode 100644 index 000000000..d1795e1ef --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-continuation-double.js @@ -0,0 +1,60 @@ +// Copyright (C) 2018 Richard Gibson. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-string-literals +description: > + Line terminators may occur within string literals as part of a |LineContinuation| + to produce the empty code points sequence. +info: | + 11.8.4 String Literals + + StringLiteral :: + `"` DoubleStringCharacters? `"` + `'` SingleStringCharacters? `'` + + DoubleStringCharacters :: + DoubleStringCharacter DoubleStringCharacters? + + DoubleStringCharacter :: + SourceCharacter but not one of `"` or `\` or LineTerminator + + + `\` EscapeSequence + LineContinuation + + LineContinuation :: + `\` LineTerminatorSequence + + 11.3 Line Terminators + + LineTerminatorSequence :: + + [lookahead != ] + + + + + 11.8.4.2 Static Semantics: SV + + The SV of DoubleStringCharacter :: LineContinuation is the empty code unit sequence. +---*/ + +// LineTerminatorSequence :: +assert.sameValue("\ +", ""); + +// LineTerminatorSequence :: [lookahead ≠ ] +assert.sameValue("\ ", ""); + +// LineTerminatorSequence :: +// is U+2028 LINE SEPARATOR; UTF8(0x2028) = 0xE2 0x80 0xA8 +assert.sameValue("\
", ""); + +// LineTerminatorSequence :: +// is U+2029 PARAGRAPH SEPARATOR; UTF8(0x2029) = 0xE2 0x80 0xA9 +assert.sameValue("\
", ""); + +// LineTerminatorSequence :: +assert.sameValue("\ +", ""); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-continuation-single.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-continuation-single.js new file mode 100644 index 000000000..3e286b0f8 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-continuation-single.js @@ -0,0 +1,60 @@ +// Copyright (C) 2018 Richard Gibson. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-string-literals +description: > + Line terminators may occur within string literals as part of a |LineContinuation| + to produce the empty code points sequence. +info: | + 11.8.4 String Literals + + StringLiteral :: + `"` DoubleStringCharacters? `"` + `'` SingleStringCharacters? `'` + + SingleStringCharacters :: + SingleStringCharacter SingleStringCharacters? + + SingleStringCharacter :: + SourceCharacter but not one of `'` or `\` or LineTerminator + + + `\` EscapeSequence + LineContinuation + + LineContinuation :: + `\` LineTerminatorSequence + + 11.3 Line Terminators + + LineTerminatorSequence :: + + [lookahead != ] + + + + + 11.8.4.2 Static Semantics: SV + + The SV of SingleStringCharacter :: LineContinuation is the empty code unit sequence. +---*/ + +// LineTerminatorSequence :: +assert.sameValue('\ +', ''); + +// LineTerminatorSequence :: [lookahead ≠ ] +assert.sameValue('\ ', ''); + +// LineTerminatorSequence :: +// is U+2028 LINE SEPARATOR; UTF8(0x2028) = 0xE2 0x80 0xA8 +assert.sameValue('\
', ''); + +// LineTerminatorSequence :: +// is U+2029 PARAGRAPH SEPARATOR; UTF8(0x2029) = 0xE2 0x80 0xA9 +assert.sameValue('\
', ''); + +// LineTerminatorSequence :: +assert.sameValue('\ +', ''); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-separator-eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-separator-eval.js new file mode 100644 index 000000000..c8f4b33cb --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-separator-eval.js @@ -0,0 +1,17 @@ +// Copyright (C) 2018 Richard Gibson. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-string-literals +description: > + U+2028 LINE SEPARATOR can appear in string literals (eval code). +info: | + 11.8.4 String Literals + + All code points may appear literally in a string literal except for the + closing quote code points, U+005C (REVERSE SOLIDUS), U+000D (CARRIAGE RETURN), + and U+000A (LINE FEED). +features: [json-superset] +---*/ + +assert.sameValue(eval("'\u2028'"), "\u2028"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-separator.js new file mode 100644 index 000000000..359b8977f --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/line-separator.js @@ -0,0 +1,18 @@ +// Copyright (C) 2018 Richard Gibson. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-string-literals +description: > + U+2028 LINE SEPARATOR can appear in string literals. +info: | + 11.8.4 String Literals + + All code points may appear literally in a string literal except for the + closing quote code points, U+005C (REVERSE SOLIDUS), U+000D (CARRIAGE RETURN), + and U+000A (LINE FEED). +features: [json-superset] +---*/ + +// U+2028 in strings; UTF8(0x2028) = 0xE2 0x80 0xA8 +assert.sameValue("
", "\u2028"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/mongolian-vowel-separator-eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/mongolian-vowel-separator-eval.js new file mode 100644 index 000000000..9a8706a19 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/mongolian-vowel-separator-eval.js @@ -0,0 +1,22 @@ +// Copyright (C) 2016 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-unicode-format-control-characters +description: > + Mongolian Vowel Separator can appear in string literals (eval code). +info: | + 11.1 Unicode Format-Control Characters + + The Unicode format-control characters (i.e., the characters in category “Cf” + in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT + MARK) are control codes used to control the formatting of a range of text in + the absence of higher-level protocols for this (such as mark-up languages). + + It is useful to allow format-control characters in source text to facilitate + editing and display. All format control characters may be used within comments, + and within string literals, template literals, and regular expression literals. +features: [u180e] +---*/ + +assert.sameValue(eval("'\u180E'"), "\u180E"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/mongolian-vowel-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/mongolian-vowel-separator.js new file mode 100644 index 000000000..ec9e066d6 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/mongolian-vowel-separator.js @@ -0,0 +1,23 @@ +// Copyright (C) 2016 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-unicode-format-control-characters +description: > + Mongolian Vowel Separator can appear in string literals. +info: | + 11.1 Unicode Format-Control Characters + + The Unicode format-control characters (i.e., the characters in category “Cf” + in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT + MARK) are control codes used to control the formatting of a range of text in + the absence of higher-level protocols for this (such as mark-up languages). + + It is useful to allow format-control characters in source text to facilitate + editing and display. All format control characters may be used within comments, + and within string literals, template literals, and regular expression literals. +features: [u180e] +---*/ + +// U+180E in strings; UTF8(0x180E) = 0xE1 0xA0 0x8E +assert.sameValue("᠎", "\u180E"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/paragraph-separator-eval.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/paragraph-separator-eval.js new file mode 100644 index 000000000..18e8df3a3 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/paragraph-separator-eval.js @@ -0,0 +1,17 @@ +// Copyright (C) 2018 Richard Gibson. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-string-literals +description: > + U+2029 PARAGRAPH SEPARATOR can appear in string literals (eval code). +info: | + 11.8.4 String Literals + + All code points may appear literally in a string literal except for the + closing quote code points, U+005C (REVERSE SOLIDUS), U+000D (CARRIAGE RETURN), + and U+000A (LINE FEED). +features: [json-superset] +---*/ + +assert.sameValue(eval("'\u2029'"), "\u2029"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/paragraph-separator.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/paragraph-separator.js new file mode 100644 index 000000000..5e0ab4476 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/paragraph-separator.js @@ -0,0 +1,18 @@ +// Copyright (C) 2018 Richard Gibson. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-literals-string-literals +description: > + U+2029 PARAGRAPH SEPARATOR can appear in string literals. +info: | + 11.8.4 String Literals + + All code points may appear literally in a string literal except for the + closing quote code points, U+005C (REVERSE SOLIDUS), U+000D (CARRIAGE RETURN), + and U+000A (LINE FEED). +features: [json-superset] +---*/ + +// U+2029 in strings; UTF8(0x2029) = 0xE2 0x80 0xA9 +assert.sameValue("
", "\u2029"); diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-nls-err-double.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-nls-err-double.js new file mode 100644 index 000000000..f544d8b69 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-nls-err-double.js @@ -0,0 +1,49 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-StringLiteral +description: NumericLiteralSeperator disallowed in unicode CodePoint sequence (DoubleStringCharacters) +info: | + StringLiteral:: + "DoubleStringCharacters opt" + 'SingleStringCharacters opt' + + DoubleStringCharacters:: + DoubleStringCharacter DoubleStringCharacters opt + + DoubleStringCharacter:: + SourceCharacter but not one of " or \ or LineTerminator + \ EscapeSequence + LineContinuation + + EscapeSequence:: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence + + UnicodeEscapeSequence :: + uHex4Digits + u{CodePoint} + + CodePoint :: + HexDigit but only if MV of HexDigits ≤ 0x10FFFF + CodePointDigits but only if MV of HexDigits ≤ 0x10FFFF + + CodePointDigits :: + HexDigit + CodePointDigitsHexDigit + + HexDigit :: one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +"\u{1F_639}" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-nls-err-single.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-nls-err-single.js new file mode 100644 index 000000000..975f51f27 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-nls-err-single.js @@ -0,0 +1,49 @@ +// Copyright (C) 2017 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-StringLiteral +description: NumericLiteralSeperator disallowed in unicode CodePoint sequence (DoubleStringCharacters) +info: | + StringLiteral:: + "DoubleStringCharacters opt" + 'SingleStringCharacters opt' + + SingleStringCharacters:: + SingleStringCharacterSingleStringCharactersopt + + SingleStringCharacter:: + SourceCharacterbut not one of ' or \ or LineTerminator + \ EscapeSequence + LineContinuation + + EscapeSequence:: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence + + UnicodeEscapeSequence :: + uHex4Digits + u{CodePoint} + + CodePoint :: + HexDigit but only if MV of HexDigits ≤ 0x10FFFF + CodePointDigits but only if MV of HexDigits ≤ 0x10FFFF + + CodePointDigits :: + HexDigit + CodePointDigitsHexDigit + + HexDigit :: one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +features: [numeric-separator-literal] +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +'\u{1F_639}'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-no-hex-err-double.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-no-hex-err-double.js new file mode 100644 index 000000000..f71c47a55 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-no-hex-err-double.js @@ -0,0 +1,46 @@ +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-StringLiteral +description: > + \u is at the end of string, Hex4Digits is required. +info: | + StringLiteral :: + " DoubleStringCharacters_opt " + ' SingleStringCharacters_opt ' + + DoubleStringCharacters :: + DoubleStringCharacter DoubleStringCharacters_opt + + DoubleStringCharacter :: + SourceCharacter but not one of " or \ or LineTerminator + + + \ EscapeSequence + LineContinuation + + EscapeSequence :: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence + + UnicodeEscapeSequence :: + u Hex4Digits + u{ CodePoint } + + Hex4Digits :: + HexDigit HexDigit HexDigit HexDigit + + HexDigit :: one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +"\u" diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-no-hex-err-single.js b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-no-hex-err-single.js new file mode 100644 index 000000000..d34e4baca --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/literals/string/unicode-escape-no-hex-err-single.js @@ -0,0 +1,46 @@ +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: prod-StringLiteral +description: > + \u is at the end of string, Hex4Digits is required. +info: | + StringLiteral :: + " DoubleStringCharacters_opt " + ' SingleStringCharacters_opt ' + + SingleStringCharacters :: + SingleStringCharacter SingleStringCharacters_opt + + SingleStringCharacter :: + SourceCharacter but not one of ' or \ or LineTerminator + + + \ EscapeSequence + LineContinuation + + EscapeSequence :: + CharacterEscapeSequence + 0 [lookahead ∉ DecimalDigit] + HexEscapeSequence + UnicodeEscapeSequence + + UnicodeEscapeSequence :: + u Hex4Digits + u{ CodePoint } + + Hex4Digits :: + HexDigit HexDigit HexDigit HexDigit + + HexDigit :: one of + 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F + +negative: + phase: parse + type: SyntaxError +---*/ + +$DONOTEVALUATE(); + +'\u' diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named-1_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named-1_FIXTURE.js new file mode 100644 index 000000000..896bdff50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named-1_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export var x; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named-2_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named-2_FIXTURE.js new file mode 100644 index 000000000..896bdff50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named-2_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export var x; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named-as.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named-as.js new file mode 100644 index 000000000..9e816ed7c --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named-as.js @@ -0,0 +1,41 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: IndirectExportEntries validation - ambiguous imported bindings +esid: sec-moduledeclarationinstantiation +info: | + [...] + 9. For each ExportEntry Record e in module.[[IndirectExportEntries]], do + a. Let resolution be ? module.ResolveExport(e.[[ExportName]], « », « »). + b. If resolution is null or resolution is "ambiguous", throw a + SyntaxError exception. + [...] + + 15.2.1.16.3 ResolveExport + + [...] + 9. Let starResolution be null. + 10. For each ExportEntry Record e in module.[[StarExportEntries]], do + a. Let importedModule be ? HostResolveImportedModule(module, + e.[[ModuleRequest]]). + b. Let resolution be ? importedModule.ResolveExport(exportName, + resolveSet, exportStarSet). + c. If resolution is "ambiguous", return "ambiguous". + d. If resolution is not null, then + i. If starResolution is null, let starResolution be resolution. + ii. Else, + 1. Assert: there is more than one * import that includes the + requested name. + 2. If resolution.[[Module]] and starResolution.[[Module]] are + not the same Module Record or + SameValue(resolution.[[BindingName]], + starResolution.[[BindingName]]) is false, return "ambiguous". +negative: + phase: resolution + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +export { x as y } from './error-export-from-named_FIXTURE.js'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named.js new file mode 100644 index 000000000..9d1a596e2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named.js @@ -0,0 +1,41 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: IndirectExportEntries validation - ambiguous imported bindings +esid: sec-moduledeclarationinstantiation +info: | + [...] + 9. For each ExportEntry Record e in module.[[IndirectExportEntries]], do + a. Let resolution be ? module.ResolveExport(e.[[ExportName]], « », « »). + b. If resolution is null or resolution is "ambiguous", throw a + SyntaxError exception. + [...] + + 15.2.1.16.3 ResolveExport + + [...] + 9. Let starResolution be null. + 10. For each ExportEntry Record e in module.[[StarExportEntries]], do + a. Let importedModule be ? HostResolveImportedModule(module, + e.[[ModuleRequest]]). + b. Let resolution be ? importedModule.ResolveExport(exportName, + resolveSet, exportStarSet). + c. If resolution is "ambiguous", return "ambiguous". + d. If resolution is not null, then + i. If starResolution is null, let starResolution be resolution. + ii. Else, + 1. Assert: there is more than one * import that includes the + requested name. + 2. If resolution.[[Module]] and starResolution.[[Module]] are + not the same Module Record or + SameValue(resolution.[[BindingName]], + starResolution.[[BindingName]]) is false, return "ambiguous". +negative: + phase: resolution + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +export { x } from './error-export-from-named_FIXTURE.js'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named_FIXTURE.js new file mode 100644 index 000000000..5091413d2 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-export-from-named_FIXTURE.js @@ -0,0 +1,5 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export * from './error-export-from-named-1_FIXTURE.js'; +export * from './error-export-from-named-2_FIXTURE.js'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named-1_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named-1_FIXTURE.js new file mode 100644 index 000000000..896bdff50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named-1_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export var x; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named-2_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named-2_FIXTURE.js new file mode 100644 index 000000000..896bdff50 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named-2_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export var x; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named-as.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named-as.js new file mode 100644 index 000000000..40cdecd9b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named-as.js @@ -0,0 +1,46 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: Named import binding - resolution failure (ambiguous name) +esid: sec-moduledeclarationinstantiation +info: | + [...] + 12. For each ImportEntry Record in in module.[[ImportEntries]], do + a. Let importedModule be ? HostResolveImportedModule(module, + in.[[ModuleRequest]]). + b. If in.[[ImportName]] is "*", then + [...] + c. Else, + i. Let resolution be ? + importedModule.ResolveExport(in.[[ImportName]], « », « »). + ii. If resolution is null or resolution is "ambiguous", throw a + SyntaxError exception. + + 15.2.1.16.3 ResolveExport + + [...] + 9. Let starResolution be null. + 10. For each ExportEntry Record e in module.[[StarExportEntries]], do + a. Let importedModule be ? HostResolveImportedModule(module, + e.[[ModuleRequest]]). + b. Let resolution be ? importedModule.ResolveExport(exportName, + resolveSet, exportStarSet). + c. If resolution is "ambiguous", return "ambiguous". + d. If resolution is not null, then + i. If starResolution is null, let starResolution be resolution. + ii. Else, + 1. Assert: there is more than one * import that includes the + requested name. + 2. If resolution.[[Module]] and starResolution.[[Module]] are + not the same Module Record or + SameValue(resolution.[[BindingName]], + starResolution.[[BindingName]]) is false, return "ambiguous". +negative: + phase: resolution + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +import { x as y } from './error-import-named_FIXTURE.js'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named.js new file mode 100644 index 000000000..ca600b47b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named.js @@ -0,0 +1,46 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: Named import binding - resolution failure (ambiguous name) +esid: sec-moduledeclarationinstantiation +info: | + [...] + 12. For each ImportEntry Record in in module.[[ImportEntries]], do + a. Let importedModule be ? HostResolveImportedModule(module, + in.[[ModuleRequest]]). + b. If in.[[ImportName]] is "*", then + [...] + c. Else, + i. Let resolution be ? + importedModule.ResolveExport(in.[[ImportName]], « », « »). + ii. If resolution is null or resolution is "ambiguous", throw a + SyntaxError exception. + + 15.2.1.16.3 ResolveExport + + [...] + 9. Let starResolution be null. + 10. For each ExportEntry Record e in module.[[StarExportEntries]], do + a. Let importedModule be ? HostResolveImportedModule(module, + e.[[ModuleRequest]]). + b. Let resolution be ? importedModule.ResolveExport(exportName, + resolveSet, exportStarSet). + c. If resolution is "ambiguous", return "ambiguous". + d. If resolution is not null, then + i. If starResolution is null, let starResolution be resolution. + ii. Else, + 1. Assert: there is more than one * import that includes the + requested name. + 2. If resolution.[[Module]] and starResolution.[[Module]] are + not the same Module Record or + SameValue(resolution.[[BindingName]], + starResolution.[[BindingName]]) is false, return "ambiguous". +negative: + phase: resolution + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +import { x } from './error-import-named_FIXTURE.js'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named_FIXTURE.js new file mode 100644 index 000000000..1b184b137 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/error-import-named_FIXTURE.js @@ -0,0 +1,5 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export * from './error-import-named-1_FIXTURE.js'; +export * from './error-import-named-2_FIXTURE.js'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/import-and-export-propagates-binding_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/import-and-export-propagates-binding_FIXTURE.js new file mode 100644 index 000000000..f4c246b65 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/import-and-export-propagates-binding_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2025 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export const foo = 2; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/import-and-export-propagates-binding_export-from_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/import-and-export-propagates-binding_export-from_FIXTURE.js new file mode 100644 index 000000000..2e233fcc0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/import-and-export-propagates-binding_export-from_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2025 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export { foo } from "./import-and-export-propagates-binding_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/import-and-export-propagates-binding_import-and-export_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/import-and-export-propagates-binding_import-and-export_FIXTURE.js new file mode 100644 index 000000000..e253a087b --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/import-and-export-propagates-binding_import-and-export_FIXTURE.js @@ -0,0 +1,5 @@ +// Copyright (C) 2025 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +import { foo } from "./import-and-export-propagates-binding_FIXTURE.js"; +export { foo }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-empty-module_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-empty-module_FIXTURE.js new file mode 100644 index 000000000..83f0192f9 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-empty-module_FIXTURE.js @@ -0,0 +1,2 @@ +// Copyright (C) 2025 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-export-star-as-from-1_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-export-star-as-from-1_FIXTURE.js new file mode 100644 index 000000000..bac718894 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-export-star-as-from-1_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2025 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export * as foo from "./namespace-empty-module_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-export-star-as-from-2_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-export-star-as-from-2_FIXTURE.js new file mode 100644 index 000000000..bac718894 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-export-star-as-from-2_FIXTURE.js @@ -0,0 +1,4 @@ +// Copyright (C) 2025 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export * as foo from "./namespace-empty-module_FIXTURE.js"; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-import-star-as-and-export-1_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-import-star-as-and-export-1_FIXTURE.js new file mode 100644 index 000000000..3f13da5a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-import-star-as-and-export-1_FIXTURE.js @@ -0,0 +1,5 @@ +// Copyright (C) 2025 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +import * as foo from "./namespace-empty-module_FIXTURE.js"; +export { foo }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-import-star-as-and-export-2_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-import-star-as-and-export-2_FIXTURE.js new file mode 100644 index 000000000..3f13da5a0 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/namespace-import-star-as-and-export-2_FIXTURE.js @@ -0,0 +1,5 @@ +// Copyright (C) 2025 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +import * as foo from "./namespace-empty-module_FIXTURE.js"; +export { foo }; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/omitted-from-namespace-1_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/omitted-from-namespace-1_FIXTURE.js new file mode 100644 index 000000000..1c568f1f5 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/omitted-from-namespace-1_FIXTURE.js @@ -0,0 +1,5 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export var first = null; +export var both = null; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/omitted-from-namespace-2_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/omitted-from-namespace-2_FIXTURE.js new file mode 100644 index 000000000..2f783f472 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/omitted-from-namespace-2_FIXTURE.js @@ -0,0 +1,5 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export var second = null; +export var both = null; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/omitted-from-namespace_FIXTURE.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/omitted-from-namespace_FIXTURE.js new file mode 100644 index 000000000..1ffa6346a --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/ambiguous-export-bindings/omitted-from-namespace_FIXTURE.js @@ -0,0 +1,5 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +export * from './omitted-from-namespace-1_FIXTURE.js'; +export * from './omitted-from-namespace-2_FIXTURE.js'; diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/comment-multi-line-html-close.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/comment-multi-line-html-close.js new file mode 100644 index 000000000..a229d0e42 --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/comment-multi-line-html-close.js @@ -0,0 +1,17 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + HTML-like comments are not available in module code + (MultiLineHTMLCloseComment) +esid: sec-html-like-comments +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +/* +*/--> diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/comment-single-line-html-close.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/comment-single-line-html-close.js new file mode 100644 index 000000000..a963398bc --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/comment-single-line-html-close.js @@ -0,0 +1,16 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + HTML-like comments are not available in module code + (SingleLineHTMLCloseComment) +esid: sec-html-like-comments +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + +--> diff --git a/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/comment-single-line-html-open.js b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/comment-single-line-html-open.js new file mode 100644 index 000000000..de509261e --- /dev/null +++ b/crates/clazel-js-lexer/tests/data/test262/test/language/module-code/comment-single-line-html-open.js @@ -0,0 +1,16 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + HTML-like comments are not available in module code + (SingleLineHTMLOpenComment) +esid: sec-html-like-comments +negative: + phase: parse + type: SyntaxError +flags: [module] +---*/ + +$DONOTEVALUATE(); + + + +
+
1
+
2
+
3
+
4
+
+ +
+
1
+
2
+
3
+
4
+
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-live-mutations.window.js b/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-live-mutations.window.js new file mode 100644 index 000000000..7dbfc6ccf --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-live-mutations.window.js @@ -0,0 +1,93 @@ +function testHTMLCollection(name, hooks) { + test(() => { + const nodes = { + root: document.createElement("div"), + div1: document.createElement("div"), + div2: document.createElement("div"), + p: document.createElement("p") + }; + + nodes.div1.id = "div1"; + nodes.div2.id = "div2"; + + const list = nodes.root.getElementsByTagName("div"); + + hooks.initial(list, nodes); + + nodes.root.appendChild(nodes.div1); + nodes.root.appendChild(nodes.p); + nodes.root.appendChild(nodes.div2); + + hooks.afterInsertion(list, nodes); + + nodes.root.removeChild(nodes.div1); + + hooks.afterRemoval(list, nodes); + }, `HTMLCollection live mutations: ${name}`); +} + +testHTMLCollection("HTMLCollection.length", { + initial(list) { + assert_equals(list.length, 0); + }, + afterInsertion(list) { + assert_equals(list.length, 2); + }, + afterRemoval(list) { + assert_equals(list.length, 1); + } +}); + +testHTMLCollection("HTMLCollection.item(index)", { + initial(list) { + assert_equals(list.item(0), null); + }, + afterInsertion(list, nodes) { + assert_equals(list.item(0), nodes.div1); + assert_equals(list.item(1), nodes.div2); + }, + afterRemoval(list, nodes) { + assert_equals(list.item(0), nodes.div2); + } +}); + +testHTMLCollection("HTMLCollection[index]", { + initial(list) { + assert_equals(list[0], undefined); + }, + afterInsertion(list, nodes) { + assert_equals(list[0], nodes.div1); + assert_equals(list[1], nodes.div2); + }, + afterRemoval(list, nodes) { + assert_equals(list[0], nodes.div2); + } +}); + +testHTMLCollection("HTMLCollection.namedItem(index)", { + initial(list) { + assert_equals(list.namedItem("div1"), null); + assert_equals(list.namedItem("div2"), null); + }, + afterInsertion(list, nodes) { + assert_equals(list.namedItem("div1"), nodes.div1); + assert_equals(list.namedItem("div2"), nodes.div2); + }, + afterRemoval(list, nodes) { + assert_equals(list.namedItem("div1"), null); + assert_equals(list.namedItem("div2"), nodes.div2); + } +}); + +testHTMLCollection("HTMLCollection ownPropertyNames", { + initial(list) { + assert_object_equals(Object.getOwnPropertyNames(list), []); + }, + afterInsertion(list) { + assert_object_equals(Object.getOwnPropertyNames(list), ["0", "1", "div1", "div2"]); + }, + afterRemoval(list) { + assert_object_equals(Object.getOwnPropertyNames(list), ["0", "div2"]); + } +}); + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-own-props.html b/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-own-props.html new file mode 100644 index 000000000..99dc425db --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-own-props.html @@ -0,0 +1,109 @@ + + +HTMLCollection getters and own properties + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-supported-property-indices.html b/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-supported-property-indices.html new file mode 100644 index 000000000..5339ec31e --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-supported-property-indices.html @@ -0,0 +1,179 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-supported-property-names.html b/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-supported-property-names.html new file mode 100644 index 000000000..3d21e1669 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/collections/HTMLCollection-supported-property-names.html @@ -0,0 +1,135 @@ + + + + + + +
+ + + + + + + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/collections/WEB_FEATURES.yml b/crates/clazel-web/tests/data/wpt-web/dom/collections/WEB_FEATURES.yml new file mode 100644 index 000000000..56f94ce0c --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/collections/WEB_FEATURES.yml @@ -0,0 +1,2 @@ +rules: +- domstringmap-supported-property-names.html: [dataset] diff --git a/crates/clazel-web/tests/data/wpt-web/dom/collections/childnodes-messagechannel-crash.html b/crates/clazel-web/tests/data/wpt-web/dom/collections/childnodes-messagechannel-crash.html new file mode 100644 index 000000000..f118eff6f --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/collections/childnodes-messagechannel-crash.html @@ -0,0 +1,9 @@ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/collections/domstringmap-supported-property-names.html b/crates/clazel-web/tests/data/wpt-web/dom/collections/domstringmap-supported-property-names.html new file mode 100644 index 000000000..430aa44c3 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/collections/domstringmap-supported-property-names.html @@ -0,0 +1,54 @@ + + +DOMStringMap Test: Supported property names + + +
+ +
Simple
+ +
Simple
+ +
+ John Doe +
+ +
Jane Doe
+ +
Jim Doe
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/collections/namednodemap-supported-property-names.html b/crates/clazel-web/tests/data/wpt-web/dom/collections/namednodemap-supported-property-names.html new file mode 100644 index 000000000..2c5dee4ef --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/collections/namednodemap-supported-property-names.html @@ -0,0 +1,30 @@ + + +NamedNodeMap Test: Supported property names + + +
+
Simple
+ + \ No newline at end of file diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/AddEventListenerOptions-once.any.js b/crates/clazel-web/tests/data/wpt-web/dom/events/AddEventListenerOptions-once.any.js new file mode 100644 index 000000000..b4edd4345 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/AddEventListenerOptions-once.any.js @@ -0,0 +1,96 @@ +// META: title=AddEventListenerOptions.once + +"use strict"; + +test(function() { + var invoked_once = false; + var invoked_normal = false; + function handler_once() { + invoked_once = true; + } + function handler_normal() { + invoked_normal = true; + } + + const et = new EventTarget(); + et.addEventListener('test', handler_once, {once: true}); + et.addEventListener('test', handler_normal); + et.dispatchEvent(new Event('test')); + assert_equals(invoked_once, true, "Once handler should be invoked"); + assert_equals(invoked_normal, true, "Normal handler should be invoked"); + + invoked_once = false; + invoked_normal = false; + et.dispatchEvent(new Event('test')); + assert_equals(invoked_once, false, "Once handler shouldn't be invoked again"); + assert_equals(invoked_normal, true, "Normal handler should be invoked again"); + et.removeEventListener('test', handler_normal); +}, "Once listener should be invoked only once"); + +test(function() { + const et = new EventTarget(); + var invoked_count = 0; + function handler() { + invoked_count++; + if (invoked_count == 1) + et.dispatchEvent(new Event('test')); + } + et.addEventListener('test', handler, {once: true}); + et.dispatchEvent(new Event('test')); + assert_equals(invoked_count, 1, "Once handler should only be invoked once"); + + invoked_count = 0; + function handler2() { + invoked_count++; + if (invoked_count == 1) + et.addEventListener('test', handler2, {once: true}); + if (invoked_count <= 2) + et.dispatchEvent(new Event('test')); + } + et.addEventListener('test', handler2, {once: true}); + et.dispatchEvent(new Event('test')); + assert_equals(invoked_count, 2, "Once handler should only be invoked once after each adding"); +}, "Once listener should be invoked only once even if the event is nested"); + +test(function() { + var invoked_count = 0; + function handler() { + invoked_count++; + } + + const et = new EventTarget(); + + et.addEventListener('test', handler, {once: true}); + et.addEventListener('test', handler); + et.dispatchEvent(new Event('test')); + assert_equals(invoked_count, 1, "The handler should only be added once"); + + invoked_count = 0; + et.dispatchEvent(new Event('test')); + assert_equals(invoked_count, 0, "The handler was added as a once listener"); + + invoked_count = 0; + et.addEventListener('test', handler, {once: true}); + et.removeEventListener('test', handler); + et.dispatchEvent(new Event('test')); + assert_equals(invoked_count, 0, "The handler should have been removed"); +}, "Once listener should be added / removed like normal listeners"); + +test(function() { + const et = new EventTarget(); + + var invoked_count = 0; + + for (let n = 4; n > 0; n--) { + et.addEventListener('test', (e) => { + invoked_count++; + e.stopImmediatePropagation(); + }, {once: true}); + } + + for (let n = 4; n > 0; n--) { + et.dispatchEvent(new Event('test')); + } + + assert_equals(invoked_count, 4, "The listeners should be invoked"); +}, "Multiple once listeners should be invoked even if the stopImmediatePropagation is set"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/AddEventListenerOptions-passive.any.js b/crates/clazel-web/tests/data/wpt-web/dom/events/AddEventListenerOptions-passive.any.js new file mode 100644 index 000000000..8e59cf5b3 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/AddEventListenerOptions-passive.any.js @@ -0,0 +1,134 @@ +// META: title=AddEventListenerOptions.passive + +test(function() { + var supportsPassive = false; + var query_options = { + get passive() { + supportsPassive = true; + return false; + }, + get dummy() { + assert_unreached("dummy value getter invoked"); + return false; + } + }; + + const et = new EventTarget(); + et.addEventListener('test_event', null, query_options); + assert_true(supportsPassive, "addEventListener doesn't support the passive option"); + + supportsPassive = false; + et.removeEventListener('test_event', null, query_options); + assert_false(supportsPassive, "removeEventListener supports the passive option when it should not"); +}, "Supports passive option on addEventListener only"); + +function testPassiveValue(optionsValue, expectedDefaultPrevented, existingEventTarget) { + var defaultPrevented = undefined; + var handler = function handler(e) { + assert_false(e.defaultPrevented, "Event prematurely marked defaultPrevented"); + e.preventDefault(); + defaultPrevented = e.defaultPrevented; + } + const et = existingEventTarget || new EventTarget(); + et.addEventListener('test', handler, optionsValue); + var uncanceled = et.dispatchEvent(new Event('test', {bubbles: true, cancelable: true})); + + assert_equals(defaultPrevented, expectedDefaultPrevented, "Incorrect defaultPrevented for options: " + JSON.stringify(optionsValue)); + assert_equals(uncanceled, !expectedDefaultPrevented, "Incorrect return value from dispatchEvent"); + + et.removeEventListener('test', handler, optionsValue); +} + +test(function() { + testPassiveValue(undefined, true); + testPassiveValue({}, true); + testPassiveValue({passive: false}, true); + testPassiveValue({passive: true}, false); + testPassiveValue({passive: 0}, true); + testPassiveValue({passive: 1}, false); +}, "preventDefault should be ignored if-and-only-if the passive option is true"); + +function testPassiveValueOnReturnValue(test, optionsValue, expectedDefaultPrevented) { + var defaultPrevented = undefined; + var handler = test.step_func(e => { + assert_false(e.defaultPrevented, "Event prematurely marked defaultPrevented"); + e.returnValue = false; + defaultPrevented = e.defaultPrevented; + }); + const et = new EventTarget(); + et.addEventListener('test', handler, optionsValue); + var uncanceled = et.dispatchEvent(new Event('test', {bubbles: true, cancelable: true})); + + assert_equals(defaultPrevented, expectedDefaultPrevented, "Incorrect defaultPrevented for options: " + JSON.stringify(optionsValue)); + assert_equals(uncanceled, !expectedDefaultPrevented, "Incorrect return value from dispatchEvent"); + + et.removeEventListener('test', handler, optionsValue); +} + +async_test(t => { + testPassiveValueOnReturnValue(t, undefined, true); + testPassiveValueOnReturnValue(t, {}, true); + testPassiveValueOnReturnValue(t, {passive: false}, true); + testPassiveValueOnReturnValue(t, {passive: true}, false); + testPassiveValueOnReturnValue(t, {passive: 0}, true); + testPassiveValueOnReturnValue(t, {passive: 1}, false); + t.done(); +}, "returnValue should be ignored if-and-only-if the passive option is true"); + +function testPassiveWithOtherHandlers(optionsValue, expectedDefaultPrevented) { + var handlerInvoked1 = false; + var dummyHandler1 = function() { + handlerInvoked1 = true; + }; + var handlerInvoked2 = false; + var dummyHandler2 = function() { + handlerInvoked2 = true; + }; + + const et = new EventTarget(); + et.addEventListener('test', dummyHandler1, {passive:true}); + et.addEventListener('test', dummyHandler2); + + testPassiveValue(optionsValue, expectedDefaultPrevented, et); + + assert_true(handlerInvoked1, "Extra passive handler not invoked"); + assert_true(handlerInvoked2, "Extra non-passive handler not invoked"); + + et.removeEventListener('test', dummyHandler1); + et.removeEventListener('test', dummyHandler2); +} + +test(function() { + testPassiveWithOtherHandlers({}, true); + testPassiveWithOtherHandlers({passive: false}, true); + testPassiveWithOtherHandlers({passive: true}, false); +}, "passive behavior of one listener should be unaffected by the presence of other listeners"); + +function testOptionEquivalence(optionValue1, optionValue2, expectedEquality) { + var invocationCount = 0; + var handler = function handler(e) { + invocationCount++; + } + const et = new EventTarget(); + et.addEventListener('test', handler, optionValue1); + et.addEventListener('test', handler, optionValue2); + et.dispatchEvent(new Event('test', {bubbles: true})); + assert_equals(invocationCount, expectedEquality ? 1 : 2, "equivalence of options " + + JSON.stringify(optionValue1) + " and " + JSON.stringify(optionValue2)); + et.removeEventListener('test', handler, optionValue1); + et.removeEventListener('test', handler, optionValue2); +} + +test(function() { + // Sanity check options that should be treated as distinct handlers + testOptionEquivalence({capture:true}, {capture:false, passive:false}, false); + testOptionEquivalence({capture:true}, {passive:true}, false); + + // Option values that should be treated as equivalent + testOptionEquivalence({}, {passive:false}, true); + testOptionEquivalence({passive:true}, {passive:false}, true); + testOptionEquivalence(undefined, {passive:true}, true); + testOptionEquivalence({capture: true, passive: false}, {capture: true, passive: true}, true); + +}, "Equivalence of option values"); + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/AddEventListenerOptions-signal.any.js b/crates/clazel-web/tests/data/wpt-web/dom/events/AddEventListenerOptions-signal.any.js new file mode 100644 index 000000000..e6a342615 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/AddEventListenerOptions-signal.any.js @@ -0,0 +1,143 @@ +'use strict'; + +test(function() { + let count = 0; + function handler() { + count++; + } + const et = new EventTarget(); + const controller = new AbortController(); + et.addEventListener('test', handler, { signal: controller.signal }); + et.dispatchEvent(new Event('test')); + assert_equals(count, 1, "Adding a signal still adds a listener"); + et.dispatchEvent(new Event('test')); + assert_equals(count, 2, "The listener was not added with the once flag"); + controller.abort(); + et.dispatchEvent(new Event('test')); + assert_equals(count, 2, "Aborting on the controller removes the listener"); + et.addEventListener('test', handler, { signal: controller.signal }); + et.dispatchEvent(new Event('test')); + assert_equals(count, 2, "Passing an aborted signal never adds the handler"); +}, "Passing an AbortSignal to addEventListener options should allow removing a listener"); + +test(function() { + let count = 0; + function handler() { + count++; + } + const et = new EventTarget(); + const controller = new AbortController(); + et.addEventListener('test', handler, { signal: controller.signal }); + et.removeEventListener('test', handler); + et.dispatchEvent(new Event('test')); + assert_equals(count, 0, "The listener was still removed"); +}, "Passing an AbortSignal to addEventListener does not prevent removeEventListener"); + +test(function() { + let count = 0; + function handler() { + count++; + } + const et = new EventTarget(); + const controller = new AbortController(); + et.addEventListener('test', handler, { signal: controller.signal, once: true }); + controller.abort(); + et.dispatchEvent(new Event('test')); + assert_equals(count, 0, "The listener was still removed"); +}, "Passing an AbortSignal to addEventListener works with the once flag"); + +test(function() { + let count = 0; + function handler() { + count++; + } + const et = new EventTarget(); + const controller = new AbortController(); + et.addEventListener('test', handler, { signal: controller.signal, once: true }); + et.removeEventListener('test', handler); + et.dispatchEvent(new Event('test')); + assert_equals(count, 0, "The listener was still removed"); +}, "Removing a once listener works with a passed signal"); + +test(function() { + let count = 0; + function handler() { + count++; + } + const et = new EventTarget(); + const controller = new AbortController(); + et.addEventListener('first', handler, { signal: controller.signal, once: true }); + et.addEventListener('second', handler, { signal: controller.signal, once: true }); + controller.abort(); + et.dispatchEvent(new Event('first')); + et.dispatchEvent(new Event('second')); + assert_equals(count, 0, "The listener was still removed"); +}, "Passing an AbortSignal to multiple listeners"); + +test(function() { + let count = 0; + function handler() { + count++; + } + const et = new EventTarget(); + const controller = new AbortController(); + et.addEventListener('test', handler, { signal: controller.signal, capture: true }); + controller.abort(); + et.dispatchEvent(new Event('test')); + assert_equals(count, 0, "The listener was still removed"); +}, "Passing an AbortSignal to addEventListener works with the capture flag"); + +test(function() { + let count = 0; + function handler() { + count++; + } + const et = new EventTarget(); + const controller = new AbortController(); + et.addEventListener('test', () => { + controller.abort(); + }, { signal: controller.signal }); + et.addEventListener('test', handler, { signal: controller.signal }); + et.dispatchEvent(new Event('test')); + assert_equals(count, 0, "The listener was still removed"); +}, "Aborting from a listener does not call future listeners"); + +test(function() { + let count = 0; + function handler() { + count++; + } + const et = new EventTarget(); + const controller = new AbortController(); + et.addEventListener('test', () => { + et.addEventListener('test', handler, { signal: controller.signal }); + controller.abort(); + }, { signal: controller.signal }); + et.dispatchEvent(new Event('test')); + assert_equals(count, 0, "The listener was still removed"); +}, "Adding then aborting a listener in another listener does not call it"); + +test(function() { + const et = new EventTarget(); + const ac = new AbortController(); + let count = 0; + et.addEventListener('foo', () => { + et.addEventListener('foo', () => { + count++; + if (count > 5) ac.abort(); + et.dispatchEvent(new Event('foo')); + }, { signal: ac.signal }); + et.dispatchEvent(new Event('foo')); + }, { once: true }); + et.dispatchEvent(new Event('foo')); +}, "Aborting from a nested listener should remove it"); + +test(function() { + const et = new EventTarget(); + assert_throws_js(TypeError, () => { et.addEventListener("foo", () => {}, { signal: null }); }); +}, "Passing null as the signal should throw"); + +test(function() { + const et = new EventTarget(); + assert_throws_js(TypeError, () => { et.addEventListener("foo", null, { signal: null }); }); +}, "Passing null as the signal should throw (listener is also null)"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Body-FrameSet-Event-Handlers.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Body-FrameSet-Event-Handlers.html new file mode 100644 index 000000000..3a891158d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Body-FrameSet-Event-Handlers.html @@ -0,0 +1,123 @@ + + +HTMLBodyElement and HTMLFrameSetElement Event Handler Tests + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/CustomEvent.html b/crates/clazel-web/tests/data/wpt-web/dom/events/CustomEvent.html new file mode 100644 index 000000000..87050943f --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/CustomEvent.html @@ -0,0 +1,35 @@ + +CustomEvent + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-cancelBubble.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-cancelBubble.html new file mode 100644 index 000000000..d8d2d7239 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-cancelBubble.html @@ -0,0 +1,132 @@ + + + + + Event.cancelBubble + + + + + + + +
+
+
+
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-constants.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-constants.html new file mode 100644 index 000000000..635e9894d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-constants.html @@ -0,0 +1,23 @@ + +Event constants + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-constructors.any.js b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-constructors.any.js new file mode 100644 index 000000000..faa623ea9 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-constructors.any.js @@ -0,0 +1,120 @@ +// META: title=Event constructors + +test(function() { + assert_throws_js( + TypeError, + () => Event(""), + "Calling Event constructor without 'new' must throw") +}) +test(function() { + assert_throws_js(TypeError, function() { + new Event() + }) +}) +test(function() { + var test_error = { name: "test" } + assert_throws_exactly(test_error, function() { + new Event({ toString: function() { throw test_error; } }) + }) +}) +test(function() { + var ev = new Event("") + assert_equals(ev.type, "") + assert_equals(ev.target, null) + assert_equals(ev.srcElement, null) + assert_equals(ev.currentTarget, null) + assert_equals(ev.eventPhase, Event.NONE) + assert_equals(ev.bubbles, false) + assert_equals(ev.cancelable, false) + assert_equals(ev.defaultPrevented, false) + assert_equals(ev.returnValue, true) + assert_equals(ev.isTrusted, false) + assert_true(ev.timeStamp > 0) + assert_true("initEvent" in ev) +}) +test(function() { + var ev = new Event("test") + assert_equals(ev.type, "test") + assert_equals(ev.target, null) + assert_equals(ev.srcElement, null) + assert_equals(ev.currentTarget, null) + assert_equals(ev.eventPhase, Event.NONE) + assert_equals(ev.bubbles, false) + assert_equals(ev.cancelable, false) + assert_equals(ev.defaultPrevented, false) + assert_equals(ev.returnValue, true) + assert_equals(ev.isTrusted, false) + assert_true(ev.timeStamp > 0) + assert_true("initEvent" in ev) +}) +test(function() { + assert_throws_js(TypeError, function() { Event("test") }, + 'Calling Event constructor without "new" must throw'); +}) +test(function() { + var ev = new Event("I am an event", { bubbles: true, cancelable: false}) + assert_equals(ev.type, "I am an event") + assert_equals(ev.bubbles, true) + assert_equals(ev.cancelable, false) +}) +test(function() { + var ev = new Event("@", { bubblesIGNORED: true, cancelable: true}) + assert_equals(ev.type, "@") + assert_equals(ev.bubbles, false) + assert_equals(ev.cancelable, true) +}) +test(function() { + var ev = new Event("@", { "bubbles\0IGNORED": true, cancelable: true}) + assert_equals(ev.type, "@") + assert_equals(ev.bubbles, false) + assert_equals(ev.cancelable, true) +}) +test(function() { + var ev = new Event("Xx", { cancelable: true}) + assert_equals(ev.type, "Xx") + assert_equals(ev.bubbles, false) + assert_equals(ev.cancelable, true) +}) +test(function() { + var ev = new Event("Xx", {}) + assert_equals(ev.type, "Xx") + assert_equals(ev.bubbles, false) + assert_equals(ev.cancelable, false) +}) +test(function() { + var ev = new Event("Xx", {bubbles: true, cancelable: false, sweet: "x"}) + assert_equals(ev.type, "Xx") + assert_equals(ev.bubbles, true) + assert_equals(ev.cancelable, false) + assert_equals(ev.sweet, undefined) +}) +test(function() { + var called = [] + var ev = new Event("Xx", { + get cancelable() { + called.push("cancelable") + return false + }, + get bubbles() { + called.push("bubbles") + return true; + }, + get sweet() { + called.push("sweet") + return "x" + } + }) + assert_array_equals(called, ["bubbles", "cancelable"]) + assert_equals(ev.type, "Xx") + assert_equals(ev.bubbles, true) + assert_equals(ev.cancelable, false) + assert_equals(ev.sweet, undefined) +}) +test(function() { + var ev = new CustomEvent("$", {detail: 54, sweet: "x", sweet2: "x", cancelable:true}) + assert_equals(ev.type, "$") + assert_equals(ev.bubbles, false) + assert_equals(ev.cancelable, true) + assert_equals(ev.sweet, undefined) + assert_equals(ev.detail, 54) +}) diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-defaultPrevented-after-dispatch.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-defaultPrevented-after-dispatch.html new file mode 100644 index 000000000..8fef005eb --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-defaultPrevented-after-dispatch.html @@ -0,0 +1,44 @@ + + +Event.defaultPrevented is not reset after dispatchEvent() + + + + +
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-defaultPrevented.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-defaultPrevented.html new file mode 100644 index 000000000..2548fa3e0 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-defaultPrevented.html @@ -0,0 +1,55 @@ + +Event.defaultPrevented + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-bubble-canceled.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-bubble-canceled.html new file mode 100644 index 000000000..20f398f66 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-bubble-canceled.html @@ -0,0 +1,59 @@ + + + +Setting cancelBubble=true prior to dispatchEvent() + + + + +
+ + + + + + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-bubbles-false.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-bubbles-false.html new file mode 100644 index 000000000..0f43cb027 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-bubbles-false.html @@ -0,0 +1,98 @@ + + + Event.bubbles attribute is set to false + + + + +
+ + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-bubbles-true.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-bubbles-true.html new file mode 100644 index 000000000..b23605a1e --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-bubbles-true.html @@ -0,0 +1,108 @@ + + + Event.bubbles attribute is set to false + + + + +
+ + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-click.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-click.html new file mode 100644 index 000000000..ab4a24a5a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-click.html @@ -0,0 +1,425 @@ + +Synthetic click event "magic" + + +
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-click.tentative.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-click.tentative.html new file mode 100644 index 000000000..cfdae55ef --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-click.tentative.html @@ -0,0 +1,78 @@ + +Clicks on input element + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-detached-click.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-detached-click.html new file mode 100644 index 000000000..76ea3d78b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-detached-click.html @@ -0,0 +1,20 @@ + +Click event on an element not in the document + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-detached-input-and-change.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-detached-input-and-change.html new file mode 100644 index 000000000..a53ae71ac --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-detached-input-and-change.html @@ -0,0 +1,190 @@ + + + +input and change events for detached checkbox and radio elements + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-handlers-changed.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-handlers-changed.html new file mode 100644 index 000000000..24e6fd70c --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-handlers-changed.html @@ -0,0 +1,91 @@ + + + Dispatch additional events inside an event listener + + + +
+ + + + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-listener-order.window.js b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-listener-order.window.js new file mode 100644 index 000000000..a01a47287 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-listener-order.window.js @@ -0,0 +1,20 @@ +test(t => { + const hostParent = document.createElement("section"), + host = hostParent.appendChild(document.createElement("div")), + shadowRoot = host.attachShadow({ mode: "closed" }), + targetParent = shadowRoot.appendChild(document.createElement("p")), + target = targetParent.appendChild(document.createElement("span")), + path = [hostParent, host, shadowRoot, targetParent, target], + expected = [], + result = []; + path.forEach((node, index) => { + expected.splice(index, 0, "capturing " + node.nodeName); + expected.splice(index + 1, 0, "bubbling " + node.nodeName); + }); + path.forEach(node => { + node.addEventListener("test", () => { result.push("bubbling " + node.nodeName) }); + node.addEventListener("test", () => { result.push("capturing " + node.nodeName) }, true); + }); + target.dispatchEvent(new CustomEvent('test', { detail: {}, bubbles: true, composed: true })); + assert_array_equals(result, expected); +}); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-multiple-cancelBubble.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-multiple-cancelBubble.html new file mode 100644 index 000000000..2873fd779 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-multiple-cancelBubble.html @@ -0,0 +1,51 @@ + + + +Multiple dispatchEvent() and cancelBubble + + + + +
+ + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-multiple-stopPropagation.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-multiple-stopPropagation.html new file mode 100644 index 000000000..72644bd86 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-multiple-stopPropagation.html @@ -0,0 +1,51 @@ + + + + Multiple dispatchEvent() and stopPropagation() + + + + +
+ + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-omitted-capture.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-omitted-capture.html new file mode 100644 index 000000000..77074d9a3 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-omitted-capture.html @@ -0,0 +1,70 @@ + + +EventTarget.addEventListener: capture argument omitted + + + + +
+ + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-on-disabled-elements.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-on-disabled-elements.html new file mode 100644 index 000000000..e7d6b455b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-on-disabled-elements.html @@ -0,0 +1,251 @@ + + + +Events must dispatch on disabled elements + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-order-at-target.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-order-at-target.html new file mode 100644 index 000000000..79673c325 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-order-at-target.html @@ -0,0 +1,31 @@ + + +Listeners are invoked in correct order (AT_TARGET phase) + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-order.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-order.html new file mode 100644 index 000000000..ca9443459 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-order.html @@ -0,0 +1,26 @@ + +Event phases order + + +
+ +
+
+
diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-other-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-other-document.html new file mode 100644 index 000000000..689b48087 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-other-document.html @@ -0,0 +1,23 @@ + +Custom event on an element in another document + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-propagation-stopped.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-propagation-stopped.html new file mode 100644 index 000000000..889f8cfe1 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-propagation-stopped.html @@ -0,0 +1,59 @@ + + + + Calling stopPropagation() prior to dispatchEvent() + + + + +
+ + + + + + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-redispatch.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-redispatch.html new file mode 100644 index 000000000..cf861ca17 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-redispatch.html @@ -0,0 +1,124 @@ + + +EventTarget#dispatchEvent(): redispatching a native event + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-reenter.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-reenter.html new file mode 100644 index 000000000..71f8517bd --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-reenter.html @@ -0,0 +1,66 @@ + + + Dispatch additional events inside an event listener + + +
+ + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-single-activation-behavior.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-single-activation-behavior.html new file mode 100644 index 000000000..f734893fa --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-single-activation-behavior.html @@ -0,0 +1,163 @@ + + + Only one activation behavior is executed during dispatch + + + + + +
+ +
+ + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-target-moved.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-target-moved.html new file mode 100644 index 000000000..facb2c7b9 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-target-moved.html @@ -0,0 +1,73 @@ + + + Determined event propagation path - target moved + + + +
+ + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-target-removed.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-target-removed.html new file mode 100644 index 000000000..531799c3a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-target-removed.html @@ -0,0 +1,72 @@ + + +Determined event propagation path - target removed + + + +
+ + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-throwing-multiple-globals.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-throwing-multiple-globals.html new file mode 100644 index 000000000..a56fdf6af --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-throwing-multiple-globals.html @@ -0,0 +1,69 @@ + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-throwing.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-throwing.html new file mode 100644 index 000000000..7d1c0d94a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-dispatch-throwing.html @@ -0,0 +1,51 @@ + + +Throwing in event listeners + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-init-while-dispatching.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-init-while-dispatching.html new file mode 100644 index 000000000..2aa1f6701 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-init-while-dispatching.html @@ -0,0 +1,83 @@ + + +Re-initializing events while dispatching them + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-initEvent.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-initEvent.html new file mode 100644 index 000000000..ad1018d4d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-initEvent.html @@ -0,0 +1,136 @@ + +Event.initEvent + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-isTrusted.any.js b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-isTrusted.any.js new file mode 100644 index 000000000..00bcecd0e --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-isTrusted.any.js @@ -0,0 +1,11 @@ +test(function() { + var desc1 = Object.getOwnPropertyDescriptor(new Event("x"), "isTrusted"); + assert_not_equals(desc1, undefined); + assert_equals(typeof desc1.get, "function"); + + var desc2 = Object.getOwnPropertyDescriptor(new Event("x"), "isTrusted"); + assert_not_equals(desc2, undefined); + assert_equals(typeof desc2.get, "function"); + + assert_equals(desc1.get, desc2.get); +}); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-propagation.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-propagation.html new file mode 100644 index 000000000..33989eb4b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-propagation.html @@ -0,0 +1,48 @@ + +Event propagation tests + +
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-returnValue.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-returnValue.html new file mode 100644 index 000000000..08df2d414 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-returnValue.html @@ -0,0 +1,64 @@ + + + + + Event.returnValue + + + + + + + +
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-stopImmediatePropagation.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-stopImmediatePropagation.html new file mode 100644 index 000000000..b75732257 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-stopImmediatePropagation.html @@ -0,0 +1,34 @@ + + +Event's stopImmediatePropagation + + + + + + +
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-stopPropagation-cancel-bubbling.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-stopPropagation-cancel-bubbling.html new file mode 100644 index 000000000..5c2c49f33 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-stopPropagation-cancel-bubbling.html @@ -0,0 +1,20 @@ + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-subclasses-constructors.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-subclasses-constructors.html new file mode 100644 index 000000000..08a5ded01 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-subclasses-constructors.html @@ -0,0 +1,179 @@ + + +Event constructors + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-cross-realm-getter.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-cross-realm-getter.html new file mode 100644 index 000000000..45823de26 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-cross-realm-getter.html @@ -0,0 +1,27 @@ + + +event.timeStamp is initialized using event's relevant global object + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-high-resolution.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-high-resolution.html new file mode 100644 index 000000000..a049fef64 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-high-resolution.html @@ -0,0 +1,16 @@ + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-high-resolution.https.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-high-resolution.https.html new file mode 100644 index 000000000..70f974294 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-high-resolution.https.html @@ -0,0 +1,16 @@ + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-safe-resolution.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-safe-resolution.html new file mode 100644 index 000000000..24f2dec93 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-timestamp-safe-resolution.html @@ -0,0 +1,49 @@ + + + + \ No newline at end of file diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-type-empty.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-type-empty.html new file mode 100644 index 000000000..225b85a61 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-type-empty.html @@ -0,0 +1,35 @@ + +Event.type set to the empty string + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/Event-type.html b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-type.html new file mode 100644 index 000000000..22792f5c6 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/Event-type.html @@ -0,0 +1,22 @@ + +Event.type + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-addEventListener.sub.window.js b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-addEventListener.sub.window.js new file mode 100644 index 000000000..b44bc3328 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-addEventListener.sub.window.js @@ -0,0 +1,9 @@ +async_test(function(t) { + let crossOriginFrame = document.createElement('iframe'); + crossOriginFrame.src = 'https://{{hosts[alt][]}}:{{ports[https][0]}}/common/blank.html'; + document.body.appendChild(crossOriginFrame); + crossOriginFrame.addEventListener('load', t.step_func_done(function() { + let crossOriginWindow = crossOriginFrame.contentWindow; + window.addEventListener('click', crossOriginWindow); + })); +}, "EventListener.addEventListener doesn't throw when a cross origin object is passed in."); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-handleEvent-cross-realm.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-handleEvent-cross-realm.html new file mode 100644 index 000000000..663d04213 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-handleEvent-cross-realm.html @@ -0,0 +1,75 @@ + + +Cross-realm EventListener throws TypeError of its associated Realm + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-handleEvent.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-handleEvent.html new file mode 100644 index 000000000..06bc1f6e2 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-handleEvent.html @@ -0,0 +1,102 @@ + + +EventListener::handleEvent() + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-1.sub.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-1.sub.html new file mode 100644 index 000000000..9d941385c --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-1.sub.html @@ -0,0 +1,20 @@ + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-2.sub.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-2.sub.html new file mode 100644 index 000000000..4433c098d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-2.sub.html @@ -0,0 +1,20 @@ + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-subframe-1.sub.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-subframe-1.sub.html new file mode 100644 index 000000000..25487cc5e --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-subframe-1.sub.html @@ -0,0 +1,13 @@ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-subframe-2.sub.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-subframe-2.sub.html new file mode 100644 index 000000000..9c7235e2a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-subframe-2.sub.html @@ -0,0 +1,13 @@ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-subsubframe.sub.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-subsubframe.sub.html new file mode 100644 index 000000000..dd683f6f6 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-incumbent-global-subsubframe.sub.html @@ -0,0 +1,20 @@ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-invoke-legacy.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-invoke-legacy.html new file mode 100644 index 000000000..a01afcd8d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListener-invoke-legacy.html @@ -0,0 +1,66 @@ + + +Invoke legacy event listener + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventListenerOptions-capture.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListenerOptions-capture.html new file mode 100644 index 000000000..f72cf3ca5 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventListenerOptions-capture.html @@ -0,0 +1,98 @@ + + +EventListenerOptions.capture + + + + +
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-add-listener-platform-object.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-add-listener-platform-object.html new file mode 100644 index 000000000..d5565c22b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-add-listener-platform-object.html @@ -0,0 +1,32 @@ + + +addEventListener with a platform object + + + +Click me! + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-add-remove-listener.any.js b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-add-remove-listener.any.js new file mode 100644 index 000000000..b1d7ffb3e --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-add-remove-listener.any.js @@ -0,0 +1,21 @@ +// META: title=EventTarget's addEventListener + removeEventListener + +"use strict"; + +function listener(evt) { + evt.preventDefault(); + return false; +} + +test(() => { + const et = new EventTarget(); + et.addEventListener("x", listener, false); + let event = new Event("x", { cancelable: true }); + let ret = et.dispatchEvent(event); + assert_false(ret); + + et.removeEventListener("x", listener); + event = new Event("x", { cancelable: true }); + ret = et.dispatchEvent(event); + assert_true(ret); +}, "Removing an event listener without explicit capture arg should succeed"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-addEventListener.any.js b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-addEventListener.any.js new file mode 100644 index 000000000..e22da4aff --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-addEventListener.any.js @@ -0,0 +1,9 @@ +// META: title=EventTarget.addEventListener + +// Step 1. +test(function() { + const et = new EventTarget(); + assert_equals(et.addEventListener("x", null, false), undefined); + assert_equals(et.addEventListener("x", null, true), undefined); + assert_equals(et.addEventListener("x", null), undefined); +}, "Adding a null event listener should succeed"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-constructible.any.js b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-constructible.any.js new file mode 100644 index 000000000..4125d23f0 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-constructible.any.js @@ -0,0 +1,79 @@ +"use strict"; + +test(() => { + const target = new EventTarget(); + const event = new Event("foo", { bubbles: true, cancelable: false }); + let callCount = 0; + + function listener(e) { + assert_equals(e, event); + ++callCount; + } + + target.addEventListener("foo", listener); + + target.dispatchEvent(event); + assert_equals(callCount, 1); + + target.dispatchEvent(event); + assert_equals(callCount, 2); + + target.removeEventListener("foo", listener); + target.dispatchEvent(event); + assert_equals(callCount, 2); +}, "A constructed EventTarget can be used as expected"); + +test(() => { + const target = new EventTarget(); + const event = new Event("foo"); + + function listener(e) { + assert_equals(e, event); + assert_equals(e.target, target); + assert_equals(e.currentTarget, target); + assert_array_equals(e.composedPath(), [target]); + } + target.addEventListener("foo", listener, { once: true }); + target.dispatchEvent(event); + assert_equals(event.target, target); + assert_equals(event.currentTarget, null); + assert_array_equals(event.composedPath(), []); +}, "A constructed EventTarget implements dispatch correctly"); + +test(() => { + class NicerEventTarget extends EventTarget { + on(...args) { + this.addEventListener(...args); + } + + off(...args) { + this.removeEventListener(...args); + } + + dispatch(type, detail) { + this.dispatchEvent(new CustomEvent(type, { detail })); + } + } + + const target = new NicerEventTarget(); + const event = new Event("foo", { bubbles: true, cancelable: false }); + const detail = "some data"; + let callCount = 0; + + function listener(e) { + assert_equals(e.detail, detail); + ++callCount; + } + + target.on("foo", listener); + + target.dispatch("foo", detail); + assert_equals(callCount, 1); + + target.dispatch("foo", detail); + assert_equals(callCount, 2); + + target.off("foo", listener); + target.dispatch("foo", detail); + assert_equals(callCount, 2); +}, "EventTarget can be subclassed"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-dispatchEvent-returnvalue.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-dispatchEvent-returnvalue.html new file mode 100644 index 000000000..c4466e0d6 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-dispatchEvent-returnvalue.html @@ -0,0 +1,71 @@ + + +EventTarget.dispatchEvent: return value + + + + + + +
+ + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-dispatchEvent.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-dispatchEvent.html new file mode 100644 index 000000000..783561f5f --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-dispatchEvent.html @@ -0,0 +1,104 @@ + + +EventTarget.dispatchEvent + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-removeEventListener.any.js b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-removeEventListener.any.js new file mode 100644 index 000000000..289dfcfba --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-removeEventListener.any.js @@ -0,0 +1,8 @@ +// META: title=EventTarget.removeEventListener + +// Step 1. +test(function() { + assert_equals(globalThis.removeEventListener("x", null, false), undefined); + assert_equals(globalThis.removeEventListener("x", null, true), undefined); + assert_equals(globalThis.removeEventListener("x", null), undefined); +}, "removing a null event listener should succeed"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-this-of-listener.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-this-of-listener.html new file mode 100644 index 000000000..506564c41 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-this-of-listener.html @@ -0,0 +1,182 @@ + + +EventTarget listeners this value + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-window-constructor.html b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-window-constructor.html new file mode 100644 index 000000000..9993e0a79 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/EventTarget-window-constructor.html @@ -0,0 +1,40 @@ + + +Event dispatch with a modified Window constructor property + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/KeyEvent-initKeyEvent.html b/crates/clazel-web/tests/data/wpt-web/dom/events/KeyEvent-initKeyEvent.html new file mode 100644 index 000000000..3fffaba01 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/KeyEvent-initKeyEvent.html @@ -0,0 +1,23 @@ + + +KeyEvent.initKeyEvent + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/WEB_FEATURES.yml b/crates/clazel-web/tests/data/wpt-web/dom/events/WEB_FEATURES.yml new file mode 100644 index 000000000..7d9e87bbc --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/WEB_FEATURES.yml @@ -0,0 +1,7 @@ +rules: +- legacy-pre-activation-behavior.window.js: [change-event] +- no-focus-events-at-clicking-editable-content-in-link.html: [focus-events] +- Event-dispatch-click.html: [mouse-events] +- Event-dispatch-click.tentative.html: [mouse-events] +- mouse-event-retarget.html: [mouse-events] +- "*": [events] diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/click-on-absolute-pseudo.html b/crates/clazel-web/tests/data/wpt-web/dom/events/click-on-absolute-pseudo.html new file mode 100644 index 000000000..6c572f500 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/click-on-absolute-pseudo.html @@ -0,0 +1,68 @@ + + + + + + + + + + + + + +
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/element-click.html b/crates/clazel-web/tests/data/wpt-web/dom/events/element-click.html new file mode 100644 index 000000000..11d4664eb --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/element-click.html @@ -0,0 +1,84 @@ + + +HTMLElement.click() and querySelectoAll + + + + + + + +
+
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-disabled-dynamic.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-disabled-dynamic.html new file mode 100644 index 000000000..3f995b02f --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-disabled-dynamic.html @@ -0,0 +1,21 @@ + + +Test that disabled is honored immediately in presence of dynamic changes + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-event-targets.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-event-targets.html new file mode 100644 index 000000000..f57351bed --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-event-targets.html @@ -0,0 +1,53 @@ + + +window.event for non-Node event targets + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-extra.window.js b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-extra.window.js new file mode 100644 index 000000000..0f14961c4 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-extra.window.js @@ -0,0 +1,90 @@ +const otherWindow = document.body.appendChild(document.createElement("iframe")).contentWindow; + +["EventTarget", "XMLHttpRequest"].forEach(constructorName => { + async_test(t => { + const eventTarget = new otherWindow[constructorName](); + eventTarget.addEventListener("hi", t.step_func_done(e => { + assert_equals(otherWindow.event, undefined); + assert_equals(e, window.event); + })); + eventTarget.dispatchEvent(new Event("hi")); + }, "window.event for constructors from another global: " + constructorName); +}); + +// XXX: It would be good to test a subclass of EventTarget once we sort out +// https://github.com/heycam/webidl/issues/540 + +async_test(t => { + const element = document.body.appendChild(otherWindow.document.createElement("meh")); + element.addEventListener("yo", t.step_func_done(e => { + assert_equals(e, window.event); + })); + element.dispatchEvent(new Event("yo")); +}, "window.event and element from another document"); + +async_test(t => { + const doc = otherWindow.document, + element = doc.body.appendChild(doc.createElement("meh")), + child = element.appendChild(doc.createElement("bleh")); + element.addEventListener("yoyo", t.step_func(e => { + document.body.appendChild(element); + assert_equals(element.ownerDocument, document); + assert_equals(window.event, e); + assert_equals(otherWindow.event, undefined); + }), true); + element.addEventListener("yoyo", t.step_func(e => { + assert_equals(element.ownerDocument, document); + assert_equals(window.event, e); + assert_equals(otherWindow.event, undefined); + }), true); + child.addEventListener("yoyo", t.step_func_done(e => { + assert_equals(child.ownerDocument, document); + assert_equals(window.event, e); + assert_equals(otherWindow.event, undefined); + })); + child.dispatchEvent(new Event("yoyo")); +}, "window.event and moving an element post-dispatch"); + +test(t => { + const host = document.createElement("div"), + shadow = host.attachShadow({ mode: "open" }), + child = shadow.appendChild(document.createElement("trala")), + furtherChild = child.appendChild(document.createElement("waddup")); + let counter = 0; + host.addEventListener("hi", t.step_func(e => { + assert_equals(window.event, e); + assert_equals(counter++, 3); + })); + child.addEventListener("hi", t.step_func(e => { + assert_equals(window.event, undefined); + assert_equals(counter++, 2); + })); + furtherChild.addEventListener("hi", t.step_func(e => { + host.appendChild(child); + assert_equals(window.event, undefined); + assert_equals(counter++, 0); + })); + furtherChild.addEventListener("hi", t.step_func(e => { + assert_equals(window.event, undefined); + assert_equals(counter++, 1); + })); + furtherChild.dispatchEvent(new Event("hi", { composed: true, bubbles: true })); + assert_equals(counter, 4); +}, "window.event should not be affected by nodes moving post-dispatch"); + +async_test(t => { + const frame = document.body.appendChild(document.createElement("iframe")); + frame.src = "resources/event-global-extra-frame.html"; + frame.onload = t.step_func_done((load_event) => { + const event = new Event("hi"); + document.addEventListener("hi", frame.contentWindow.listener); // listener intentionally not wrapped in t.step_func + document.addEventListener("hi", t.step_func(e => { + assert_equals(event, e); + assert_equals(window.event, e); + })); + document.dispatchEvent(event); + assert_equals(frameState.event, event); + assert_equals(frameState.windowEvent, event); + assert_equals(frameState.parentEvent, load_event); + }); +}, "Listener from a different global"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-is-still-set-when-coercing-beforeunload-result.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-is-still-set-when-coercing-beforeunload-result.html new file mode 100644 index 000000000..a64c8b6b8 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-is-still-set-when-coercing-beforeunload-result.html @@ -0,0 +1,23 @@ + + +window.event is still set when 'beforeunload' result is coerced to string + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-is-still-set-when-reporting-exception-onerror.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-is-still-set-when-reporting-exception-onerror.html new file mode 100644 index 000000000..ceaac4fe2 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-is-still-set-when-reporting-exception-onerror.html @@ -0,0 +1,43 @@ + + +window.onerror handler restores window.event after it reports an exception + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-replaceable.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-replaceable.html new file mode 100644 index 000000000..5fe48bcad --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-replaceable.html @@ -0,0 +1,31 @@ + + +window.event is [Replaceable] + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-set-before-handleEvent-lookup.window.js b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-set-before-handleEvent-lookup.window.js new file mode 100644 index 000000000..8f934bcea --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global-set-before-handleEvent-lookup.window.js @@ -0,0 +1,19 @@ +// https://dom.spec.whatwg.org/#concept-event-listener-inner-invoke (steps 8.2 - 12) +// https://webidl.spec.whatwg.org/#call-a-user-objects-operation (step 10.1) + +test(() => { + const eventTarget = new EventTarget; + + let currentEvent; + eventTarget.addEventListener("foo", { + get handleEvent() { + currentEvent = window.event; + return () => {}; + } + }); + + const event = new Event("foo"); + eventTarget.dispatchEvent(event); + + assert_equals(currentEvent, event); +}, "window.event is set before 'handleEvent' lookup"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-global.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global.html new file mode 100644 index 000000000..f70606fb6 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global.html @@ -0,0 +1,127 @@ + +window.event tests + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-global.worker.js b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global.worker.js new file mode 100644 index 000000000..116cf3293 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-global.worker.js @@ -0,0 +1,14 @@ +importScripts("/resources/testharness.js"); +test(t => { + let seen = false; + const event = new Event("hi"); + assert_equals(self.event, undefined); + self.addEventListener("hi", t.step_func(e => { + seen = true; + assert_equals(self.event, undefined); + assert_equals(e, event); + })); + self.dispatchEvent(event); + assert_true(seen); +}, "There's no self.event (that's why we call it window.event) in workers"); +done(); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-handler-attribute-replace-preserves-passive.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-handler-attribute-replace-preserves-passive.html new file mode 100644 index 000000000..c4289da75 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-handler-attribute-replace-preserves-passive.html @@ -0,0 +1,65 @@ + +Event handler attribute replacement via setAttribute preserves passive flag + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-adopted-node.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-adopted-node.html new file mode 100644 index 000000000..0e5642f2e --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-adopted-node.html @@ -0,0 +1,134 @@ + + +Event listeners on nodes whose realm and node document disagree + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-callback.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-callback.html new file mode 100644 index 000000000..3f8b890dc --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-callback.html @@ -0,0 +1,87 @@ + + +Event listener callbacks from a document that is not fully active + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-navigated.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-navigated.html new file mode 100644 index 000000000..3b8b410e6 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-navigated.html @@ -0,0 +1,110 @@ + + +Event listeners are not invoked for targets in a navigated-away-from document + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-target.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-target.html new file mode 100644 index 000000000..ece406c46 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-listener-not-fully-active-target.html @@ -0,0 +1,220 @@ + + +Event listeners are not invoked when the target's document is not fully active + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/event-src-element-nullable.html b/crates/clazel-web/tests/data/wpt-web/dom/events/event-src-element-nullable.html new file mode 100644 index 000000000..528d4688c --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/event-src-element-nullable.html @@ -0,0 +1,20 @@ + + +Event srcElement should be nullable + + + +
+ + \ No newline at end of file diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/focus-event-document-move.html b/crates/clazel-web/tests/data/wpt-web/dom/events/focus-event-document-move.html new file mode 100644 index 000000000..2943761ce --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/focus-event-document-move.html @@ -0,0 +1,33 @@ + + + + + + + + + + + + +
Click me
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/handler-count.html b/crates/clazel-web/tests/data/wpt-web/dom/events/handler-count.html new file mode 100644 index 000000000..deabdaa4d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/handler-count.html @@ -0,0 +1,131 @@ + + + + + + + + + + + + + +
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/keypress-dispatch-crash.html b/crates/clazel-web/tests/data/wpt-web/dom/events/keypress-dispatch-crash.html new file mode 100644 index 000000000..3207adbd8 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/keypress-dispatch-crash.html @@ -0,0 +1,15 @@ + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/label-default-action.html b/crates/clazel-web/tests/data/wpt-web/dom/events/label-default-action.html new file mode 100644 index 000000000..5ac5ab548 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/label-default-action.html @@ -0,0 +1,22 @@ + +Label default action with interactive content + + + + \ No newline at end of file diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/legacy-pre-activation-behavior.window.js b/crates/clazel-web/tests/data/wpt-web/dom/events/legacy-pre-activation-behavior.window.js new file mode 100644 index 000000000..e9e84bfad --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/legacy-pre-activation-behavior.window.js @@ -0,0 +1,10 @@ +test(t => { + const input = document.body.appendChild(document.createElement('input')); + input.type = "radio"; + t.add_cleanup(() => input.remove()); + const clickEvent = new MouseEvent('click', { button: 0, which: 1 }); + input.addEventListener('change', t.step_func(() => { + assert_equals(clickEvent.eventPhase, Event.NONE); + })); + input.dispatchEvent(clickEvent); +}, "Use NONE phase during legacy-pre-activation behavior"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/mouse-event-retarget.html b/crates/clazel-web/tests/data/wpt-web/dom/events/mouse-event-retarget.html new file mode 100644 index 000000000..c9ce6240d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/mouse-event-retarget.html @@ -0,0 +1,26 @@ + + +Script created MouseEvent properly retargets and adjusts offsetX + + + + + +
Hello
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/no-focus-events-at-clicking-editable-content-in-link.html b/crates/clazel-web/tests/data/wpt-web/dom/events/no-focus-events-at-clicking-editable-content-in-link.html new file mode 100644 index 000000000..dc08636c4 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/no-focus-events-at-clicking-editable-content-in-link.html @@ -0,0 +1,80 @@ + + + + +Clicking editable content in link shouldn't cause redundant focus related events + + + + + + + +
Hello +Hello + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/WEB_FEATURES.yml b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/WEB_FEATURES.yml new file mode 100644 index 000000000..019d3957d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/WEB_FEATURES.yml @@ -0,0 +1,5 @@ +rules: +- non-passive-mousewheel-event-listener-*: [wheel-events] +- non-passive-wheel-event-listener-*: [wheel-events] +- passive-mousewheel-event-listener-*: [wheel-events] +- passive-wheel-event-listener-*: [wheel-events] diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/generic-events-stay-cancelable.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/generic-events-stay-cancelable.html new file mode 100644 index 000000000..961794728 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/generic-events-stay-cancelable.html @@ -0,0 +1,14 @@ + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-body.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-body.html new file mode 100644 index 000000000..5574fe0ac --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-body.html @@ -0,0 +1,19 @@ + +non-passive mousewheel event listener on body + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-div.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-div.html new file mode 100644 index 000000000..6fbf692cd --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-div.html @@ -0,0 +1,35 @@ + +non-passive mousewheel event listener on div + + + + + + + + + +
+
+
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-document.html new file mode 100644 index 000000000..7d07393c6 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-document.html @@ -0,0 +1,19 @@ + +non-passive mousewheel event listener on document + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-root.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-root.html new file mode 100644 index 000000000..e85fbacab --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-root.html @@ -0,0 +1,19 @@ + +non-passive mousewheel event listener on root + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-window.html new file mode 100644 index 000000000..29b09f856 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-mousewheel-event-listener-on-window.html @@ -0,0 +1,19 @@ + +non-passive mousewheel event listener on window + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-body.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-body.html new file mode 100644 index 000000000..f417bdd0a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-body.html @@ -0,0 +1,25 @@ + +non-passive touchmove event listener on body + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-div.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-div.html new file mode 100644 index 000000000..11c934540 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-div.html @@ -0,0 +1,25 @@ + +non-passive touchmove event listener on div + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-document.html new file mode 100644 index 000000000..8b95a8d49 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-document.html @@ -0,0 +1,25 @@ + +non-passive touchmove event listener on document + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-root.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-root.html new file mode 100644 index 000000000..c41ab72bd --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-root.html @@ -0,0 +1,25 @@ + +non-passive touchmove event listener on root + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-window.html new file mode 100644 index 000000000..3d6675c56 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchmove-event-listener-on-window.html @@ -0,0 +1,25 @@ + + + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-body.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-body.html new file mode 100644 index 000000000..f6e6ecb06 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-body.html @@ -0,0 +1,25 @@ + +non-passive touchstart event listener on body + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-div.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-div.html new file mode 100644 index 000000000..2e7c6e6b3 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-div.html @@ -0,0 +1,25 @@ + +non-passive touchstart event listener on div + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-document.html new file mode 100644 index 000000000..22fcbdc32 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-document.html @@ -0,0 +1,25 @@ + +non-passive touchstart event listener on document + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-root.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-root.html new file mode 100644 index 000000000..56c51349a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-root.html @@ -0,0 +1,25 @@ + +non-passive touchstart event listener on root + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-window.html new file mode 100644 index 000000000..4e9d424a9 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-touchstart-event-listener-on-window.html @@ -0,0 +1,25 @@ + +non-passive touchstart event listener on window + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-body.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-body.html new file mode 100644 index 000000000..070cadc29 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-body.html @@ -0,0 +1,18 @@ + +non-passive wheel event listener on body + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-div.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-div.html new file mode 100644 index 000000000..c49d18ac1 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-div.html @@ -0,0 +1,34 @@ + +non-passive wheel event listener on div + + + + + + + + +
+
+
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-document.html new file mode 100644 index 000000000..31a55cad4 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-document.html @@ -0,0 +1,18 @@ + +non-passive wheel event listener on document + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-root.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-root.html new file mode 100644 index 000000000..b7bacbfc7 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-root.html @@ -0,0 +1,18 @@ + +non-passive wheel event listener on root + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-window.html new file mode 100644 index 000000000..c236059df --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/non-passive-wheel-event-listener-on-window.html @@ -0,0 +1,18 @@ + +non-passive wheel event listener on window + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-body.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-body.html new file mode 100644 index 000000000..9db12cfbd --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-body.html @@ -0,0 +1,19 @@ + +passive mousewheel event listener on body + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-div.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-div.html new file mode 100644 index 000000000..373670856 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-div.html @@ -0,0 +1,35 @@ + +passive mousewheel event listener on div + + + + + + + + + +
+
+
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-document.html new file mode 100644 index 000000000..71262280b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-document.html @@ -0,0 +1,19 @@ + +passive mousewheel event listener on document + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-root.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-root.html new file mode 100644 index 000000000..fc641d172 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-root.html @@ -0,0 +1,19 @@ + +passive mousewheel event listener on root + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-window.html new file mode 100644 index 000000000..f60955c7c --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-mousewheel-event-listener-on-window.html @@ -0,0 +1,19 @@ + +passive mousewheel event listener on window + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-body.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-body.html new file mode 100644 index 000000000..2349bad25 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-body.html @@ -0,0 +1,25 @@ + +passive touchmove event listener on body + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-div.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-div.html new file mode 100644 index 000000000..a61b34851 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-div.html @@ -0,0 +1,25 @@ + +passive touchmove event listener on div + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-document.html new file mode 100644 index 000000000..b49971b5b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-document.html @@ -0,0 +1,25 @@ + +passive touchmove event listener on document + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-root.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-root.html new file mode 100644 index 000000000..b85170459 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-root.html @@ -0,0 +1,25 @@ + +passive touchmove event listener on root + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-window.html new file mode 100644 index 000000000..351d6ace8 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchmove-event-listener-on-window.html @@ -0,0 +1,25 @@ + +passive touchmove event listener on window + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-body.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-body.html new file mode 100644 index 000000000..c3d2b577f --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-body.html @@ -0,0 +1,25 @@ + +passive touchstart event listener on body + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-div.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-div.html new file mode 100644 index 000000000..103e7f0d2 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-div.html @@ -0,0 +1,25 @@ + +passive touchstart event listener on div + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-document.html new file mode 100644 index 000000000..2e4de2405 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-document.html @@ -0,0 +1,25 @@ + +passive touchstart event listener on document + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-root.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-root.html new file mode 100644 index 000000000..0f52e9a16 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-root.html @@ -0,0 +1,25 @@ + +passive touchstart event listener on root + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-window.html new file mode 100644 index 000000000..c47af8101 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-touchstart-event-listener-on-window.html @@ -0,0 +1,25 @@ + +passive touchstart event listener on window + + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-body.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-body.html new file mode 100644 index 000000000..fe0869b02 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-body.html @@ -0,0 +1,18 @@ + +passive wheel event listener on body + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-div.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-div.html new file mode 100644 index 000000000..e2ca6e795 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-div.html @@ -0,0 +1,34 @@ + +passive wheel event listener on div + + + + + + + + +
+
+
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-document.html new file mode 100644 index 000000000..61b716f7b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-document.html @@ -0,0 +1,18 @@ + +passive wheel event listener on document + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-root.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-root.html new file mode 100644 index 000000000..6b383bc87 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-root.html @@ -0,0 +1,18 @@ + +passive wheel event listener on root + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-window.html new file mode 100644 index 000000000..a1e901f55 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/passive-wheel-event-listener-on-window.html @@ -0,0 +1,18 @@ + +passive wheel event listener on window + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/resources/scrolling.js b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/resources/scrolling.js new file mode 100644 index 000000000..88e10f5ef --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/resources/scrolling.js @@ -0,0 +1,34 @@ +function raf() { + return new Promise((resolve) => { + // rAF twice. + window.requestAnimationFrame(() => { + window.requestAnimationFrame(resolve); + }); + }); +} + +async function runTest({target, eventName, passive, expectCancelable}) { + await raf(); + + let cancelable = null; + let arrived = false; + target.addEventListener(eventName, function (event) { + cancelable = event.cancelable; + arrived = true; + }, {passive:passive, once:true}); + + promise_test(async (t) => { + t.add_cleanup(() => { + document.querySelector('.remove-on-cleanup')?.remove(); + }); + const pos_x = Math.floor(window.innerWidth / 2); + const pos_y = Math.floor(window.innerHeight / 2); + const delta_x = 0; + const delta_y = 100; + + await new test_driver.Actions() + .scroll(pos_x, pos_y, delta_x, delta_y).send(); + await t.step_wait(() => arrived, `Didn't get event ${eventName} on ${target.localName}`); + assert_equals(cancelable, expectCancelable); + }); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/resources/touching.js b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/resources/touching.js new file mode 100644 index 000000000..620d26804 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/resources/touching.js @@ -0,0 +1,34 @@ +function waitForCompositorCommit() { + return new Promise((resolve) => { + // rAF twice. + window.requestAnimationFrame(() => { + window.requestAnimationFrame(resolve); + }); + }); +} + +function injectInput(touchDiv) { + return new test_driver.Actions() + .addPointer("touch_pointer", "touch") + .pointerMove(0, 0, {origin: touchDiv}) + .pointerDown() + .pointerMove(30, 30) + .pointerUp() + .send(); +} + +function runTest({target, eventName, passive, expectCancelable}) { + let touchDiv = document.getElementById("touchDiv"); + let cancelable = null; + let arrived = false; + target.addEventListener(eventName, function (event) { + cancelable = event.cancelable; + arrived = true; + }, {passive}); + promise_test(async () => { + await waitForCompositorCommit(); + await injectInput(touchDiv); + await waitFor(() => arrived); + assert_equals(cancelable, expectCancelable); + }); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/resources/wait-for.js b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/resources/wait-for.js new file mode 100644 index 000000000..0bf3e5583 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/resources/wait-for.js @@ -0,0 +1,15 @@ +function waitFor(condition, MAX_FRAME = 500) { + return new Promise((resolve, reject) => { + function tick(frames) { + // We requestAnimationFrame either for MAX_FRAME frames or until condition is + // met. + if (frames >= MAX_FRAME) + reject(new Error(`Condition did not become true after ${MAX_FRAME} frames`)); + else if (condition()) + resolve(); + else + requestAnimationFrame(() => tick(frames + 1)); + } + tick(0); + }); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/synthetic-events-cancelable.html b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/synthetic-events-cancelable.html new file mode 100644 index 000000000..4287770b8 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/non-cancelable-when-passive/synthetic-events-cancelable.html @@ -0,0 +1,34 @@ + +Synthetic events are always cancelable by default + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/passive-by-default-non-node.html b/crates/clazel-web/tests/data/wpt-web/dom/events/passive-by-default-non-node.html new file mode 100644 index 000000000..1c4ca07c5 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/passive-by-default-non-node.html @@ -0,0 +1,32 @@ + + +Default passive event listeners on non-Node event targets + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/passive-by-default.html b/crates/clazel-web/tests/data/wpt-web/dom/events/passive-by-default.html new file mode 100644 index 000000000..02029f4da --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/passive-by-default.html @@ -0,0 +1,50 @@ + +Default passive event listeners on window, document, document element, body + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/pointer-event-document-move.html b/crates/clazel-web/tests/data/wpt-web/dom/events/pointer-event-document-move.html new file mode 100644 index 000000000..91e7c3686 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/pointer-event-document-move.html @@ -0,0 +1,29 @@ + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/preventDefault-during-activation-behavior.html b/crates/clazel-web/tests/data/wpt-web/dom/events/preventDefault-during-activation-behavior.html new file mode 100644 index 000000000..928740313 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/preventDefault-during-activation-behavior.html @@ -0,0 +1,53 @@ + +preventDefault during activation behavior + + + + + + + + + +
+ +
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/relatedTarget.window.js b/crates/clazel-web/tests/data/wpt-web/dom/events/relatedTarget.window.js new file mode 100644 index 000000000..ebc83ceb2 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/relatedTarget.window.js @@ -0,0 +1,81 @@ +// https://dom.spec.whatwg.org/#concept-event-dispatch + +const host = document.createElement("div"), + child = host.appendChild(document.createElement("p")), + shadow = host.attachShadow({ mode: "closed" }), + slot = shadow.appendChild(document.createElement("slot")); + +test(() => { + for (target of [shadow, slot]) { + for (relatedTarget of [new XMLHttpRequest(), self, host]) { + const event = new FocusEvent("demo", { relatedTarget: relatedTarget }); + target.dispatchEvent(event); + assert_equals(event.target, null); + assert_equals(event.relatedTarget, null); + } + } +}, "Reset if target pointed to a shadow tree"); + +test(() => { + for (relatedTarget of [shadow, slot]) { + for (target of [new XMLHttpRequest(), self, host]) { + const event = new FocusEvent("demo", { relatedTarget: relatedTarget }); + target.dispatchEvent(event); + assert_equals(event.target, target); + assert_equals(event.relatedTarget, host); + } + } +}, "Retarget a shadow-tree relatedTarget"); + +test(t => { + const shadowChild = shadow.appendChild(document.createElement("div")); + shadowChild.addEventListener("demo", t.step_func(() => document.body.appendChild(shadowChild))); + const event = new FocusEvent("demo", { relatedTarget: new XMLHttpRequest() }); + shadowChild.dispatchEvent(event); + assert_equals(shadowChild.parentNode, document.body); + assert_equals(event.target, null); + assert_equals(event.relatedTarget, null); + shadowChild.remove(); +}, "Reset if target pointed to a shadow tree pre-dispatch"); + +test(t => { + const shadowChild = shadow.appendChild(document.createElement("div")); + document.body.addEventListener("demo", t.step_func(() => document.body.appendChild(shadowChild))); + const event = new FocusEvent("demo", { relatedTarget: shadowChild }); + document.body.dispatchEvent(event); + assert_equals(shadowChild.parentNode, document.body); + assert_equals(event.target, document.body); + assert_equals(event.relatedTarget, host); + shadowChild.remove(); +}, "Retarget a shadow-tree relatedTarget, part 2"); + +test(t => { + const event = new FocusEvent("heya", { relatedTarget: shadow, cancelable: true }), + callback = t.unreached_func(); + host.addEventListener("heya", callback); + t.add_cleanup(() => host.removeEventListener("heya", callback)); + event.preventDefault(); + assert_true(event.defaultPrevented); + assert_false(host.dispatchEvent(event)); + assert_equals(event.target, null); + assert_equals(event.relatedTarget, null); + // Check that the dispatch flag is cleared + event.initEvent("x"); + assert_equals(event.type, "x"); +}, "Reset targets on early return"); + +test(t => { + const input = document.body.appendChild(document.createElement("input")), + event = new MouseEvent("click", { relatedTarget: shadow }); + let seen = false; + t.add_cleanup(() => input.remove()); + input.type = "checkbox"; + input.oninput = t.step_func(() => { + assert_equals(event.target, null); + assert_equals(event.relatedTarget, null); + assert_equals(event.composedPath().length, 0); + seen = true; + }); + assert_true(input.dispatchEvent(event)); + assert_true(seen); +}, "Reset targets before activation behavior"); diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/remove-all-listeners.html b/crates/clazel-web/tests/data/wpt-web/dom/events/remove-all-listeners.html new file mode 100644 index 000000000..3a2a751a1 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/remove-all-listeners.html @@ -0,0 +1,95 @@ + +Various edge cases where listeners are removed during iteration + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/replace-event-listener-null-browsing-context-crash.html b/crates/clazel-web/tests/data/wpt-web/dom/events/replace-event-listener-null-browsing-context-crash.html new file mode 100644 index 000000000..f41955eed --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/replace-event-listener-null-browsing-context-crash.html @@ -0,0 +1,16 @@ + +Event listeners: replace listener after moving between documents + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/resources/empty-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/empty-document.html new file mode 100644 index 000000000..b9cd130a0 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/empty-document.html @@ -0,0 +1,3 @@ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/resources/event-global-extra-frame.html b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/event-global-extra-frame.html new file mode 100644 index 000000000..241dda8b6 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/event-global-extra-frame.html @@ -0,0 +1,9 @@ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/resources/event-global-is-still-set-when-coercing-beforeunload-result-frame.html b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/event-global-is-still-set-when-coercing-beforeunload-result-frame.html new file mode 100644 index 000000000..5df4fa279 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/event-global-is-still-set-when-coercing-beforeunload-result-frame.html @@ -0,0 +1,6 @@ + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/resources/large-dimension-document.sub.html b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/large-dimension-document.sub.html new file mode 100644 index 000000000..5d29f7be0 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/large-dimension-document.sub.html @@ -0,0 +1,5 @@ + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/resources/not-fully-active-frame.html b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/not-fully-active-frame.html new file mode 100644 index 000000000..526bc9353 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/not-fully-active-frame.html @@ -0,0 +1,18 @@ + + +Helper frame for the "not fully active" event listener tests +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/resources/not-fully-active-helpers.js b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/not-fully-active-helpers.js new file mode 100644 index 000000000..820fa01a8 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/not-fully-active-helpers.js @@ -0,0 +1,37 @@ +"use strict"; + +// Appends an iframe with the given srcdoc to the document and resolves with it +// once it has loaded. The iframe is removed again during cleanup (removing an +// already-removed iframe is a no-op). +globalThis.addFrame = (t, srcdoc = "") => { + const frame = document.createElement("iframe"); + frame.srcdoc = srcdoc; + return appendAndWait(t, frame); +}; + +// As above, but navigating to a URL, so that the iframe can be navigated again +// later. (Setting src on an iframe with a srcdoc attribute has no effect.) +globalThis.addSrcFrame = (t, src) => { + const frame = document.createElement("iframe"); + frame.src = src; + return appendAndWait(t, frame); +}; + +// Navigates an already-loaded iframe and resolves once the new document has +// loaded. +globalThis.navigateFrame = (frame, url) => { + const loaded = new Promise(resolve => { + frame.addEventListener("load", resolve, { once: true }); + }); + frame.src = url; + return loaded; +}; + +function appendAndWait(t, frame) { + const loaded = new Promise(resolve => { + frame.addEventListener("load", resolve, { once: true }); + }); + t.add_cleanup(() => frame.remove()); + document.body.append(frame); + return loaded.then(() => frame); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/resources/prefixed-animation-event-tests.js b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/prefixed-animation-event-tests.js new file mode 100644 index 000000000..021b6bb9d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/resources/prefixed-animation-event-tests.js @@ -0,0 +1,366 @@ +'use strict' + +// Runs a set of tests for a given prefixed/unprefixed animation event (e.g. +// animationstart/webkitAnimationStart). +// +// The eventDetails object must have the following form: +// { +// isTransition: false, <-- can be omitted, default false +// unprefixedType: 'animationstart', +// prefixedType: 'webkitAnimationStart', +// animationCssStyle: '1ms', <-- must NOT include animation name or +// transition property +// } +function runAnimationEventTests(eventDetails) { + const { + isTransition, + unprefixedType, + prefixedType, + animationCssStyle + } = eventDetails; + + // Derive the DOM event handler names, e.g. onanimationstart. + const unprefixedHandler = `on${unprefixedType}`; + const prefixedHandler = `on${prefixedType.toLowerCase()}`; + + const style = document.createElement('style'); + document.head.appendChild(style); + if (isTransition) { + style.sheet.insertRule( + `.baseStyle { width: 100px; transition: width ${animationCssStyle}; }`); + style.sheet.insertRule('.transition { width: 200px !important; }'); + } else { + style.sheet.insertRule('@keyframes anim {}'); + } + + function triggerAnimation(div) { + if (isTransition) { + div.classList.add('transition'); + } else { + div.style.animation = `anim ${animationCssStyle}`; + } + } + + test(t => { + const div = createDiv(t); + + assert_equals(div[unprefixedHandler], null, + `${unprefixedHandler} should initially be null`); + assert_equals(div[prefixedHandler], null, + `${prefixedHandler} should initially be null`); + + // Setting one should not affect the other. + div[unprefixedHandler] = () => { }; + + assert_not_equals(div[unprefixedHandler], null, + `setting ${unprefixedHandler} should make it non-null`); + assert_equals(div[prefixedHandler], null, + `setting ${unprefixedHandler} should not affect ${prefixedHandler}`); + + div[prefixedHandler] = () => { }; + + assert_not_equals(div[prefixedHandler], null, + `setting ${prefixedHandler} should make it non-null`); + assert_not_equals(div[unprefixedHandler], div[prefixedHandler], + 'the setters should be different'); + }, `${unprefixedHandler} and ${prefixedHandler} are not aliases`); + + // The below tests primarily test the interactions of prefixed animation + // events in the algorithm for invoking events: + // https://dom.spec.whatwg.org/#concept-event-listener-invoke + + promise_test(async t => { + const div = createDiv(t); + + let receivedEventCount = 0; + addTestScopedEventHandler(t, div, prefixedHandler, () => { + receivedEventCount++; + }); + addTestScopedEventListener(t, div, prefixedType, () => { + receivedEventCount++; + }); + + // The HTML spec[0] specifies that the prefixed event handlers have an + // 'Event handler event type' of the appropriate prefixed event type. E.g. + // onwebkitanimationend creates a listener for the event type + // 'webkitAnimationEnd'. + // + // [0]: https://html.spec.whatwg.org/multipage/webappapis.html#event-handlers-on-elements,-document-objects,-and-window-objects + div.dispatchEvent(new AnimationEvent(prefixedType)); + assert_equals(receivedEventCount, 2, + 'prefixed listener and handler received event'); + }, `dispatchEvent of a ${prefixedType} event does trigger a ` + + `prefixed event handler or listener`); + + promise_test(async t => { + const div = createDiv(t); + + let receivedEvent = false; + addTestScopedEventHandler(t, div, unprefixedHandler, () => { + receivedEvent = true; + }); + addTestScopedEventListener(t, div, unprefixedType, () => { + receivedEvent = true; + }); + + div.dispatchEvent(new AnimationEvent(prefixedType)); + assert_false(receivedEvent, + 'prefixed listener or handler received event'); + }, `dispatchEvent of a ${prefixedType} event does not trigger an ` + + `unprefixed event handler or listener`); + + + promise_test(async t => { + const div = createDiv(t); + + let receivedEvent = false; + addTestScopedEventHandler(t, div, prefixedHandler, () => { + receivedEvent = true; + }); + addTestScopedEventListener(t, div, prefixedType, () => { + receivedEvent = true; + }); + + // The rewrite rules from + // https://dom.spec.whatwg.org/#concept-event-listener-invoke step 8 do not + // apply because isTrusted will be false. + div.dispatchEvent(new AnimationEvent(unprefixedType)); + assert_false(receivedEvent, 'prefixed listener or handler received event'); + }, `dispatchEvent of an ${unprefixedType} event does not trigger a ` + + `prefixed event handler or listener`); + + promise_test(async t => { + const div = createDiv(t); + + let receivedEvent = false; + addTestScopedEventHandler(t, div, prefixedHandler, () => { + receivedEvent = true; + }); + + triggerAnimation(div); + await waitForEventThenAnimationFrame(t, unprefixedType); + assert_true(receivedEvent, `received ${prefixedHandler} event`); + }, `${prefixedHandler} event handler should trigger for an animation`); + + promise_test(async t => { + const div = createDiv(t); + + let receivedPrefixedEvent = false; + addTestScopedEventHandler(t, div, prefixedHandler, () => { + receivedPrefixedEvent = true; + }); + let receivedUnprefixedEvent = false; + addTestScopedEventHandler(t, div, unprefixedHandler, () => { + receivedUnprefixedEvent = true; + }); + + triggerAnimation(div); + await waitForEventThenAnimationFrame(t, unprefixedType); + assert_true(receivedUnprefixedEvent, `received ${unprefixedHandler} event`); + assert_false(receivedPrefixedEvent, `received ${prefixedHandler} event`); + }, `${prefixedHandler} event handler should not trigger if an unprefixed ` + + `event handler also exists`); + + promise_test(async t => { + const div = createDiv(t); + + let receivedPrefixedEvent = false; + addTestScopedEventHandler(t, div, prefixedHandler, () => { + receivedPrefixedEvent = true; + }); + let receivedUnprefixedEvent = false; + addTestScopedEventListener(t, div, unprefixedType, () => { + receivedUnprefixedEvent = true; + }); + + triggerAnimation(div); + await waitForEventThenAnimationFrame(t, unprefixedHandler); + assert_true(receivedUnprefixedEvent, `received ${unprefixedHandler} event`); + assert_false(receivedPrefixedEvent, `received ${prefixedHandler} event`); + }, `${prefixedHandler} event handler should not trigger if an unprefixed ` + + `listener also exists`); + + promise_test(async t => { + // We use a parent/child relationship to be able to register both prefixed + // and unprefixed event handlers without the deduplication logic kicking in. + const parent = createDiv(t); + const child = createDiv(t); + parent.appendChild(child); + // After moving the child, we have to clean style again. + getComputedStyle(child).transition; + getComputedStyle(child).width; + + let observedUnprefixedType; + addTestScopedEventHandler(t, parent, unprefixedHandler, e => { + observedUnprefixedType = e.type; + }); + let observedPrefixedType; + addTestScopedEventHandler(t, child, prefixedHandler, e => { + observedPrefixedType = e.type; + }); + + triggerAnimation(child); + await waitForEventThenAnimationFrame(t, unprefixedType); + + assert_equals(observedUnprefixedType, unprefixedType); + assert_equals(observedPrefixedType, prefixedType); + }, `event types for prefixed and unprefixed ${unprefixedType} event ` + + `handlers should be named appropriately`); + + promise_test(async t => { + const div = createDiv(t); + + let receivedEvent = false; + addTestScopedEventListener(t, div, prefixedType, () => { + receivedEvent = true; + }); + + triggerAnimation(div); + await waitForEventThenAnimationFrame(t, unprefixedHandler); + assert_true(receivedEvent, `received ${prefixedType} event`); + }, `${prefixedType} event listener should trigger for an animation`); + + promise_test(async t => { + const div = createDiv(t); + + let receivedPrefixedEvent = false; + addTestScopedEventListener(t, div, prefixedType, () => { + receivedPrefixedEvent = true; + }); + let receivedUnprefixedEvent = false; + addTestScopedEventListener(t, div, unprefixedType, () => { + receivedUnprefixedEvent = true; + }); + + triggerAnimation(div); + await waitForEventThenAnimationFrame(t, unprefixedHandler); + assert_true(receivedUnprefixedEvent, `received ${unprefixedType} event`); + assert_false(receivedPrefixedEvent, `received ${prefixedType} event`); + }, `${prefixedType} event listener should not trigger if an unprefixed ` + + `listener also exists`); + + promise_test(async t => { + const div = createDiv(t); + + let receivedPrefixedEvent = false; + addTestScopedEventListener(t, div, prefixedType, () => { + receivedPrefixedEvent = true; + }); + let receivedUnprefixedEvent = false; + addTestScopedEventHandler(t, div, unprefixedHandler, () => { + receivedUnprefixedEvent = true; + }); + + triggerAnimation(div); + await waitForEventThenAnimationFrame(t, unprefixedHandler); + assert_true(receivedUnprefixedEvent, `received ${unprefixedType} event`); + assert_false(receivedPrefixedEvent, `received ${prefixedType} event`); + }, `${prefixedType} event listener should not trigger if an unprefixed ` + + `event handler also exists`); + + promise_test(async t => { + // We use a parent/child relationship to be able to register both prefixed + // and unprefixed event listeners without the deduplication logic kicking in. + const parent = createDiv(t); + const child = createDiv(t); + parent.appendChild(child); + // After moving the child, we have to clean style again. + getComputedStyle(child).transition; + getComputedStyle(child).width; + + let observedUnprefixedType; + addTestScopedEventListener(t, parent, unprefixedType, e => { + observedUnprefixedType = e.type; + }); + let observedPrefixedType; + addTestScopedEventListener(t, child, prefixedType, e => { + observedPrefixedType = e.type; + }); + + triggerAnimation(child); + await waitForEventThenAnimationFrame(t, unprefixedHandler); + + assert_equals(observedUnprefixedType, unprefixedType); + assert_equals(observedPrefixedType, prefixedType); + }, `event types for prefixed and unprefixed ${unprefixedType} event ` + + `listeners should be named appropriately`); + + promise_test(async t => { + const div = createDiv(t); + + let receivedEvent = false; + addTestScopedEventListener(t, div, prefixedType.toLowerCase(), () => { + receivedEvent = true; + }); + addTestScopedEventListener(t, div, prefixedType.toUpperCase(), () => { + receivedEvent = true; + }); + + triggerAnimation(div); + await waitForEventThenAnimationFrame(t, unprefixedHandler); + assert_false(receivedEvent, `received ${prefixedType} event`); + }, `${prefixedType} event listener is case sensitive`); +} + +// Below are utility functions. + +// Creates a div element, appends it to the document body and removes the +// created element during test cleanup. +function createDiv(test) { + const element = document.createElement('div'); + element.classList.add('baseStyle'); + document.body.appendChild(element); + test.add_cleanup(() => { + element.remove(); + }); + + // Flush style before returning. Some browsers only do partial style re-calc, + // so ask for all important properties to make sure they are applied. + getComputedStyle(element).transition; + getComputedStyle(element).width; + + return element; +} + +// Adds an event handler for |handlerName| (calling |callback|) to the given +// |target|, that will automatically be cleaned up at the end of the test. +function addTestScopedEventHandler(test, target, handlerName, callback) { + assert_regexp_match( + handlerName, /^on/, 'Event handler names must start with "on"'); + assert_equals(target[handlerName], null, + `${handlerName} must be supported and not previously set`); + target[handlerName] = callback; + // We need this cleaned up even if the event handler doesn't run. + test.add_cleanup(() => { + if (target[handlerName]) + target[handlerName] = null; + }); +} + +// Adds an event listener for |type| (calling |callback|) to the given +// |target|, that will automatically be cleaned up at the end of the test. +function addTestScopedEventListener(test, target, type, callback) { + target.addEventListener(type, callback); + // We need this cleaned up even if the event handler doesn't run. + test.add_cleanup(() => { + target.removeEventListener(type, callback); + }); +} + +// Returns a promise that will resolve once the passed event (|eventName|) has +// triggered and one more animation frame has happened. Automatically chooses +// between an event handler or event listener based on whether |eventName| +// begins with 'on'. +// +// We always listen on window as we don't want to interfere with the test via +// triggering the prefixed event deduplication logic. +function waitForEventThenAnimationFrame(test, eventName) { + return new Promise((resolve, _) => { + const eventFunc = eventName.startsWith('on') + ? addTestScopedEventHandler : addTestScopedEventListener; + eventFunc(test, window, eventName, () => { + // rAF once to give the event under test time to come through. + requestAnimationFrame(resolve); + }); + }); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/WEB_FEATURES.yml b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/WEB_FEATURES.yml new file mode 100644 index 000000000..34c514745 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/WEB_FEATURES.yml @@ -0,0 +1,4 @@ +rules: +- scroll-*: [scroll-elements] +- scrollend-*: [scrollend] +- wheel-event-transactions-*: [wheel-events] diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/iframe-chains.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/iframe-chains.html new file mode 100644 index 000000000..c11721053 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/iframe-chains.html @@ -0,0 +1,49 @@ + + + + + + + + + + + + +
+ +
+
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/input-text-scroll-event-when-using-arrow-keys.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/input-text-scroll-event-when-using-arrow-keys.html new file mode 100644 index 000000000..f84e44652 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/input-text-scroll-event-when-using-arrow-keys.html @@ -0,0 +1,71 @@ + + + + + + + + + + + +

Moving the cursor using the arrow keys into an + input element fires scroll events when text has to scroll into view. + Uses arrow keys to move forward and backwards in the input + element.

+ + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/save-iframe-scroll-offset-when-display-none.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/save-iframe-scroll-offset-when-display-none.html new file mode 100644 index 000000000..3947e4779 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/save-iframe-scroll-offset-when-display-none.html @@ -0,0 +1,86 @@ + + +Ensure that the scroll position isn't lost when the iframe is set to display:none and shown again + + + + + + + +
+ +
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/save-iframe-scroll-offset-when-display-none.sub.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/save-iframe-scroll-offset-when-display-none.sub.html new file mode 100644 index 000000000..f9c22d998 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/save-iframe-scroll-offset-when-display-none.sub.html @@ -0,0 +1,34 @@ + +
+ + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-cross-origin-iframes.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-cross-origin-iframes.html new file mode 100644 index 000000000..7184e44e3 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-cross-origin-iframes.html @@ -0,0 +1,78 @@ + + +Verify that two sibling cross-origin iframes both correctly scroll on MouseWheel events, as per https://crbug.com/675695. + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-cross-origin-iframes.sub.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-cross-origin-iframes.sub.html new file mode 100644 index 000000000..e6d12794e --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-cross-origin-iframes.sub.html @@ -0,0 +1,51 @@ + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-event-fired-to-element.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-event-fired-to-element.html new file mode 100644 index 000000000..3484a2ec9 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-event-fired-to-element.html @@ -0,0 +1,100 @@ + + +Scroll event should behave correctly for Element.offsetTop and Element.offsetLeft + + + + + + +
+
+
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-event-fired-to-iframe.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-event-fired-to-iframe.html new file mode 100644 index 000000000..2ff3de79d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-event-fired-to-iframe.html @@ -0,0 +1,116 @@ + + +Scroll event should behave correctly for Element.ScrollX and Element.ScrollLeft + + + + + + +
+
+
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-event-not-fired-on-ancestor-style-change.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-event-not-fired-on-ancestor-style-change.html new file mode 100644 index 000000000..7f55de74c --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-event-not-fired-on-ancestor-style-change.html @@ -0,0 +1,43 @@ + + +No scroll event is fired when a style change on an ancestor leaves the scroll position alone + + + + +
+ +
+
+
+
+
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-events-fired-once-per-frame-across-display-none.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-events-fired-once-per-frame-across-display-none.html new file mode 100644 index 000000000..634853a0e --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll-events-fired-once-per-frame-across-display-none.html @@ -0,0 +1,51 @@ + + +Only one scroll / scrollend event is fired per frame, even if the scroller is hidden and shown again in between scrolls + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollIntoView-in-onscroll-to-sticky.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollIntoView-in-onscroll-to-sticky.html new file mode 100644 index 000000000..fd8c7af40 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollIntoView-in-onscroll-to-sticky.html @@ -0,0 +1,63 @@ + + + + + + + + + + +
+
+
+
+
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll_support.js b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll_support.js new file mode 100644 index 000000000..2baeabd43 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scroll_support.js @@ -0,0 +1,388 @@ +async function waitForEvent(eventName, test, target, timeoutMs = 500) { + return new Promise((resolve, reject) => { + const timeoutCallback = test.step_timeout(() => { + reject(`No ${eventName} event received for target ${target}`); + }, timeoutMs); + target.addEventListener(eventName, (evt) => { + clearTimeout(timeoutCallback); + resolve(evt); + }, { once: true }); + }); +} + +async function waitForScrollendEvent(test, target, timeoutMs = 500) { + return waitForEvent("scrollend", test, target, timeoutMs); +} + +async function waitForScrollendEventNoTimeout(target) { + return new Promise((resolve) => { + target.addEventListener("scrollend", resolve); + }); +} + +// Waits until a rAF callback with no "scroll" event in the last 200ms. +function waitForDelayWithoutScrollEvent(eventTarget) { + const TIMEOUT_IN_MS = 200; + + return new Promise(resolve => { + let lastScrollEventTime = performance.now(); + + const scrollListener = () => { + lastScrollEventTime = performance.now(); + }; + eventTarget.addEventListener('scroll', scrollListener); + + const tick = () => { + if (performance.now() - lastScrollEventTime > TIMEOUT_IN_MS) { + eventTarget.removeEventListener('scroll', scrollListener); + resolve(); + return; + } + requestAnimationFrame(tick); // wait another frame + } + requestAnimationFrame(tick); + }); +} + +// Waits for the end of scrolling. Uses the "scrollend" event if available. +// Otherwise, fall backs to waitForDelayWithoutScrollEvent(). +function waitForScrollEndFallbackToDelayWithoutScrollEvent(eventTargets) { + return new Promise(resolve => { + if (!Array.isArray(eventTargets)) { + eventTargets = [eventTargets]; + } + let listeners = []; + const cleanup = () => { + for (const [eventTarget, eventName, listener] of listeners) { + eventTarget.removeEventListener(eventName, listener); + } + listeners = []; + } + const addListener = (eventTarget, eventName, listener) => { + listeners.push([eventTarget, eventName, listener]); + eventTarget.addEventListener(eventName, listener); + } + if (window.onscrollend !== undefined) { + // If scrollend is supported, wait for the first scrollend event. + for (const eventTarget of eventTargets) { + addListener(eventTarget, 'scrollend', () => { + cleanup(); + resolve(eventTarget); + }); + } + } else { + // Otherwise, wait for the first scroll event, then wait until that + // scroller finishes scrolling. + for (const eventTarget of eventTargets) { + addListener(eventTarget, 'scroll', async () => { + cleanup(); + await waitForDelayWithoutScrollEvent(eventTarget); + resolve(eventTarget); + }); + } + } + }); +} + +// Waits for the end of scrolling, but resolves after the given timeout if no +// scroll event occurs. +function waitForScrollEndOrTimeout(eventTarget, timeout) { + const rafTimeout = new Promise(resolve => { + const startTime = performance.now(); + const tick = () => { + if (performance.now() - startTime >= timeout) { + resolve(); + } else { + requestAnimationFrame(tick); + } + }; + requestAnimationFrame(tick); + }); + + return Promise.race([ + waitForScrollEndFallbackToDelayWithoutScrollEvent(eventTarget), + rafTimeout + ]); +} + +async function waitForPointercancelEvent(test, target, timeoutMs = 500) { + return waitForEvent("pointercancel", test, target, timeoutMs); +} + +// Resets the scroll position to (0,0). If a scroll is required, then the +// promise is not resolved until the scrollend event is received. +async function waitForScrollReset(test, scroller, x = 0, y = 0) { + return new Promise(resolve => { + if (scroller.scrollLeft == x && scroller.scrollTop == y) { + resolve(); + } else { + const eventTarget = + scroller == document.scrollingElement ? document : scroller; + scroller.scrollTo(x, y); + waitForScrollendEventNoTimeout(eventTarget).then(resolve); + } + }); +} + +async function createScrollendPromiseForTarget(test, + target_div, + timeoutMs = 500, + targetIsRoot = false) { + return waitForScrollendEvent(test, target_div, timeoutMs).then(evt => { + assert_false(evt.cancelable, 'Event is not cancelable'); + if (targetIsRoot) { + assert_true(evt.bubbles, 'Event targeting element does not bubble'); + } else { + assert_false(evt.bubbles, 'Event targeting element does not bubble'); + } + }); +} + +function verifyNoScrollendOnDocument(test) { + const callback = + test.unreached_func("window got unexpected scrollend event."); + window.addEventListener('scrollend', callback); + test.add_cleanup(() => { + window.removeEventListener('scrollend', callback); + }); +} + +async function verifyScrollStopped(test, target_div) { + const unscaled_pause_time_in_ms = 100; + const x = target_div.scrollLeft; + const y = target_div.scrollTop; + return new Promise(resolve => { + test.step_timeout(() => { + assert_equals(target_div.scrollLeft, x); + assert_equals(target_div.scrollTop, y); + resolve(); + }, unscaled_pause_time_in_ms); + }); +} + +async function resetTargetScrollState(test, target_div) { + if (target_div.scrollTop != 0 || target_div.scrollLeft != 0) { + target_div.scrollTop = 0; + target_div.scrollLeft = 0; + return waitForScrollendEvent(test, target_div); + } +} + +const MAX_FRAME = 700; +const MAX_UNCHANGED_FRAMES = 20; + +// Returns a promise that resolves when the given condition is met or rejects +// after MAX_FRAME animation frames. +// TODO(crbug.com/1400399): deprecate. We should not use frame based waits in +// WPT as frame rates may vary greatly in different testing environments. +function waitFor(condition, error_message = 'Reaches the maximum frames.') { + return new Promise((resolve, reject) => { + function tick(frames) { + // We requestAnimationFrame either for MAX_FRAM frames or until condition + // is met. + if (frames >= MAX_FRAME) + reject(error_message); + else if (condition()) + resolve(); + else + requestAnimationFrame(tick.bind(this, frames + 1)); + } + tick(0); + }); +} + +// TODO(crbug.com/1400446): Test driver should defer sending events until the +// browser is ready. Also the term compositor-commit is misleading as not all +// user-agents use a compositor process. +function waitForCompositorCommit() { + return new Promise((resolve) => { + // rAF twice. + window.requestAnimationFrame(() => { + window.requestAnimationFrame(resolve); + }); + }); +} + +// Please don't remove this. This is necessary for chromium-based browsers. It +// can be a no-op on user-agents that do not have a separate compositor thread. +// TODO(crbug.com/1509054): This shouldn't be necessary if the test harness +// deferred running the tests until after paint holding. +async function waitForCompositorReady() { + const animation = + document.body.animate({ opacity: [ 0, 1 ] }, {duration: 1 }); + return animation.finished; +} + +function waitForNextFrame() { + const startTime = performance.now(); + return new Promise(resolve => { + window.requestAnimationFrame((frameTime) => { + if (frameTime < startTime) { + window.requestAnimationFrame(resolve); + } else { + resolve(); + } + }); + }); +} + +// TODO(crbug.com/1400399): Deprecate as frame rates may vary greatly in +// different test environments. +function waitForAnimationEnd(getValue) { + var last_changed_frame = 0; + var last_position = getValue(); + return new Promise((resolve, reject) => { + function tick(frames) { + // We requestAnimationFrame either for MAX_FRAME or until + // MAX_UNCHANGED_FRAMES with no change have been observed. + if (frames >= MAX_FRAME || frames - last_changed_frame > MAX_UNCHANGED_FRAMES) { + resolve(); + } else { + current_value = getValue(); + if (last_position != current_value) { + last_changed_frame = frames; + last_position = current_value; + } + requestAnimationFrame(tick.bind(this, frames + 1)); + } + } + tick(0); + }) +} + +// Scrolls in target according to move_path with pauses in between +// The move_path should contains coordinates that are within target boundaries. +// Keep in mind that 0,0 is the center of the target element and is also +// the pointerDown position. +// pointerUp() is fired after sequence of moves. +function touchScrollInTargetSequentiallyWithPause(target, move_path, pause_time_in_ms = 100) { + const test_driver_actions = new test_driver.Actions() + .addPointer("pointer1", "touch") + .pointerMove(0, 0, {origin: target}) + .pointerDown(); + + const substeps = 5; + let x = 0; + let y = 0; + // Do each move in 5 steps + for(let move of move_path) { + let step_x = (move.x - x) / substeps; + let step_y = (move.y - y) / substeps; + for(let step = 0; step < substeps; step++) { + x += step_x; + y += step_y; + test_driver_actions.pointerMove(x, y, {origin: target}); + } + test_driver_actions.pause(pause_time_in_ms); // To prevent inertial scroll + } + + return test_driver_actions.pointerUp().send(); +} + +function touchScrollInTarget(pixels_to_scroll, target, direction, pause_time_in_ms = 100) { + var x_delta = 0; + var y_delta = 0; + const num_movs = 5; + if (direction == "down") { + y_delta = -1 * pixels_to_scroll / num_movs; + } else if (direction == "up") { + y_delta = pixels_to_scroll / num_movs; + } else if (direction == "right") { + x_delta = -1 * pixels_to_scroll / num_movs; + } else if (direction == "left") { + x_delta = pixels_to_scroll / num_movs; + } else { + throw("scroll direction '" + direction + "' is not expected, direction should be 'down', 'up', 'left' or 'right'"); + } + return new test_driver.Actions() + .addPointer("pointer1", "touch") + .pointerMove(0, 0, {origin: target}) + .pointerDown() + .pointerMove(x_delta, y_delta, {origin: target}) + .pointerMove(2 * x_delta, 2 * y_delta, {origin: target}) + .pointerMove(3 * x_delta, 3 * y_delta, {origin: target}) + .pointerMove(4 * x_delta, 4 * y_delta, {origin: target}) + .pointerMove(5 * x_delta, 5 * y_delta, {origin: target}) + .pause(pause_time_in_ms) + .pointerUp() + .send(); +} + +// Trigger fling by doing pointerUp right after pointerMoves. +function touchFlingInTarget(pixels_to_scroll, target, direction) { + return touchScrollInTarget(pixels_to_scroll, target, direction, 0 /* pause_time */); +} + +function mouseActionsInTarget(target, origin, delta, pause_time_in_ms = 100) { + return new test_driver.Actions() + .addPointer("pointer1", "mouse") + .pointerMove(origin.x, origin.y, { origin: target }) + .pointerDown() + .pointerMove(origin.x + delta.x, origin.y + delta.y, { origin: target }) + .pointerMove(origin.x + delta.x * 2, origin.y + delta.y * 2, { origin: target }) + .pause(pause_time_in_ms) + .pointerUp() + .send(); +} + +// Returns a promise that resolves when the given condition holds for 10 +// animation frames or rejects if the condition changes to false within 10 +// animation frames. +// TODO(crbug.com/1400399): Deprecate as frame rates may very greatly in +// different test environments. +function conditionHolds(condition, error_message = 'Condition is not true anymore.') { + const MAX_FRAME = 10; + return new Promise((resolve, reject) => { + function tick(frames) { + // We requestAnimationFrame either for 10 frames or until condition is + // violated. + if (frames >= MAX_FRAME) + resolve(); + else if (!condition()) + reject(error_message); + else + requestAnimationFrame(tick.bind(this, frames + 1)); + } + tick(0); + }); +} + +function scrollElementDown(element, scroll_amount) { + let x = 0; + let y = 0; + let delta_x = 0; + let delta_y = scroll_amount; + let actions = new test_driver.Actions() + .scroll(x, y, delta_x, delta_y, {origin: element}); + return actions.send(); +} + +function scrollElementLeft(element, scroll_amount) { + let x = 0; + let y = 0; + let delta_x = scroll_amount; + let delta_y = 0; + let actions = new test_driver.Actions() + .scroll(x, y, delta_x, delta_y, {origin: element}); + return actions.send(); +} + +async function scrollElementByKeyboard(key) { + const KEY_CODE_MAP = { + 'ArrowLeft': '\uE012', + 'ArrowUp': '\uE013', + 'ArrowRight': '\uE014', + 'ArrowDown': '\uE015', + }; + + if (!KEY_CODE_MAP.hasOwnProperty(key)) { + return Promise.reject(`Invalid key for scrollElementByKeyboard: ${key}`); + } + const code = KEY_CODE_MAP[key]; + for (let i = 0; i < 10; i++) { + await new test_driver.Actions() + .keyDown(code) + .keyUp(code) + .send(); + } +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-instant-scroll-in-microtask.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-instant-scroll-in-microtask.html new file mode 100644 index 000000000..d4a683b75 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-instant-scroll-in-microtask.html @@ -0,0 +1,51 @@ + + +Scrollend should fire after scroll instant scrolling triggered in promise microtask + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-layout-clamping.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-layout-clamping.html new file mode 100644 index 000000000..2877a4beb --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-layout-clamping.html @@ -0,0 +1,49 @@ + + +Scrollend event fires after layout scroll clamping + + + + + +
+
+
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-sequence-of-scrolls.tentative.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-sequence-of-scrolls.tentative.html new file mode 100644 index 000000000..dab6dcc9b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-sequence-of-scrolls.tentative.html @@ -0,0 +1,91 @@ + + + + + + + + + + + +
+
+
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-snap.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-snap.html new file mode 100644 index 000000000..03079ddc6 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-after-snap.html @@ -0,0 +1,87 @@ + + + + + + + + + + + +
+
+
+
+
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-mandatory-snap-point-after-load.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-mandatory-snap-point-after-load.html new file mode 100644 index 000000000..f37911342 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-mandatory-snap-point-after-load.html @@ -0,0 +1,87 @@ + + + + + + + + + + + + scrollend + mandatory scroll snap test + + + + + + + + + + + \ No newline at end of file diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-programmatic-scroll.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-programmatic-scroll.html new file mode 100644 index 000000000..a958ff675 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-programmatic-scroll.html @@ -0,0 +1,139 @@ + + + + + + + + + + + + + + + + + + + + +
+
+
+
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-scroll-attr-change.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-scroll-attr-change.html new file mode 100644 index 000000000..0e59aba17 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-scroll-attr-change.html @@ -0,0 +1,138 @@ + + + + + + + + + + + + + + + + + + + + +
+
+
+
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-scrollIntoView.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-scrollIntoView.html new file mode 100644 index 000000000..e3e63f282 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-for-scrollIntoView.html @@ -0,0 +1,199 @@ + + + + + + + + + + + + + + + + + + +
+
+
+
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-to-document.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-to-document.html new file mode 100644 index 000000000..797c2eb53 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-to-document.html @@ -0,0 +1,106 @@ + + + + + + + + + + + +
+
+
+
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-to-element-with-overscroll-behavior.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-to-element-with-overscroll-behavior.html new file mode 100644 index 000000000..edda88e7c --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-to-element-with-overscroll-behavior.html @@ -0,0 +1,173 @@ + + + + + + + + + + + +
+
+
+
+
+
+
+
+
+ +
+
+
+
+
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-to-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-to-window.html new file mode 100644 index 000000000..d2fd6f4d3 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fired-to-window.html @@ -0,0 +1,69 @@ + + + + + + + + + + + +
+
+
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-for-repeat-key-ending-after-scroll-container-end-is-reached.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-for-repeat-key-ending-after-scroll-container-end-is-reached.html new file mode 100644 index 000000000..33c2b1312 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-for-repeat-key-ending-after-scroll-container-end-is-reached.html @@ -0,0 +1,71 @@ + + + + + + + + + + + + + + +
+
+
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-on-visual-viewport.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-on-visual-viewport.html new file mode 100644 index 000000000..841931a7c --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-on-visual-viewport.html @@ -0,0 +1,100 @@ + + + + + + + + + + + + + + +
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-to-iframe-inner-frame.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-to-iframe-inner-frame.html new file mode 100644 index 000000000..115e583c0 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-to-iframe-inner-frame.html @@ -0,0 +1,30 @@ + + + + +
+
+
+
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-to-iframe-window.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-to-iframe-window.html new file mode 100644 index 000000000..d90203e28 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-fires-to-iframe-window.html @@ -0,0 +1,77 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-for-user-scroll.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-for-user-scroll.html new file mode 100644 index 000000000..a06843a35 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-for-user-scroll.html @@ -0,0 +1,64 @@ + + + + + + + + + + + + + + +
+
+
+
+ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-handler-content-attributes.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-handler-content-attributes.html new file mode 100644 index 000000000..47f563c39 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-handler-content-attributes.html @@ -0,0 +1,108 @@ + + + + + + + + + + + +
+
+
+
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-not-fired-after-removing-scroller.tentative.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-not-fired-after-removing-scroller.tentative.html new file mode 100644 index 000000000..95447fbd1 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-not-fired-after-removing-scroller.tentative.html @@ -0,0 +1,84 @@ + + + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-not-fired-on-no-scroll.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-not-fired-on-no-scroll.html new file mode 100644 index 000000000..761574605 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-event-not-fired-on-no-scroll.html @@ -0,0 +1,115 @@ + + + + + + + + + + + +
+ + +
+
+ +
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-fires-to-text-input.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-fires-to-text-input.html new file mode 100644 index 000000000..540fa730b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-fires-to-text-input.html @@ -0,0 +1,99 @@ + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-user-scroll-common.js b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-user-scroll-common.js new file mode 100644 index 000000000..1b6372338 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-user-scroll-common.js @@ -0,0 +1,150 @@ + +async function test_scrollend_on_touch_drag(t, target_div) { + // Skip the test on a Mac as they do not support touch screens. + const isMac = navigator.platform.toUpperCase().indexOf('MAC') >= 0; + if (isMac) + return; + + await resetTargetScrollState(t, target_div); + await waitForCompositorReady(); + + const targetScrollendPromise = waitForScrollendEventNoTimeout(target_div); + verifyNoScrollendOnDocument(t); + + let scrollend_count = 0; + const scrollend_listener = () => { + scrollend_count += 1; + }; + target_div.addEventListener("scrollend", scrollend_listener); + t.add_cleanup(() => { + target_div.removeEventListener('scrollend', scrollend_listener); + }); + + // Perform a touch drag on target div and wait for target_div to get + // a scrollend event. + await new test_driver.Actions() + .addPointer('TestPointer', 'touch') + .pointerMove(0, 0, { origin: target_div }) // 0, 0 is center of element. + .pointerDown() + .addTick() + .pointerMove(0, -40, { origin: target_div }) // Drag up to move down. + .addTick() + .pause(200) // Prevent inertial scroll. + .pointerMove(0, -60, { origin: target_div }) + .addTick() + .pause(200) // Prevent inertial scroll. + .pointerUp() + .send(); + + await targetScrollendPromise; + + assert_true(target_div.scrollTop > 0); + await verifyScrollStopped(t, target_div); + assert_equals(scrollend_count, 1); +} + +async function test_scrollend_on_scrollbar_gutter_click(t, target_div) { + // Skip test on platforms that do not have a visible scrollbar (e.g. + // overlay scrollbar). + const scrollbar_width = target_div.offsetWidth - target_div.clientWidth; + if (scrollbar_width == 0) + return; + + await resetTargetScrollState(t, target_div); + await waitForCompositorReady(); + + const targetScrollendPromise = waitForScrollendEventNoTimeout(target_div); + verifyNoScrollendOnDocument(t); + + const bounds = target_div.getBoundingClientRect(); + // Some versions of webdriver have been known to frown at non-int arguments + // to pointerMove. + const x = Math.round(bounds.right - scrollbar_width / 2); + const y = Math.round(bounds.bottom - 20); + await new test_driver.Actions() + .addPointer('TestPointer', 'mouse') + .pointerMove(x, y, { origin: 'viewport' }) + .pointerDown() + .addTick() + .pointerUp() + .send(); + + await targetScrollendPromise; + assert_true(target_div.scrollTop > 0); + await verifyScrollStopped(t, target_div); +} + +// Same issue as previous test. +async function test_scrollend_on_scrollbar_thumb_drag(t, target_div) { + // Skip test on platforms that do not have a visible scrollbar (e.g. + // overlay scrollbar). + const scrollbar_width = target_div.offsetWidth - target_div.clientWidth; + if (scrollbar_width == 0) + return; + + await resetTargetScrollState(t, target_div); + await waitForCompositorReady(); + + const targetScrollendPromise = waitForScrollendEventNoTimeout(target_div); + verifyNoScrollendOnDocument(t); + + const bounds = target_div.getBoundingClientRect(); + // Some versions of webdriver have been known to frown at non-int arguments + // to pointerMove. + const x = Math.round(bounds.right - scrollbar_width / 2); + const y = Math.round(bounds.top + 30); + const dy = 30; + await new test_driver.Actions() + .addPointer('TestPointer', 'mouse') + .pointerMove(x, y, { origin: 'viewport' }) + .pointerDown() + .pointerMove(x, y + dy, { origin: 'viewport' }) + .addTick() + .pointerUp() + .send(); + + await targetScrollendPromise; + assert_true(target_div.scrollTop > 0); + await verifyScrollStopped(t, target_div); +} + +async function test_scrollend_on_mousewheel_scroll(t, target_div, frame) { + await resetTargetScrollState(t, target_div); + await waitForCompositorReady(); + + const targetScrollendPromise = waitForScrollendEventNoTimeout(target_div); + verifyNoScrollendOnDocument(t); + + let scroll_origin = target_div; + if (frame) { + // chromedriver doesn't support passing { origin: element } + // for an element within a subframe. Use the frame element itself. + scroll_origin = frame; + } + const x = 0; + const y = 0; + const dx = 0; + const dy = 40; + await new test_driver.Actions() + .scroll(x, y, dx, dy, { origin: scroll_origin }) + .send(); + + await targetScrollendPromise; + assert_true(target_div.scrollTop > 0); + await verifyScrollStopped(t, target_div); +} + +async function test_scrollend_on_keyboard_scroll(t, target_div) { + await resetTargetScrollState(t, target_div); + await waitForCompositorReady(); + + verifyNoScrollendOnDocument(t); + const targetScrollendPromise = waitForScrollendEventNoTimeout(target_div); + + target_div.focus(); + window.test_driver.send_keys(target_div, '\ue015'); + + await targetScrollendPromise; + assert_true(target_div.scrollTop > 0); + await verifyScrollStopped(t, target_div); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-with-snap-on-fractional-offset.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-with-snap-on-fractional-offset.html new file mode 100644 index 000000000..d1f50304a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/scrollend-with-snap-on-fractional-offset.html @@ -0,0 +1,85 @@ + + + + + + + +
+
1
+
2
+
3
+
+ + + \ No newline at end of file diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/visibility-hidden-scrolls.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/visibility-hidden-scrolls.html new file mode 100644 index 000000000..b5d325a5a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/visibility-hidden-scrolls.html @@ -0,0 +1,88 @@ + + + + + + + + + + + + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-composed.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-composed.html new file mode 100644 index 000000000..6c6a162ce --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-composed.html @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-no-scroll-after-prevent-default.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-no-scroll-after-prevent-default.html new file mode 100644 index 000000000..bd9f523e9 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-no-scroll-after-prevent-default.html @@ -0,0 +1,61 @@ + + + + +Ensure that the calling `preventDefault` on a wheel event prevents a scroll from happening + + + + + + + + + +
+
+
+
+ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-basic.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-basic.html new file mode 100644 index 000000000..1b9df69ec --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-basic.html @@ -0,0 +1,140 @@ + + + + + + + + + + + + + + + + + + +
+
+
+
+
+
+
+
+
+
+ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-multiple-action-chains.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-multiple-action-chains.html new file mode 100644 index 000000000..3b46b2f99 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-multiple-action-chains.html @@ -0,0 +1,101 @@ + + + + + + + + + + + + + + +
+
+ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-display-change.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-display-change.html new file mode 100644 index 000000000..6ca3c78b7 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-display-change.html @@ -0,0 +1,100 @@ + + + + + + + + + + + + + + + + + +
+
+
+ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-elements.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-elements.html new file mode 100644 index 000000000..0109b7b6b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-elements.html @@ -0,0 +1,74 @@ + + + + + + + + + + + + + + + +
X
+
+ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-move.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-move.html new file mode 100644 index 000000000..a739d1cd5 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-move.html @@ -0,0 +1,85 @@ + + + + + + + + + + + + + + +
+
+
+ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-removal.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-removal.html new file mode 100644 index 000000000..c25a30a3d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-removal.html @@ -0,0 +1,92 @@ + + + + + + + + + + + + + + +
+
+
+ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-resize.html b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-resize.html new file mode 100644 index 000000000..eb7431fca --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/scrolling/wheel-event-transactions-target-resize.html @@ -0,0 +1,97 @@ + + + + + + + + + + + + + + + + + +
+
+
+ + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/shadow-relatedTarget.html b/crates/clazel-web/tests/data/wpt-web/dom/events/shadow-relatedTarget.html new file mode 100644 index 000000000..713555b7d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/shadow-relatedTarget.html @@ -0,0 +1,30 @@ + + + + +
+ + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-animation-end-event.html b/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-animation-end-event.html new file mode 100644 index 000000000..4186f6b7a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-animation-end-event.html @@ -0,0 +1,20 @@ + + +Prefixed CSS Animation end events + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-animation-iteration-event.html b/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-animation-iteration-event.html new file mode 100644 index 000000000..fb251972a --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-animation-iteration-event.html @@ -0,0 +1,23 @@ + + +Prefixed CSS Animation iteration events + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-animation-start-event.html b/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-animation-start-event.html new file mode 100644 index 000000000..ad1036644 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-animation-start-event.html @@ -0,0 +1,20 @@ + + +Prefixed CSS Animation start events + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-transition-end-event.html b/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-transition-end-event.html new file mode 100644 index 000000000..2741824e3 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/webkit-transition-end-event.html @@ -0,0 +1,21 @@ + + +Prefixed CSS Transition End event + + + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/window-composed-path.html b/crates/clazel-web/tests/data/wpt-web/dom/events/window-composed-path.html new file mode 100644 index 000000000..2411f87f2 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/window-composed-path.html @@ -0,0 +1,20 @@ + +Window: Event.composedPath() + + + + + + \ No newline at end of file diff --git a/crates/clazel-web/tests/data/wpt-web/dom/events/window-event-restored-after-throwing-onerror.html b/crates/clazel-web/tests/data/wpt-web/dom/events/window-event-restored-after-throwing-onerror.html new file mode 100644 index 000000000..4ad444009 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/events/window-event-restored-after-throwing-onerror.html @@ -0,0 +1,34 @@ + + +window.event is restored after a throwing window.onerror handler + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/Attr-prefix-xhtml.xhtml b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Attr-prefix-xhtml.xhtml new file mode 100644 index 000000000..04c046b72 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Attr-prefix-xhtml.xhtml @@ -0,0 +1,40 @@ + + + +Attr.prefix + + + + + +
+
+ + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/Attr-prefix.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Attr-prefix.html new file mode 100644 index 000000000..840b79d35 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Attr-prefix.html @@ -0,0 +1,91 @@ + + +Attr.prefix + + + +
+
+ + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-appendChild.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-appendChild.html new file mode 100644 index 000000000..eb4f36c68 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-appendChild.html @@ -0,0 +1,34 @@ + + +Node.appendChild applied to CharacterData + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-appendData.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-appendData.html new file mode 100644 index 000000000..a5d407224 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-appendData.html @@ -0,0 +1,70 @@ + + +CharacterData.appendData + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-data.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-data.html new file mode 100644 index 000000000..b3b29ea4d --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-data.html @@ -0,0 +1,82 @@ + + +CharacterData.data + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-deleteData.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-deleteData.html new file mode 100644 index 000000000..84f4d5b41 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-deleteData.html @@ -0,0 +1,95 @@ + + +CharacterData.deleteData + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-insertData.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-insertData.html new file mode 100644 index 000000000..62c0ca101 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-insertData.html @@ -0,0 +1,90 @@ + + +CharacterData.insertData + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-remove.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-remove.html new file mode 100644 index 000000000..aef9d56bf --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-remove.html @@ -0,0 +1,24 @@ + + +CharacterData.remove + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-replaceData.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-replaceData.html new file mode 100644 index 000000000..537751d83 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-replaceData.html @@ -0,0 +1,163 @@ + + +CharacterData.replaceData + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-substringData.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-substringData.html new file mode 100644 index 000000000..b35352648 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-substringData.html @@ -0,0 +1,137 @@ + + +CharacterData.substringData + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-surrogates.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-surrogates.html new file mode 100644 index 000000000..ff1014c5f --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/CharacterData-surrogates.html @@ -0,0 +1,74 @@ + + +Splitting and joining surrogate pairs in CharacterData methods + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-after.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-after.html new file mode 100644 index 000000000..b5bf7ab5c --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-after.html @@ -0,0 +1,166 @@ + + +ChildNode.after + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-before.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-before.html new file mode 100644 index 000000000..865942446 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-before.html @@ -0,0 +1,166 @@ + + +ChildNode.before + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-remove.js b/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-remove.js new file mode 100644 index 000000000..c36ba0d11 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-remove.js @@ -0,0 +1,30 @@ +function testRemove(node, parent, type) { + test(function() { + assert_true("remove" in node); + assert_equals(typeof node.remove, "function"); + assert_equals(node.remove.length, 0); + }, type + " should support remove()"); + test(function() { + assert_equals(node.parentNode, null, "Node should not have a parent"); + assert_equals(node.remove(), undefined); + assert_equals(node.parentNode, null, "Removed new node should not have a parent"); + }, "remove() should work if " + type + " doesn't have a parent"); + test(function() { + assert_equals(node.parentNode, null, "Node should not have a parent"); + parent.appendChild(node); + assert_equals(node.parentNode, parent, "Appended node should have a parent"); + assert_equals(node.remove(), undefined); + assert_equals(node.parentNode, null, "Removed node should not have a parent"); + assert_array_equals(parent.childNodes, [], "Parent should not have children"); + }, "remove() should work if " + type + " does have a parent"); + test(function() { + assert_equals(node.parentNode, null, "Node should not have a parent"); + var before = parent.appendChild(document.createComment("before")); + parent.appendChild(node); + var after = parent.appendChild(document.createComment("after")); + assert_equals(node.parentNode, parent, "Appended node should have a parent"); + assert_equals(node.remove(), undefined); + assert_equals(node.parentNode, null, "Removed node should not have a parent"); + assert_array_equals(parent.childNodes, [before, after], "Parent should have two children left"); + }, "remove() should work if " + type + " does have a parent and siblings"); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-replaceWith.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-replaceWith.html new file mode 100644 index 000000000..aab8b17f2 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/ChildNode-replaceWith.html @@ -0,0 +1,110 @@ + + +ChildNode.replaceWith + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/Comment-Text-constructor.js b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Comment-Text-constructor.js new file mode 100644 index 000000000..24b4425f4 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Comment-Text-constructor.js @@ -0,0 +1,77 @@ +function test_constructor(ctor) { + test(function() { + var object = new window[ctor](); + assert_equals(Object.getPrototypeOf(object), + window[ctor].prototype, "Prototype chain: " + ctor); + assert_equals(Object.getPrototypeOf(Object.getPrototypeOf(object)), + CharacterData.prototype, "Prototype chain: CharacterData"); + assert_equals(Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(object))), + Node.prototype, "Prototype chain: Node"); + }, "new " + ctor + "(): prototype chain"); + + test(function() { + var object = new window[ctor](); + assert_true(object instanceof Node, "Should be a Node"); + assert_true(object instanceof CharacterData, "Should be a CharacterData"); + assert_true(object instanceof window[ctor], "Should be a " + ctor); + }, "new " + ctor + "(): instanceof"); + + test(function() { + var object = new window[ctor](); + assert_equals(object.data, ""); + assert_equals(object.nodeValue, ""); + assert_equals(object.ownerDocument, document); + }, "new " + ctor + "(): no arguments"); + + var testArgs = [ + [undefined, ""], + [null, "null"], + [42, "42"], + ["", ""], + ["-", "-"], + ["--", "--"], + ["-->", "-->"], + ["]> + + XML: Comment in doctype internal subset + + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocument-no-browsing-context.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocument-no-browsing-context.html new file mode 100644 index 000000000..f0da33fa8 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocument-no-browsing-context.html @@ -0,0 +1,53 @@ + + +DOMImplementation.createDocument: documents without a browsing context + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocument-with-null-browsing-context-crash.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocument-with-null-browsing-context-crash.html new file mode 100644 index 000000000..c9393d0a0 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocument-with-null-browsing-context-crash.html @@ -0,0 +1,13 @@ + + +DOMImplementation.createDocument() + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocument.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocument.html new file mode 100644 index 000000000..7dc29d8e7 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocument.html @@ -0,0 +1,172 @@ + + +DOMImplementation.createDocument(namespace, qualifiedName, doctype) + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocumentType.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocumentType.html new file mode 100644 index 000000000..f103a8da3 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createDocumentType.html @@ -0,0 +1,123 @@ + + +DOMImplementation.createDocumentType(qualifiedName, publicId, systemId) + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument-with-null-browsing-context-crash.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument-with-null-browsing-context-crash.html new file mode 100644 index 000000000..d0cd6f1f7 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument-with-null-browsing-context-crash.html @@ -0,0 +1,13 @@ + + +DOMImplementation.createHTMLDocument() + + + + + + diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument-with-saved-implementation.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument-with-saved-implementation.html new file mode 100644 index 000000000..bae22660b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument-with-saved-implementation.html @@ -0,0 +1,16 @@ + +DOMImplementation.createHTMLDocument + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument.html new file mode 100644 index 000000000..c6e0beaf7 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument.html @@ -0,0 +1,96 @@ + + + +DOMImplementation.createHTMLDocument + + + + + + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument.js b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument.js new file mode 100644 index 000000000..3e7e9aa9b --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-createHTMLDocument.js @@ -0,0 +1,25 @@ +function createHTMLDocuments(checkDoc) { + var tests = [ + ["", "", ""], + [null, "null", "null"], + [undefined, undefined, ""], + ["foo bar baz", "foo bar baz", "foo bar baz"], + ["foo\t\tbar baz", "foo\t\tbar baz", "foo bar baz"], + ["foo\n\nbar baz", "foo\n\nbar baz", "foo bar baz"], + ["foo\f\fbar baz", "foo\f\fbar baz", "foo bar baz"], + ["foo\r\rbar baz", "foo\r\rbar baz", "foo bar baz"], + ] + + tests.forEach(function(t, i) { + var title = t[0], expectedtitle = t[1], normalizedtitle = t[2] + test(function() { + var doc = document.implementation.createHTMLDocument(title); + checkDoc(doc, expectedtitle, normalizedtitle) + }, "createHTMLDocument test " + i + ": " + t.map(function(el) { return format_value(el) })) + }) + + test(function() { + var doc = document.implementation.createHTMLDocument(); + checkDoc(doc, undefined, "") + }, "Missing title argument"); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-hasFeature.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-hasFeature.html new file mode 100644 index 000000000..637565a60 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/DOMImplementation-hasFeature.html @@ -0,0 +1,155 @@ + + +DOMImplementation.hasFeature(feature, version) + + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-Element-getElementsByTagName.js b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-Element-getElementsByTagName.js new file mode 100644 index 000000000..dbbe667ff --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-Element-getElementsByTagName.js @@ -0,0 +1,208 @@ +function test_getElementsByTagName(context, element) { + // TODO: getElementsByTagName("*") + test(function() { + assert_false(context.getElementsByTagName("html") instanceof NodeList, + "Should not return a NodeList") + assert_true(context.getElementsByTagName("html") instanceof HTMLCollection, + "Should return an HTMLCollection") + }, "Interfaces") + + test(function() { + var firstCollection = context.getElementsByTagName("html"), + secondCollection = context.getElementsByTagName("html") + assert_true(firstCollection !== secondCollection || + firstCollection === secondCollection) + }, "Caching is allowed") + + test(function() { + var l = context.getElementsByTagName("nosuchtag") + l[5] = "foopy" + assert_equals(l[5], undefined) + assert_equals(l.item(5), null) + }, "Shouldn't be able to set unsigned properties on a HTMLCollection (non-strict mode)") + + test(function() { + var l = context.getElementsByTagName("nosuchtag") + assert_throws_js(TypeError, function() { + "use strict"; + l[5] = "foopy" + }) + assert_equals(l[5], undefined) + assert_equals(l.item(5), null) + }, "Shouldn't be able to set unsigned properties on a HTMLCollection (strict mode)") + + test(function() { + var l = context.getElementsByTagName("nosuchtag") + var fn = l.item; + assert_equals(fn, HTMLCollection.prototype.item); + l.item = "pass" + assert_equals(l.item, "pass") + assert_equals(HTMLCollection.prototype.item, fn); + }, "Should be able to set expando shadowing a proto prop (item)") + + test(function() { + var l = context.getElementsByTagName("nosuchtag") + var fn = l.namedItem; + assert_equals(fn, HTMLCollection.prototype.namedItem); + l.namedItem = "pass" + assert_equals(l.namedItem, "pass") + assert_equals(HTMLCollection.prototype.namedItem, fn); + }, "Should be able to set expando shadowing a proto prop (namedItem)") + + test(function() { + var t1 = element.appendChild(document.createElement("pre")); + t1.id = "x"; + var t2 = element.appendChild(document.createElement("pre")); + t2.setAttribute("name", "y"); + var t3 = element.appendChild(document.createElementNS("", "pre")); + t3.setAttribute("id", "z"); + var t4 = element.appendChild(document.createElementNS("", "pre")); + t4.setAttribute("name", "w"); + this.add_cleanup(function() { + element.removeChild(t1) + element.removeChild(t2) + element.removeChild(t3) + element.removeChild(t4) + }); + + var list = context.getElementsByTagName('pre'); + var pre = list[0]; + assert_equals(pre.id, "x"); + + var exposedNames = { 'x': 0, 'y': 1, 'z': 2 }; + for (var exposedName in exposedNames) { + assert_equals(list[exposedName], list[exposedNames[exposedName]]); + assert_equals(list[exposedName], list.namedItem(exposedName)); + assert_true(exposedName in list, "'" + exposedName + "' in list"); + assert_true(list.hasOwnProperty(exposedName), + "list.hasOwnProperty('" + exposedName + "')"); + } + + var unexposedNames = ["w"]; + for (var unexposedName of unexposedNames) { + assert_false(unexposedName in list); + assert_false(list.hasOwnProperty(unexposedName)); + assert_equals(list[unexposedName], undefined); + assert_equals(list.namedItem(unexposedName), null); + } + + assert_array_equals(Object.getOwnPropertyNames(list).sort(), + ["0", "1", "2", "3", "x", "y", "z"]); + + var desc = Object.getOwnPropertyDescriptor(list, '0'); + assert_equals(typeof desc, "object", "descriptor should be an object"); + assert_true(desc.enumerable, "desc.enumerable"); + assert_true(desc.configurable, "desc.configurable"); + + desc = Object.getOwnPropertyDescriptor(list, 'x'); + assert_equals(typeof desc, "object", "descriptor should be an object"); + assert_false(desc.enumerable, "desc.enumerable"); + assert_true(desc.configurable, "desc.configurable"); + }, "hasOwnProperty, getOwnPropertyDescriptor, getOwnPropertyNames") + + test(function() { + assert_equals(document.createElementNS("http://www.w3.org/1999/xhtml", "i").localName, "i") // Sanity + var t = element.appendChild(document.createElementNS("http://www.w3.org/1999/xhtml", "I")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_equals(t.localName, "I") + assert_equals(t.tagName, "I") + assert_equals(context.getElementsByTagName("I").length, 0) + assert_equals(context.getElementsByTagName("i").length, 0) + }, "HTML element with uppercase tagName never matches in HTML Documents") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "st")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagName("st"), [t]) + assert_array_equals(context.getElementsByTagName("ST"), []) + }, "Element in non-HTML namespace, no prefix, lowercase name") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "ST")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagName("ST"), [t]) + assert_array_equals(context.getElementsByTagName("st"), []) + }, "Element in non-HTML namespace, no prefix, uppercase name") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "te:st")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagName("st"), []) + assert_array_equals(context.getElementsByTagName("ST"), []) + assert_array_equals(context.getElementsByTagName("te:st"), [t]) + assert_array_equals(context.getElementsByTagName("te:ST"), []) + }, "Element in non-HTML namespace, prefix, lowercase name") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "te:ST")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagName("st"), []) + assert_array_equals(context.getElementsByTagName("ST"), []) + assert_array_equals(context.getElementsByTagName("te:st"), []) + assert_array_equals(context.getElementsByTagName("te:ST"), [t]) + }, "Element in non-HTML namespace, prefix, uppercase name") + + test(function() { + var t = element.appendChild(document.createElement("aÇ")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_equals(t.localName, "aÇ") + assert_array_equals(context.getElementsByTagName("AÇ"), [t], "All uppercase input") + assert_array_equals(context.getElementsByTagName("aÇ"), [t], "Ascii lowercase input") + assert_array_equals(context.getElementsByTagName("aç"), [], "All lowercase input") + }, "Element in HTML namespace, no prefix, non-ascii characters in name") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "AÇ")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagName("AÇ"), [t]) + assert_array_equals(context.getElementsByTagName("aÇ"), []) + assert_array_equals(context.getElementsByTagName("aç"), []) + }, "Element in non-HTML namespace, non-ascii characters in name") + + test(function() { + var t = element.appendChild(document.createElementNS("http://www.w3.org/1999/xhtml", "test:aÇ")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagName("TEST:AÇ"), [t], "All uppercase input") + assert_array_equals(context.getElementsByTagName("test:aÇ"), [t], "Ascii lowercase input") + assert_array_equals(context.getElementsByTagName("test:aç"), [], "All lowercase input") + }, "Element in HTML namespace, prefix, non-ascii characters in name") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "TEST:AÇ")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagName("TEST:AÇ"), [t], "All uppercase input") + assert_array_equals(context.getElementsByTagName("test:aÇ"), [], "Ascii lowercase input") + assert_array_equals(context.getElementsByTagName("test:aç"), [], "All lowercase input") + }, "Element in non-HTML namespace, prefix, non-ascii characters in name") + + test(function() { + var actual = context.getElementsByTagName("*"); + var expected = []; + var get_elements = function(node) { + for (var i = 0; i < node.childNodes.length; i++) { + var child = node.childNodes[i]; + if (child.nodeType === child.ELEMENT_NODE) { + expected.push(child); + get_elements(child); + } + } + } + get_elements(context); + assert_array_equals(actual, expected); + }, "getElementsByTagName('*')") + + test(function() { + var t1 = element.appendChild(document.createElement("abc")); + this.add_cleanup(function() {element.removeChild(t1)}); + + var l = context.getElementsByTagName("abc"); + assert_true(l instanceof HTMLCollection); + assert_equals(l.length, 1); + + var t2 = element.appendChild(document.createElement("abc")); + assert_equals(l.length, 2); + + element.removeChild(t2); + assert_equals(l.length, 1); + }, "getElementsByTagName() should be a live collection"); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-Element-getElementsByTagNameNS.js b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-Element-getElementsByTagNameNS.js new file mode 100644 index 000000000..b610c49d8 --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-Element-getElementsByTagNameNS.js @@ -0,0 +1,143 @@ +function test_getElementsByTagNameNS(context, element) { + test(function() { + assert_false(context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "html") instanceof NodeList, "NodeList") + assert_true(context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "html") instanceof HTMLCollection, "HTMLCollection") + var firstCollection = context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "html"), + secondCollection = context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "html") + assert_true(firstCollection !== secondCollection || firstCollection === secondCollection, + "Caching is allowed.") + }) + + test(function() { + var t = element.appendChild(document.createElementNS("test", "body")) + this.add_cleanup(function() {element.removeChild(t)}) + var actual = context.getElementsByTagNameNS("*", "body"); + var expected = []; + var get_elements = function(node) { + for (var i = 0; i < node.childNodes.length; i++) { + var child = node.childNodes[i]; + if (child.nodeType === child.ELEMENT_NODE) { + if (child.localName == "body") { + expected.push(child); + } + get_elements(child); + } + } + } + get_elements(context); + assert_array_equals(actual, expected); + }, "getElementsByTagNameNS('*', 'body')") + + test(function() { + assert_array_equals(context.getElementsByTagNameNS("", "*"), []); + var t = element.appendChild(document.createElementNS("", "body")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagNameNS("", "*"), [t]); + }, "Empty string namespace") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "body")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagNameNS("test", "body"), [t]); + }, "body element in test namespace, no prefix") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "test:body")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagNameNS("test", "body"), [t]); + }, "body element in test namespace, prefix") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "BODY")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagNameNS("test", "BODY"), [t]); + assert_array_equals(context.getElementsByTagNameNS("test", "body"), []); + }, "BODY element in test namespace, no prefix") + + test(function() { + var t = element.appendChild(document.createElementNS("http://www.w3.org/1999/xhtml", "abc")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "abc"), [t]); + assert_array_equals(context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "ABC"), []); + assert_array_equals(context.getElementsByTagNameNS("test", "ABC"), []); + }, "abc element in html namespace") + + test(function() { + var t = element.appendChild(document.createElementNS("http://www.w3.org/1999/xhtml", "ABC")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "abc"), []); + assert_array_equals(context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "ABC"), [t]); + }, "ABC element in html namespace") + + test(function() { + var t = element.appendChild(document.createElementNS("http://www.w3.org/1999/xhtml", "AÇ")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "AÇ"), [t]); + assert_array_equals(context.getElementsByTagNameNS("test", "aÇ"), []); + assert_array_equals(context.getElementsByTagNameNS("test", "aç"), []); + }, "AÇ, case sensitivity") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "test:BODY")) + this.add_cleanup(function() {element.removeChild(t)}) + assert_array_equals(context.getElementsByTagNameNS("test", "BODY"), [t]); + assert_array_equals(context.getElementsByTagNameNS("test", "body"), []); + }, "BODY element in test namespace, prefix") + + test(function() { + var t = element.appendChild(document.createElementNS("test", "test:test")) + this.add_cleanup(function() {element.removeChild(t)}) + var actual = context.getElementsByTagNameNS("http://www.w3.org/1999/xhtml", "*"); + var expected = []; + var get_elements = function(node) { + for (var i = 0; i < node.childNodes.length; i++) { + var child = node.childNodes[i]; + if (child.nodeType === child.ELEMENT_NODE) { + if (child !== t) { + expected.push(child); + } + get_elements(child); + } + } + } + get_elements(context); + assert_array_equals(actual, expected); + }, "getElementsByTagNameNS('http://www.w3.org/1999/xhtml', '*')") + + test(function() { + var actual = context.getElementsByTagNameNS("*", "*"); + var expected = []; + var get_elements = function(node) { + for (var i = 0; i < node.childNodes.length; i++) { + var child = node.childNodes[i]; + if (child.nodeType === child.ELEMENT_NODE) { + expected.push(child); + get_elements(child); + } + } + } + get_elements(context); + assert_array_equals(actual, expected); + }, "getElementsByTagNameNS('*', '*')") + + test(function() { + assert_array_equals(context.getElementsByTagNameNS("**", "*"), []); + assert_array_equals(context.getElementsByTagNameNS(null, "0"), []); + assert_array_equals(context.getElementsByTagNameNS(null, "div"), []); + }, "Empty lists") + + test(function() { + var t1 = element.appendChild(document.createElementNS("test", "abc")); + this.add_cleanup(function() {element.removeChild(t1)}); + + var l = context.getElementsByTagNameNS("test", "abc"); + assert_true(l instanceof HTMLCollection); + assert_equals(l.length, 1); + + var t2 = element.appendChild(document.createElementNS("test", "abc")); + assert_equals(l.length, 2); + + element.removeChild(t2); + assert_equals(l.length, 1); + }, "getElementsByTagNameNS() should be a live collection"); +} diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-URL.html b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-URL.html new file mode 100644 index 000000000..242def1fb --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-URL.html @@ -0,0 +1,18 @@ + + +Document.URL with redirect + + +
+ diff --git a/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-adoptNode-DocumentFragment-with-host.window.js b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-adoptNode-DocumentFragment-with-host.window.js new file mode 100644 index 000000000..b10a325da --- /dev/null +++ b/crates/clazel-web/tests/data/wpt-web/dom/nodes/Document-adoptNode-DocumentFragment-with-host.window.js @@ -0,0 +1,131 @@ +// Tests for adopt() + DocumentFragment-with-host. See whatwg/dom#813, #814. +// +// A DocumentFragment can have a non-null host in two cases: +// - a shadow root (host is the shadow host element), and +// - a template element's content fragment (host is the