Deployed the page to Github Pages.
This commit is contained in:
parent
1d79754e93
commit
2c89899458
SSH key fingerprint:
SHA256:kEsnuHX+qbwhxSAXPUQ4ox535wFHu/hIRaa53FzxRpo
62797 changed files with 6551425 additions and 15279 deletions
4
node_modules/@webassemblyjs/ast/esm/clone.js
generated
vendored
Normal file
4
node_modules/@webassemblyjs/ast/esm/clone.js
generated
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
export function cloneNode(n) {
|
||||
// $FlowIgnore
|
||||
return Object.assign({}, n);
|
||||
}
|
||||
668
node_modules/@webassemblyjs/ast/esm/definitions.js
generated
vendored
Normal file
668
node_modules/@webassemblyjs/ast/esm/definitions.js
generated
vendored
Normal file
|
|
@ -0,0 +1,668 @@
|
|||
var definitions = {};
|
||||
|
||||
function defineType(typeName, metadata) {
|
||||
definitions[typeName] = metadata;
|
||||
}
|
||||
|
||||
defineType("Module", {
|
||||
spec: {
|
||||
wasm: "https://webassembly.github.io/spec/core/binary/modules.html#binary-module",
|
||||
wat: "https://webassembly.github.io/spec/core/text/modules.html#text-module"
|
||||
},
|
||||
doc: "A module consists of a sequence of sections (termed fields in the text format).",
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
id: {
|
||||
maybe: true,
|
||||
type: "string"
|
||||
},
|
||||
fields: {
|
||||
array: true,
|
||||
type: "Node"
|
||||
},
|
||||
metadata: {
|
||||
optional: true,
|
||||
type: "ModuleMetadata"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ModuleMetadata", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
sections: {
|
||||
array: true,
|
||||
type: "SectionMetadata"
|
||||
},
|
||||
functionNames: {
|
||||
optional: true,
|
||||
array: true,
|
||||
type: "FunctionNameMetadata"
|
||||
},
|
||||
localNames: {
|
||||
optional: true,
|
||||
array: true,
|
||||
type: "ModuleMetadata"
|
||||
},
|
||||
producers: {
|
||||
optional: true,
|
||||
array: true,
|
||||
type: "ProducersSectionMetadata"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ModuleNameMetadata", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("FunctionNameMetadata", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "string"
|
||||
},
|
||||
index: {
|
||||
type: "number"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("LocalNameMetadata", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "string"
|
||||
},
|
||||
localIndex: {
|
||||
type: "number"
|
||||
},
|
||||
functionIndex: {
|
||||
type: "number"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("BinaryModule", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
id: {
|
||||
maybe: true,
|
||||
type: "string"
|
||||
},
|
||||
blob: {
|
||||
array: true,
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("QuoteModule", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
id: {
|
||||
maybe: true,
|
||||
type: "string"
|
||||
},
|
||||
string: {
|
||||
array: true,
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("SectionMetadata", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
section: {
|
||||
type: "SectionName"
|
||||
},
|
||||
startOffset: {
|
||||
type: "number"
|
||||
},
|
||||
size: {
|
||||
type: "NumberLiteral"
|
||||
},
|
||||
vectorOfSize: {
|
||||
comment: "Size of the vector in the section (if any)",
|
||||
type: "NumberLiteral"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ProducersSectionMetadata", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
producers: {
|
||||
array: true,
|
||||
type: "ProducerMetadata"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ProducerMetadata", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
language: {
|
||||
type: "ProducerMetadataVersionedName",
|
||||
array: true
|
||||
},
|
||||
processedBy: {
|
||||
type: "ProducerMetadataVersionedName",
|
||||
array: true
|
||||
},
|
||||
sdk: {
|
||||
type: "ProducerMetadataVersionedName",
|
||||
array: true
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ProducerMetadataVersionedName", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
name: {
|
||||
type: "string"
|
||||
},
|
||||
version: {
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
/*
|
||||
Instructions
|
||||
*/
|
||||
|
||||
defineType("LoopInstruction", {
|
||||
unionType: ["Node", "Block", "Instruction"],
|
||||
fields: {
|
||||
id: {
|
||||
constant: true,
|
||||
type: "string",
|
||||
value: "loop"
|
||||
},
|
||||
label: {
|
||||
maybe: true,
|
||||
type: "Identifier"
|
||||
},
|
||||
resulttype: {
|
||||
maybe: true,
|
||||
type: "Valtype"
|
||||
},
|
||||
instr: {
|
||||
array: true,
|
||||
type: "Instruction"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Instr", {
|
||||
unionType: ["Node", "Expression", "Instruction"],
|
||||
fields: {
|
||||
id: {
|
||||
type: "string"
|
||||
},
|
||||
object: {
|
||||
optional: true,
|
||||
type: "Valtype"
|
||||
},
|
||||
args: {
|
||||
array: true,
|
||||
type: "Expression"
|
||||
},
|
||||
namedArgs: {
|
||||
optional: true,
|
||||
type: "Object"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("IfInstruction", {
|
||||
unionType: ["Node", "Instruction"],
|
||||
fields: {
|
||||
id: {
|
||||
constant: true,
|
||||
type: "string",
|
||||
value: "if"
|
||||
},
|
||||
testLabel: {
|
||||
comment: "only for WAST",
|
||||
type: "Identifier"
|
||||
},
|
||||
test: {
|
||||
array: true,
|
||||
type: "Instruction"
|
||||
},
|
||||
result: {
|
||||
maybe: true,
|
||||
type: "Valtype"
|
||||
},
|
||||
consequent: {
|
||||
array: true,
|
||||
type: "Instruction"
|
||||
},
|
||||
alternate: {
|
||||
array: true,
|
||||
type: "Instruction"
|
||||
}
|
||||
}
|
||||
});
|
||||
/*
|
||||
Concrete value types
|
||||
*/
|
||||
|
||||
defineType("StringLiteral", {
|
||||
unionType: ["Node", "Expression"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("NumberLiteral", {
|
||||
unionType: ["Node", "NumericLiteral", "Expression"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "number"
|
||||
},
|
||||
raw: {
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("LongNumberLiteral", {
|
||||
unionType: ["Node", "NumericLiteral", "Expression"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "LongNumber"
|
||||
},
|
||||
raw: {
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("FloatLiteral", {
|
||||
unionType: ["Node", "NumericLiteral", "Expression"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "number"
|
||||
},
|
||||
nan: {
|
||||
optional: true,
|
||||
type: "boolean"
|
||||
},
|
||||
inf: {
|
||||
optional: true,
|
||||
type: "boolean"
|
||||
},
|
||||
raw: {
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Elem", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
table: {
|
||||
type: "Index"
|
||||
},
|
||||
offset: {
|
||||
array: true,
|
||||
type: "Instruction"
|
||||
},
|
||||
funcs: {
|
||||
array: true,
|
||||
type: "Index"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("IndexInFuncSection", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
index: {
|
||||
type: "Index"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ValtypeLiteral", {
|
||||
unionType: ["Node", "Expression"],
|
||||
fields: {
|
||||
name: {
|
||||
type: "Valtype"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("TypeInstruction", {
|
||||
unionType: ["Node", "Instruction"],
|
||||
fields: {
|
||||
id: {
|
||||
maybe: true,
|
||||
type: "Index"
|
||||
},
|
||||
functype: {
|
||||
type: "Signature"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Start", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
index: {
|
||||
type: "Index"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("GlobalType", {
|
||||
unionType: ["Node", "ImportDescr"],
|
||||
fields: {
|
||||
valtype: {
|
||||
type: "Valtype"
|
||||
},
|
||||
mutability: {
|
||||
type: "Mutability"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("LeadingComment", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("BlockComment", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Data", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
memoryIndex: {
|
||||
type: "Memidx"
|
||||
},
|
||||
offset: {
|
||||
type: "Instruction"
|
||||
},
|
||||
init: {
|
||||
type: "ByteArray"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Global", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
globalType: {
|
||||
type: "GlobalType"
|
||||
},
|
||||
init: {
|
||||
array: true,
|
||||
type: "Instruction"
|
||||
},
|
||||
name: {
|
||||
maybe: true,
|
||||
type: "Identifier"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Table", {
|
||||
unionType: ["Node", "ImportDescr"],
|
||||
fields: {
|
||||
elementType: {
|
||||
type: "TableElementType"
|
||||
},
|
||||
limits: {
|
||||
assertNodeType: true,
|
||||
type: "Limit"
|
||||
},
|
||||
name: {
|
||||
maybe: true,
|
||||
type: "Identifier"
|
||||
},
|
||||
elements: {
|
||||
array: true,
|
||||
optional: true,
|
||||
type: "Index"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Memory", {
|
||||
unionType: ["Node", "ImportDescr"],
|
||||
fields: {
|
||||
limits: {
|
||||
type: "Limit"
|
||||
},
|
||||
id: {
|
||||
maybe: true,
|
||||
type: "Index"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("FuncImportDescr", {
|
||||
unionType: ["Node", "ImportDescr"],
|
||||
fields: {
|
||||
id: {
|
||||
type: "Identifier"
|
||||
},
|
||||
signature: {
|
||||
type: "Signature"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ModuleImport", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
module: {
|
||||
type: "string"
|
||||
},
|
||||
name: {
|
||||
type: "string"
|
||||
},
|
||||
descr: {
|
||||
type: "ImportDescr"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ModuleExportDescr", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
exportType: {
|
||||
type: "ExportDescrType"
|
||||
},
|
||||
id: {
|
||||
type: "Index"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ModuleExport", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
name: {
|
||||
type: "string"
|
||||
},
|
||||
descr: {
|
||||
type: "ModuleExportDescr"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Limit", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
min: {
|
||||
type: "number"
|
||||
},
|
||||
max: {
|
||||
optional: true,
|
||||
type: "number"
|
||||
},
|
||||
// Threads proposal, shared memory
|
||||
shared: {
|
||||
optional: true,
|
||||
type: "boolean"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Signature", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
params: {
|
||||
array: true,
|
||||
type: "FuncParam"
|
||||
},
|
||||
results: {
|
||||
array: true,
|
||||
type: "Valtype"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Program", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
body: {
|
||||
array: true,
|
||||
type: "Node"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Identifier", {
|
||||
unionType: ["Node", "Expression"],
|
||||
fields: {
|
||||
value: {
|
||||
type: "string"
|
||||
},
|
||||
raw: {
|
||||
optional: true,
|
||||
type: "string"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("BlockInstruction", {
|
||||
unionType: ["Node", "Block", "Instruction"],
|
||||
fields: {
|
||||
id: {
|
||||
constant: true,
|
||||
type: "string",
|
||||
value: "block"
|
||||
},
|
||||
label: {
|
||||
maybe: true,
|
||||
type: "Identifier"
|
||||
},
|
||||
instr: {
|
||||
array: true,
|
||||
type: "Instruction"
|
||||
},
|
||||
result: {
|
||||
maybe: true,
|
||||
type: "Valtype"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("CallInstruction", {
|
||||
unionType: ["Node", "Instruction"],
|
||||
fields: {
|
||||
id: {
|
||||
constant: true,
|
||||
type: "string",
|
||||
value: "call"
|
||||
},
|
||||
index: {
|
||||
type: "Index"
|
||||
},
|
||||
instrArgs: {
|
||||
array: true,
|
||||
optional: true,
|
||||
type: "Expression"
|
||||
},
|
||||
numeric: {
|
||||
type: "Index",
|
||||
optional: true
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("CallIndirectInstruction", {
|
||||
unionType: ["Node", "Instruction"],
|
||||
fields: {
|
||||
id: {
|
||||
constant: true,
|
||||
type: "string",
|
||||
value: "call_indirect"
|
||||
},
|
||||
signature: {
|
||||
type: "SignatureOrTypeRef"
|
||||
},
|
||||
intrs: {
|
||||
array: true,
|
||||
optional: true,
|
||||
type: "Expression"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("ByteArray", {
|
||||
unionType: ["Node"],
|
||||
fields: {
|
||||
values: {
|
||||
array: true,
|
||||
type: "Byte"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("Func", {
|
||||
unionType: ["Node", "Block"],
|
||||
fields: {
|
||||
name: {
|
||||
maybe: true,
|
||||
type: "Index"
|
||||
},
|
||||
signature: {
|
||||
type: "SignatureOrTypeRef"
|
||||
},
|
||||
body: {
|
||||
array: true,
|
||||
type: "Instruction"
|
||||
},
|
||||
isExternal: {
|
||||
comment: "means that it has been imported from the outside js",
|
||||
optional: true,
|
||||
type: "boolean"
|
||||
},
|
||||
metadata: {
|
||||
optional: true,
|
||||
type: "FuncMetadata"
|
||||
}
|
||||
}
|
||||
});
|
||||
/**
|
||||
* Intrinsics
|
||||
*/
|
||||
|
||||
defineType("InternalBrUnless", {
|
||||
unionType: ["Node", "Intrinsic"],
|
||||
fields: {
|
||||
target: {
|
||||
type: "number"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("InternalGoto", {
|
||||
unionType: ["Node", "Intrinsic"],
|
||||
fields: {
|
||||
target: {
|
||||
type: "number"
|
||||
}
|
||||
}
|
||||
});
|
||||
defineType("InternalCallExtern", {
|
||||
unionType: ["Node", "Intrinsic"],
|
||||
fields: {
|
||||
target: {
|
||||
type: "number"
|
||||
}
|
||||
}
|
||||
}); // function bodies are terminated by an `end` instruction but are missing a
|
||||
// return instruction
|
||||
//
|
||||
// Since we can't inject a new instruction we are injecting a new instruction.
|
||||
|
||||
defineType("InternalEndAndReturn", {
|
||||
unionType: ["Node", "Intrinsic"],
|
||||
fields: {}
|
||||
});
|
||||
module.exports = definitions;
|
||||
7
node_modules/@webassemblyjs/ast/esm/index.js
generated
vendored
Normal file
7
node_modules/@webassemblyjs/ast/esm/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
export * from "./nodes";
|
||||
export { numberLiteralFromRaw, withLoc, withRaw, funcParam, indexLiteral, memIndexLiteral, instruction, objectInstruction } from "./node-helpers.js";
|
||||
export { traverse } from "./traverse";
|
||||
export { signatures } from "./signatures";
|
||||
export * from "./utils";
|
||||
export { cloneNode } from "./clone";
|
||||
export { moduleContextFromModuleAST } from "./transform/ast-module-to-module-context";
|
||||
84
node_modules/@webassemblyjs/ast/esm/node-helpers.js
generated
vendored
Normal file
84
node_modules/@webassemblyjs/ast/esm/node-helpers.js
generated
vendored
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
import { parse32F, parse64F, parse32I, parse64I, parseU32, isNanLiteral, isInfLiteral } from "@webassemblyjs/helper-numbers";
|
||||
import { longNumberLiteral, floatLiteral, numberLiteral, instr } from "./nodes";
|
||||
export function numberLiteralFromRaw(rawValue) {
|
||||
var instructionType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "i32";
|
||||
var original = rawValue; // Remove numeric separators _
|
||||
|
||||
if (typeof rawValue === "string") {
|
||||
rawValue = rawValue.replace(/_/g, "");
|
||||
}
|
||||
|
||||
if (typeof rawValue === "number") {
|
||||
return numberLiteral(rawValue, String(original));
|
||||
} else {
|
||||
switch (instructionType) {
|
||||
case "i32":
|
||||
{
|
||||
return numberLiteral(parse32I(rawValue), String(original));
|
||||
}
|
||||
|
||||
case "u32":
|
||||
{
|
||||
return numberLiteral(parseU32(rawValue), String(original));
|
||||
}
|
||||
|
||||
case "i64":
|
||||
{
|
||||
return longNumberLiteral(parse64I(rawValue), String(original));
|
||||
}
|
||||
|
||||
case "f32":
|
||||
{
|
||||
return floatLiteral(parse32F(rawValue), isNanLiteral(rawValue), isInfLiteral(rawValue), String(original));
|
||||
}
|
||||
// f64
|
||||
|
||||
default:
|
||||
{
|
||||
return floatLiteral(parse64F(rawValue), isNanLiteral(rawValue), isInfLiteral(rawValue), String(original));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
export function instruction(id) {
|
||||
var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
||||
var namedArgs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
||||
return instr(id, undefined, args, namedArgs);
|
||||
}
|
||||
export function objectInstruction(id, object) {
|
||||
var args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
|
||||
var namedArgs = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
|
||||
return instr(id, object, args, namedArgs);
|
||||
}
|
||||
/**
|
||||
* Decorators
|
||||
*/
|
||||
|
||||
export function withLoc(n, end, start) {
|
||||
var loc = {
|
||||
start: start,
|
||||
end: end
|
||||
};
|
||||
n.loc = loc;
|
||||
return n;
|
||||
}
|
||||
export function withRaw(n, raw) {
|
||||
n.raw = raw;
|
||||
return n;
|
||||
}
|
||||
export function funcParam(valtype, id) {
|
||||
return {
|
||||
id: id,
|
||||
valtype: valtype
|
||||
};
|
||||
}
|
||||
export function indexLiteral(value) {
|
||||
// $FlowIgnore
|
||||
var x = numberLiteralFromRaw(value, "u32");
|
||||
return x;
|
||||
}
|
||||
export function memIndexLiteral(value) {
|
||||
// $FlowIgnore
|
||||
var x = numberLiteralFromRaw(value, "u32");
|
||||
return x;
|
||||
}
|
||||
141
node_modules/@webassemblyjs/ast/esm/node-path.js
generated
vendored
Normal file
141
node_modules/@webassemblyjs/ast/esm/node-path.js
generated
vendored
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
|
||||
|
||||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
||||
|
||||
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
||||
|
||||
function findParent(_ref, cb) {
|
||||
var parentPath = _ref.parentPath;
|
||||
|
||||
if (parentPath == null) {
|
||||
throw new Error("node is root");
|
||||
}
|
||||
|
||||
var currentPath = parentPath;
|
||||
|
||||
while (cb(currentPath) !== false) {
|
||||
// Hit the root node, stop
|
||||
// $FlowIgnore
|
||||
if (currentPath.parentPath == null) {
|
||||
return null;
|
||||
} // $FlowIgnore
|
||||
|
||||
|
||||
currentPath = currentPath.parentPath;
|
||||
}
|
||||
|
||||
return currentPath.node;
|
||||
}
|
||||
|
||||
function insertBefore(context, newNode) {
|
||||
return insert(context, newNode);
|
||||
}
|
||||
|
||||
function insertAfter(context, newNode) {
|
||||
return insert(context, newNode, 1);
|
||||
}
|
||||
|
||||
function insert(_ref2, newNode) {
|
||||
var node = _ref2.node,
|
||||
inList = _ref2.inList,
|
||||
parentPath = _ref2.parentPath,
|
||||
parentKey = _ref2.parentKey;
|
||||
var indexOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
|
||||
|
||||
if (!inList) {
|
||||
throw new Error('inList' + " error: " + ("insert can only be used for nodes that are within lists" || "unknown"));
|
||||
}
|
||||
|
||||
if (!(parentPath != null)) {
|
||||
throw new Error('parentPath != null' + " error: " + ("Can not remove root node" || "unknown"));
|
||||
}
|
||||
|
||||
// $FlowIgnore
|
||||
var parentList = parentPath.node[parentKey];
|
||||
var indexInList = parentList.findIndex(function (n) {
|
||||
return n === node;
|
||||
});
|
||||
parentList.splice(indexInList + indexOffset, 0, newNode);
|
||||
}
|
||||
|
||||
function remove(_ref3) {
|
||||
var node = _ref3.node,
|
||||
parentKey = _ref3.parentKey,
|
||||
parentPath = _ref3.parentPath;
|
||||
|
||||
if (!(parentPath != null)) {
|
||||
throw new Error('parentPath != null' + " error: " + ("Can not remove root node" || "unknown"));
|
||||
}
|
||||
|
||||
// $FlowIgnore
|
||||
var parentNode = parentPath.node; // $FlowIgnore
|
||||
|
||||
var parentProperty = parentNode[parentKey];
|
||||
|
||||
if (Array.isArray(parentProperty)) {
|
||||
// $FlowIgnore
|
||||
parentNode[parentKey] = parentProperty.filter(function (n) {
|
||||
return n !== node;
|
||||
});
|
||||
} else {
|
||||
// $FlowIgnore
|
||||
delete parentNode[parentKey];
|
||||
}
|
||||
|
||||
node._deleted = true;
|
||||
}
|
||||
|
||||
function stop(context) {
|
||||
context.shouldStop = true;
|
||||
}
|
||||
|
||||
function replaceWith(context, newNode) {
|
||||
// $FlowIgnore
|
||||
var parentNode = context.parentPath.node; // $FlowIgnore
|
||||
|
||||
var parentProperty = parentNode[context.parentKey];
|
||||
|
||||
if (Array.isArray(parentProperty)) {
|
||||
var indexInList = parentProperty.findIndex(function (n) {
|
||||
return n === context.node;
|
||||
});
|
||||
parentProperty.splice(indexInList, 1, newNode);
|
||||
} else {
|
||||
// $FlowIgnore
|
||||
parentNode[context.parentKey] = newNode;
|
||||
}
|
||||
|
||||
context.node._deleted = true;
|
||||
context.node = newNode;
|
||||
} // bind the context to the first argument of node operations
|
||||
|
||||
|
||||
function bindNodeOperations(operations, context) {
|
||||
var keys = Object.keys(operations);
|
||||
var boundOperations = {};
|
||||
keys.forEach(function (key) {
|
||||
boundOperations[key] = operations[key].bind(null, context);
|
||||
});
|
||||
return boundOperations;
|
||||
}
|
||||
|
||||
function createPathOperations(context) {
|
||||
// $FlowIgnore
|
||||
return bindNodeOperations({
|
||||
findParent: findParent,
|
||||
replaceWith: replaceWith,
|
||||
remove: remove,
|
||||
insertBefore: insertBefore,
|
||||
insertAfter: insertAfter,
|
||||
stop: stop
|
||||
}, context);
|
||||
}
|
||||
|
||||
export function createPath(context) {
|
||||
var path = _objectSpread({}, context); // $FlowIgnore
|
||||
|
||||
|
||||
Object.assign(path, createPathOperations(path)); // $FlowIgnore
|
||||
|
||||
return path;
|
||||
}
|
||||
925
node_modules/@webassemblyjs/ast/esm/nodes.js
generated
vendored
Normal file
925
node_modules/@webassemblyjs/ast/esm/nodes.js
generated
vendored
Normal file
|
|
@ -0,0 +1,925 @@
|
|||
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
||||
|
||||
// THIS FILE IS AUTOGENERATED
|
||||
// see scripts/generateNodeUtils.js
|
||||
function isTypeOf(t) {
|
||||
return function (n) {
|
||||
return n.type === t;
|
||||
};
|
||||
}
|
||||
|
||||
function assertTypeOf(t) {
|
||||
return function (n) {
|
||||
return function () {
|
||||
if (!(n.type === t)) {
|
||||
throw new Error('n.type === t' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
}();
|
||||
};
|
||||
}
|
||||
|
||||
export function module(id, fields, metadata) {
|
||||
if (id !== null && id !== undefined) {
|
||||
if (!(typeof id === "string")) {
|
||||
throw new Error('typeof id === "string"' + " error: " + ("Argument id must be of type string, given: " + _typeof(id) || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
if (!(_typeof(fields) === "object" && typeof fields.length !== "undefined")) {
|
||||
throw new Error('typeof fields === "object" && typeof fields.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Module",
|
||||
id: id,
|
||||
fields: fields
|
||||
};
|
||||
|
||||
if (typeof metadata !== "undefined") {
|
||||
node.metadata = metadata;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function moduleMetadata(sections, functionNames, localNames, producers) {
|
||||
if (!(_typeof(sections) === "object" && typeof sections.length !== "undefined")) {
|
||||
throw new Error('typeof sections === "object" && typeof sections.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
if (functionNames !== null && functionNames !== undefined) {
|
||||
if (!(_typeof(functionNames) === "object" && typeof functionNames.length !== "undefined")) {
|
||||
throw new Error('typeof functionNames === "object" && typeof functionNames.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
if (localNames !== null && localNames !== undefined) {
|
||||
if (!(_typeof(localNames) === "object" && typeof localNames.length !== "undefined")) {
|
||||
throw new Error('typeof localNames === "object" && typeof localNames.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
if (producers !== null && producers !== undefined) {
|
||||
if (!(_typeof(producers) === "object" && typeof producers.length !== "undefined")) {
|
||||
throw new Error('typeof producers === "object" && typeof producers.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "ModuleMetadata",
|
||||
sections: sections
|
||||
};
|
||||
|
||||
if (typeof functionNames !== "undefined" && functionNames.length > 0) {
|
||||
node.functionNames = functionNames;
|
||||
}
|
||||
|
||||
if (typeof localNames !== "undefined" && localNames.length > 0) {
|
||||
node.localNames = localNames;
|
||||
}
|
||||
|
||||
if (typeof producers !== "undefined" && producers.length > 0) {
|
||||
node.producers = producers;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function moduleNameMetadata(value) {
|
||||
if (!(typeof value === "string")) {
|
||||
throw new Error('typeof value === "string"' + " error: " + ("Argument value must be of type string, given: " + _typeof(value) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "ModuleNameMetadata",
|
||||
value: value
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function functionNameMetadata(value, index) {
|
||||
if (!(typeof value === "string")) {
|
||||
throw new Error('typeof value === "string"' + " error: " + ("Argument value must be of type string, given: " + _typeof(value) || "unknown"));
|
||||
}
|
||||
|
||||
if (!(typeof index === "number")) {
|
||||
throw new Error('typeof index === "number"' + " error: " + ("Argument index must be of type number, given: " + _typeof(index) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "FunctionNameMetadata",
|
||||
value: value,
|
||||
index: index
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function localNameMetadata(value, localIndex, functionIndex) {
|
||||
if (!(typeof value === "string")) {
|
||||
throw new Error('typeof value === "string"' + " error: " + ("Argument value must be of type string, given: " + _typeof(value) || "unknown"));
|
||||
}
|
||||
|
||||
if (!(typeof localIndex === "number")) {
|
||||
throw new Error('typeof localIndex === "number"' + " error: " + ("Argument localIndex must be of type number, given: " + _typeof(localIndex) || "unknown"));
|
||||
}
|
||||
|
||||
if (!(typeof functionIndex === "number")) {
|
||||
throw new Error('typeof functionIndex === "number"' + " error: " + ("Argument functionIndex must be of type number, given: " + _typeof(functionIndex) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "LocalNameMetadata",
|
||||
value: value,
|
||||
localIndex: localIndex,
|
||||
functionIndex: functionIndex
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function binaryModule(id, blob) {
|
||||
if (id !== null && id !== undefined) {
|
||||
if (!(typeof id === "string")) {
|
||||
throw new Error('typeof id === "string"' + " error: " + ("Argument id must be of type string, given: " + _typeof(id) || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
if (!(_typeof(blob) === "object" && typeof blob.length !== "undefined")) {
|
||||
throw new Error('typeof blob === "object" && typeof blob.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "BinaryModule",
|
||||
id: id,
|
||||
blob: blob
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function quoteModule(id, string) {
|
||||
if (id !== null && id !== undefined) {
|
||||
if (!(typeof id === "string")) {
|
||||
throw new Error('typeof id === "string"' + " error: " + ("Argument id must be of type string, given: " + _typeof(id) || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
if (!(_typeof(string) === "object" && typeof string.length !== "undefined")) {
|
||||
throw new Error('typeof string === "object" && typeof string.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "QuoteModule",
|
||||
id: id,
|
||||
string: string
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function sectionMetadata(section, startOffset, size, vectorOfSize) {
|
||||
if (!(typeof startOffset === "number")) {
|
||||
throw new Error('typeof startOffset === "number"' + " error: " + ("Argument startOffset must be of type number, given: " + _typeof(startOffset) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "SectionMetadata",
|
||||
section: section,
|
||||
startOffset: startOffset,
|
||||
size: size,
|
||||
vectorOfSize: vectorOfSize
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function producersSectionMetadata(producers) {
|
||||
if (!(_typeof(producers) === "object" && typeof producers.length !== "undefined")) {
|
||||
throw new Error('typeof producers === "object" && typeof producers.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "ProducersSectionMetadata",
|
||||
producers: producers
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function producerMetadata(language, processedBy, sdk) {
|
||||
if (!(_typeof(language) === "object" && typeof language.length !== "undefined")) {
|
||||
throw new Error('typeof language === "object" && typeof language.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
if (!(_typeof(processedBy) === "object" && typeof processedBy.length !== "undefined")) {
|
||||
throw new Error('typeof processedBy === "object" && typeof processedBy.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
if (!(_typeof(sdk) === "object" && typeof sdk.length !== "undefined")) {
|
||||
throw new Error('typeof sdk === "object" && typeof sdk.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "ProducerMetadata",
|
||||
language: language,
|
||||
processedBy: processedBy,
|
||||
sdk: sdk
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function producerMetadataVersionedName(name, version) {
|
||||
if (!(typeof name === "string")) {
|
||||
throw new Error('typeof name === "string"' + " error: " + ("Argument name must be of type string, given: " + _typeof(name) || "unknown"));
|
||||
}
|
||||
|
||||
if (!(typeof version === "string")) {
|
||||
throw new Error('typeof version === "string"' + " error: " + ("Argument version must be of type string, given: " + _typeof(version) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "ProducerMetadataVersionedName",
|
||||
name: name,
|
||||
version: version
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function loopInstruction(label, resulttype, instr) {
|
||||
if (!(_typeof(instr) === "object" && typeof instr.length !== "undefined")) {
|
||||
throw new Error('typeof instr === "object" && typeof instr.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "LoopInstruction",
|
||||
id: "loop",
|
||||
label: label,
|
||||
resulttype: resulttype,
|
||||
instr: instr
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function instr(id, object, args, namedArgs) {
|
||||
if (!(typeof id === "string")) {
|
||||
throw new Error('typeof id === "string"' + " error: " + ("Argument id must be of type string, given: " + _typeof(id) || "unknown"));
|
||||
}
|
||||
|
||||
if (!(_typeof(args) === "object" && typeof args.length !== "undefined")) {
|
||||
throw new Error('typeof args === "object" && typeof args.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Instr",
|
||||
id: id,
|
||||
args: args
|
||||
};
|
||||
|
||||
if (typeof object !== "undefined") {
|
||||
node.object = object;
|
||||
}
|
||||
|
||||
if (typeof namedArgs !== "undefined" && Object.keys(namedArgs).length !== 0) {
|
||||
node.namedArgs = namedArgs;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function ifInstruction(testLabel, test, result, consequent, alternate) {
|
||||
if (!(_typeof(test) === "object" && typeof test.length !== "undefined")) {
|
||||
throw new Error('typeof test === "object" && typeof test.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
if (!(_typeof(consequent) === "object" && typeof consequent.length !== "undefined")) {
|
||||
throw new Error('typeof consequent === "object" && typeof consequent.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
if (!(_typeof(alternate) === "object" && typeof alternate.length !== "undefined")) {
|
||||
throw new Error('typeof alternate === "object" && typeof alternate.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "IfInstruction",
|
||||
id: "if",
|
||||
testLabel: testLabel,
|
||||
test: test,
|
||||
result: result,
|
||||
consequent: consequent,
|
||||
alternate: alternate
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function stringLiteral(value) {
|
||||
if (!(typeof value === "string")) {
|
||||
throw new Error('typeof value === "string"' + " error: " + ("Argument value must be of type string, given: " + _typeof(value) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "StringLiteral",
|
||||
value: value
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function numberLiteral(value, raw) {
|
||||
if (!(typeof value === "number")) {
|
||||
throw new Error('typeof value === "number"' + " error: " + ("Argument value must be of type number, given: " + _typeof(value) || "unknown"));
|
||||
}
|
||||
|
||||
if (!(typeof raw === "string")) {
|
||||
throw new Error('typeof raw === "string"' + " error: " + ("Argument raw must be of type string, given: " + _typeof(raw) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "NumberLiteral",
|
||||
value: value,
|
||||
raw: raw
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function longNumberLiteral(value, raw) {
|
||||
if (!(typeof raw === "string")) {
|
||||
throw new Error('typeof raw === "string"' + " error: " + ("Argument raw must be of type string, given: " + _typeof(raw) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "LongNumberLiteral",
|
||||
value: value,
|
||||
raw: raw
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function floatLiteral(value, nan, inf, raw) {
|
||||
if (!(typeof value === "number")) {
|
||||
throw new Error('typeof value === "number"' + " error: " + ("Argument value must be of type number, given: " + _typeof(value) || "unknown"));
|
||||
}
|
||||
|
||||
if (nan !== null && nan !== undefined) {
|
||||
if (!(typeof nan === "boolean")) {
|
||||
throw new Error('typeof nan === "boolean"' + " error: " + ("Argument nan must be of type boolean, given: " + _typeof(nan) || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
if (inf !== null && inf !== undefined) {
|
||||
if (!(typeof inf === "boolean")) {
|
||||
throw new Error('typeof inf === "boolean"' + " error: " + ("Argument inf must be of type boolean, given: " + _typeof(inf) || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
if (!(typeof raw === "string")) {
|
||||
throw new Error('typeof raw === "string"' + " error: " + ("Argument raw must be of type string, given: " + _typeof(raw) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "FloatLiteral",
|
||||
value: value,
|
||||
raw: raw
|
||||
};
|
||||
|
||||
if (nan === true) {
|
||||
node.nan = true;
|
||||
}
|
||||
|
||||
if (inf === true) {
|
||||
node.inf = true;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function elem(table, offset, funcs) {
|
||||
if (!(_typeof(offset) === "object" && typeof offset.length !== "undefined")) {
|
||||
throw new Error('typeof offset === "object" && typeof offset.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
if (!(_typeof(funcs) === "object" && typeof funcs.length !== "undefined")) {
|
||||
throw new Error('typeof funcs === "object" && typeof funcs.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Elem",
|
||||
table: table,
|
||||
offset: offset,
|
||||
funcs: funcs
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function indexInFuncSection(index) {
|
||||
var node = {
|
||||
type: "IndexInFuncSection",
|
||||
index: index
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function valtypeLiteral(name) {
|
||||
var node = {
|
||||
type: "ValtypeLiteral",
|
||||
name: name
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function typeInstruction(id, functype) {
|
||||
var node = {
|
||||
type: "TypeInstruction",
|
||||
id: id,
|
||||
functype: functype
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function start(index) {
|
||||
var node = {
|
||||
type: "Start",
|
||||
index: index
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function globalType(valtype, mutability) {
|
||||
var node = {
|
||||
type: "GlobalType",
|
||||
valtype: valtype,
|
||||
mutability: mutability
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function leadingComment(value) {
|
||||
if (!(typeof value === "string")) {
|
||||
throw new Error('typeof value === "string"' + " error: " + ("Argument value must be of type string, given: " + _typeof(value) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "LeadingComment",
|
||||
value: value
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function blockComment(value) {
|
||||
if (!(typeof value === "string")) {
|
||||
throw new Error('typeof value === "string"' + " error: " + ("Argument value must be of type string, given: " + _typeof(value) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "BlockComment",
|
||||
value: value
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function data(memoryIndex, offset, init) {
|
||||
var node = {
|
||||
type: "Data",
|
||||
memoryIndex: memoryIndex,
|
||||
offset: offset,
|
||||
init: init
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function global(globalType, init, name) {
|
||||
if (!(_typeof(init) === "object" && typeof init.length !== "undefined")) {
|
||||
throw new Error('typeof init === "object" && typeof init.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Global",
|
||||
globalType: globalType,
|
||||
init: init,
|
||||
name: name
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function table(elementType, limits, name, elements) {
|
||||
if (!(limits.type === "Limit")) {
|
||||
throw new Error('limits.type === "Limit"' + " error: " + ("Argument limits must be of type Limit, given: " + limits.type || "unknown"));
|
||||
}
|
||||
|
||||
if (elements !== null && elements !== undefined) {
|
||||
if (!(_typeof(elements) === "object" && typeof elements.length !== "undefined")) {
|
||||
throw new Error('typeof elements === "object" && typeof elements.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Table",
|
||||
elementType: elementType,
|
||||
limits: limits,
|
||||
name: name
|
||||
};
|
||||
|
||||
if (typeof elements !== "undefined" && elements.length > 0) {
|
||||
node.elements = elements;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function memory(limits, id) {
|
||||
var node = {
|
||||
type: "Memory",
|
||||
limits: limits,
|
||||
id: id
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function funcImportDescr(id, signature) {
|
||||
var node = {
|
||||
type: "FuncImportDescr",
|
||||
id: id,
|
||||
signature: signature
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function moduleImport(module, name, descr) {
|
||||
if (!(typeof module === "string")) {
|
||||
throw new Error('typeof module === "string"' + " error: " + ("Argument module must be of type string, given: " + _typeof(module) || "unknown"));
|
||||
}
|
||||
|
||||
if (!(typeof name === "string")) {
|
||||
throw new Error('typeof name === "string"' + " error: " + ("Argument name must be of type string, given: " + _typeof(name) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "ModuleImport",
|
||||
module: module,
|
||||
name: name,
|
||||
descr: descr
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function moduleExportDescr(exportType, id) {
|
||||
var node = {
|
||||
type: "ModuleExportDescr",
|
||||
exportType: exportType,
|
||||
id: id
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function moduleExport(name, descr) {
|
||||
if (!(typeof name === "string")) {
|
||||
throw new Error('typeof name === "string"' + " error: " + ("Argument name must be of type string, given: " + _typeof(name) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "ModuleExport",
|
||||
name: name,
|
||||
descr: descr
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function limit(min, max, shared) {
|
||||
if (!(typeof min === "number")) {
|
||||
throw new Error('typeof min === "number"' + " error: " + ("Argument min must be of type number, given: " + _typeof(min) || "unknown"));
|
||||
}
|
||||
|
||||
if (max !== null && max !== undefined) {
|
||||
if (!(typeof max === "number")) {
|
||||
throw new Error('typeof max === "number"' + " error: " + ("Argument max must be of type number, given: " + _typeof(max) || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
if (shared !== null && shared !== undefined) {
|
||||
if (!(typeof shared === "boolean")) {
|
||||
throw new Error('typeof shared === "boolean"' + " error: " + ("Argument shared must be of type boolean, given: " + _typeof(shared) || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Limit",
|
||||
min: min
|
||||
};
|
||||
|
||||
if (typeof max !== "undefined") {
|
||||
node.max = max;
|
||||
}
|
||||
|
||||
if (shared === true) {
|
||||
node.shared = true;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function signature(params, results) {
|
||||
if (!(_typeof(params) === "object" && typeof params.length !== "undefined")) {
|
||||
throw new Error('typeof params === "object" && typeof params.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
if (!(_typeof(results) === "object" && typeof results.length !== "undefined")) {
|
||||
throw new Error('typeof results === "object" && typeof results.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Signature",
|
||||
params: params,
|
||||
results: results
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function program(body) {
|
||||
if (!(_typeof(body) === "object" && typeof body.length !== "undefined")) {
|
||||
throw new Error('typeof body === "object" && typeof body.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Program",
|
||||
body: body
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function identifier(value, raw) {
|
||||
if (!(typeof value === "string")) {
|
||||
throw new Error('typeof value === "string"' + " error: " + ("Argument value must be of type string, given: " + _typeof(value) || "unknown"));
|
||||
}
|
||||
|
||||
if (raw !== null && raw !== undefined) {
|
||||
if (!(typeof raw === "string")) {
|
||||
throw new Error('typeof raw === "string"' + " error: " + ("Argument raw must be of type string, given: " + _typeof(raw) || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Identifier",
|
||||
value: value
|
||||
};
|
||||
|
||||
if (typeof raw !== "undefined") {
|
||||
node.raw = raw;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function blockInstruction(label, instr, result) {
|
||||
if (!(_typeof(instr) === "object" && typeof instr.length !== "undefined")) {
|
||||
throw new Error('typeof instr === "object" && typeof instr.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "BlockInstruction",
|
||||
id: "block",
|
||||
label: label,
|
||||
instr: instr,
|
||||
result: result
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function callInstruction(index, instrArgs, numeric) {
|
||||
if (instrArgs !== null && instrArgs !== undefined) {
|
||||
if (!(_typeof(instrArgs) === "object" && typeof instrArgs.length !== "undefined")) {
|
||||
throw new Error('typeof instrArgs === "object" && typeof instrArgs.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "CallInstruction",
|
||||
id: "call",
|
||||
index: index
|
||||
};
|
||||
|
||||
if (typeof instrArgs !== "undefined" && instrArgs.length > 0) {
|
||||
node.instrArgs = instrArgs;
|
||||
}
|
||||
|
||||
if (typeof numeric !== "undefined") {
|
||||
node.numeric = numeric;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function callIndirectInstruction(signature, intrs) {
|
||||
if (intrs !== null && intrs !== undefined) {
|
||||
if (!(_typeof(intrs) === "object" && typeof intrs.length !== "undefined")) {
|
||||
throw new Error('typeof intrs === "object" && typeof intrs.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "CallIndirectInstruction",
|
||||
id: "call_indirect",
|
||||
signature: signature
|
||||
};
|
||||
|
||||
if (typeof intrs !== "undefined" && intrs.length > 0) {
|
||||
node.intrs = intrs;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function byteArray(values) {
|
||||
if (!(_typeof(values) === "object" && typeof values.length !== "undefined")) {
|
||||
throw new Error('typeof values === "object" && typeof values.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "ByteArray",
|
||||
values: values
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function func(name, signature, body, isExternal, metadata) {
|
||||
if (!(_typeof(body) === "object" && typeof body.length !== "undefined")) {
|
||||
throw new Error('typeof body === "object" && typeof body.length !== "undefined"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
if (isExternal !== null && isExternal !== undefined) {
|
||||
if (!(typeof isExternal === "boolean")) {
|
||||
throw new Error('typeof isExternal === "boolean"' + " error: " + ("Argument isExternal must be of type boolean, given: " + _typeof(isExternal) || "unknown"));
|
||||
}
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "Func",
|
||||
name: name,
|
||||
signature: signature,
|
||||
body: body
|
||||
};
|
||||
|
||||
if (isExternal === true) {
|
||||
node.isExternal = true;
|
||||
}
|
||||
|
||||
if (typeof metadata !== "undefined") {
|
||||
node.metadata = metadata;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
export function internalBrUnless(target) {
|
||||
if (!(typeof target === "number")) {
|
||||
throw new Error('typeof target === "number"' + " error: " + ("Argument target must be of type number, given: " + _typeof(target) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "InternalBrUnless",
|
||||
target: target
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function internalGoto(target) {
|
||||
if (!(typeof target === "number")) {
|
||||
throw new Error('typeof target === "number"' + " error: " + ("Argument target must be of type number, given: " + _typeof(target) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "InternalGoto",
|
||||
target: target
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function internalCallExtern(target) {
|
||||
if (!(typeof target === "number")) {
|
||||
throw new Error('typeof target === "number"' + " error: " + ("Argument target must be of type number, given: " + _typeof(target) || "unknown"));
|
||||
}
|
||||
|
||||
var node = {
|
||||
type: "InternalCallExtern",
|
||||
target: target
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export function internalEndAndReturn() {
|
||||
var node = {
|
||||
type: "InternalEndAndReturn"
|
||||
};
|
||||
return node;
|
||||
}
|
||||
export var isModule = isTypeOf("Module");
|
||||
export var isModuleMetadata = isTypeOf("ModuleMetadata");
|
||||
export var isModuleNameMetadata = isTypeOf("ModuleNameMetadata");
|
||||
export var isFunctionNameMetadata = isTypeOf("FunctionNameMetadata");
|
||||
export var isLocalNameMetadata = isTypeOf("LocalNameMetadata");
|
||||
export var isBinaryModule = isTypeOf("BinaryModule");
|
||||
export var isQuoteModule = isTypeOf("QuoteModule");
|
||||
export var isSectionMetadata = isTypeOf("SectionMetadata");
|
||||
export var isProducersSectionMetadata = isTypeOf("ProducersSectionMetadata");
|
||||
export var isProducerMetadata = isTypeOf("ProducerMetadata");
|
||||
export var isProducerMetadataVersionedName = isTypeOf("ProducerMetadataVersionedName");
|
||||
export var isLoopInstruction = isTypeOf("LoopInstruction");
|
||||
export var isInstr = isTypeOf("Instr");
|
||||
export var isIfInstruction = isTypeOf("IfInstruction");
|
||||
export var isStringLiteral = isTypeOf("StringLiteral");
|
||||
export var isNumberLiteral = isTypeOf("NumberLiteral");
|
||||
export var isLongNumberLiteral = isTypeOf("LongNumberLiteral");
|
||||
export var isFloatLiteral = isTypeOf("FloatLiteral");
|
||||
export var isElem = isTypeOf("Elem");
|
||||
export var isIndexInFuncSection = isTypeOf("IndexInFuncSection");
|
||||
export var isValtypeLiteral = isTypeOf("ValtypeLiteral");
|
||||
export var isTypeInstruction = isTypeOf("TypeInstruction");
|
||||
export var isStart = isTypeOf("Start");
|
||||
export var isGlobalType = isTypeOf("GlobalType");
|
||||
export var isLeadingComment = isTypeOf("LeadingComment");
|
||||
export var isBlockComment = isTypeOf("BlockComment");
|
||||
export var isData = isTypeOf("Data");
|
||||
export var isGlobal = isTypeOf("Global");
|
||||
export var isTable = isTypeOf("Table");
|
||||
export var isMemory = isTypeOf("Memory");
|
||||
export var isFuncImportDescr = isTypeOf("FuncImportDescr");
|
||||
export var isModuleImport = isTypeOf("ModuleImport");
|
||||
export var isModuleExportDescr = isTypeOf("ModuleExportDescr");
|
||||
export var isModuleExport = isTypeOf("ModuleExport");
|
||||
export var isLimit = isTypeOf("Limit");
|
||||
export var isSignature = isTypeOf("Signature");
|
||||
export var isProgram = isTypeOf("Program");
|
||||
export var isIdentifier = isTypeOf("Identifier");
|
||||
export var isBlockInstruction = isTypeOf("BlockInstruction");
|
||||
export var isCallInstruction = isTypeOf("CallInstruction");
|
||||
export var isCallIndirectInstruction = isTypeOf("CallIndirectInstruction");
|
||||
export var isByteArray = isTypeOf("ByteArray");
|
||||
export var isFunc = isTypeOf("Func");
|
||||
export var isInternalBrUnless = isTypeOf("InternalBrUnless");
|
||||
export var isInternalGoto = isTypeOf("InternalGoto");
|
||||
export var isInternalCallExtern = isTypeOf("InternalCallExtern");
|
||||
export var isInternalEndAndReturn = isTypeOf("InternalEndAndReturn");
|
||||
export var isNode = function isNode(node) {
|
||||
return isModule(node) || isModuleMetadata(node) || isModuleNameMetadata(node) || isFunctionNameMetadata(node) || isLocalNameMetadata(node) || isBinaryModule(node) || isQuoteModule(node) || isSectionMetadata(node) || isProducersSectionMetadata(node) || isProducerMetadata(node) || isProducerMetadataVersionedName(node) || isLoopInstruction(node) || isInstr(node) || isIfInstruction(node) || isStringLiteral(node) || isNumberLiteral(node) || isLongNumberLiteral(node) || isFloatLiteral(node) || isElem(node) || isIndexInFuncSection(node) || isValtypeLiteral(node) || isTypeInstruction(node) || isStart(node) || isGlobalType(node) || isLeadingComment(node) || isBlockComment(node) || isData(node) || isGlobal(node) || isTable(node) || isMemory(node) || isFuncImportDescr(node) || isModuleImport(node) || isModuleExportDescr(node) || isModuleExport(node) || isLimit(node) || isSignature(node) || isProgram(node) || isIdentifier(node) || isBlockInstruction(node) || isCallInstruction(node) || isCallIndirectInstruction(node) || isByteArray(node) || isFunc(node) || isInternalBrUnless(node) || isInternalGoto(node) || isInternalCallExtern(node) || isInternalEndAndReturn(node);
|
||||
};
|
||||
export var isBlock = function isBlock(node) {
|
||||
return isLoopInstruction(node) || isBlockInstruction(node) || isFunc(node);
|
||||
};
|
||||
export var isInstruction = function isInstruction(node) {
|
||||
return isLoopInstruction(node) || isInstr(node) || isIfInstruction(node) || isTypeInstruction(node) || isBlockInstruction(node) || isCallInstruction(node) || isCallIndirectInstruction(node);
|
||||
};
|
||||
export var isExpression = function isExpression(node) {
|
||||
return isInstr(node) || isStringLiteral(node) || isNumberLiteral(node) || isLongNumberLiteral(node) || isFloatLiteral(node) || isValtypeLiteral(node) || isIdentifier(node);
|
||||
};
|
||||
export var isNumericLiteral = function isNumericLiteral(node) {
|
||||
return isNumberLiteral(node) || isLongNumberLiteral(node) || isFloatLiteral(node);
|
||||
};
|
||||
export var isImportDescr = function isImportDescr(node) {
|
||||
return isGlobalType(node) || isTable(node) || isMemory(node) || isFuncImportDescr(node);
|
||||
};
|
||||
export var isIntrinsic = function isIntrinsic(node) {
|
||||
return isInternalBrUnless(node) || isInternalGoto(node) || isInternalCallExtern(node) || isInternalEndAndReturn(node);
|
||||
};
|
||||
export var assertModule = assertTypeOf("Module");
|
||||
export var assertModuleMetadata = assertTypeOf("ModuleMetadata");
|
||||
export var assertModuleNameMetadata = assertTypeOf("ModuleNameMetadata");
|
||||
export var assertFunctionNameMetadata = assertTypeOf("FunctionNameMetadata");
|
||||
export var assertLocalNameMetadata = assertTypeOf("LocalNameMetadata");
|
||||
export var assertBinaryModule = assertTypeOf("BinaryModule");
|
||||
export var assertQuoteModule = assertTypeOf("QuoteModule");
|
||||
export var assertSectionMetadata = assertTypeOf("SectionMetadata");
|
||||
export var assertProducersSectionMetadata = assertTypeOf("ProducersSectionMetadata");
|
||||
export var assertProducerMetadata = assertTypeOf("ProducerMetadata");
|
||||
export var assertProducerMetadataVersionedName = assertTypeOf("ProducerMetadataVersionedName");
|
||||
export var assertLoopInstruction = assertTypeOf("LoopInstruction");
|
||||
export var assertInstr = assertTypeOf("Instr");
|
||||
export var assertIfInstruction = assertTypeOf("IfInstruction");
|
||||
export var assertStringLiteral = assertTypeOf("StringLiteral");
|
||||
export var assertNumberLiteral = assertTypeOf("NumberLiteral");
|
||||
export var assertLongNumberLiteral = assertTypeOf("LongNumberLiteral");
|
||||
export var assertFloatLiteral = assertTypeOf("FloatLiteral");
|
||||
export var assertElem = assertTypeOf("Elem");
|
||||
export var assertIndexInFuncSection = assertTypeOf("IndexInFuncSection");
|
||||
export var assertValtypeLiteral = assertTypeOf("ValtypeLiteral");
|
||||
export var assertTypeInstruction = assertTypeOf("TypeInstruction");
|
||||
export var assertStart = assertTypeOf("Start");
|
||||
export var assertGlobalType = assertTypeOf("GlobalType");
|
||||
export var assertLeadingComment = assertTypeOf("LeadingComment");
|
||||
export var assertBlockComment = assertTypeOf("BlockComment");
|
||||
export var assertData = assertTypeOf("Data");
|
||||
export var assertGlobal = assertTypeOf("Global");
|
||||
export var assertTable = assertTypeOf("Table");
|
||||
export var assertMemory = assertTypeOf("Memory");
|
||||
export var assertFuncImportDescr = assertTypeOf("FuncImportDescr");
|
||||
export var assertModuleImport = assertTypeOf("ModuleImport");
|
||||
export var assertModuleExportDescr = assertTypeOf("ModuleExportDescr");
|
||||
export var assertModuleExport = assertTypeOf("ModuleExport");
|
||||
export var assertLimit = assertTypeOf("Limit");
|
||||
export var assertSignature = assertTypeOf("Signature");
|
||||
export var assertProgram = assertTypeOf("Program");
|
||||
export var assertIdentifier = assertTypeOf("Identifier");
|
||||
export var assertBlockInstruction = assertTypeOf("BlockInstruction");
|
||||
export var assertCallInstruction = assertTypeOf("CallInstruction");
|
||||
export var assertCallIndirectInstruction = assertTypeOf("CallIndirectInstruction");
|
||||
export var assertByteArray = assertTypeOf("ByteArray");
|
||||
export var assertFunc = assertTypeOf("Func");
|
||||
export var assertInternalBrUnless = assertTypeOf("InternalBrUnless");
|
||||
export var assertInternalGoto = assertTypeOf("InternalGoto");
|
||||
export var assertInternalCallExtern = assertTypeOf("InternalCallExtern");
|
||||
export var assertInternalEndAndReturn = assertTypeOf("InternalEndAndReturn");
|
||||
export var unionTypesMap = {
|
||||
Module: ["Node"],
|
||||
ModuleMetadata: ["Node"],
|
||||
ModuleNameMetadata: ["Node"],
|
||||
FunctionNameMetadata: ["Node"],
|
||||
LocalNameMetadata: ["Node"],
|
||||
BinaryModule: ["Node"],
|
||||
QuoteModule: ["Node"],
|
||||
SectionMetadata: ["Node"],
|
||||
ProducersSectionMetadata: ["Node"],
|
||||
ProducerMetadata: ["Node"],
|
||||
ProducerMetadataVersionedName: ["Node"],
|
||||
LoopInstruction: ["Node", "Block", "Instruction"],
|
||||
Instr: ["Node", "Expression", "Instruction"],
|
||||
IfInstruction: ["Node", "Instruction"],
|
||||
StringLiteral: ["Node", "Expression"],
|
||||
NumberLiteral: ["Node", "NumericLiteral", "Expression"],
|
||||
LongNumberLiteral: ["Node", "NumericLiteral", "Expression"],
|
||||
FloatLiteral: ["Node", "NumericLiteral", "Expression"],
|
||||
Elem: ["Node"],
|
||||
IndexInFuncSection: ["Node"],
|
||||
ValtypeLiteral: ["Node", "Expression"],
|
||||
TypeInstruction: ["Node", "Instruction"],
|
||||
Start: ["Node"],
|
||||
GlobalType: ["Node", "ImportDescr"],
|
||||
LeadingComment: ["Node"],
|
||||
BlockComment: ["Node"],
|
||||
Data: ["Node"],
|
||||
Global: ["Node"],
|
||||
Table: ["Node", "ImportDescr"],
|
||||
Memory: ["Node", "ImportDescr"],
|
||||
FuncImportDescr: ["Node", "ImportDescr"],
|
||||
ModuleImport: ["Node"],
|
||||
ModuleExportDescr: ["Node"],
|
||||
ModuleExport: ["Node"],
|
||||
Limit: ["Node"],
|
||||
Signature: ["Node"],
|
||||
Program: ["Node"],
|
||||
Identifier: ["Node", "Expression"],
|
||||
BlockInstruction: ["Node", "Block", "Instruction"],
|
||||
CallInstruction: ["Node", "Instruction"],
|
||||
CallIndirectInstruction: ["Node", "Instruction"],
|
||||
ByteArray: ["Node"],
|
||||
Func: ["Node", "Block"],
|
||||
InternalBrUnless: ["Node", "Intrinsic"],
|
||||
InternalGoto: ["Node", "Intrinsic"],
|
||||
InternalCallExtern: ["Node", "Intrinsic"],
|
||||
InternalEndAndReturn: ["Node", "Intrinsic"]
|
||||
};
|
||||
export var nodeAndUnionTypes = ["Module", "ModuleMetadata", "ModuleNameMetadata", "FunctionNameMetadata", "LocalNameMetadata", "BinaryModule", "QuoteModule", "SectionMetadata", "ProducersSectionMetadata", "ProducerMetadata", "ProducerMetadataVersionedName", "LoopInstruction", "Instr", "IfInstruction", "StringLiteral", "NumberLiteral", "LongNumberLiteral", "FloatLiteral", "Elem", "IndexInFuncSection", "ValtypeLiteral", "TypeInstruction", "Start", "GlobalType", "LeadingComment", "BlockComment", "Data", "Global", "Table", "Memory", "FuncImportDescr", "ModuleImport", "ModuleExportDescr", "ModuleExport", "Limit", "Signature", "Program", "Identifier", "BlockInstruction", "CallInstruction", "CallIndirectInstruction", "ByteArray", "Func", "InternalBrUnless", "InternalGoto", "InternalCallExtern", "InternalEndAndReturn", "Node", "Block", "Instruction", "Expression", "NumericLiteral", "ImportDescr", "Intrinsic"];
|
||||
199
node_modules/@webassemblyjs/ast/esm/signatures.js
generated
vendored
Normal file
199
node_modules/@webassemblyjs/ast/esm/signatures.js
generated
vendored
Normal file
|
|
@ -0,0 +1,199 @@
|
|||
function sign(input, output) {
|
||||
return [input, output];
|
||||
}
|
||||
|
||||
var u32 = "u32";
|
||||
var i32 = "i32";
|
||||
var i64 = "i64";
|
||||
var f32 = "f32";
|
||||
var f64 = "f64";
|
||||
|
||||
var vector = function vector(t) {
|
||||
var vecType = [t]; // $FlowIgnore
|
||||
|
||||
vecType.vector = true;
|
||||
return vecType;
|
||||
};
|
||||
|
||||
var controlInstructions = {
|
||||
unreachable: sign([], []),
|
||||
nop: sign([], []),
|
||||
// block ?
|
||||
// loop ?
|
||||
// if ?
|
||||
// if else ?
|
||||
br: sign([u32], []),
|
||||
br_if: sign([u32], []),
|
||||
br_table: sign(vector(u32), []),
|
||||
"return": sign([], []),
|
||||
call: sign([u32], []),
|
||||
call_indirect: sign([u32], [])
|
||||
};
|
||||
var parametricInstructions = {
|
||||
drop: sign([], []),
|
||||
select: sign([], [])
|
||||
};
|
||||
var variableInstructions = {
|
||||
get_local: sign([u32], []),
|
||||
set_local: sign([u32], []),
|
||||
tee_local: sign([u32], []),
|
||||
get_global: sign([u32], []),
|
||||
set_global: sign([u32], [])
|
||||
};
|
||||
var memoryInstructions = {
|
||||
"i32.load": sign([u32, u32], [i32]),
|
||||
"i64.load": sign([u32, u32], []),
|
||||
"f32.load": sign([u32, u32], []),
|
||||
"f64.load": sign([u32, u32], []),
|
||||
"i32.load8_s": sign([u32, u32], [i32]),
|
||||
"i32.load8_u": sign([u32, u32], [i32]),
|
||||
"i32.load16_s": sign([u32, u32], [i32]),
|
||||
"i32.load16_u": sign([u32, u32], [i32]),
|
||||
"i64.load8_s": sign([u32, u32], [i64]),
|
||||
"i64.load8_u": sign([u32, u32], [i64]),
|
||||
"i64.load16_s": sign([u32, u32], [i64]),
|
||||
"i64.load16_u": sign([u32, u32], [i64]),
|
||||
"i64.load32_s": sign([u32, u32], [i64]),
|
||||
"i64.load32_u": sign([u32, u32], [i64]),
|
||||
"i32.store": sign([u32, u32], []),
|
||||
"i64.store": sign([u32, u32], []),
|
||||
"f32.store": sign([u32, u32], []),
|
||||
"f64.store": sign([u32, u32], []),
|
||||
"i32.store8": sign([u32, u32], []),
|
||||
"i32.store16": sign([u32, u32], []),
|
||||
"i64.store8": sign([u32, u32], []),
|
||||
"i64.store16": sign([u32, u32], []),
|
||||
"i64.store32": sign([u32, u32], []),
|
||||
current_memory: sign([], []),
|
||||
grow_memory: sign([], [])
|
||||
};
|
||||
var numericInstructions = {
|
||||
"i32.const": sign([i32], [i32]),
|
||||
"i64.const": sign([i64], [i64]),
|
||||
"f32.const": sign([f32], [f32]),
|
||||
"f64.const": sign([f64], [f64]),
|
||||
"i32.eqz": sign([i32], [i32]),
|
||||
"i32.eq": sign([i32, i32], [i32]),
|
||||
"i32.ne": sign([i32, i32], [i32]),
|
||||
"i32.lt_s": sign([i32, i32], [i32]),
|
||||
"i32.lt_u": sign([i32, i32], [i32]),
|
||||
"i32.gt_s": sign([i32, i32], [i32]),
|
||||
"i32.gt_u": sign([i32, i32], [i32]),
|
||||
"i32.le_s": sign([i32, i32], [i32]),
|
||||
"i32.le_u": sign([i32, i32], [i32]),
|
||||
"i32.ge_s": sign([i32, i32], [i32]),
|
||||
"i32.ge_u": sign([i32, i32], [i32]),
|
||||
"i64.eqz": sign([i64], [i64]),
|
||||
"i64.eq": sign([i64, i64], [i32]),
|
||||
"i64.ne": sign([i64, i64], [i32]),
|
||||
"i64.lt_s": sign([i64, i64], [i32]),
|
||||
"i64.lt_u": sign([i64, i64], [i32]),
|
||||
"i64.gt_s": sign([i64, i64], [i32]),
|
||||
"i64.gt_u": sign([i64, i64], [i32]),
|
||||
"i64.le_s": sign([i64, i64], [i32]),
|
||||
"i64.le_u": sign([i64, i64], [i32]),
|
||||
"i64.ge_s": sign([i64, i64], [i32]),
|
||||
"i64.ge_u": sign([i64, i64], [i32]),
|
||||
"f32.eq": sign([f32, f32], [i32]),
|
||||
"f32.ne": sign([f32, f32], [i32]),
|
||||
"f32.lt": sign([f32, f32], [i32]),
|
||||
"f32.gt": sign([f32, f32], [i32]),
|
||||
"f32.le": sign([f32, f32], [i32]),
|
||||
"f32.ge": sign([f32, f32], [i32]),
|
||||
"f64.eq": sign([f64, f64], [i32]),
|
||||
"f64.ne": sign([f64, f64], [i32]),
|
||||
"f64.lt": sign([f64, f64], [i32]),
|
||||
"f64.gt": sign([f64, f64], [i32]),
|
||||
"f64.le": sign([f64, f64], [i32]),
|
||||
"f64.ge": sign([f64, f64], [i32]),
|
||||
"i32.clz": sign([i32], [i32]),
|
||||
"i32.ctz": sign([i32], [i32]),
|
||||
"i32.popcnt": sign([i32], [i32]),
|
||||
"i32.add": sign([i32, i32], [i32]),
|
||||
"i32.sub": sign([i32, i32], [i32]),
|
||||
"i32.mul": sign([i32, i32], [i32]),
|
||||
"i32.div_s": sign([i32, i32], [i32]),
|
||||
"i32.div_u": sign([i32, i32], [i32]),
|
||||
"i32.rem_s": sign([i32, i32], [i32]),
|
||||
"i32.rem_u": sign([i32, i32], [i32]),
|
||||
"i32.and": sign([i32, i32], [i32]),
|
||||
"i32.or": sign([i32, i32], [i32]),
|
||||
"i32.xor": sign([i32, i32], [i32]),
|
||||
"i32.shl": sign([i32, i32], [i32]),
|
||||
"i32.shr_s": sign([i32, i32], [i32]),
|
||||
"i32.shr_u": sign([i32, i32], [i32]),
|
||||
"i32.rotl": sign([i32, i32], [i32]),
|
||||
"i32.rotr": sign([i32, i32], [i32]),
|
||||
"i64.clz": sign([i64], [i64]),
|
||||
"i64.ctz": sign([i64], [i64]),
|
||||
"i64.popcnt": sign([i64], [i64]),
|
||||
"i64.add": sign([i64, i64], [i64]),
|
||||
"i64.sub": sign([i64, i64], [i64]),
|
||||
"i64.mul": sign([i64, i64], [i64]),
|
||||
"i64.div_s": sign([i64, i64], [i64]),
|
||||
"i64.div_u": sign([i64, i64], [i64]),
|
||||
"i64.rem_s": sign([i64, i64], [i64]),
|
||||
"i64.rem_u": sign([i64, i64], [i64]),
|
||||
"i64.and": sign([i64, i64], [i64]),
|
||||
"i64.or": sign([i64, i64], [i64]),
|
||||
"i64.xor": sign([i64, i64], [i64]),
|
||||
"i64.shl": sign([i64, i64], [i64]),
|
||||
"i64.shr_s": sign([i64, i64], [i64]),
|
||||
"i64.shr_u": sign([i64, i64], [i64]),
|
||||
"i64.rotl": sign([i64, i64], [i64]),
|
||||
"i64.rotr": sign([i64, i64], [i64]),
|
||||
"f32.abs": sign([f32], [f32]),
|
||||
"f32.neg": sign([f32], [f32]),
|
||||
"f32.ceil": sign([f32], [f32]),
|
||||
"f32.floor": sign([f32], [f32]),
|
||||
"f32.trunc": sign([f32], [f32]),
|
||||
"f32.nearest": sign([f32], [f32]),
|
||||
"f32.sqrt": sign([f32], [f32]),
|
||||
"f32.add": sign([f32, f32], [f32]),
|
||||
"f32.sub": sign([f32, f32], [f32]),
|
||||
"f32.mul": sign([f32, f32], [f32]),
|
||||
"f32.div": sign([f32, f32], [f32]),
|
||||
"f32.min": sign([f32, f32], [f32]),
|
||||
"f32.max": sign([f32, f32], [f32]),
|
||||
"f32.copysign": sign([f32, f32], [f32]),
|
||||
"f64.abs": sign([f64], [f64]),
|
||||
"f64.neg": sign([f64], [f64]),
|
||||
"f64.ceil": sign([f64], [f64]),
|
||||
"f64.floor": sign([f64], [f64]),
|
||||
"f64.trunc": sign([f64], [f64]),
|
||||
"f64.nearest": sign([f64], [f64]),
|
||||
"f64.sqrt": sign([f64], [f64]),
|
||||
"f64.add": sign([f64, f64], [f64]),
|
||||
"f64.sub": sign([f64, f64], [f64]),
|
||||
"f64.mul": sign([f64, f64], [f64]),
|
||||
"f64.div": sign([f64, f64], [f64]),
|
||||
"f64.min": sign([f64, f64], [f64]),
|
||||
"f64.max": sign([f64, f64], [f64]),
|
||||
"f64.copysign": sign([f64, f64], [f64]),
|
||||
"i32.wrap/i64": sign([i64], [i32]),
|
||||
"i32.trunc_s/f32": sign([f32], [i32]),
|
||||
"i32.trunc_u/f32": sign([f32], [i32]),
|
||||
"i32.trunc_s/f64": sign([f32], [i32]),
|
||||
"i32.trunc_u/f64": sign([f64], [i32]),
|
||||
"i64.extend_s/i32": sign([i32], [i64]),
|
||||
"i64.extend_u/i32": sign([i32], [i64]),
|
||||
"i64.trunc_s/f32": sign([f32], [i64]),
|
||||
"i64.trunc_u/f32": sign([f32], [i64]),
|
||||
"i64.trunc_s/f64": sign([f64], [i64]),
|
||||
"i64.trunc_u/f64": sign([f64], [i64]),
|
||||
"f32.convert_s/i32": sign([i32], [f32]),
|
||||
"f32.convert_u/i32": sign([i32], [f32]),
|
||||
"f32.convert_s/i64": sign([i64], [f32]),
|
||||
"f32.convert_u/i64": sign([i64], [f32]),
|
||||
"f32.demote/f64": sign([f64], [f32]),
|
||||
"f64.convert_s/i32": sign([i32], [f64]),
|
||||
"f64.convert_u/i32": sign([i32], [f64]),
|
||||
"f64.convert_s/i64": sign([i64], [f64]),
|
||||
"f64.convert_u/i64": sign([i64], [f64]),
|
||||
"f64.promote/f32": sign([f32], [f64]),
|
||||
"i32.reinterpret/f32": sign([f32], [i32]),
|
||||
"i64.reinterpret/f64": sign([f64], [i64]),
|
||||
"f32.reinterpret/i32": sign([i32], [f32]),
|
||||
"f64.reinterpret/i64": sign([i64], [f64])
|
||||
};
|
||||
export var signatures = Object.assign({}, controlInstructions, parametricInstructions, variableInstructions, memoryInstructions, numericInstructions);
|
||||
76
node_modules/@webassemblyjs/ast/esm/transform/denormalize-type-references/index.js
generated
vendored
Normal file
76
node_modules/@webassemblyjs/ast/esm/transform/denormalize-type-references/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
var t = require("../../index"); // func and call_indirect instructions can either define a signature inline, or
|
||||
// reference a signature, e.g.
|
||||
//
|
||||
// ;; inline signature
|
||||
// (func (result i64)
|
||||
// (i64.const 2)
|
||||
// )
|
||||
// ;; signature reference
|
||||
// (type (func (result i64)))
|
||||
// (func (type 0)
|
||||
// (i64.const 2))
|
||||
// )
|
||||
//
|
||||
// this AST transform denormalises the type references, making all signatures within the module
|
||||
// inline.
|
||||
|
||||
|
||||
export function transform(ast) {
|
||||
var typeInstructions = [];
|
||||
t.traverse(ast, {
|
||||
TypeInstruction: function TypeInstruction(_ref) {
|
||||
var node = _ref.node;
|
||||
typeInstructions.push(node);
|
||||
}
|
||||
});
|
||||
|
||||
if (!typeInstructions.length) {
|
||||
return;
|
||||
}
|
||||
|
||||
function denormalizeSignature(signature) {
|
||||
// signature referenced by identifier
|
||||
if (signature.type === "Identifier") {
|
||||
var identifier = signature;
|
||||
var typeInstruction = typeInstructions.find(function (t) {
|
||||
return t.id.type === identifier.type && t.id.value === identifier.value;
|
||||
});
|
||||
|
||||
if (!typeInstruction) {
|
||||
throw new Error("A type instruction reference was not found ".concat(JSON.stringify(signature)));
|
||||
}
|
||||
|
||||
return typeInstruction.functype;
|
||||
} // signature referenced by index
|
||||
|
||||
|
||||
if (signature.type === "NumberLiteral") {
|
||||
var signatureRef = signature;
|
||||
var _typeInstruction = typeInstructions[signatureRef.value];
|
||||
return _typeInstruction.functype;
|
||||
}
|
||||
|
||||
return signature;
|
||||
}
|
||||
|
||||
t.traverse(ast, {
|
||||
Func: function (_Func) {
|
||||
function Func(_x) {
|
||||
return _Func.apply(this, arguments);
|
||||
}
|
||||
|
||||
Func.toString = function () {
|
||||
return _Func.toString();
|
||||
};
|
||||
|
||||
return Func;
|
||||
}(function (_ref2) {
|
||||
var node = _ref2.node;
|
||||
node.signature = denormalizeSignature(node.signature);
|
||||
}),
|
||||
CallIndirectInstruction: function CallIndirectInstruction(_ref3) {
|
||||
var node = _ref3.node;
|
||||
node.signature = denormalizeSignature(node.signature);
|
||||
}
|
||||
});
|
||||
}
|
||||
229
node_modules/@webassemblyjs/ast/esm/transform/wast-identifier-to-index/index.js
generated
vendored
Normal file
229
node_modules/@webassemblyjs/ast/esm/transform/wast-identifier-to-index/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,229 @@
|
|||
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
||||
|
||||
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
|
||||
|
||||
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
||||
|
||||
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
||||
|
||||
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
||||
|
||||
function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_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"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
||||
|
||||
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
||||
|
||||
import { isBlock, isFunc, isIdentifier, numberLiteralFromRaw, traverse } from "../../index";
|
||||
import { moduleContextFromModuleAST } from "../ast-module-to-module-context"; // FIXME(sven): do the same with all block instructions, must be more generic here
|
||||
|
||||
function newUnexpectedFunction(i) {
|
||||
return new Error("unknown function at offset: " + i);
|
||||
}
|
||||
|
||||
export function transform(ast) {
|
||||
var module = null;
|
||||
traverse(ast, {
|
||||
Module: function (_Module) {
|
||||
function Module(_x) {
|
||||
return _Module.apply(this, arguments);
|
||||
}
|
||||
|
||||
Module.toString = function () {
|
||||
return _Module.toString();
|
||||
};
|
||||
|
||||
return Module;
|
||||
}(function (path) {
|
||||
module = path.node;
|
||||
})
|
||||
});
|
||||
|
||||
if (module == null) {
|
||||
throw new Error("Module not foudn in program");
|
||||
}
|
||||
|
||||
var moduleContext = moduleContextFromModuleAST(module); // Transform the actual instruction in function bodies
|
||||
|
||||
traverse(ast, {
|
||||
Func: function (_Func) {
|
||||
function Func(_x2) {
|
||||
return _Func.apply(this, arguments);
|
||||
}
|
||||
|
||||
Func.toString = function () {
|
||||
return _Func.toString();
|
||||
};
|
||||
|
||||
return Func;
|
||||
}(function (path) {
|
||||
transformFuncPath(path, moduleContext);
|
||||
}),
|
||||
Start: function (_Start) {
|
||||
function Start(_x3) {
|
||||
return _Start.apply(this, arguments);
|
||||
}
|
||||
|
||||
Start.toString = function () {
|
||||
return _Start.toString();
|
||||
};
|
||||
|
||||
return Start;
|
||||
}(function (path) {
|
||||
var index = path.node.index;
|
||||
|
||||
if (isIdentifier(index) === true) {
|
||||
var offsetInModule = moduleContext.getFunctionOffsetByIdentifier(index.value);
|
||||
|
||||
if (typeof offsetInModule === "undefined") {
|
||||
throw newUnexpectedFunction(index.value);
|
||||
} // Replace the index Identifier
|
||||
// $FlowIgnore: reference?
|
||||
|
||||
|
||||
path.node.index = numberLiteralFromRaw(offsetInModule);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
function transformFuncPath(funcPath, moduleContext) {
|
||||
var funcNode = funcPath.node;
|
||||
var signature = funcNode.signature;
|
||||
|
||||
if (signature.type !== "Signature") {
|
||||
throw new Error("Function signatures must be denormalised before execution");
|
||||
}
|
||||
|
||||
var params = signature.params; // Add func locals in the context
|
||||
|
||||
params.forEach(function (p) {
|
||||
return moduleContext.addLocal(p.valtype);
|
||||
});
|
||||
traverse(funcNode, {
|
||||
Instr: function (_Instr) {
|
||||
function Instr(_x4) {
|
||||
return _Instr.apply(this, arguments);
|
||||
}
|
||||
|
||||
Instr.toString = function () {
|
||||
return _Instr.toString();
|
||||
};
|
||||
|
||||
return Instr;
|
||||
}(function (instrPath) {
|
||||
var instrNode = instrPath.node;
|
||||
/**
|
||||
* Local access
|
||||
*/
|
||||
|
||||
if (instrNode.id === "get_local" || instrNode.id === "set_local" || instrNode.id === "tee_local") {
|
||||
var _instrNode$args = _slicedToArray(instrNode.args, 1),
|
||||
firstArg = _instrNode$args[0];
|
||||
|
||||
if (firstArg.type === "Identifier") {
|
||||
var offsetInParams = params.findIndex(function (_ref) {
|
||||
var id = _ref.id;
|
||||
return id === firstArg.value;
|
||||
});
|
||||
|
||||
if (offsetInParams === -1) {
|
||||
throw new Error("".concat(firstArg.value, " not found in ").concat(instrNode.id, ": not declared in func params"));
|
||||
} // Replace the Identifer node by our new NumberLiteral node
|
||||
|
||||
|
||||
instrNode.args[0] = numberLiteralFromRaw(offsetInParams);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Global access
|
||||
*/
|
||||
|
||||
|
||||
if (instrNode.id === "get_global" || instrNode.id === "set_global") {
|
||||
var _instrNode$args2 = _slicedToArray(instrNode.args, 1),
|
||||
_firstArg = _instrNode$args2[0];
|
||||
|
||||
if (isIdentifier(_firstArg) === true) {
|
||||
var globalOffset = moduleContext.getGlobalOffsetByIdentifier( // $FlowIgnore: reference?
|
||||
_firstArg.value);
|
||||
|
||||
if (typeof globalOffset === "undefined") {
|
||||
// $FlowIgnore: reference?
|
||||
throw new Error("global ".concat(_firstArg.value, " not found in module"));
|
||||
} // Replace the Identifer node by our new NumberLiteral node
|
||||
|
||||
|
||||
instrNode.args[0] = numberLiteralFromRaw(globalOffset);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Labels lookup
|
||||
*/
|
||||
|
||||
|
||||
if (instrNode.id === "br") {
|
||||
var _instrNode$args3 = _slicedToArray(instrNode.args, 1),
|
||||
_firstArg2 = _instrNode$args3[0];
|
||||
|
||||
if (isIdentifier(_firstArg2) === true) {
|
||||
// if the labels is not found it is going to be replaced with -1
|
||||
// which is invalid.
|
||||
var relativeBlockCount = -1; // $FlowIgnore: reference?
|
||||
|
||||
instrPath.findParent(function (_ref2) {
|
||||
var node = _ref2.node;
|
||||
|
||||
if (isBlock(node)) {
|
||||
relativeBlockCount++; // $FlowIgnore: reference?
|
||||
|
||||
var name = node.label || node.name;
|
||||
|
||||
if (_typeof(name) === "object") {
|
||||
// $FlowIgnore: isIdentifier ensures that
|
||||
if (name.value === _firstArg2.value) {
|
||||
// Found it
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (isFunc(node)) {
|
||||
return false;
|
||||
}
|
||||
}); // Replace the Identifer node by our new NumberLiteral node
|
||||
|
||||
instrNode.args[0] = numberLiteralFromRaw(relativeBlockCount);
|
||||
}
|
||||
}
|
||||
}),
|
||||
|
||||
/**
|
||||
* Func lookup
|
||||
*/
|
||||
CallInstruction: function (_CallInstruction) {
|
||||
function CallInstruction(_x5) {
|
||||
return _CallInstruction.apply(this, arguments);
|
||||
}
|
||||
|
||||
CallInstruction.toString = function () {
|
||||
return _CallInstruction.toString();
|
||||
};
|
||||
|
||||
return CallInstruction;
|
||||
}(function (_ref3) {
|
||||
var node = _ref3.node;
|
||||
var index = node.index;
|
||||
|
||||
if (isIdentifier(index) === true) {
|
||||
var offsetInModule = moduleContext.getFunctionOffsetByIdentifier(index.value);
|
||||
|
||||
if (typeof offsetInModule === "undefined") {
|
||||
throw newUnexpectedFunction(index.value);
|
||||
} // Replace the index Identifier
|
||||
// $FlowIgnore: reference?
|
||||
|
||||
|
||||
node.index = numberLiteralFromRaw(offsetInModule);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
96
node_modules/@webassemblyjs/ast/esm/traverse.js
generated
vendored
Normal file
96
node_modules/@webassemblyjs/ast/esm/traverse.js
generated
vendored
Normal file
|
|
@ -0,0 +1,96 @@
|
|||
import { createPath } from "./node-path";
|
||||
import { unionTypesMap, nodeAndUnionTypes } from "./nodes"; // recursively walks the AST starting at the given node. The callback is invoked for
|
||||
// and object that has a 'type' property.
|
||||
|
||||
function walk(context, callback) {
|
||||
var stop = false;
|
||||
|
||||
function innerWalk(context, callback) {
|
||||
if (stop) {
|
||||
return;
|
||||
}
|
||||
|
||||
var node = context.node;
|
||||
|
||||
if (node === undefined) {
|
||||
console.warn("traversing with an empty context");
|
||||
return;
|
||||
}
|
||||
|
||||
if (node._deleted === true) {
|
||||
return;
|
||||
}
|
||||
|
||||
var path = createPath(context);
|
||||
callback(node.type, path);
|
||||
|
||||
if (path.shouldStop) {
|
||||
stop = true;
|
||||
return;
|
||||
}
|
||||
|
||||
Object.keys(node).forEach(function (prop) {
|
||||
var value = node[prop];
|
||||
|
||||
if (value === null || value === undefined) {
|
||||
return;
|
||||
}
|
||||
|
||||
var valueAsArray = Array.isArray(value) ? value : [value];
|
||||
valueAsArray.forEach(function (childNode) {
|
||||
if (typeof childNode.type === "string") {
|
||||
var childContext = {
|
||||
node: childNode,
|
||||
parentKey: prop,
|
||||
parentPath: path,
|
||||
shouldStop: false,
|
||||
inList: Array.isArray(value)
|
||||
};
|
||||
innerWalk(childContext, callback);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
innerWalk(context, callback);
|
||||
}
|
||||
|
||||
var noop = function noop() {};
|
||||
|
||||
export function traverse(node, visitors) {
|
||||
var before = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : noop;
|
||||
var after = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : noop;
|
||||
Object.keys(visitors).forEach(function (visitor) {
|
||||
if (!nodeAndUnionTypes.includes(visitor)) {
|
||||
throw new Error("Unexpected visitor ".concat(visitor));
|
||||
}
|
||||
});
|
||||
var context = {
|
||||
node: node,
|
||||
inList: false,
|
||||
shouldStop: false,
|
||||
parentPath: null,
|
||||
parentKey: null
|
||||
};
|
||||
walk(context, function (type, path) {
|
||||
if (typeof visitors[type] === "function") {
|
||||
before(type, path);
|
||||
visitors[type](path);
|
||||
after(type, path);
|
||||
}
|
||||
|
||||
var unionTypes = unionTypesMap[type];
|
||||
|
||||
if (!unionTypes) {
|
||||
throw new Error("Unexpected node type ".concat(type));
|
||||
}
|
||||
|
||||
unionTypes.forEach(function (unionType) {
|
||||
if (typeof visitors[unionType] === "function") {
|
||||
before(unionType, path);
|
||||
visitors[unionType](path);
|
||||
after(unionType, path);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
0
node_modules/@webassemblyjs/ast/esm/types/basic.js
generated
vendored
Normal file
0
node_modules/@webassemblyjs/ast/esm/types/basic.js
generated
vendored
Normal file
0
node_modules/@webassemblyjs/ast/esm/types/nodes.js
generated
vendored
Normal file
0
node_modules/@webassemblyjs/ast/esm/types/nodes.js
generated
vendored
Normal file
0
node_modules/@webassemblyjs/ast/esm/types/traverse.js
generated
vendored
Normal file
0
node_modules/@webassemblyjs/ast/esm/types/traverse.js
generated
vendored
Normal file
272
node_modules/@webassemblyjs/ast/esm/utils.js
generated
vendored
Normal file
272
node_modules/@webassemblyjs/ast/esm/utils.js
generated
vendored
Normal file
|
|
@ -0,0 +1,272 @@
|
|||
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
|
||||
|
||||
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
||||
|
||||
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
||||
|
||||
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
||||
|
||||
function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_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"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
||||
|
||||
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
||||
|
||||
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
||||
|
||||
import { signatures } from "./signatures";
|
||||
import { traverse } from "./traverse";
|
||||
import constants from "@webassemblyjs/helper-wasm-bytecode";
|
||||
import { getSectionForNode } from "@webassemblyjs/helper-wasm-bytecode";
|
||||
export function isAnonymous(ident) {
|
||||
return ident.raw === "";
|
||||
}
|
||||
export function getSectionMetadata(ast, name) {
|
||||
var section;
|
||||
traverse(ast, {
|
||||
SectionMetadata: function (_SectionMetadata) {
|
||||
function SectionMetadata(_x) {
|
||||
return _SectionMetadata.apply(this, arguments);
|
||||
}
|
||||
|
||||
SectionMetadata.toString = function () {
|
||||
return _SectionMetadata.toString();
|
||||
};
|
||||
|
||||
return SectionMetadata;
|
||||
}(function (_ref) {
|
||||
var node = _ref.node;
|
||||
|
||||
if (node.section === name) {
|
||||
section = node;
|
||||
}
|
||||
})
|
||||
});
|
||||
return section;
|
||||
}
|
||||
export function getSectionMetadatas(ast, name) {
|
||||
var sections = [];
|
||||
traverse(ast, {
|
||||
SectionMetadata: function (_SectionMetadata2) {
|
||||
function SectionMetadata(_x2) {
|
||||
return _SectionMetadata2.apply(this, arguments);
|
||||
}
|
||||
|
||||
SectionMetadata.toString = function () {
|
||||
return _SectionMetadata2.toString();
|
||||
};
|
||||
|
||||
return SectionMetadata;
|
||||
}(function (_ref2) {
|
||||
var node = _ref2.node;
|
||||
|
||||
if (node.section === name) {
|
||||
sections.push(node);
|
||||
}
|
||||
})
|
||||
});
|
||||
return sections;
|
||||
}
|
||||
export function sortSectionMetadata(m) {
|
||||
if (m.metadata == null) {
|
||||
console.warn("sortSectionMetadata: no metadata to sort");
|
||||
return;
|
||||
} // $FlowIgnore
|
||||
|
||||
|
||||
m.metadata.sections.sort(function (a, b) {
|
||||
var aId = constants.sections[a.section];
|
||||
var bId = constants.sections[b.section];
|
||||
|
||||
if (typeof aId !== "number" || typeof bId !== "number") {
|
||||
throw new Error("Section id not found");
|
||||
}
|
||||
|
||||
return aId - bId;
|
||||
});
|
||||
}
|
||||
export function orderedInsertNode(m, n) {
|
||||
assertHasLoc(n);
|
||||
var didInsert = false;
|
||||
|
||||
if (n.type === "ModuleExport") {
|
||||
m.fields.push(n);
|
||||
return;
|
||||
}
|
||||
|
||||
m.fields = m.fields.reduce(function (acc, field) {
|
||||
var fieldEndCol = Infinity;
|
||||
|
||||
if (field.loc != null) {
|
||||
// $FlowIgnore
|
||||
fieldEndCol = field.loc.end.column;
|
||||
} // $FlowIgnore: assertHasLoc ensures that
|
||||
|
||||
|
||||
if (didInsert === false && n.loc.start.column < fieldEndCol) {
|
||||
didInsert = true;
|
||||
acc.push(n);
|
||||
}
|
||||
|
||||
acc.push(field);
|
||||
return acc;
|
||||
}, []); // Handles empty modules or n is the last element
|
||||
|
||||
if (didInsert === false) {
|
||||
m.fields.push(n);
|
||||
}
|
||||
}
|
||||
export function assertHasLoc(n) {
|
||||
if (n.loc == null || n.loc.start == null || n.loc.end == null) {
|
||||
throw new Error("Internal failure: node (".concat(JSON.stringify(n.type), ") has no location information"));
|
||||
}
|
||||
}
|
||||
export function getEndOfSection(s) {
|
||||
assertHasLoc(s.size);
|
||||
return s.startOffset + s.size.value + (s.size.loc.end.column - s.size.loc.start.column);
|
||||
}
|
||||
export function shiftLoc(node, delta) {
|
||||
// $FlowIgnore
|
||||
node.loc.start.column += delta; // $FlowIgnore
|
||||
|
||||
node.loc.end.column += delta;
|
||||
}
|
||||
export function shiftSection(ast, node, delta) {
|
||||
if (node.type !== "SectionMetadata") {
|
||||
throw new Error("Can not shift node " + JSON.stringify(node.type));
|
||||
}
|
||||
|
||||
node.startOffset += delta;
|
||||
|
||||
if (_typeof(node.size.loc) === "object") {
|
||||
shiftLoc(node.size, delta);
|
||||
} // Custom sections doesn't have vectorOfSize
|
||||
|
||||
|
||||
if (_typeof(node.vectorOfSize) === "object" && _typeof(node.vectorOfSize.loc) === "object") {
|
||||
shiftLoc(node.vectorOfSize, delta);
|
||||
}
|
||||
|
||||
var sectionName = node.section; // shift node locations within that section
|
||||
|
||||
traverse(ast, {
|
||||
Node: function Node(_ref3) {
|
||||
var node = _ref3.node;
|
||||
var section = getSectionForNode(node);
|
||||
|
||||
if (section === sectionName && _typeof(node.loc) === "object") {
|
||||
shiftLoc(node, delta);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
export function signatureForOpcode(object, name) {
|
||||
var opcodeName = name;
|
||||
|
||||
if (object !== undefined && object !== "") {
|
||||
opcodeName = object + "." + name;
|
||||
}
|
||||
|
||||
var sign = signatures[opcodeName];
|
||||
|
||||
if (sign == undefined) {
|
||||
// TODO: Uncomment this when br_table and others has been done
|
||||
//throw new Error("Invalid opcode: "+opcodeName);
|
||||
return [object, object];
|
||||
}
|
||||
|
||||
return sign[0];
|
||||
}
|
||||
export function getUniqueNameGenerator() {
|
||||
var inc = {};
|
||||
return function () {
|
||||
var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "temp";
|
||||
|
||||
if (!(prefix in inc)) {
|
||||
inc[prefix] = 0;
|
||||
} else {
|
||||
inc[prefix] = inc[prefix] + 1;
|
||||
}
|
||||
|
||||
return prefix + "_" + inc[prefix];
|
||||
};
|
||||
}
|
||||
export function getStartByteOffset(n) {
|
||||
// $FlowIgnore
|
||||
if (typeof n.loc === "undefined" || typeof n.loc.start === "undefined") {
|
||||
throw new Error( // $FlowIgnore
|
||||
"Can not get byte offset without loc informations, node: " + String(n.id));
|
||||
}
|
||||
|
||||
return n.loc.start.column;
|
||||
}
|
||||
export function getEndByteOffset(n) {
|
||||
// $FlowIgnore
|
||||
if (typeof n.loc === "undefined" || typeof n.loc.end === "undefined") {
|
||||
throw new Error("Can not get byte offset without loc informations, node: " + n.type);
|
||||
}
|
||||
|
||||
return n.loc.end.column;
|
||||
}
|
||||
export function getFunctionBeginingByteOffset(n) {
|
||||
if (!(n.body.length > 0)) {
|
||||
throw new Error('n.body.length > 0' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var _n$body = _slicedToArray(n.body, 1),
|
||||
firstInstruction = _n$body[0];
|
||||
|
||||
return getStartByteOffset(firstInstruction);
|
||||
}
|
||||
export function getEndBlockByteOffset(n) {
|
||||
// $FlowIgnore
|
||||
if (!(n.instr.length > 0 || n.body.length > 0)) {
|
||||
throw new Error('n.instr.length > 0 || n.body.length > 0' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var lastInstruction;
|
||||
|
||||
if (n.instr) {
|
||||
// $FlowIgnore
|
||||
lastInstruction = n.instr[n.instr.length - 1];
|
||||
}
|
||||
|
||||
if (n.body) {
|
||||
// $FlowIgnore
|
||||
lastInstruction = n.body[n.body.length - 1];
|
||||
}
|
||||
|
||||
if (!(_typeof(lastInstruction) === "object")) {
|
||||
throw new Error('typeof lastInstruction === "object"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
// $FlowIgnore
|
||||
return getStartByteOffset(lastInstruction);
|
||||
}
|
||||
export function getStartBlockByteOffset(n) {
|
||||
// $FlowIgnore
|
||||
if (!(n.instr.length > 0 || n.body.length > 0)) {
|
||||
throw new Error('n.instr.length > 0 || n.body.length > 0' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
var fistInstruction;
|
||||
|
||||
if (n.instr) {
|
||||
// $FlowIgnore
|
||||
var _n$instr = _slicedToArray(n.instr, 1);
|
||||
|
||||
fistInstruction = _n$instr[0];
|
||||
}
|
||||
|
||||
if (n.body) {
|
||||
// $FlowIgnore
|
||||
var _n$body2 = _slicedToArray(n.body, 1);
|
||||
|
||||
fistInstruction = _n$body2[0];
|
||||
}
|
||||
|
||||
if (!(_typeof(fistInstruction) === "object")) {
|
||||
throw new Error('typeof fistInstruction === "object"' + " error: " + (undefined || "unknown"));
|
||||
}
|
||||
|
||||
// $FlowIgnore
|
||||
return getStartByteOffset(fistInstruction);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue