asciidisco/asciidisco.com
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
s.golasch
2023-08-01 13:49:46 +02:00
commit 1fc239fd54
20238 changed files with 3112246 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
build/node_modules/prepack/lib/evaluators/SwitchStatement.js generated vendored Normal file
View File

@@ -0,0 +1,285 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); /**
* Copyright (c) 2017-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
exports.default = function (ast, strictCode, env, realm, labelSet) {
var expression = ast.discriminant;
var cases = ast.cases;
// 1. Let exprRef be the result of evaluating Expression.
var exprRef = env.evaluate(expression, strictCode);
// 2. Let switchValue be ? GetValue(exprRef).
var switchValue = _singletons.Environment.GetValue(realm, exprRef);
// 3. Let oldEnv be the running execution context's LexicalEnvironment.
var oldEnv = realm.getRunningContext().lexicalEnvironment;
// 4. Let blockEnv be NewDeclarativeEnvironment(oldEnv).
var blockEnv = _singletons.Environment.NewDeclarativeEnvironment(realm, oldEnv);
// 5. Perform BlockDeclarationInstantiation(CaseBlock, blockEnv).
var CaseBlock = cases.map(function (c) {
return c.consequent;
}).reduce(function (stmts, case_blk) {
return stmts.concat(case_blk);
}, []);
_singletons.Environment.BlockDeclarationInstantiation(realm, strictCode, CaseBlock, blockEnv);
// 6. Set the running execution context's LexicalEnvironment to blockEnv.
realm.getRunningContext().lexicalEnvironment = blockEnv;
var R = void 0;
try {
// 7. Let R be the result of performing CaseBlockEvaluation of CaseBlock with argument switchValue.
R = CaseBlockEvaluation(cases, switchValue, strictCode, blockEnv, realm);
// 9. Return R.
return R;
} catch (e) {
if (e instanceof _completions.BreakCompletion) {
if (!e.target) return (0, _index2.UpdateEmpty)(realm, e, realm.intrinsics.undefined).value;
}
throw e;
} finally {
// 8. Set the running execution context's LexicalEnvironment to oldEnv.
realm.getRunningContext().lexicalEnvironment = oldEnv;
realm.onDestroyScope(blockEnv);
}
};
var _completions = require("../completions.js");
var _ForOfStatement = require("./ForOfStatement.js");
var _index = require("../values/index.js");
var _index2 = require("../methods/index.js");
var _singletons = require("../singletons.js");
var _invariant = require("../invariant.js");
var _invariant2 = _interopRequireDefault(_invariant);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
// 13.12.10 Runtime Semantics: CaseSelectorEvaluation
function CaseSelectorEvaluation(expression, strictCode, env, realm) {
// 1. Let exprRef be the result of evaluating Expression.
var exprRef = env.evaluate(expression, strictCode);
// 2. Return ? GetValue(exprRef).
return _singletons.Environment.GetValue(realm, exprRef);
}
function CaseBlockEvaluation(cases, input, strictCode, env, realm) {
var EvaluateCase = function EvaluateCase(c) {
var r = realm.intrinsics.empty;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = c.consequent[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var node = _step.value;
var res = env.evaluateCompletion(node, strictCode);
if (res instanceof _completions.AbruptCompletion) return (0, _index2.UpdateEmpty)(realm, res, r);
if (!(res instanceof _index.EmptyValue)) r = res;
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return r;
};
var EvaluateCaseClauses = function EvaluateCaseClauses(A, V) {
// 2. Let A be the List of CaseClause items in CaseClauses, in source text order.
// A is passed in
// 3. Let found be false.
var found = false;
// 4. Repeat for each CaseClause C in A,
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = A[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var C = _step2.value;
// a. If found is false, then
if (!found) {
// i. Let clauseSelector be the result of CaseSelectorEvaluation of C.
var test = C.test;
(0, _invariant2.default)(test);
var clauseSelector = CaseSelectorEvaluation(test, strictCode, env, realm);
// ii. ReturnIfAbrupt(clauseSelector).
// above will throw a Completion which will return
// iii. Let found be the result of performing Strict Equality Comparison input === clauseSelector.[[Value]].
found = (0, _index2.StrictEqualityComparisonPartial)(realm, input, clauseSelector);
}
if (found) {
// b. If found is true, then
// i. Let R be the result of evaluating C.
var R = EvaluateCase(C);
// ii. If R.[[Value]] is not empty, let V be R.[[Value]].
var val = (0, _ForOfStatement.InternalGetResultValue)(realm, R);
if (!(val instanceof _index.EmptyValue)) V = val;
// iii. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
if (R instanceof _completions.AbruptCompletion) {
throw (0, _index2.UpdateEmpty)(realm, R, V);
}
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return [found, V];
};
// CaseBlock:{}
// 1. Return NormalCompletion(undefined).
if (cases.length === 0) return realm.intrinsics.undefined;
// CaseBlock:{CaseClauses DefaultClause CaseClauses}
var default_case_num = cases.findIndex(function (clause) {
return clause.test === null;
});
if (default_case_num !== -1) {
// 2. Let A be the List of CaseClause items in the first CaseClauses, in source text order. If the first CaseClauses is not present, A is « ».
var A = cases.slice(0, default_case_num);
var V = realm.intrinsics.undefined;
// 4. Repeat for each CaseClause C in A
// 5. Let foundInB be false.
var _EvaluateCaseClauses = EvaluateCaseClauses(A, V);
var _EvaluateCaseClauses2 = _slicedToArray(_EvaluateCaseClauses, 2);
V = _EvaluateCaseClauses2[1];
var foundInB = false;
// 6. Let B be the List containing the CaseClause items in the second CaseClauses, in source text order. If the second CaseClauses is not present, B is « ».
var B = cases.slice(default_case_num + 1);
// 8. If foundInB is true, return NormalCompletion(V).
var _EvaluateCaseClauses3 = EvaluateCaseClauses(B, V);
var _EvaluateCaseClauses4 = _slicedToArray(_EvaluateCaseClauses3, 2);
foundInB = _EvaluateCaseClauses4[0];
V = _EvaluateCaseClauses4[1];
if (foundInB) return V;
// 9. Let R be the result of evaluating DefaultClause.
var R = EvaluateCase(cases[default_case_num]);
// 10. If R.[[Value]] is not empty, let V be R.[[Value]].
var val = (0, _ForOfStatement.InternalGetResultValue)(realm, R);
if (!(val instanceof _index.EmptyValue)) V = val;
// 11. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
if (R instanceof _completions.AbruptCompletion) {
throw (0, _index2.UpdateEmpty)(realm, R, V);
}
// 12: Repeat for each CaseClause C in B (NOTE this is another complete iteration of the second CaseClauses)
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = B[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var C = _step3.value;
// a. Let R be the result of evaluating CaseClause C.
R = EvaluateCase(C);
// b. If R.[[Value]] is not empty, let V be R.[[Value]].
var value = (0, _ForOfStatement.InternalGetResultValue)(realm, R);
if (!(value instanceof _index.EmptyValue)) V = value;
// c. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
if (R instanceof _completions.AbruptCompletion) {
throw (0, _index2.UpdateEmpty)(realm, R, V);
}
}
// 13. Return NormalCompletion(V).
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
return V;
} else {
// CaseBlock:{CaseClauses}
var _V = void 0;
var _EvaluateCaseClauses5 = EvaluateCaseClauses(cases, realm.intrinsics.undefined);
var _EvaluateCaseClauses6 = _slicedToArray(_EvaluateCaseClauses5, 2);
_V = _EvaluateCaseClauses6[1];
return _V;
}
}
// 13.12.11
//# sourceMappingURL=SwitchStatement.js.map