@mindfiredigital/pivothead
Version:
PivotHead is a powerful and flexible library for creating interactive pivot tables in JavaScript applications. It provides a core engine for data manipulation and, in the future, will be compatible with wrappers for React, Vue, Svelte, and Angular, making
1 lines • 222 kB
Source Map (JSON)
{"version":3,"sources":["~lib/rt/common.ts","assembly/csvParser.ts","~lib/rt/stub.ts","~lib/util/error.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/shared/runtime.ts","~lib/util/sort.ts","~lib/string.ts"],"names":[],"mappings":"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","sourceRoot":"./csvParser","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << <usize>AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof<BLOCK>();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof<OBJECT>() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","/**\n * High-Performance CSV Parser (TypeScript)\n *\n * This module provides a fast CSV parsing implementation adapted\n * from AssemblyScript to TypeScript for use in Node/browser.\n */\n\n// Constants\nconst COMMA: number = 44; // ','\nconst QUOTE: number = 34; // '\"'\nconst NEWLINE: number = 10; // '\\n'\nconst CARRIAGE: number = 13; // '\\r'\nconst SPACE: number = 32; // ' '\nconst TAB: number = 9; // '\\t'\n\n/**\n * Parse state for tracking parser position\n */\nclass ParseState {\n position: number = 0;\n currentRow: number = 0;\n currentCol: number = 0;\n inQuotes: boolean = false;\n fieldStart: number = 0;\n}\n\n/**\n * Result of CSV parsing (internal use only)\n */\nclass CSVResult {\n rowCount: number = 0;\n colCount: number = 0;\n errorCode: number = 0; // 0 = success, 1 = error\n errorMessage: string = '';\n}\n\n// Export individual result getters instead of the class\nlet lastResult: CSVResult = new CSVResult();\n\nexport function getLastRowCount(): number {\n return lastResult.rowCount;\n}\n\nexport function getLastColCount(): number {\n return lastResult.colCount;\n}\n\nexport function getLastErrorCode(): number {\n return lastResult.errorCode;\n}\n\nexport function getLastErrorMessage(): string {\n return lastResult.errorMessage;\n}\n\n/**\n * Parse a CSV chunk and store results internally\n * Use getLastRowCount(), getLastColCount(), etc. to retrieve results\n *\n * @param input - CSV data as string\n * @param delimiter - Field delimiter (default: comma)\n * @param hasHeader - Whether first row is header\n * @param trimValues - Trim whitespace from values\n * @returns Error code (0 = success, 1 = error)\n */\nexport function parseCSVChunk(\n input: string,\n delimiter: number = COMMA,\n hasHeader: boolean = true,\n trimValues: boolean = true\n): number {\n lastResult = new CSVResult();\n\n if (input.length === 0) {\n lastResult.errorCode = 1;\n lastResult.errorMessage = 'Empty input';\n return 1;\n }\n\n const state = new ParseState();\n const length = input.length;\n let rows = 0;\n let cols = 0;\n let maxCols = 0;\n\n // First pass: count rows and columns\n while (state.position < length) {\n const char = input.charCodeAt(i32(state.position));\n\n if (char === QUOTE) {\n state.inQuotes = !state.inQuotes;\n } else if (!state.inQuotes) {\n if (char === delimiter) {\n cols++;\n } else if (\n char === NEWLINE ||\n (char === CARRIAGE &&\n state.position + 1 < length &&\n input.charCodeAt(i32(state.position + 1)) === NEWLINE)\n ) {\n cols++; // Count last column\n if (cols > maxCols) {\n maxCols = cols;\n }\n rows++;\n cols = 0;\n\n // Skip \\r\\n\n if (char === CARRIAGE && state.position + 1 < length) {\n state.position++;\n }\n }\n }\n\n state.position++;\n }\n\n // Handle last row if no trailing newline\n if (cols > 0) {\n if (cols > maxCols) {\n maxCols = cols;\n }\n rows++;\n }\n\n lastResult.rowCount = rows;\n lastResult.colCount = maxCols;\n lastResult.errorCode = 0;\n\n return 0; // Success\n}\n\n/**\n * Extract a field value from CSV data\n *\n * @param input - CSV string\n * @param start - Start position\n * @param end - End position\n * @param trimValues - Whether to trim whitespace\n * @returns Extracted field value\n */\nexport function extractField(\n input: string,\n start: number,\n end: number,\n trimValues: boolean\n): string {\n if (start >= end) {\n return '';\n }\n\n let value = input.substring(i32(start), i32(end));\n\n // Remove quotes if present\n if (\n value.length >= 2 &&\n value.charCodeAt(0) === QUOTE &&\n value.charCodeAt(value.length - 1) === QUOTE\n ) {\n value = value.substring(1, value.length - 1);\n // Unescape double quotes\n value = value.replaceAll('\"\"', '\"');\n }\n\n // Trim whitespace if requested\n if (trimValues) {\n value = value.trim();\n }\n\n return value;\n}\n\n/**\n * Fast number parsing\n *\n * @param input - String to parse\n * @returns Parsed number or NaN\n */\nexport function parseNumber(input: string): number {\n if (input.length === 0) {\n return NaN;\n }\n\n // Remove whitespace\n const trimmed = input.trim();\n if (trimmed.length === 0) {\n return NaN;\n }\n\n // Check for number format\n let isNegative = false;\n let hasDecimal = false;\n let position = 0;\n\n if (trimmed.charCodeAt(0) === 45) {\n // '-'\n isNegative = true;\n position = 1;\n }\n\n let intPart: number = 0;\n let fracPart: number = 0;\n let fracDivisor: number = 1;\n\n // Parse integer part\n while (position < trimmed.length) {\n const char = trimmed.charCodeAt(position);\n\n if (char >= 48 && char <= 57) {\n // '0'-'9'\n if (!hasDecimal) {\n intPart = intPart * 10 + (char - 48);\n } else {\n fracDivisor *= 10;\n fracPart = fracPart * 10 + (char - 48);\n }\n } else if (char === 46) {\n // '.'\n if (hasDecimal) {\n return NaN; // Multiple decimal points\n }\n hasDecimal = true;\n } else {\n return NaN; // Invalid character\n }\n\n position++;\n }\n\n let result = intPart;\n if (hasDecimal) {\n result += fracPart / fracDivisor;\n }\n\n return isNegative ? -result : result;\n}\n\n/**\n * Detect field type from value\n *\n * @param value - Field value\n * @returns Type: 0=string, 1=number, 2=boolean, 3=null\n */\nexport function detectFieldType(value: string): number {\n if (value.length === 0 || value === 'null' || value === 'NULL') {\n return 3; // null\n }\n\n if (\n value === 'true' ||\n value === 'false' ||\n value === 'TRUE' ||\n value === 'FALSE'\n ) {\n return 2; // boolean\n }\n\n // Try to parse as number\n const num = parseNumber(value);\n if (!isNaN(num)) {\n return 1; // number\n }\n\n return 0; // string\n}\n\n/**\n * Calculate memory usage for parsed data\n *\n * @param rowCount - Number of rows\n * @param colCount - Number of columns\n * @returns Estimated memory in bytes\n */\nexport function estimateMemory(rowCount: number, colCount: number): number {\n // Rough estimate: 64 bytes per cell (pointers + overhead)\n return rowCount * colCount * 64;\n}\n\n/**\n * Initialize module\n */\nexport function initialize(): void {\n // Initialization code if needed\n lastResult = new CSVResult();\n}\n\n/**\n * Get module version\n */\nexport function getVersion(): string {\n return '1.0.0';\n}\n\n/**\n * Benchmark: Parse performance test\n *\n * @param input - Test CSV data\n * @returns Parse time in milliseconds (simulated)\n */\nexport function benchmark(input: string): number {\n parseCSVChunk(input);\n const rowCount = getLastRowCount();\n return rowCount * 0.001; // Simulated timing\n}\n","import { AL_MASK, OBJECT, OBJECT_OVERHEAD, BLOCK_MAXSIZE, BLOCK_OVERHEAD, BLOCK, OBJECT_MAXSIZE } from \"./common\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === A minimal runtime stub ===\n\n// @ts-ignore: decorator\n@lazy let startOffset: usize = ((__heap_base + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n// @ts-ignore: decorator\n@lazy let offset: usize = startOffset;\n\nfunction maybeGrowMemory(newOffset: usize): void {\n // assumes newOffset is aligned\n let pagesBefore = memory.size();\n let maxOffset = ((<usize>pagesBefore << 16) + AL_MASK) & ~AL_MASK;\n if (newOffset > maxOffset) {\n let pagesNeeded = <i32>(((newOffset - maxOffset + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable(); // out of memory\n }\n }\n offset = newOffset;\n}\n\n// @ts-ignore: decorator\n@inline function computeSize(size: usize): usize {\n return ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __alloc(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n let block = changetype<BLOCK>(offset);\n let ptr = offset + BLOCK_OVERHEAD;\n let payloadSize = computeSize(size);\n maybeGrowMemory(ptr + payloadSize);\n block.mmInfo = payloadSize;\n return ptr;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __realloc(ptr: usize, size: usize): usize {\n assert(ptr != 0 && !(ptr & AL_MASK)); // must exist and be aligned\n let block = changetype<BLOCK>(ptr - BLOCK_OVERHEAD);\n let actualSize = block.mmInfo;\n let isLast = ptr + actualSize == offset;\n let payloadSize = computeSize(size);\n if (size > actualSize) {\n if (isLast) { // last block: grow\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n maybeGrowMemory(ptr + payloadSize);\n block.mmInfo = payloadSize;\n } else { // copy to new block at least double the size\n let newPtr = __alloc(max<usize>(payloadSize, actualSize << 1));\n memory.copy(newPtr, ptr, actualSize);\n block = changetype<BLOCK>((ptr = newPtr) - BLOCK_OVERHEAD);\n }\n } else if (isLast) { // last block: shrink\n offset = ptr + payloadSize;\n block.mmInfo = payloadSize;\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __free(ptr: usize): void {\n assert(ptr != 0 && !(ptr & AL_MASK)); // must exist and be aligned\n let block = changetype<BLOCK>(ptr - BLOCK_OVERHEAD);\n if (ptr + block.mmInfo == offset) { // last block: discard\n offset = changetype<usize>(block);\n }\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __reset(): void { // special\n offset = startOffset;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __new(size: usize, id: u32): usize {\n if (size > OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n let ptr = __alloc(OBJECT_OVERHEAD + size);\n let object = changetype<OBJECT>(ptr - BLOCK_OVERHEAD);\n object.gcInfo = 0;\n object.gcInfo2 = 0;\n object.rtId = id;\n object.rtSize = <u32>size;\n return ptr + OBJECT_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __renew(oldPtr: usize, size: usize): usize {\n if (size > OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n let newPtr = __realloc(oldPtr - OBJECT_OVERHEAD, OBJECT_OVERHEAD + size);\n changetype<OBJECT>(newPtr - BLOCK_OVERHEAD).rtSize = <u32>size;\n return newPtr + OBJECT_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // nop\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n // nop\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __visit(ptr: usize, cookie: u32): void { // eslint-disable-line @typescript-eslint/no-unused-vars\n // nop\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n // nop\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","/// <reference path=\"../rt/index.d.ts\" />\n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data<u32>([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data<u32>([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data<i16>([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data<u64>([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2<T extends number>(value: T): bool {\n return popcnt<T>(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - <u32>clz(num)) / (31 - <u32>clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = <u64>load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n let digits2 = <u64>load<u32>(DIGITS + (<usize>d2 << alignof<u32>()));\n\n offset -= 4;\n store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n store<u32>(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load<u32>(DIGITS + (<usize>num << alignof<u32>()));\n store<u32>(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store<u16>(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = <usize>(num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = <u64>load<u32>(DIGITS + (<usize>c1 << alignof<u32>()));\n let digits2 = <u64>load<u32>(DIGITS + (<usize>c2 << alignof<u32>()));\n\n offset -= 4;\n store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = <u64>load<u32>(DIGITS + (<usize>b1 << alignof<u32>()));\n digits2 = <u64>load<u32>(DIGITS + (<usize>b2 << alignof<u32>()));\n\n offset -= 4;\n store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, <u32>num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype<usize>(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store<u32>(\n buffer + (offset << 1),\n load<u32>(lut + ((<usize>num & 0xFF) << alignof<u32>()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store<u16>(buffer, load<u16>(lut + (<usize>num << 6)));\n }\n}\n\nfunction utoa_dec_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = <u32>(num % 10);\n num = changetype<T>(t);\n offset--;\n store<u16>(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select<T>(<T>0x27, <T>0, d > <T>CharCode._9);\n offset--;\n store<u16>(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple<u32>(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple<u32>(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple<u64>(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple<u64>(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype<usize>(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype<String>(__new(decimals << 1, idof<String>()));\n utoa32_dec_core(changetype<usize>(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype<String>(__new(decimals << 1, idof<String>()));\n utoa32_hex_core(changetype<usize>(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype<String>(__new(decimals << 1, idof<String>()));\n utoa64_any_core(changetype<usize>(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n utoa32_dec_core(changetype<usize>(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n utoa32_hex_core(changetype<usize>(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n utoa64_any_core(changetype<usize>(out) + sign, val32, decimals, radix);\n }\n if (sign) store<u16>(changetype<usize>(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = <u32>value;\n let decimals = decimalCount32(val32);\n out = changetype<String>(__new(decimals << 1, idof<String>()));\n utoa32_dec_core(changetype<usize>(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype<String>(__new(decimals << 1, idof<String>()));\n utoa64_dec_core(changetype<usize>(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype<String>(__new(decimals << 1, idof<String>()));\n utoa64_hex_core(changetype<usize>(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype<String>(__new(decimals << 1, idof<String>()));\n utoa64_any_core(changetype<usize>(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (<u64>value <= <u64>u32.MAX_VALUE) {\n let val32 = <u32>value;\n let decimals = decimalCount32(val32);\n out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n utoa32_dec_core(changetype<usize>(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n utoa64_dec_core(changetype<usize>(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n utoa64_hex_core(changetype<usize>(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n utoa64_any_core(changetype<usize>(out) + sign, value, decimals, radix);\n }\n if (sign) store<u16>(changetype<usize>(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = <i32>clz<u64>(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == 0x0010000000000000);\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load<u16>(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store<u16>(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret<f64>(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = <i32>dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load<u64>(FRC_POWERS + (<usize>index << alignof<u64>()));\n _exp_pow = load<i16>(EXP_POWERS + (<usize>index << alignof<i16>()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32): i32 {\n\n // frexp routine\n let uv = reinterpret<u64>(value);\n let exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n let frc = (u64(exp != 0) << 52) + sid;\n exp = select<i32>(exp, 1, exp) - (0x3FF + 52);\n\n normalizedBoundaries(frc, exp);\n getCachedPower(_exp);\n\n // normalize\n let off = <i32>clz<u64>(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (<u64>1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = <i32>decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n --kappa;\n let tmp = ((<u64>p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, <u64>load<u32>(POWERS10 + (<usize>kappa << alignof<u32>())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= <u64>load<u32>(POWERS10 + (<usize>-kappa << alignof<u32>()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store<u16>(buffer, <u16>select<u32>(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store<u32>(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store<u16>(buffer + (i << 1), CharCode._0);\n }\n store<u32>(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store<u16>(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store<u32>(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store<u16>(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store<u16>(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store<u16>(buffer, CharCode.DOT, 2);\n store<u16>(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store<u16>(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= 1.7976931348623157e308);\n let len = grisu2(value, buffer, sign);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: f64): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select<String>(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value) << 1;\n let result = changetype<String>(__new(size, idof<String>()));\n memory.copy(changetype<usize>(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered<T extends number>(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned<T>()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof<T>() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store<u64>(buffer,\n <u64>CharCode.MINUS |\n <u64>(CharCode._0 + 1) << 16 |\n <u64>(CharCode._0 + 2) << 32 |\n <u64>(CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof<T>() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store<u64>(buffer,\n <u64>CharCode.MINUS |\n <u64>(CharCode._0 + 3) << 16 |\n <u64>(CharCode._0 + 2) << 32 |\n <u64>(CharCode._0 + 7) << 48\n ); // -327\n store<u32>(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store<u16>(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned<T>()) {\n if (sizeof<T>() <= 4) {\n if (<u32>value < 10) {\n store<u16>(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (<u64>value < 10) {\n store<u16>(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store<u16>(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof<T>() <= 4) {\n let val32 = <u32>value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (<u64>value <= <u64>u32.MAX_VALUE) {\n let val32 = <u32>value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = <u64>value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: f64): u32 {\n if (value == 0) {\n store<u16>(buffer, CharCode._0);\n store<u16>(buffer, CharCode.DOT, 2);\n store<u16>(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store<u16>(buffer, CharCode.N);\n store<u16>(buffer, CharCode.a, 2);\n store<u16>(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store<u16>(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store<u64>(buffer, 0x690066006E0049, 0); // ifnI\n store<u64>(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data<u64>([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69