30:T7ac, In this implementation, we define enum objects as regular JavaScript objects with a `tag` property that identifies the variant, and an optional `value` property that holds any associated data. Unlike some other implementations, this one does not make the enum objects immutable. They can be modified after creation by changing the `tag` or `value` properties, or adding new properties to the objects. Whether or not the enum objects should be mutable depends on the requirements of your application. If you need the enum objects to be immutable, you can use techniques like `Object.freeze` (in modern JavaScript) or `Object.defineProperty` (in older versions of JavaScript) to make the objects and their properties non-writable and non-configurable. Example usage: - Define an enum for a result type: ```javascript var Result = { tag: 'success', // The 'success' variant value: null }; ``` - Define an enum for an error type: ```javascript var Error = { tag: 'failure', // The 'failure' variant value: { reason: 'Something went wrong' } }; ``` - Define an enum for a value type: ```javascript var Value = { tag: 'value', // The 'value' variant value: 42 }; ``` To use the enum, you can check the 'tag' property to determine the variant, and access the 'value' property to get any associated data. Example usage: ```javascript function handleResult(result) { switch (result.tag) { case 'success': console.log('Operation was successful'); break; case 'failure': console.log('Operation failed: ' + result.value.reason); break; case 'value': console.log('The value is: ' + result.value); break; // Handle other variants as needed default: console.log('Unknown result variant'); } } // Example usage handleResult(Result); // Output: Operation was successful handleResult(Error); // Output: Operation failed: Something went wrong handleResult(Value); // Output: The value is: 42 ``` 31:T444,Result = { function Result(tag, value) { this.tag = tag; this.value = value; } Result.ok = function (value) { return new Result("ok", value); }; Result.error = function (value) { return new Result("error", value); }; Result.prototype.unwrap = function () { if (this.tag === "ok") { return this.value; } else { throw new Error("called `Result.unwrap()` on an `Error` value"); } }; Result.prototype.expect = function (message) { if (this.tag === "ok") { return this.value; } else { throw new Error(message); } }; Result.prototype.okMap = function (fn) { if (this.tag === "ok") { return Result.ok(fn(this.value)); } else { return this; } }; Result.prototype.errMap = function (fn) { if (this.tag === "error") { return Result.error(fn(this.value)); } else { return this; } }; Result.prototype.isErr = function () { return this.tag === "error"; }; Result.prototype.isOk = function () { return this.tag === "ok"; }; return Result; }32:T5e1,// Concatenate parser: applies multiple parsers sequentially. function concatP(parsers) { return function (index, bytes) { let currentIndex = index; const results = []; let start = -1; let end = -1; for (let i = 0; i < parsers.length; i++) { const parser = parsers[i]; const result = parser(currentIndex, bytes); // If the parser returns an error, propagate the error. if (result.isErr()) { return result.errMap((_) => ["concatP", _]); } const { nextIndex, value } = result.unwrap(); if ( !(Object.keys(value).length == 2 && "value" in value && "tag" in value) ) { return Result.error([ "concatP:Parser returns ok, but it must be object {tag,value}, returned: ", value ]); } // Set the start index to the start of the first parsed value. if (start === -1) { start = value.value.start; // Assumes that `value` is an enum object with a `value` property. } // Set/update the end index to the end of the last parsed value. end = value.value.end; results.push(value); currentIndex = nextIndex; } const concatEnum = { tag: "concatEnum", value: { start: start, end: end, get value() { // Returns an array of the values of the individual parsers. return results; } } }; return Result.ok({ nextIndex: currentIndex, value: concatEnum }); }; }33:T6d5,// expectP function: takes a parser and returns an object with the toBe method. function expectP(parser) { // Default error message formatter that takes expected and actual values and returns a formatted error message. function defaultErrorMessageFormatter(expected, actual) { const expectedFormatted = typeof expected === "function" ? "the provided condition" : `0x${expected.toString(16).toUpperCase()}`; const actualFormatted = `0x${actual.toString(16).toUpperCase()}`; return `Expected value to be ${expectedFormatted}, but found ${actualFormatted}.`; } return { // The toBe method: creates a parser that asserts the value to be equal to `val`. // The `err` is an optional custom error message or formatter function. toBe: function (val, err) { const errorMessageFormatter = err || defaultErrorMessageFormatter; return function (index, bytes) { const result = parser(index, bytes); // If the parser failed, propagate the error. if (result.isErr()) { return result; } const { value, nextIndex } = result.unwrap(); const actualValue = value.value.value; const checkPassed = typeof val === "function" ? val(actualValue) : actualValue === val; // If check fails, return an error with the formatted message using the provided or default formatter. if (!checkPassed) { const errorMessage = typeof err === "function" ? err(actualValue) : errorMessageFormatter(val, actualValue); return Result.error(errorMessage); } // If the check passes, return the result unchanged. return result; }; } }; }34:T417,function createConstantInfoParser(tag, fields) { return function (index, bytes) { let currentIndex = index; let start = -1; let end = -1; const valueObject = {}; for (const [fieldParser, key] of fields) { const result = fieldParser(currentIndex, bytes); if (result.isErr()) { return result.errMap((_) => ["createConstantInfoParser", tag, _]); // Propagate the error } const { value, nextIndex } = result.unwrap(); if ( !(Object.keys(value).length == 2 && "value" in value && "tag" in value) ) { return Result.error([ "createConstantInfoParser:Parser returns ok, but it must be object {tag,value}, returned: ", value ]); } valueObject[key] = value.value; currentIndex = nextIndex; } const parsedResult = { tag: tag, value: { start: index, end: currentIndex, value: valueObject } }; return Result.ok({ nextIndex: currentIndex, value: parsedResult }); }; }35:T8a7,//Example, this does not handle sizes /*{ class Struct { constructor(data) { this.data = data; this.keys = Object.keys(data); } get(keyOrIndex) { if (typeof keyOrIndex === "number") { return this.data[this.keys[keyOrIndex]]; } return this.data[keyOrIndex]; } *[Symbol.iterator]() { for (const value of Object.values(this.data)) { yield value; } } values() { return Object.values(this.data); } keys() { return [...this.keys]; } } class StructConstructor { constructor() { this.bufferSizeMap = new WeakMap(); } registerBufferSize(parser, size) { this.bufferSizeMap.set(parser, size); } createStruct(parsers, bytes = null) { if (!Array.isArray(parsers)) { throw new TypeError( "parsers must be an array of parsers or [name, parser] pairs" ); } const structData = {}; let currentIndex = 0; let bufferSize = bytes ? bytes.length : 1024; bytes = bytes || new Uint8Array(bufferSize); for (let item of parsers) { let parser, name; if (Array.isArray(item)) { [name, parser] = item; } else { parser = item; name = undefined; // No specific name assigned } if (typeof parser !== "function") { throw new TypeError("Each parser must be a function"); } const result = parser(currentIndex, bytes); if (result.isErr()) { throw new Error(result.unwrapErr()); } const { value, nextIndex } = result.unwrap(); const key = name || `field${Object.keys(structData).length}`; structData[key] = value.value; // Assuming value property returns the needed result currentIndex = nextIndex; } return { struct: new Struct(structData), buffer: bytes.slice(0, currentIndex) // Only use relevant part of the buffer }; } } // Example usage: const structConstructor = new StructConstructor(); const { struct, buffer } = structConstructor.createStruct([ ["intValue", u4le], u1 ]); return [struct, buffer]; }*/36:[] 2e:{"title":"Parser combinator","cells":[{"id":0,"value":"# Parser combinator","pinned":false,"hidden":false,"mode":"md"},{"id":5,"value":"$30","pinned":false,"hidden":false,"mode":"md"},{"id":7,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":12,"value":"function u1(index, bytes) {\n if (index >= bytes.length) {\n return Result.error(`u1: Index out of bounds: Index ${index} exceeds the length of the byte array (${bytes.length})`);\n }\n\n var start = index;\n var end = index + 1;\n\n var u1Enum = {\n tag: \"u1\",\n value: {\n start: start,\n end: end,\n get value() {\n return bytes[start];\n },\n set value(newValue) {\n if (newValue >= 0 && newValue <= 255) {\n bytes[start] = newValue;\n } else {\n throw new Error(\"Invalid value for u1: \" + newValue);\n }\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: u1Enum });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":15,"value":"function applyNTimes(parser, n) {\n return function (index, bytes) {\n let currentIndex = index;\n let values = [];\n\n for (let i = 0; i < n; i++) {\n const result = parser(currentIndex, bytes);\n\n if (result.isErr()) {\n return result.errMap((_) => [\n \"applyNTimes:\" +\n n +\n \",iteration:\" +\n i +\n \",index:\" +\n currentIndex.toString(16),\n _,\n values\n ]); // Propagate the error\n }\n\n const { value, nextIndex } = result.unwrap();\n\n values.push(value);\n currentIndex = nextIndex;\n }\n const repeatEnum = {\n tag: \"repeatEnum\",\n value: {\n start: index,\n end: currentIndex,\n get value() {\n // Returns an array of the values of the individual parsers.\n return values;\n }\n }\n };\n\n return Result.ok({ nextIndex: currentIndex, value: repeatEnum });\n };\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":18,"value":"function u2be(index, bytes) {\n if (index + 1 >= bytes.length) {\n return Result.error('Index out of bounds');\n }\n\n var start = index;\n var end = index + 2;\n\n var u2beEnum = {\n tag: 'u2be',\n value: {\n start: start,\n end: end,\n get value() {\n return new DataView(bytes.buffer).getUint16(start, false);\n },\n set value(newValue) {\n if (newValue >= 0 && newValue <= 65535) {\n new DataView(bytes.buffer).setUint16(start, newValue, false);\n } else {\n throw new Error('Invalid value for u2be: ' + newValue);\n }\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: u2beEnum });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":20,"value":"function u2le(index, bytes) {\n if (index + 1 >= bytes.length) {\n return Result.error('Index out of bounds');\n }\n\n var start = index;\n var end = index + 2;\n\n var u2leEnum = {\n tag: 'u2le',\n value: {\n start: start,\n end: end,\n get value() {\n return new DataView(bytes.buffer).getUint16(start, true);\n },\n set value(newValue) {\n if (newValue >= 0 && newValue <= 65535) {\n new DataView(bytes.buffer).setUint16(start, newValue, true);\n } else {\n throw new Error('Invalid value for u2le: ' + newValue);\n }\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: u2leEnum });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":22,"value":"function u4be(index, bytes) {\n if (index + 3 >= bytes.length) {\n return Result.error('Index out of bounds');\n }\n\n var start = index;\n var end = index + 4;\n\n var u4beEnum = {\n tag: 'u4be',\n value: {\n start: start,\n end: end,\n get value() {\n return new DataView(bytes.buffer).getUint32(start, false);\n },\n set value(newValue) {\n if (newValue >= 0 && newValue <= 4294967295) {\n new DataView(bytes.buffer).setUint32(start, newValue, false);\n } else {\n throw new Error('Invalid value for u4be: ' + newValue);\n }\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: u4beEnum });\n}\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":24,"value":"\nfunction u4le(index, bytes) {\n if (index + 3 >= bytes.length) {\n return Result.error('Index out of bounds');\n }\n\n var start = index;\n var end = index + 4;\n\n var u4leEnum = {\n tag: 'u4le',\n value: {\n start: start,\n end: end,\n get value() {\n return new DataView(bytes.buffer).getUint32(start, true);\n },\n set value(newValue) {\n console.log(\"you are setting me\")\n if (newValue >= 0 && newValue <= 4294967295) {\n new DataView(bytes.buffer).setUint32(start, newValue, true);\n } else {\n throw new Error('Invalid value for u4le: ' + newValue);\n }\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: u4leEnum });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":35,"value":"function u8be(index, bytes) {\n if (index + 7 >= bytes.length) {\n return Result.error('Index out of bounds');\n }\n\n var start = index;\n var end = index + 8;\n\n var u8beEnum = {\n tag: 'u8be',\n value: {\n start: start,\n end: end,\n get value() {\n var array = new Uint8Array(bytes.buffer, start, 8);\n var result = BigInt(0);\n for (var i = 0; i < 8; i++) {\n result = (result << 8n) + BigInt(array[i]);\n }\n return result;\n },\n set value(newValue) {\n if (newValue >= 0n && newValue <= 18446744073709551615n) {\n var array = new Uint8Array(bytes.buffer, start, 8);\n for (var i = 0; i < 8; i++) {\n array[7 - i] = Number((newValue >> BigInt(8 * i)) & 0xffn);\n }\n } else {\n throw new Error('Invalid value for u8be: ' + newValue);\n }\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: u8beEnum });\n}\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":37,"value":"\nfunction u8le(index, bytes) {\n if (index + 7 >= bytes.length) {\n return Result.error('Index out of bounds');\n }\n\n var start = index;\n var end = index + 8;\n\n var u8leEnum = {\n tag: 'u8le',\n value: {\n start: start,\n end: end,\n get value() {\n var array = new Uint8Array(bytes.buffer, start, 8);\n var result = BigInt(0);\n for (var i = 0; i < 8; i++) {\n result = (result << 8n) + BigInt(array[7 - i]);\n }\n return result;\n },\n set value(newValue) {\n if (newValue >= 0n && newValue <= 18446744073709551615n) {\n var array = new Uint8Array(bytes.buffer, start, 8);\n for (var i = 0; i < 8; i++) {\n array[i] = Number((newValue >> BigInt(8 * i)) & 0xffn);\n }\n } else {\n throw new Error('Invalid value for u8le: ' + newValue);\n }\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: u8leEnum });\n}\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":39,"value":"function f4be(index, bytes) {\n if (index + 3 >= bytes.length) {\n return Result.error(\"Index out of bounds\");\n }\n\n var start = index;\n var end = index + 4;\n\n var f4beEnum = {\n tag: \"f4be\",\n value: {\n start: start,\n end: end,\n get value() {\n return new DataView(bytes.buffer).getFloat32(start, false);\n },\n set value(newValue) {\n new DataView(bytes.buffer).setFloat32(start, newValue, false);\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: f4beEnum });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":41,"value":"function f4le(index, bytes) {\n if (index + 3 >= bytes.length) {\n return Result.error(\"Index out of bounds\");\n }\n\n var start = index;\n var end = index + 4;\n\n var f4leEnum = {\n tag: \"f4le\",\n value: {\n start: start,\n end: end,\n get value() {\n return new DataView(bytes.buffer).getFloat32(start, true);\n },\n set value(newValue) {\n new DataView(bytes.buffer).setFloat32(start, newValue, true);\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: f4leEnum });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":46,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":57,"value":"function takeN(n) {\n return function (index, bytes) {\n if (index + n > bytes.length) {\n return Result.error(\n `takeN: Index out of bounds: Required ${n} bytes but only ${\n bytes.length - index\n } bytes available`\n );\n }\n\n var start = index;\n var end = index + n;\n\n var bufferView = {\n tag: \"bufferView\",\n value: {\n start: start,\n end: end,\n get value() {\n return bytes.slice(start, end);\n },\n set value(newValue) {\n if (newValue.length === n) {\n for (var i = 0; i < n; i++) {\n bytes[start + i] = newValue[i];\n }\n } else {\n throw new Error(\n \"Invalid length for buffer view: \" + newValue.length\n );\n }\n }\n }\n };\n\n return Result.ok({ nextIndex: end, value: bufferView });\n };\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":48,"value":"// mapParser function: applies a transformation function to the result of a parser.\nfunction mapParser(parser, transformFn) {\n return function(index, bytes) {\n // Apply the given parser first.\n const result = parser(index, bytes);\n\n // If the parser returns an error, propagate the error.\n if (result.isErr()) {\n return result;\n }\n\n // Extract the result value and next index.\n const { value, nextIndex } = result.unwrap();\n\n // Apply the transformation function to the value.\n const transformedValue = transformFn(value);\n\n // Return a new Result object with the transformed value.\n return Result.ok({ nextIndex: nextIndex, value: transformedValue });\n };\n}\n\n\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":50,"value":"// flatMapParser function: applies a transformation function to the result of a parser\n// and then applies another parser returned by the transformation function.\nfunction flatMapParser(parser, transformFn) {\n return function (index, bytes) {\n // Apply the given parser first.\n const result = parser(index, bytes);\n\n // If the parser returns an error, propagate the error.\n if (result.isErr()) {\n return result.mapErr((_) => [\"flatMapParser\", _]);\n }\n\n // Extract the result value and next index.\n const { value, nextIndex } = result.unwrap();\n if (!(Object.keys(value).length == 2 && \"value\" in value && \"tag\" in value)) {\n return Result.error([\n \"flatMapParser:Parser returns ok, but it must be object {tag,value}, returned: \",\n value\n ]);\n }\n // Apply the transformation function to get the next parser.\n const nextParser = transformFn(value);\n\n // Apply the next parser.\n return nextParser(nextIndex, bytes);\n };\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":52,"value":"function parseBytesBasedOnLength(lengthEnum) {\n var lengthValue = lengthEnum.value.value; // The actual length value\n // We return a new parser that will take the specified number of bytes based on the length value.\n return takeN(lengthValue);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":54,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":293,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":213,"value":"{\n var bytes = new Uint8Array([0x01, 0, 1, 4, 5, 6, 7, 8, 8, 9, 19, 11]);\n return flatMapParser(u1, (_) => {\n return tagToParserMap[_.value.value];\n })(0, bytes);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":88,"value":"{\n var parseConstantClassInfo = createConstantInfoParser(\"ConstantClassInfo\", [\n [u2be, \"name_index\"]\n ]);\n var bytes = new Uint8Array([0x01, 0x03, 0x0, 4, 5, 6, 7, 8, 8, 9, 19, 11]);\n var t = parseConstantClassInfo(0, bytes);\n t.value;\n return [t, bytes, t.value.value];\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":76,"value":"assert = import(\"https://esm.sh/uvu/assert\")","pinned":true,"hidden":false,"mode":"ojs"},{"id":96,"value":"$35","pinned":true,"hidden":false,"mode":"ojs"},{"id":10,"value":"{\n var bytes = new Uint8Array([0x01, 0x02, 0x03, 4, 5, 6, 7, 8, 8, 9, 19, 11]);\n var result = applyNTimes(u1, 5)(0, bytes);\n result.value.value.value.value[3].value.value = 0;\n return [result, bytes];\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":190,"value":"\n\n// Define the CpInfo parser using switchParser to select the correct parser\n// based on the tag value\nvar parseCpInfo = mapParser(\n concatenateParsers([u1]), // Parse the tag first\n resultsArray => { // Transform to a structure containing the tag and info\n const tag = resultsArray[0].value.value;\n return {\n tag: tag,\n info: switchParser(tagToParserMap[tag], tagToParserMap)\n };\n }\n);","pinned":true,"hidden":false,"mode":"ojs"}],"files":"$W36","stdlib":"1","titling":"auto"}