From e06ec920f7a5d784e674c4c4b4e6d1da3dc7391d Mon Sep 17 00:00:00 2001
From: Piotr Russ <mail@pruss.it>
Date: Mon, 16 Nov 2020 00:10:28 +0100
Subject: api, login, auth

---
 node_modules/@webassemblyjs/ast/esm/definitions.js | 663 +++++++++++++++++++++
 1 file changed, 663 insertions(+)
 create mode 100644 node_modules/@webassemblyjs/ast/esm/definitions.js

(limited to 'node_modules/@webassemblyjs/ast/esm/definitions.js')

diff --git a/node_modules/@webassemblyjs/ast/esm/definitions.js b/node_modules/@webassemblyjs/ast/esm/definitions.js
new file mode 100644
index 0000000..120311b
--- /dev/null
+++ b/node_modules/@webassemblyjs/ast/esm/definitions.js
@@ -0,0 +1,663 @@
+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"
+    }
+  }
+});
+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;
\ No newline at end of file
-- 
cgit v1.2.3