diff --git a/quest/m2/README.md b/quest/m2/README.md index aed8acf65..a117a4fcb 100644 --- a/quest/m2/README.md +++ b/quest/m2/README.md @@ -26,7 +26,7 @@ The fork's feature quests folded into the [exporter](/quest/m1/ffi-export.md); ## Required -- [Cheaper byte slices](/quest/m2/ts-byte-views.md) - splitting a `&[u8]` stops making a `Uint8Array` view per split +- [Byte slices without objects](/quest/m2/ts-byte-views.md) - splitting a `&[u8]` allocates nothing, neither a chunk view nor a `ByteSlice` - [Smaller output from MIR](/quest/m2/ts-mir-size.md) - the bench's bundles shrink back to THIR's sizes, coroutine classes first - [Time Timestamp's checked_add and Ord](/quest/m2/ts-bench-timestamp.md) - the `u128` paths #89 sped up get a Chrome timing - [Time the minified bundles](/quest/m2/ts-bench-minified.md) - `just ts bench` times what it measures for size, as consumers ship it diff --git a/quest/m2/ts-byte-views.md b/quest/m2/ts-byte-views.md index aa5320811..b3296cba4 100644 --- a/quest/m2/ts-byte-views.md +++ b/quest/m2/ts-byte-views.md @@ -1,28 +1,26 @@ -# [L] Cheaper byte slices +# [L] Byte slices without objects ## Goal -Splitting a `&[u8]` in translated code stops costing a `Uint8Array` view per -split, so the codec's decode on the [TS benchmark](/ts/README.md#bench) moves -toward moq's hand-written cursor, with every differential test still passing. +Splitting a `&[u8]` in translated code allocates nothing, so the codec's decode on the +[TS benchmark](/ts/README.md#bench) moves toward moq's hand-written cursor, with every +differential test still passing. ## Plan -The report in PR #15 puts views at most of what decode still costs: -about 25 ns each in V8, and a varint takes one to four (`split_first`'s rest, -`split_first_chunk`'s chunk and rest, a `lo @ ..` pattern). moq's hand-written -`Cursor` reads through an offset and makes none. +`&[u8]` is an `rt.ByteSlice`, a range of a `Uint8Array`, so a split makes an object +rather than a view. What decode still pays per varint: -Options to measure, not a decision: +- `split_first_chunk`'s chunk is a `&[u8; N]`, which is a `Uint8Array` view of the + slice's bytes: one per multi-byte varint. A chunk only indexed could read the slice in + place, or a reference to a byte array could be a `ByteSlice` too. +- Each split's rest is a new `ByteSlice`, and its tuple and `Result` are objects. Byte + slices in locals, parameters, and fields could be scalar-replaced as `(data, start, + length)`, as `u64` halves are, materializing a `ByteSlice` only where one escapes. + A microbenchmark of QUIC varint decode measured offsets in locals about 2x faster than a + `ByteSlice` per split in V8 and about the same in JavaScriptCore. +- Iterating a byte slice makes one view, which `rt.iterSlice` and stepping in place read. -- Lower `&[u8]` to an offset and length into a shared array, as `(buf, start, - end)` locals the translator scalar-replaces, materializing a `Uint8Array` - only at the API edge. -- Keep `Uint8Array` but skip views nothing reads: a split whose chunk is only - destructured into bytes, or whose rest is unused on the path taken. - -Engines differ: JavaScriptCore makes views slower than V8 but small copies -faster, and V8 gives a lone small array its own buffer, about a microsecond, -the first time it is viewed. Measure Node, Bun, and Chrome. +Measure Node, Bun, and Chrome, and Firefox once the bench has it; Chrome decides. Public API: the translator's output for byte slices. diff --git a/ts/README.md b/ts/README.md index 1041e387e..d01719fd7 100644 --- a/ts/README.md +++ b/ts/README.md @@ -66,7 +66,7 @@ in `rt/str.ts`, collections in `rt/collections.ts`, and ownership and async in | `Option` | `T \| undefined`; refused if `T` can already be `undefined`, as `()` and `Option` can | | `Result` | `rt.Result`: `{ ok: true, value }` or `{ ok: false, error }` | | `ControlFlow` | `rt.Result`, `Ok` to continue; what `?` branches on is the value it was applied to | -| tuple, `[T; N]`, `&[T]`, `Vec` | an array, `Uint8Array` for bytes, `rt.ByteVec` for `Vec` | +| tuple, `[T; N]`, `&[T]`, `Vec` | an array; for bytes, `Uint8Array` for `[u8; N]`, `rt.ByteSlice` for `&[u8]`, and `rt.ByteVec` for `Vec` | | `&T`, `&mut T`, `Box` | the value: a `&mut` must point at an object JS can change in place, or at a map's value through an `rt.Place` | | an iterator | `rt.Iter`, whose adaptors are runtime functions: `rt.iterMap(rt.iterSlice(v), f)` | | `a..b`, `a..=b` | `rt.Range`, `rt.RangeInclusive`, which are iterators too | @@ -84,6 +84,10 @@ in `rt/str.ts`, collections in `rt/collections.ts`, and ownership and async in `Buffer` pool does, so the `buffer` behind a view holds other bytes too: read it through `byteOffset` and `byteLength`, and copy it before transferring it. +An `rt.ByteSlice` is a range of a `Uint8Array`: its `data`, from `start`, for `length` +bytes. A caller passes bytes as `rt.byteSliceFrom(array)` and reads a slice it gets as +`rt.byteSliceView(slice)`, a view of it. + `usize` is 32 bits, as on wasm32, so it is exact in a `number`. Arithmetic is checked as a debug build checks it, so translated code panics where native code would: it never wraps silently. A panic throws `rt.Panic`, with the message native Rust panics with. @@ -265,6 +269,13 @@ they need. - `Result` is a plain `{ ok, value } | { ok, error }` object rather than an exception, so `?` and `match` keep Rust's control flow exactly. Making no `Ok` objects at all measured no faster on `just ts bench`, in V8 or JavaScriptCore. +- A `&[u8]` is an `rt.ByteSlice` rather than a `Uint8Array` view, since a view costs + several times what an object does to make in V8 and JavaScriptCore, and a varint's + decode splits its slice once to four times. `just ts bench` measured the codec's decode + workloads at 0.75 times the views' time in Chrome, 0.81-0.84 in Node, and 0.82-0.85 in + Bun at the geometric mean, over two runs whose A/A route measured within 0.05 of them, + and encode no slower. A chunk, `&[u8; N]`, is still a view + ([byte slices without objects](/quest/m2/ts-byte-views.md)). - A `BTreeMap` is a B+ tree of up to 64 keys a node, O(log n) as std's B-tree is: its leaves hold the keys and values and link to their neighbors, which iterators walk from either end, and its branches hold each child's lower bound. A node's slots shift in a diff --git a/ts/bench/main.ts b/ts/bench/main.ts index 3334853ee..a3784f8d9 100644 --- a/ts/bench/main.ts +++ b/ts/bench/main.ts @@ -66,12 +66,12 @@ async function extraRoute(arg: string): Promise<{ name: string; codec: string; t if (at < 1 || at === arg.length - 1) throw new Error(`--route takes name=dir, not ${arg}`); if ([...codecRoutes, ...handoffRoutes].includes(name)) throw new Error(`--route ${name} is already a route`); const dir = resolve(arg.slice(at + 1)); - const codec = join(dir, "translated", "bench.ts"); + const codec = join(dir, "translated"); const task = join(dir, "task"); - for (const file of [codec, join(task, "model.ts")]) { + for (const file of [join(codec, "bench.ts"), join(task, "model.ts")]) { if (!(await Bun.file(file).exists())) throw new Error(`--route ${name}: ${file} is missing`); } - return { name, codec, task: await taskEntry(task) }; + return { name, codec: await codecEntry(codec), task: await taskEntry(task) }; } // `moq/` is the checkout, whose own imports resolve through its install. @@ -101,7 +101,21 @@ const page = ` `; const handWritten = join(import.meta.dir, "moq.ts"); -const translated = join(arg("translated"), "bench.ts"); + +// The codec fixture's translation, whose `bench::run` takes its input as a byte slice. +async function codecEntry(dir: string): Promise { + const entry = join(dir, "bench-entry.ts"); + await Bun.write( + entry, + `import * as rt from "./rt.ts"; +import { run as bench } from "./bench.ts"; + +export const run = (input: Uint8Array) => bench(rt.byteSliceFrom(input)); +`, + ); + return entry; +} +const translated = await codecEntry(arg("translated")); const wasmBytes = await read(arg("wasm")); const translation = await bundle(translated); diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 76cd49842..f71940aa4 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -12,12 +12,12 @@ import * as Group from "./lite/group.Group.ts"; import type * as Version from "./lite/version.Version.ts"; /** Run one workload. */ -export function run(input: Uint8Array): rt.ByteVec { +export function run(input: rt.ByteSlice): rt.ByteVec { const out: rt.ByteVec = new rt.ByteVec(); - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(input); + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(input); if (_5 !== undefined) { const op: rt.u8 = _5[0]; - const _9: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(_5[1]); + const _9: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(_5[1]); if (_9 !== undefined) { const selector: rt.u8 = _9[0]; if (op === 0) { @@ -61,8 +61,8 @@ export function decoded(result: rt.Result, o } /** The same value, `count` times. */ -export function encodeVarints(data: Uint8Array, form_: Form.Form, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, Uint8Array] = takeU64(data); +export function encodeVarints(data: rt.ByteSlice, form_: Form.Form, out: rt.ByteVec): rt.Result { + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); const count: rt.u64 = _6[0]; const value: rt.u64 = takeU64(_6[1])[0]; const w: Encoder.Encoder = Encoder.new(out, form_); @@ -78,7 +78,7 @@ export function encodeVarints(data: Uint8Array, form_: Form.Form, out: rt.ByteVe } /** Every varint on the wire: how many, and the last. */ -export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVec): rt.Result { +export function decodeVarints(wire: rt.ByteSlice, form_: Form.Form, out: rt.ByteVec): rt.Result { const r: Decoder.Decoder = Decoder.new(wire, form_); let count: rt.usize = 0; let last: rt.u64 = 0; @@ -101,18 +101,18 @@ export function decodeVarints(wire: Uint8Array, form_: Form.Form, out: rt.ByteVe * zigzag timestamp delta, then the size. The first frame has no delta and its own size, * and every `key_every`th frame after it is `key_size`, as moq's benchmark samples are. */ -export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { +export function encodeFrames(data: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { let _32!: rt.usize; let _38!: [rt.i64, rt.u64]; - const _6: [rt.u64, Uint8Array] = takeU64(data); + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); const count: rt.u64 = _6[0]; - const _9: [rt.u64, Uint8Array] = takeU64(_6[1]); + const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1]); const delta: rt.u64 = _9[0]; - const _12: [rt.u64, Uint8Array] = takeU64(_9[1]); + const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1]); const first: rt.u64 = _12[0]; - const _15: [rt.u64, Uint8Array] = takeU64(_12[1]); + const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1]); const size: rt.u64 = _15[0]; - const _18: [rt.u64, Uint8Array] = takeU64(_15[1]); + const _18: [rt.u64, rt.ByteSlice] = takeU64(_15[1]); const keyEvery: rt.u64 = _18[0]; const keySize: rt.u64 = takeU64(_18[1])[0]; const _24: rt.i64 = rt.i64Cast(delta); @@ -154,7 +154,7 @@ export function encodeFrames(data: Uint8Array, version: Version.Version, out: rt } /** Every FRAME header on the wire: how many, their total size, and the last delta. */ -export function decodeFrames(wire: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { +export function decodeFrames(wire: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { const r: Decoder.Decoder = Decoder.new(wire, Form.from$From_Version(version)); let count: rt.usize = 0; let total: rt.u64 = 0; @@ -187,8 +187,8 @@ export function decodeFrames(wire: Uint8Array, version: Version.Version, out: rt * decoded again from its start on the next. How many, their total size, the last delta, * and how many decodes came up short. */ -export function decodeSplit(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, Uint8Array] = takeU64(data); +export function decodeSplit(data: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); const read2: rt.usize = rt.max(rt.u64Low(_6[0]), 1); let start: rt.usize = 0; let end: rt.usize = 0; @@ -203,7 +203,7 @@ export function decodeSplit(data: Uint8Array, version: Version.Version, out: rt. continue l2; } const slice = _6[1]; - const r: Decoder.Decoder = Decoder.new(rt.sliceRange(slice, start, end), Form.from$From_Version(version)); + const r: Decoder.Decoder = Decoder.new(rt.byteSliceRange(slice, start, end), Form.from$From_Version(version)); const _32: rt.Result<[rt.i64, rt.u64], DecodeError.DecodeError> = frameHeader(r); if (_32.ok) { const delta: rt.i64 = _32.value[0]; @@ -247,8 +247,8 @@ export function frameHeader(r: Decoder.Decoder): rt.Result<[rt.i64, rt.u64], Dec } /** One size-prefixed GROUP header, starting at the first frame. */ -export function encodeGroup(data: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, Uint8Array] = takeU64(data); +export function encodeGroup(data: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); const group: Group.Group = { subscribe: _6[0], sequence: takeU64(_6[1])[0], frameStart: 0 }; const _12: Encoder.Encoder = Encoder.new(out, Form.from$From_Version(version)); return Group.encode$Encode_Version(group, _12, version); @@ -259,7 +259,7 @@ export function encodeGroup(data: Uint8Array, version: Version.Version, out: rt. * up, summed over a quarter of the key space, and removed again. The sum of the values * found. */ -export function ordered(data: Uint8Array, out: rt.ByteVec): void { +export function ordered(data: rt.ByteSlice, out: rt.ByteVec): void { let _15!: rt.u32; let _28!: rt.u32; let _66!: rt.u32; @@ -307,33 +307,33 @@ export function ordered(data: Uint8Array, out: rt.ByteVec): void { * One iterator chain over every byte, picked by `chain`, with closures that cost little * next to the iterator protocol they run through. */ -export function iterate(chain: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function iterate(chain: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (chain === 0) { - putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (_211: rt.u8): rt.u8 => { + putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): rt.u8 => { return _211 >> 1; }), (_212: rt.u8): boolean => { return (_212 & 1) === 0; }))); } else if (chain === 1) { - const _11: rt.Iter = rt.iterSlice(data); + const _11: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.byteVecPush(out, rt.iterAny(_11, (_210: rt.u8): boolean => { return _210 === 255; }) ? 1 : 0); } else if (chain === 2) { - putUsize(out, rt.iterToByteVec(rt.iterFilter(rt.iterSlice(data), (_28: rt.u8): boolean => { + putUsize(out, rt.iterToByteVec(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): boolean => { return (_28 & 1) === 1; })).length); } else if (chain === 3) { - putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.u32 => { + putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { return _2 as rt.u32; }), rt.u32Add, 0) as rt.u64); } else if (chain === 4) { - putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(data), 16), 512), 0, (acc: rt.u32, _3: rt.u8): rt.u32 => { + putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), 16), 512), 0, (acc: rt.u32, _3: rt.u8): rt.u32 => { return (acc ^ _3 as rt.u32) >>> 0; }) as rt.u64); } else { let last: rt.usize = 0; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _33: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_33 === rt.DONE) { @@ -353,16 +353,16 @@ export function iterate(chain: rt.u8, data: Uint8Array, out: rt.ByteVec): void { * `Timestamp::convert` in `u128`, or the same in `u64` (selector 1), which overflows * sooner. How many converted, how many overflowed, and the last converted. */ -export function rescale(selector: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function rescale(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _26!: rt.usize; let scaled!: rt.u64 | undefined; - const _6: [rt.u64, Uint8Array] = takeU64(data); + const _6: [rt.u64, rt.ByteSlice] = takeU64(data); const count: rt.u64 = _6[0]; - const _9: [rt.u64, Uint8Array] = takeU64(_6[1]); + const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1]); const start: rt.u64 = _9[0]; - const _12: [rt.u64, Uint8Array] = takeU64(_9[1]); + const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1]); const step: rt.u64 = _12[0]; - const _15: [rt.u64, Uint8Array] = takeU64(_12[1]); + const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1]); const from: rt.u64 = _15[0]; const to: rt.u64 = takeU64(_15[1])[0]; let converted: rt.u64 = 0; @@ -413,7 +413,7 @@ export function bounded(value: rt.u128): rt.u64 | undefined { return rt.u64Cast(value); } -export function decodeGroup(wire: Uint8Array, version: Version.Version, out: rt.ByteVec): rt.Result { +export function decodeGroup(wire: rt.ByteSlice, version: Version.Version, out: rt.ByteVec): rt.Result { const _6: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$Decode_Version(wire, version); if (_6.ok) { const val: [Group.Group, rt.usize] = _6.value; diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 0d99db5f1..8256764bc 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -14,7 +14,7 @@ import type * as Control from "../stats.Control.ts"; * [`DecodeError::Short`] can be retried once more bytes arrive. */ export interface Decoder { - buf: Uint8Array; + buf: rt.ByteSlice; form: Form.Form; /** The length of the buffer this decoder started with. */ len: rt.usize; @@ -30,7 +30,7 @@ export interface Decoder { } /** Read `buf`, with varints in the given form. */ -function new_(buf: Uint8Array, form: Form.Form): Decoder { +function new_(buf: rt.ByteSlice, form: Form.Form): Decoder { return { buf, form: copy$Form(form), len: buf.length, need: 0, control: undefined, uncounted: 0 }; } @@ -62,8 +62,8 @@ export function isEmpty(self: Decoder): boolean { } /** Read `len` raw bytes. */ -export function slice(self: Decoder, len: rt.usize): rt.Result { - const _6: [Uint8Array, Uint8Array] | undefined = rt.sliceSplitAtChecked(self.buf, len); +export function slice(self: Decoder, len: rt.usize): rt.Result { + const _6: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(self.buf, len); if (_6 !== undefined) { self.buf = _6[1]; return rt.Ok(_6[0]); @@ -72,15 +72,15 @@ export function slice(self: Decoder, len: rt.usize): rt.Result { - const _4: rt.Result = slice(self, len); + const _4: rt.Result = slice(self, len); if (_4.ok) { return rt.Ok(new_(_4.value, copy$Form(self.form))); } @@ -89,22 +89,22 @@ export function sub(self: Decoder, len: rt.usize): rt.Result { - const _3: rt.Result = slice(self, 1); + const _3: rt.Result = slice(self, 1); if (_3.ok) { rt.idx(_3.value, 0); - return rt.Ok(_3.value[0]); + return rt.Ok(_3.value.data[_3.value.start]); } return _3; } /** Read a big-endian `u16`. */ export function u16(self: Decoder): rt.Result { - const _2: rt.Result = slice(self, 2); + const _2: rt.Result = slice(self, 2); if (_2.ok) { rt.idx(_2.value, 0); - const _9: rt.u8 = _2.value[0]; + const _9: rt.u8 = _2.value.data[_2.value.start]; rt.idx(_2.value, 1); - return rt.Ok((_9 << 8) | _2.value[1]); + return rt.Ok((_9 << 8) | _2.value.data[_2.value.start + 1]); } return _2; } @@ -128,9 +128,9 @@ export function bool(self: Decoder): rt.Result /** Read a varint. */ export function varint(self: Decoder): rt.Result { let _0!: rt.Result; - const _13: Uint8Array = self.buf; + const _13: rt.ByteSlice = self.buf; const _3: Form.Form = copy$Form(self.form); - const _2: rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> = read(_13, _3); + const _2: rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> = read(_13, _3); if (_2.ok) { const value: rt.u64 = _2.value[0]; self.buf = _2.value[1]; @@ -153,8 +153,8 @@ export function varintOpt(self: Decoder): rt.Result { - const start: Uint8Array = self.buf; +export function bytes(self: Decoder): rt.Result { + const start: rt.ByteSlice = self.buf; const _6: rt.Result = varint(self); if (_6.ok) { const _3: rt.Result = rt.resultMapErr(rt.usizeTryFrom(_6.value), (_2: rt.TryFromIntError): DecodeError.DecodeError => { @@ -172,9 +172,9 @@ export function bytes(self: Decoder): rt.Result { - const _5: rt.Result = bytes(self); + const _5: rt.Result = bytes(self); if (_5.ok) { - const _2: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(_5.value)); + const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(_5.value)); if (_2.ok) { return rt.Ok(_2.value); } diff --git a/ts/fixtures/codec/expected/coding/encode.Encoder.ts b/ts/fixtures/codec/expected/coding/encode.Encoder.ts index 8e431f7cc..9d94dd04f 100644 --- a/ts/fixtures/codec/expected/coding/encode.Encoder.ts +++ b/ts/fixtures/codec/expected/coding/encode.Encoder.ts @@ -27,7 +27,7 @@ function new_(buf: rt.ByteVec, form: Form.Form): Encoder { } /** Write raw bytes. */ -export function slice(self: Encoder, v: Uint8Array): void { +export function slice(self: Encoder, v: rt.ByteSlice): void { rt.byteVecExtendFromSlice(self.buf, v); } @@ -38,7 +38,7 @@ export function u8(self: Encoder, v: rt.u8): void { /** Write a big-endian `u16`. */ export function u16(self: Encoder, v: rt.u16): void { - rt.byteVecExtendFromSlice(self.buf, rt.u16ToBeBytes(v)); + rt.byteVecExtendFromSlice(self.buf, rt.byteSliceFrom(rt.u16ToBeBytes(v))); } /** Write a bool as a 0 or 1 byte. */ @@ -72,7 +72,7 @@ export function varintOpt(self: Encoder, v: rt.u64 | undefined): rt.Result { +export function bytes(self: Encoder, v: rt.ByteSlice): rt.Result { const _3: rt.Result = varint(self, v.length as rt.u64); if (_3.ok) { slice(self, v); @@ -98,7 +98,7 @@ export function prefixVarint(self: Encoder): Prefix.Prefix { /** Reserve a big-endian `u16` size prefix for the body written next; [`Self::fill`] sizes it. */ export function prefixU16(self: Encoder): Prefix.Prefix { - rt.byteVecExtendFromSlice(self.buf, Uint8Array.of(0, 0)); + rt.byteVecExtendFromSlice(self.buf, rt.byteSliceFrom(Uint8Array.of(0, 0))); return { body: self.buf.length, kind: "U16" as PrefixKind.PrefixKind }; } @@ -128,27 +128,29 @@ export function fill(self: Encoder, prefix: Prefix.Prefix): rt.Result>> 0)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes((2147483648 | lo) >>> 0))); break b1; } } @@ -133,7 +133,7 @@ export function writeQuic(value: rt.u64, out: rt.ByteVec): rt.Result>> 8) & 0xff), hi & 0xff, a, b, c, d)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(248 | ((hi >>> 8) & 0xff), hi & 0xff, a, b, c, d))); } } else { - rt.byteVecExtendFromSlice(out, Uint8Array.of(240 | (hi & 0xff), a, b, c, d)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(240 | (hi & 0xff), a, b, c, d))); } } } /** Decode a varint in `form` from the front of `buf`, returning it and the rest of `buf`. */ -export function read(buf: Uint8Array, form: Form.Form): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { +export function read(buf: rt.ByteSlice, form: Form.Form): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { if (form.tag === "Quic") { return readQuic(buf); } return readLeadingOnes(buf, form.seven); } -export function readQuic(buf: Uint8Array): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(buf); +export function readQuic(buf: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(buf); if (_5 !== undefined) { const first: rt.u8 = _5[0]; if (!(first < 64)) { if (!(first < 128)) { if (!(first < 192)) { - const _54: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); + const _54: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); if (_54.ok) { - const val3: [Uint8Array, Uint8Array] = _54.value; + const val3: [Uint8Array, rt.ByteSlice] = _54.value; const slice = val3[0]; - return rt.Ok([fromHalves((((val3[0][0] & 63) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0, rt.u32FromBeBytes(slice.subarray(4, 8))), val3[1]] as [rt.u64, Uint8Array]); + return rt.Ok([fromHalves((((val3[0][0] & 63) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0, rt.u32FromBeBytes(slice.subarray(4, 8))), val3[1]] as [rt.u64, rt.ByteSlice]); } return _54; } - const _33: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); + const _33: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); if (_33.ok) { - const val2: [Uint8Array, Uint8Array] = _33.value; - return rt.Ok([(((val2[0][0] & 63) << 24) | (val2[0][1] << 16) | (val2[0][2] << 8) | val2[0][3]) >>> 0 as rt.u64, val2[1]] as [rt.u64, Uint8Array]); + const val2: [Uint8Array, rt.ByteSlice] = _33.value; + return rt.Ok([(((val2[0][0] & 63) << 24) | (val2[0][1] << 16) | (val2[0][2] << 8) | val2[0][3]) >>> 0 as rt.u64, val2[1]] as [rt.u64, rt.ByteSlice]); } return _33; } - const _14: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); + const _14: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); if (_14.ok) { - const val: [Uint8Array, Uint8Array] = _14.value; - return rt.Ok([(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]); + const val: [Uint8Array, rt.ByteSlice] = _14.value; + return rt.Ok([(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, rt.ByteSlice]); } return _14; } - return rt.Ok([first as rt.u64, _5[1]] as [rt.u64, Uint8Array]); + return rt.Ok([first as rt.u64, _5[1]] as [rt.u64, rt.ByteSlice]); } return rt.Err({ tag: "Short" } as DecodeError.DecodeError); } -export function readLeadingOnes(buf: Uint8Array, seven: boolean): rt.Result<[rt.u64, Uint8Array], DecodeError.DecodeError> { - let _8!: [rt.u64, Uint8Array]; - const _6: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(buf); +export function readLeadingOnes(buf: rt.ByteSlice, seven: boolean): rt.Result<[rt.u64, rt.ByteSlice], DecodeError.DecodeError> { + let _8!: [rt.u64, rt.ByteSlice]; + const _6: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(buf); if (_6 !== undefined) { const first: rt.u8 = _6[0]; const _9: rt.u32 = rt.u8LeadingOnes(first); if (_9 === 0) { - _8 = [first as rt.u64, _6[1]] as [rt.u64, Uint8Array]; + _8 = [first as rt.u64, _6[1]] as [rt.u64, rt.ByteSlice]; } else if (_9 === 1) { - const _14: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); + const _14: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 2), { tag: "Short" } as DecodeError.DecodeError); if (_14.ok) { - const val: [Uint8Array, Uint8Array] = _14.value; - _8 = [(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, Uint8Array]; + const val: [Uint8Array, rt.ByteSlice] = _14.value; + _8 = [(((val[0][0] & 63) << 8) | val[0][1]) as rt.u64, val[1]] as [rt.u64, rt.ByteSlice]; } else { return _14; } } else if (_9 === 2) { - const _30: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 3), { tag: "Short" } as DecodeError.DecodeError); + const _30: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 3), { tag: "Short" } as DecodeError.DecodeError); if (_30.ok) { - const val2: [Uint8Array, Uint8Array] = _30.value; - _8 = [(((val2[0][0] & 31) << 16) | (val2[0][1] << 8) | val2[0][2]) as rt.u64, val2[1]] as [rt.u64, Uint8Array]; + const val2: [Uint8Array, rt.ByteSlice] = _30.value; + _8 = [(((val2[0][0] & 31) << 16) | (val2[0][1] << 8) | val2[0][2]) as rt.u64, val2[1]] as [rt.u64, rt.ByteSlice]; } else { return _30; } } else if (_9 === 3) { - const _48: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); + const _48: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 4), { tag: "Short" } as DecodeError.DecodeError); if (_48.ok) { - const val3: [Uint8Array, Uint8Array] = _48.value; - _8 = [(((val3[0][0] & 15) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0 as rt.u64, val3[1]] as [rt.u64, Uint8Array]; + const val3: [Uint8Array, rt.ByteSlice] = _48.value; + _8 = [(((val3[0][0] & 15) << 24) | (val3[0][1] << 16) | (val3[0][2] << 8) | val3[0][3]) >>> 0 as rt.u64, val3[1]] as [rt.u64, rt.ByteSlice]; } else { return _48; } } else if (_9 === 4) { - const _65: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 5), { tag: "Short" } as DecodeError.DecodeError); + const _65: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 5), { tag: "Short" } as DecodeError.DecodeError); if (_65.ok) { - const val4: [Uint8Array, Uint8Array] = _65.value; + const val4: [Uint8Array, rt.ByteSlice] = _65.value; const slice5 = val4[0]; - _8 = [fromHalves(((val4[0][0] & 7)) as rt.u32, rt.u32FromBeBytes(slice5.subarray(1, 5))), val4[1]] as [rt.u64, Uint8Array]; + _8 = [fromHalves(((val4[0][0] & 7)) as rt.u32, rt.u32FromBeBytes(slice5.subarray(1, 5))), val4[1]] as [rt.u64, rt.ByteSlice]; } else { return _65; } } else if (_9 === 5) { - const _81: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 6), { tag: "Short" } as DecodeError.DecodeError); + const _81: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 6), { tag: "Short" } as DecodeError.DecodeError); if (_81.ok) { - const val5: [Uint8Array, Uint8Array] = _81.value; + const val5: [Uint8Array, rt.ByteSlice] = _81.value; const slice4 = val5[0]; - _8 = [fromHalves(((val5[0][0] & 3) << 8) | val5[0][1], rt.u32FromBeBytes(slice4.subarray(2, 6))), val5[1]] as [rt.u64, Uint8Array]; + _8 = [fromHalves(((val5[0][0] & 3) << 8) | val5[0][1], rt.u32FromBeBytes(slice4.subarray(2, 6))), val5[1]] as [rt.u64, rt.ByteSlice]; } else { return _81; } @@ -286,29 +286,29 @@ export function readLeadingOnes(buf: Uint8Array, seven: boolean): rt.Result<[rt. if (!seven) { return rt.Err({ tag: "InvalidValue" } as DecodeError.DecodeError); } - const _101: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 7), { tag: "Short" } as DecodeError.DecodeError); + const _101: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 7), { tag: "Short" } as DecodeError.DecodeError); if (_101.ok) { - const val6: [Uint8Array, Uint8Array] = _101.value; + const val6: [Uint8Array, rt.ByteSlice] = _101.value; const slice3 = val6[0]; - _8 = [fromHalves(((val6[0][0] & 1) << 16) | (val6[0][1] << 8) | val6[0][2], rt.u32FromBeBytes(slice3.subarray(3, 7))), val6[1]] as [rt.u64, Uint8Array]; + _8 = [fromHalves(((val6[0][0] & 1) << 16) | (val6[0][1] << 8) | val6[0][2], rt.u32FromBeBytes(slice3.subarray(3, 7))), val6[1]] as [rt.u64, rt.ByteSlice]; } else { return _101; } } else if (_9 === 7) { - const _121: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); + const _121: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 8), { tag: "Short" } as DecodeError.DecodeError); if (_121.ok) { - const val7: [Uint8Array, Uint8Array] = _121.value; + const val7: [Uint8Array, rt.ByteSlice] = _121.value; const slice2 = val7[0]; - _8 = [fromHalves((val7[0][1] << 16) | (val7[0][2] << 8) | val7[0][3], rt.u32FromBeBytes(slice2.subarray(4, 8))), val7[1]] as [rt.u64, Uint8Array]; + _8 = [fromHalves((val7[0][1] << 16) | (val7[0][2] << 8) | val7[0][3], rt.u32FromBeBytes(slice2.subarray(4, 8))), val7[1]] as [rt.u64, rt.ByteSlice]; } else { return _121; } } else { - const _142: rt.Result<[Uint8Array, Uint8Array], DecodeError.DecodeError> = rt.optionOkOr(rt.sliceSplitFirstChunk(buf, 9), { tag: "Short" } as DecodeError.DecodeError); + const _142: rt.Result<[Uint8Array, rt.ByteSlice], DecodeError.DecodeError> = rt.optionOkOr(rt.byteSliceSplitFirstChunk(buf, 9), { tag: "Short" } as DecodeError.DecodeError); if (_142.ok) { - const val8: [Uint8Array, Uint8Array] = _142.value; + const val8: [Uint8Array, rt.ByteSlice] = _142.value; const slice = val8[0]; - _8 = [fromHalves(rt.u32FromBeBytes(slice.subarray(1, 5)), ((val8[0][5] << 24) | (val8[0][6] << 16) | (val8[0][7] << 8) | val8[0][8]) >>> 0), val8[1]] as [rt.u64, Uint8Array]; + _8 = [fromHalves(rt.u32FromBeBytes(slice.subarray(1, 5)), ((val8[0][5] << 24) | (val8[0][6] << 16) | (val8[0][7] << 8) | val8[0][8]) >>> 0), val8[1]] as [rt.u64, rt.ByteSlice]; } else { return _142; } diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index 0cc38ef26..191849b5c 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -11,7 +11,7 @@ import * as Version from "../coding/version.Version.ts"; import type * as version_Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$Decode_Form(buf: Uint8Array, version: Form.Form): rt.Result<[Versions, rt.usize], DecodeError.DecodeError> { +export function decodeSlice$Decode_Form(buf: rt.ByteSlice, version: Form.Form): rt.Result<[Versions, rt.usize], DecodeError.DecodeError> { const r: Decoder.Decoder = Decoder.new(buf, version); const _6: rt.Result = decode$Decode_Form(r, version); if (_6.ok) { diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 5d91d1f77..3541b576f 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -16,9 +16,9 @@ import * as Probe from "./lite/probe.Probe.ts"; import type * as Version from "./lite/version.Version.ts"; /** Run one case. */ -export function run(input: Uint8Array): rt.ByteVec { +export function run(input: rt.ByteSlice): rt.ByteVec { const out: rt.ByteVec = new rt.ByteVec(); - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(input); + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(input); if (_5 !== undefined) { const _8: rt.u8 = rt.u8Rem(_5[0], 9); if (_8 === 0) { @@ -80,7 +80,7 @@ export function liteVersion(selector: rt.u8): Version.Version { } export function putU64(out: rt.ByteVec, value: rt.u64): void { - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(value)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(value))); } export function putUsize(out: rt.ByteVec, value: rt.usize): void { @@ -88,11 +88,12 @@ export function putUsize(out: rt.ByteVec, value: rt.usize): void { } /** Take up to 8 big-endian bytes as a `u64`, zero-padded on the right. */ -export function takeU64(data: Uint8Array): [rt.u64, Uint8Array] { +export function takeU64(data: rt.ByteSlice): [rt.u64, rt.ByteSlice] { const buf: Uint8Array = rt.bytes(8); const n: rt.usize = rt.min(data.length, 8); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - return [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u64, Uint8Array]; + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + return [rt.u64FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.u64, rt.ByteSlice]; } /** A decode error's code, then its text. */ @@ -194,17 +195,17 @@ export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void * Read primitives as a script says until one fails: the script is the first * `data[1]` bytes after the form selector, and the wire is everything after it. */ -export function decodeScript(data: Uint8Array, out: rt.ByteVec): void { - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); +export function decodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); if (_5 !== undefined) { const selector: rt.u8 = _5[0]; - const _9: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(_5[1]); + const _9: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(_5[1]); if (_9 !== undefined) { const len: rt.u8 = _9[0]; const _15: rt.usize = _9[1].length; - const _13: [Uint8Array, Uint8Array] = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); + const _13: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); const r: Decoder.Decoder = Decoder.new(_13[1], form(selector)); - const iterS: Uint8Array = _13[0]; + const iterS: Uint8Array = rt.byteSliceView(_13[0]); let iterI: number = 0; while (true) { const _21: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -238,7 +239,7 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt } else if (_5 === 1) { const _15: rt.Result = Decoder.u16(r); if (_15.ok) { - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_15.value)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_15.value))); } else { return _15; } @@ -271,7 +272,7 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _31; } } else if (_5 === 5) { - const _40: rt.Result = Decoder.bytes(r); + const _40: rt.Result = Decoder.bytes(r); if (_40.ok) { putUsize(out, _40.value.length); rt.byteVecExtendFromSlice(out, _40.value); @@ -286,7 +287,7 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt return _49; } } else if (_5 === 7) { - const _57: rt.Result = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); + const _57: rt.Result = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); if (_57.ok) { rt.byteVecExtendFromSlice(out, _57.value); } else { @@ -313,24 +314,24 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt } /** Write primitives as a script says, taking each value from the data that follows. */ -export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { +export function encodeScript(data: rt.ByteSlice, out: rt.ByteVec): void { let result!: rt.Result; let _47!: rt.u64 | undefined; let _74!: Prefix.Prefix; - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); if (_5 !== undefined) { const selector: rt.u8 = _5[0]; - const _9: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(_5[1]); + const _9: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(_5[1]); if (_9 !== undefined) { const len: rt.u8 = _9[0]; const _15: rt.usize = _9[1].length; - const _13: [Uint8Array, Uint8Array] = rt.sliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); - let values: Uint8Array = _13[1]; + const _13: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(_9[1], rt.min(_15, len as rt.usize)); + let values: rt.ByteSlice = _13[1]; const buf: rt.ByteVec = new rt.ByteVec(); const _20: Form.Form = form(selector); const w: Encoder.Encoder = Encoder.new(buf, _20); const prefixes: Prefix.Prefix[] = []; - const iterS: Uint8Array = _13[0]; + const iterS: Uint8Array = rt.byteSliceView(_13[0]); let iterI: number = 0; while (true) { const _24: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -338,7 +339,7 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { break; } const step: rt.u8 = _24; - const _30: [rt.u64, Uint8Array] = takeU64(values); + const _30: [rt.u64, rt.ByteSlice] = takeU64(values); const value: rt.u64 = _30[0]; values = _30[1]; const _33: rt.u8 = rt.u8Rem(step, 10); @@ -364,12 +365,13 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { } result = Encoder.varintOpt(w, _47); } else if (_33 === 5) { - const part = rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize; const _53: Uint8Array = rt.u64ToBeBytes(value); - const _51: Uint8Array = rt.sliceRange(_53, 0, part); + const part = rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize; + const slice = rt.byteSliceFrom(_53); + const _51: rt.ByteSlice = rt.byteSliceRange(slice, 0, part); result = Encoder.bytes(w, _51); } else if (_33 === 6) { - const _60: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(rt.u64ToBeBytes(value))); + const _60: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(rt.byteSliceFrom(rt.u64ToBeBytes(value)))); if (_60.ok) { const _68: string = _60.value; result = Encoder.string(w, _68); @@ -416,12 +418,12 @@ export function encodeScript(data: Uint8Array, out: rt.ByteVec): void { } } putUsize(out, buf.length); - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); } } } -export function zigzag(data: Uint8Array, out: rt.ByteVec): void { +export function zigzag(data: rt.ByteSlice, out: rt.ByteVec): void { const value: rt.u64 = takeU64(data)[0]; const signed: rt.i64 = rt.i64Cast(value); putU64(out, varint_zigzag(signed)); @@ -429,7 +431,7 @@ export function zigzag(data: Uint8Array, out: rt.ByteVec): void { putU64(out, rt.u64Cast(unzigzag(varint_zigzag(signed)))); } -export function sizes(data: Uint8Array, out: rt.ByteVec): void { +export function sizes(data: rt.ByteSlice, out: rt.ByteVec): void { let _9!: rt.u8; const value: rt.u64 = takeU64(data)[0]; let iterStart: rt.u8 = 0; @@ -445,8 +447,8 @@ export function sizes(data: Uint8Array, out: rt.ByteVec): void { } /** Decode a `T` from the wire, then encode what came out. */ -export function roundtrip$Versions(data: Uint8Array, out: rt.ByteVec): void { - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); +export function roundtrip$Versions(data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); if (_5 !== undefined) { const form_: Form.Form = form(_5[0]); const _8: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError> = Versions.decodeSlice$Decode_Form(_5[1], form_); @@ -457,7 +459,7 @@ export function roundtrip$Versions(data: Uint8Array, out: rt.ByteVec): void { const _17: Encoder.Encoder = Encoder.new(buf, form_); const _14: rt.Result = Versions.encode$Encode_Form(value, _17, form_); if (_14.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); } else { encodeFailed(out, _14.error); } @@ -468,8 +470,8 @@ export function roundtrip$Versions(data: Uint8Array, out: rt.ByteVec): void { } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ -export function roundtripLite$Group(data: Uint8Array, out: rt.ByteVec): void { - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); +export function roundtripLite$Group(data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); if (_5 !== undefined) { const version: Version.Version = liteVersion(_5[0]); const _8: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$Decode_Version(_5[1], version); @@ -481,7 +483,7 @@ export function roundtripLite$Group(data: Uint8Array, out: rt.ByteVec): void { const _17: Encoder.Encoder = Encoder.new(buf, _19); const _14: rt.Result = Group.encode$Encode_Version(value, _17, version); if (_14.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); } else { encodeFailed(out, _14.error); } @@ -492,8 +494,8 @@ export function roundtripLite$Group(data: Uint8Array, out: rt.ByteVec): void { } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ -export function roundtripLite$Probe(data: Uint8Array, out: rt.ByteVec): void { - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); +export function roundtripLite$Probe(data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); if (_5 !== undefined) { const version: Version.Version = liteVersion(_5[0]); const _8: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError> = Probe.decodeSlice$Decode_Version(_5[1], version); @@ -505,7 +507,7 @@ export function roundtripLite$Probe(data: Uint8Array, out: rt.ByteVec): void { const _17: Encoder.Encoder = Encoder.new(buf, _19); const _14: rt.Result = Probe.encode$Encode_Version(value, _17, version); if (_14.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); } else { encodeFailed(out, _14.error); } @@ -516,17 +518,17 @@ export function roundtripLite$Probe(data: Uint8Array, out: rt.ByteVec): void { } /** Encode messages built from the data, at a lite version. */ -export function encodeMessages(data: Uint8Array, out: rt.ByteVec): void { - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); +export function encodeMessages(data: rt.ByteSlice, out: rt.ByteVec): void { + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); if (_5 !== undefined) { const version: Version.Version = liteVersion(_5[0]); - const _10: [rt.u64, Uint8Array] = takeU64(_5[1]); + const _10: [rt.u64, rt.ByteSlice] = takeU64(_5[1]); const subscribe: rt.u64 = _10[0]; - const _13: [rt.u64, Uint8Array] = takeU64(_10[1]); + const _13: [rt.u64, rt.ByteSlice] = takeU64(_10[1]); const sequence: rt.u64 = _13[0]; - const _16: [rt.u64, Uint8Array] = takeU64(_13[1]); + const _16: [rt.u64, rt.ByteSlice] = takeU64(_13[1]); const frameStart: rt.u64 = _16[0]; - const _19: [rt.u64, Uint8Array] = takeU64(_16[1]); + const _19: [rt.u64, rt.ByteSlice] = takeU64(_16[1]); const bitrate: rt.u64 = _19[0]; const rtt: rt.u64 = takeU64(_19[1])[0]; encodeMessage$Group({ subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }, version, out); @@ -537,7 +539,7 @@ export function encodeMessages(data: Uint8Array, out: rt.ByteVec): void { const _43: Encoder.Encoder = Encoder.new(buf, _45); const _40: rt.Result = Versions.encode$Encode_Version(versions, _43, version); if (_40.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); } else { encodeFailed(out, _40.error); } @@ -552,7 +554,7 @@ export function encodeMessage$Group(msg: Group.Group, version: Version.Version, if (_8.ok) { rt.byteVecPush(out, w.control !== undefined ? 1 : 0); putUsize(out, buf.length); - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); } else { encodeFailed(out, _8.error); } @@ -566,16 +568,16 @@ export function encodeMessage$Probe(msg: Probe.Probe, version: Version.Version, if (_8.ok) { rt.byteVecPush(out, w.control !== undefined ? 1 : 0); putUsize(out, buf.length); - rt.byteVecExtendFromSlice(out, rt.byteVecView(buf)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); } else { encodeFailed(out, _8.error); } } /** Each error the codec can return, built from the data, as callers see it. */ -export function errors(data: Uint8Array, out: rt.ByteVec): void { +export function errors(data: rt.ByteSlice, out: rt.ByteVec): void { let err!: DecodeError.DecodeError; - const _5: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); + const _5: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); b0: { if (_5 !== undefined) { const selector: rt.u8 = _5[0]; @@ -590,7 +592,7 @@ export function errors(data: Uint8Array, out: rt.ByteVec): void { } else if (_10 === 3) { err = { tag: "Session", _0: { tag: "ProtocolViolation" } as SessionError.SessionError } as DecodeError.DecodeError; } else if (_10 === 4) { - const _20: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(_5[1])); + const _20: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(_5[1])); if (_20.ok) { err = { tag: "Missing" } as DecodeError.DecodeError; } else { diff --git a/ts/fixtures/codec/expected/lite/group.Group.ts b/ts/fixtures/codec/expected/lite/group.Group.ts index d5b7e21ef..958015b1c 100644 --- a/ts/fixtures/codec/expected/lite/group.Group.ts +++ b/ts/fixtures/codec/expected/lite/group.Group.ts @@ -11,7 +11,7 @@ import { decodeWith$Group_decode_closure0 } from "../lite/message.ts"; import * as Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$Decode_Version(buf: Uint8Array, version: Version.Version): rt.Result<[Group, rt.usize], DecodeError.DecodeError> { +export function decodeSlice$Decode_Version(buf: rt.ByteSlice, version: Version.Version): rt.Result<[Group, rt.usize], DecodeError.DecodeError> { const r: Decoder.Decoder = Decoder.new(buf, Form.from$From_Version(version)); const _6: rt.Result = decode$Decode_Version(r, version); if (_6.ok) { diff --git a/ts/fixtures/codec/expected/lite/probe.Probe.ts b/ts/fixtures/codec/expected/lite/probe.Probe.ts index b2586ccd5..0aed40fbd 100644 --- a/ts/fixtures/codec/expected/lite/probe.Probe.ts +++ b/ts/fixtures/codec/expected/lite/probe.Probe.ts @@ -12,7 +12,7 @@ import * as Version from "../lite/version.Version.ts"; import type * as Control from "../stats.Control.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$Decode_Version(buf: Uint8Array, version: Version.Version): rt.Result<[Probe, rt.usize], DecodeError.DecodeError> { +export function decodeSlice$Decode_Version(buf: rt.ByteSlice, version: Version.Version): rt.Result<[Probe, rt.usize], DecodeError.DecodeError> { const r: Decoder.Decoder = Decoder.new(buf, Form.from$From_Version(version)); const _6: rt.Result = decode$Decode_Version(r, version); if (_6.ok) { diff --git a/ts/fixtures/lang/brands.ts b/ts/fixtures/lang/brands.ts index d70401fa7..17f935230 100644 --- a/ts/fixtures/lang/brands.ts +++ b/ts/fixtures/lang/brands.ts @@ -7,7 +7,7 @@ import * as Meters from "./shapes.Meters.ts"; import * as Point from "./shapes.Point.ts"; import { returnedNever, tailBreak } from "./shapes.ts"; -export function mixed(data: Uint8Array): void { +export function mixed(data: rt.ByteSlice): void { returnedNever(7, 1); const meters: Meters.Meters = { _0: tailBreak(data) as rt.u64 }; // @ts-expect-error A `u16` is not a `u8`. diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 3846b8a4a..c138750ab 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -7,9 +7,9 @@ import * as Fault from "./fmt.Fault.ts"; import { run as harness } from "./harness.ts"; import * as rt from "./rt.ts"; -export function run(input: Uint8Array): rt.ByteVec { - if (input[0] !== 0xff) return harness(input); - const fault = Fault.new(input.subarray(1)); +export function run(input: rt.ByteSlice): rt.ByteVec { + if (rt.byteSliceFirst(input) !== 0xff) return harness(input); + const fault = Fault.new(rt.byteSliceRange(input, 1)); const display: rt.Fmt = (f) => Fault.fmt$Display(fault, f); const debug: rt.Fmt = (f) => Fault.fmt$Debug(fault, f); const text = rt.fmtFormat([ diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 5b36bf8a6..677ac4280 100644 --- a/ts/fixtures/lang/expected/chars.ts +++ b/ts/fixtures/lang/expected/chars.ts @@ -4,19 +4,20 @@ import * as rt from "./rt.ts"; import { put } from "./fmt.ts"; /** The scalars to try: the edges, then each big-endian `u32` in `data`, zero-padded. */ -export function scalars(data: Uint8Array): rt.u32[] { +export function scalars(data: rt.ByteSlice): rt.u32[] { const all: rt.u32[] = [0, 127, 128, 255, 256, 2047, 2048, 55295, 55296, 56319, 56320, 57343, 57344, 65533, 65535, 65536, 1114109, 1114111, 1114112, 4294967295].slice(); - let rest: Uint8Array = data; + let rest: rt.ByteSlice = data; while (true) { if (!((rest.length === 0))) { const buf: Uint8Array = rt.bytes(4); const n: rt.usize = rt.min(rest.length, 4); - const _13: Uint8Array = rt.sliceRange(buf, 0, n); - const _17: Uint8Array = rest; - rt.sliceCopyFromSlice(_13, rt.sliceRange(_17, 0, n)); + const slice = rt.byteSliceFrom(buf); + const _13: rt.ByteSlice = rt.byteSliceRange(slice, 0, n); + const _17: rt.ByteSlice = rest; + rt.byteSliceCopyFromSlice(_13, rt.byteSliceRange(_17, 0, n)); all.push(rt.u32FromBeBytes(buf)); - const _24: Uint8Array = rest; - rest = rt.sliceRange(_24, n); + const _24: rt.ByteSlice = rest; + rest = rt.byteSliceRange(_24, n); } else { return all; } @@ -67,7 +68,7 @@ export function class_(c: rt.char): rt.u8 { return 2; } -export function chars(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { const iterS: rt.u32[] = scalars(data); @@ -83,7 +84,7 @@ export function chars(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const c: rt.char = _14; rt.byteVecPush(out, class_(c)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(c as rt.u32)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(c as rt.u32))); } } } else if (_4 === 1) { @@ -97,14 +98,14 @@ export function chars(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const n2: rt.u32 = _27; const c2: rt.char = rt.optionUnwrapOr(rt.charFromU32(n2), (n2 & 0xff) as rt.char); rt.byteVecPush(out, c2 & 0xff); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(c2 & 0xffff)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(c2 & 0xffff))); rt.byteVecPush(out, ((c2 << 24) >> 24) & 0xff); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes((c2 << 16) >> 16)); - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(c2 as rt.i32)); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(c2 as rt.u64)); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(c2 as rt.i128)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((c2 << 16) >> 16))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(c2 as rt.i32))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(c2 as rt.u64))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(c2 as rt.i128))); rt.byteVecPush(out, ((n2 & 0xff) as rt.char) & 0xff); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(((c2 as rt.u32) & 0xff) as rt.u16)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(((c2 as rt.u32) & 0xff) as rt.u16))); } } else if (_4 === 2) { const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { @@ -133,7 +134,7 @@ export function chars(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { if (_128 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(_128 as rt.u32)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_128 as rt.u32))); } } else { const iterS3: rt.u32[] = scalars(data); diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index 8ad49a973..6dd869fde 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -49,7 +49,7 @@ export function rankByte(r: Rank.Rank): rt.u8 { } /** A `HashMap` by each kind of key, through a script of inserts, lookups, and removals. */ -export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _161!: rt.usize; let _286!: rt.usize; let _364!: rt.u8; @@ -70,7 +70,7 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } const i: rt.usize = _13; rt.idx(data, i); - const _19: [rt.u8, rt.u16] = [rt.u8Rem(data[i], 16), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0) as rt.u16]; + const _19: [rt.u8, rt.u16] = [rt.u8Rem(data.data[data.start + i], 16), rt.optionUnwrapOr(rt.byteSliceGet(data, rt.usizeAdd(i, 1)), 0) as rt.u16]; const k: rt.u8 = _19[0]; const v: rt.u16 = _19[1]; const _31: rt.u16 = rt.u16Rem(v, 5); @@ -93,9 +93,9 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, rt.hashLen(map) & 0xff); rt.byteVecPush(out, rt.hashLen(map) === 0 ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.iterSum(rt.iterMap(rt.hashValues(map), (v5: rt.u16): rt.u16 => { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.iterSum(rt.iterMap(rt.hashValues(map), (v5: rt.u16): rt.u16 => { return rt.u16Rem(v5, 256); - }), rt.u16Add, 0))); + }), rt.u16Add, 0)))); const _67: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.hashIter(map), (_227: [rt.u8, rt.u16]): [rt.u8, rt.u16] => { return [_227[0], _227[1]] as [rt.u8, rt.u16]; }); @@ -106,13 +106,13 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { break; } rt.byteVecPush(out, _73[0]); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_73[1])); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_73[1]))); } rt.hashClear(map); rt.byteVecPush(out, rt.hashLen(map) & 0xff); } else if (_4 === 1) { const map2: rt.HashMap = rt.hashNew(rt.hashing(rt.hashInt, rt.u64Eq)) as rt.HashMap; - const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); + const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _97: [rt.usize, rt.u8] | rt.Done = iter3.next(); if (_97 === rt.DONE) { @@ -137,10 +137,10 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { if (_129 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_129)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_129))); rt.byteVecPush(out, rt.hashIndex(map2, _129)); } - const _142: rt.u8 | undefined = rt.sliceFirst(data); + const _142: rt.u8 | undefined = rt.byteSliceFirst(data); if (_142 !== undefined) { const _150: rt.u64 = wide(rt.u8Rem(_142, 13)); rt.byteVecPush(out, rt.hashIndex(map2, _150)); @@ -156,9 +156,9 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const i3: rt.usize = _161; const _169: rt.usize = rt.usizeSub(i3, 1); rt.idx(data, _169); - const _168: rt.u8 = data[_169]; + const _168: rt.u8 = data.data[data.start + _169]; rt.idx(data, i3); - const _167: [rt.u8, rt.u8] = [_168, data[i3]]; + const _167: [rt.u8, rt.u8] = [_168, data.data[data.start + i3]]; const a: rt.u8 = _168; const b3: rt.u8 = _167[1]; rt.byteVecPush(out, rt.optionUnwrapOr(rt.hashInsert(map3, { _0: a }, b3), 204)); @@ -229,9 +229,9 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const i4: rt.usize = _286; const _294: rt.usize = rt.usizeSub(i4, 1); rt.idx(data, _294); - const _293: rt.u8 = data[_294]; + const _293: rt.u8 = data.data[data.start + _294]; rt.idx(data, i4); - const _292: [rt.u8, rt.u8] = [_293, data[i4]]; + const _292: [rt.u8, rt.u8] = [_293, data.data[data.start + i4]]; const a2: rt.u8 = _293; const b4: rt.u8 = _292[1]; const _305: Rank.Rank = copy$Rank(rank(b4, a2)); @@ -242,7 +242,7 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { }); t4.n = rt.u16WrappingAdd(t4.n, t4.n); rt.idx(data, i4); - const _313: Rank.Rank = copy$Rank(rank(data[i4], 0)); + const _313: Rank.Rank = copy$Rank(rank(data.data[data.start + i4], 0)); const e: rt.Entry = rt.entry(ranks, _313); rt.byteVecPush(out, rankByte(rt.entryKey(e))); rt.byteVecPush(out, rt.entryOrInsertWith(e, (k9: Rank.Rank): Tally.Tally => { @@ -265,7 +265,7 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const t12: Tally.Tally = _218[1]; return rankByte(k10) ^ (t12.n & 0xff); })); - const _348: rt.Iter<[rt.u8, Tally.Tally]> = rt.iterMap(rt.iterSlice(data), (_223: rt.u8): [rt.u8, Tally.Tally] => { + const _348: rt.Iter<[rt.u8, Tally.Tally]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_223: rt.u8): [rt.u8, Tally.Tally] => { const b8: rt.u8 = _223; return [rt.u8Rem(b8, 8), { n: b8 as rt.u16 }] as [rt.u8, Tally.Tally]; }); @@ -290,7 +290,7 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { return t14.n & 0xff; })); } - const iterS: Uint8Array = data; + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _380: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -327,7 +327,7 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { return t16.n & 0xff; })); } - const first: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + const first: rt.u8 = rt.optionUnwrapOr(rt.byteSliceFirst(data), 0); rt.byteVecPush(out, rt.u64Eq(_430({ _0: first }), _430({ _0: first ^ 240 })) ? 1 : 0); const _448: [rt.Hasher, Tally.Tally] = [rt.hasher(), { n: first as rt.u16 }]; const h: rt.Hasher = _448[0]; @@ -359,7 +359,7 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.hashLen(tuples) & 0xff); } else { const words: rt.HashMap = rt.hashNew() as rt.HashMap; - const iterS2: Uint8Array = data; + const iterS2: Uint8Array = rt.byteSliceView(data); let iterI2: number = 0; while (true) { const _496: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; @@ -401,7 +401,7 @@ export function hashMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { }), rt.usizeAdd, 0) & 0xff); rt.byteVecPush(out, rt.hashLen(words) === 0 ? 1 : 0); const clashes: rt.HashMap = rt.hashNew(rt.hashing(Clash.hash$Hash_DefaultHasher, Clash.eq$PartialEq)) as rt.HashMap; - const iter18: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); + const iter18: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _555: [rt.usize, rt.u8] | rt.Done = iter18.next(); if (_555 === rt.DONE) { @@ -472,12 +472,12 @@ export function claim(map: rt.HashMap, k: rt.u8, n: rt.u16): } /** `HashSet` and `BTreeSet`, each with the same script. */ -export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 3); if (_4 === 0) { const hashed: rt.HashSet = rt.hashNew() as rt.HashSet; const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; - const iterS: Uint8Array = data; + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _10: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -526,7 +526,7 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else if (_4 === 1) { const nibbles: rt.BTreeSet = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet; const seen: rt.HashSet = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashSet; - const iterS2: Uint8Array = data; + const iterS2: Uint8Array = rt.byteSliceView(data); let iterI2: number = 0; while (true) { const _106: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; @@ -560,7 +560,7 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, rt.hashLen(seen) & 0xff); const dirs: rt.HashSet = rt.hashNew(rt.hashing(Dir.hash$Hash_DefaultHasher, Dir.eq$PartialEq, true)) as rt.HashSet; - const iterS3: Uint8Array = data; + const iterS3: Uint8Array = rt.byteSliceView(data); let iterI3: number = 0; while (true) { const _151: rt.u8 | rt.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; @@ -576,7 +576,7 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.hashLen(dirs) & 0xff); } else { const words: rt.BTreeSet = rt.btreeNew(rt.cmpStr) as rt.BTreeSet; - const iterS4: Uint8Array = data; + const iterS4: Uint8Array = rt.byteSliceView(data); let iterI4: number = 0; while (true) { const _175: rt.u8 | rt.Done = iterI4 < iterS4.length ? iterS4[iterI4++] : rt.DONE; @@ -598,7 +598,7 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_192)); rt.byteVecPush(out, 0); } - const _200: rt.Iter = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.u64 => { + const _200: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u64 => { return wide(_2); }); const iter8: rt.Iter = rt.iterRev(rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _200, true))); @@ -607,13 +607,13 @@ export function sets(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { if (_207 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_207)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_207))); } } } /** `BTreeMap`: ordered by the key's `Ord`, through inserts, removals, and ranges. */ -export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let within!: rt.ByteVec; let _164!: rt.usize; let _344!: rt.usize; @@ -629,7 +629,7 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } const i: rt.usize = _13; rt.idx(data, i); - const _19: [rt.u8, rt.u8] = [rt.u8Rem(data[i], 32), rt.optionUnwrapOr(rt.sliceGet(data, rt.usizeAdd(i, 1)), 0)]; + const _19: [rt.u8, rt.u8] = [rt.u8Rem(data.data[data.start + i], 32), rt.optionUnwrapOr(rt.byteSliceGet(data, rt.usizeAdd(i, 1)), 0)]; const k: rt.u8 = _19[0]; const v: rt.u8 = _19[1]; const _30: rt.u8 = rt.u8Rem(v, 6); @@ -692,8 +692,8 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void rt.btreeRemove(map, 3); rt.byteVecPush(out, rt.btreeLen(map) & 0xff); rt.byteVecPush(out, rt.btreeContains(map, 3) ? 1 : 0); - const lo: rt.u8 = rt.u8Rem(rt.optionUnwrapOr(rt.sliceFirst(data), 0), 32); - const hi: rt.u8 = rt.u8Rem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0), 32); + const lo: rt.u8 = rt.u8Rem(rt.optionUnwrapOr(rt.byteSliceFirst(data), 0), 32); + const hi: rt.u8 = rt.u8Rem(rt.optionUnwrapOr(rt.byteSliceGet(data, 1), 0), 32); const _137: rt.u8 = rt.u8Rem(lo, 3); if (_137 === 0) { within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.Range(lo, hi)), (_238: [rt.u8, rt.u8]): rt.u8 => { @@ -709,7 +709,7 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void return _231[0]; })); } - rt.byteVecExtendFromSlice(out, rt.byteVecView(within)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(within)); rt.iterExtendBytes(out, rt.btreeValues(map)); } else if (_4 === 1) { const ranks: rt.BTreeMap = rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap; @@ -721,9 +721,9 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void const i2: rt.usize = _164; const _172: rt.usize = rt.usizeSub(i2, 1); rt.idx(data, _172); - const _171: rt.u8 = data[_172]; + const _171: rt.u8 = data.data[data.start + _172]; rt.idx(data, i2); - const _170: [rt.u8, rt.u8] = [_171, data[i2]]; + const _170: [rt.u8, rt.u8] = [_171, data.data[data.start + i2]]; const a: rt.u8 = _171; const b: rt.u8 = _170[1]; const _182: Rank.Rank = copy$Rank(rank(a, b)); @@ -738,7 +738,7 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void if (_197 !== undefined) { _197.n = _197.n ^ 23130; } - const iterS: Uint8Array = data; + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _205: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -767,7 +767,7 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void break; } rt.byteVecPush(out, rankByte(_240[0])); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_240[1].n)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_240[1].n))); } const iter8: rt.Iter<[[rt.u8, rt.u8], rt.u8]> = rt.btreeIter(pairs); while (true) { @@ -785,11 +785,11 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void if (_274 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(_274[0])); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_274[0]))); rt.byteVecPush(out, _274[1]); } } else if (_4 === 2) { - const _287: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.iterMap(rt.iterSlice(data), (_215: rt.u8): [Fussy.Fussy, Fussy.Fussy] => { + const _287: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): [Fussy.Fussy, Fussy.Fussy] => { const b8: rt.u8 = _215; return [{ _0: b8 }, { _0: b8 ^ 90 }] as [Fussy.Fussy, Fussy.Fussy]; }); @@ -804,7 +804,7 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } else { const nibbles: rt.BTreeMap = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap; const words: rt.BTreeMap = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; - const iterS2: Uint8Array = data; + const iterS2: Uint8Array = rt.byteSliceView(data); let iterI2: number = 0; while (true) { const _307: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; @@ -835,16 +835,16 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void const i3: rt.usize = _344; const _353: rt.usize = rt.usizeSub(i3, 1); rt.idx(data, _353); - const _351: Nibble.Nibble = { _0: data[_353] }; + const _351: Nibble.Nibble = { _0: data.data[data.start + _353] }; rt.idx(data, i3); - const _350: [Nibble.Nibble, Nibble.Nibble] = [_351, { _0: data[i3] }]; + const _350: [Nibble.Nibble, Nibble.Nibble] = [_351, { _0: data.data[data.start + i3] }]; const a2: Nibble.Nibble = _351; const b4: Nibble.Nibble = _350[1]; const _365: rt.usize = rt.usizeSub(i3, 1); rt.idx(data, _365); - const _364: rt.u8 = data[_365]; + const _364: rt.u8 = data.data[data.start + _365]; rt.idx(data, i3); - const _363: [rt.u8, rt.u8] = [_364, data[i3]]; + const _363: [rt.u8, rt.u8] = [_364, data.data[data.start + i3]]; const x: rt.u8 = _364; const y: rt.u8 = _363[1]; const o: rt.Ordering = rt.orderingThen(rt.orderingReverse(Nibble.cmp$Ord(a2, b4)), (): rt.Ordering => { @@ -861,16 +861,16 @@ export function btreeMaps(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void rt.byteVecPush(out, _401); rt.byteVecPush(out, o === 1 ? 1 : 0); } - const _409: rt.Iter<[Nibble.Nibble, rt.u8]> = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): [Nibble.Nibble, rt.u8] => { + const _409: rt.Iter<[Nibble.Nibble, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [Nibble.Nibble, rt.u8] => { const b5: rt.u8 = _2; return [{ _0: b5 }, b5] as [Nibble.Nibble, rt.u8]; }); const collected: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap, _409, true); - const _412: rt.Iter = rt.iterMap(rt.iterSlice(data), (_213: rt.u8): Nibble.Nibble => { + const _412: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): Nibble.Nibble => { return { _0: _213 }; }); const keys: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet, _412, true); - const _416: rt.Iter = rt.iterMap(rt.iterSlice(data), (_214: rt.u8): Nibble.Nibble => { + const _416: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): Nibble.Nibble => { return { _0: _214 ^ 48 }; }); rt.btreeExtendKeys(keys, _416); @@ -909,11 +909,11 @@ export function touch(q: rt.VecDeque): rt.VecDeque { } /** `VecDeque`: a ring buffer, pushed and popped at both ends past its capacity. */ -export function deques(data: Uint8Array, out: rt.ByteVec): void { +export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { let drained2!: rt.ByteVec; const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const pairs: rt.VecDeque<[rt.u8, rt.u8]> = rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8]>; - const iterS: Uint8Array = data; + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _7: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -962,9 +962,9 @@ export function deques(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, _83[0] ^ _83[1]); } - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.dequeDrain(q, undefined)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.dequeDrain(q, undefined)))); rt.byteVecPush(out, q.n === 0 ? 1 : 0); - const _101: rt.Iter = rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tally.Tally => { + const _101: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Tally.Tally => { return { n: _2 as rt.u16 }; }); const tallies: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _101); @@ -991,7 +991,7 @@ export function deques(data: Uint8Array, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t4: Tally.Tally): rt.u8 => { return t4.n & 0xff; })); - const _135: rt.Iter = rt.iterSlice(data); + const _135: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.dequeExtend(q, _135); const _139: rt.usize = rt.usizeDiv(q.n, 2); rt.dequeInsert(q, _139, 66); @@ -999,9 +999,9 @@ export function deques(data: Uint8Array, out: rt.ByteVec): void { rt.dequeTruncate(q, 5); rt.byteVecPush(out, rt.dequeContains(q, 66, rt.same) ? 1 : 0); rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); - const a: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.usize, 8); - const b2: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(data, 1), 0) as rt.usize, 8); - const _171: rt.Iter = rt.iterSlice(data); + const a: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.byteSliceFirst(data), 0) as rt.usize, 8); + const b2: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.byteSliceGet(data, 1), 0) as rt.usize, 8); + const _171: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); const q2: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _171); const _174: rt.usize = rt.usizeRem(a, 4); if (_174 === 0) { @@ -1014,25 +1014,25 @@ export function deques(data: Uint8Array, out: rt.ByteVec): void { } else { drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { start: a })); } - rt.byteVecExtendFromSlice(out, rt.byteVecView(drained2)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(drained2)); rt.iterExtendBytes(out, rt.dequeIter(q2)); rt.byteVecPush(out, rt.dequeIndex(q2, b2)); } /** `vec![a, b]` and `vec![x; n]`, of bytes, numbers, `Copy` tuples, and types that clone. */ -export function vecs(data: Uint8Array, out: rt.ByteVec): void { +export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { let name!: string; - const a: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const b: rt.u8 = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); - const n: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(data, 2), 0) as rt.usize, 5); - const _16: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(data)); + const a: rt.u8 = rt.optionUnwrapOr(rt.byteSliceFirst(data), 0); + const b: rt.u8 = rt.optionUnwrapOr(rt.byteSliceGet(data, 1), 0); + const n: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.byteSliceGet(data, 2), 0) as rt.usize, 5); + const _16: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(data)); if (_16.ok) { const s: string = _16.value; name = s; } else { name = "?"; } - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.byteVecFrom(Uint8Array.of(a, b, 66)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteVecFrom(Uint8Array.of(a, b, 66)))); const pairs: [rt.u8, rt.u16][] = copy$u8_u16s([[a, b as rt.u16] as [rt.u8, rt.u16]]).map(copy$u8_u16); pairs.push([b, a as rt.u16] as [rt.u8, rt.u16]); const at = rt.idx(pairs, 0); @@ -1050,7 +1050,7 @@ export function vecs(data: Uint8Array, out: rt.ByteVec): void { const one: Cloned.Cloned[] = [{ depth: a, name: name }]; const at2 = rt.idx(one, 0); rt.byteVecPush(out, one[at2].depth); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.byteVecOf(b, n))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteVecOf(b, n))); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem(rt.u16Mul(a as rt.u16, 257), n, undefined)), (w: rt.u16): rt.u8 => { return rt.u16Shr(w, 4) & 0xff; })); @@ -1094,7 +1094,7 @@ export function vecs(data: Uint8Array, out: rt.ByteVec): void { const _147: rt.u8 = a; const _148: rt.u8 = b; const at7 = rt.idx(listed, 1); - rt.byteVecExtendFromSlice(out, Uint8Array.of(_147, _148, listed[at7][0], a)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_147, _148, listed[at7][0], a))); rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(repeated), rt.iterSlice(again)), (t2: [rt.u8, rt.u8]): rt.u8 => { return t2[1]; })); @@ -1128,9 +1128,9 @@ export function hold(pair: [rt.u8, rt.u8]): Holder.Holder { * A `Copy` aggregate a std call stores by value is the container's own copy: changing * one stored element leaves the value it came from and the other elements as they were. */ -export function stores(data: Uint8Array, out: rt.ByteVec): void { - const a: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const b: rt.u8 = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); +export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: rt.u8 = rt.optionUnwrapOr(rt.byteSliceFirst(data), 0); + const b: rt.u8 = rt.optionUnwrapOr(rt.byteSliceGet(data, 1), 0); const pair: [rt.u8, rt.u8] = same([a, b] as [rt.u8, rt.u8]); const changed: [rt.u8, rt.u8] = [b, a]; changed[0] = changed[0] ^ 16; @@ -1165,7 +1165,7 @@ export function stores(data: Uint8Array, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (p: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(p[0], p[1]); }, (value: Uint8Array) => rt.iterSlice(value))); - rt.byteVecExtendFromSlice(out, Uint8Array.of(changed[0], changed[1], old[0], old[1])); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(changed[0], changed[1], old[0], old[1]))); const tally: Tally.Tally = { n: a as rt.u16 }; const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; rt.dequePushBack(q, copy$Tally(tally)); @@ -1218,7 +1218,7 @@ export function stores(data: Uint8Array, out: rt.ByteVec): void { const at10 = rt.idx(holders, 0); const _130: rt.u8 = holders[at10].pair[1]; const at11 = rt.idx(holders, 1); - rt.byteVecExtendFromSlice(out, Uint8Array.of(_128, _129, _130, holders[at11].pair[1])); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_128, _129, _130, holders[at11].pair[1]))); rt.byteVecPush(out, bump({ pair: copy$u8_u8(pair) })); const held: Holder.Holder = hold(pair); held.pair[1] = held.pair[1] ^ 4; @@ -1228,8 +1228,8 @@ export function stores(data: Uint8Array, out: rt.ByteVec): void { holders[at12].pair[0] = holders[at12].pair[0] ^ 8; const _149: rt.u8 = held.pair[1]; const at13 = rt.idx(holders, 2); - rt.byteVecExtendFromSlice(out, Uint8Array.of(_149, holders[at13].pair[0])); - rt.byteVecExtendFromSlice(out, Uint8Array.of(pair[0], pair[1])); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_149, holders[at13].pair[0]))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); } //# sourceMappingURL=collections.ts.map diff --git a/ts/fixtures/lang/expected/fmt.Fault.ts b/ts/fixtures/lang/expected/fmt.Fault.ts index 60038b842..cdf0ea26c 100644 --- a/ts/fixtures/lang/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/expected/fmt.Fault.ts @@ -57,9 +57,9 @@ export function fmt$Display(self: Fault, f: rt.Formatter): rt.Result rt.u8 = (i: rt.usize): rt.u8 => { - return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); + return rt.optionUnwrapOr(rt.byteSliceGet(data, i), 0); }; const _3: rt.u8 = rt.u8Rem(at(0), 4); if (_3 === 0) { diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index a70e49ea8..a5a7215e0 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -25,100 +25,112 @@ export function put(out: rt.ByteVec, s: string): void { } /** Integers of every width, with each spec. */ -export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 12); if (_4 === 0) { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice12 = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice12, 0, n), rt.byteSliceRange(data, 0, n)); const v: rt.u8 = rt.u8FromBeBytes(buf); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8LowerHex(v, f), (f: rt.Formatter) => rt.u8UpperHex(v, f)]; put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", rt.fmtSpec({ width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rt.fmtSpec({ alternate: true }, args2[2]), " ", rt.fmtSpec({ alternate: true }, args2[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rt.fmtSpec({ alternate: true }, args2[1]), " ", rt.fmtSpec({ width: 3 }, args2[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(v, f))); } else if (_4 === 1) { const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(data.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data, 0, n2)); + const n2: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf2).length); + const slice11 = rt.byteSliceFrom(buf2); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice11, 0, n2), rt.byteSliceRange(data, 0, n2)); const v2: rt.u16 = rt.u16FromBeBytes(buf2); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16LowerHex(v2, f), (f: rt.Formatter) => rt.u16UpperHex(v2, f)]; put(out, rt.fmtFormat([args4[0], " ", args4[1], " ", rt.fmtSpec({ width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args4[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args4[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args4[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args4[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args4[0]), "|", args4[2], " ", args4[3], " ", rt.fmtSpec({ alternate: true }, args4[2]), " ", rt.fmtSpec({ alternate: true }, args4[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args4[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args4[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args4[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args4[3]), "|", rt.fmtSpec({ alternate: true }, args4[1]), " ", rt.fmtSpec({ width: 3 }, args4[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.u16Display(v2, f))); } else if (_4 === 2) { const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(data.length, buf3.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data, 0, n3)); + const n3: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf3).length); + const slice10 = rt.byteSliceFrom(buf3); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice10, 0, n3), rt.byteSliceRange(data, 0, n3)); const v3: rt.u32 = rt.u32FromBeBytes(buf3); const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32LowerHex(v3, f), (f: rt.Formatter) => rt.u32UpperHex(v3, f)]; put(out, rt.fmtFormat([args6[0], " ", args6[1], " ", rt.fmtSpec({ width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args6[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args6[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args6[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args6[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args6[0]), "|", args6[2], " ", args6[3], " ", rt.fmtSpec({ alternate: true }, args6[2]), " ", rt.fmtSpec({ alternate: true }, args6[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args6[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args6[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args6[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args6[3]), "|", rt.fmtSpec({ alternate: true }, args6[1]), " ", rt.fmtSpec({ width: 3 }, args6[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.u32Display(v3, f))); } else if (_4 === 3) { const buf4: Uint8Array = rt.bytes(8); - const n4: rt.usize = rt.min(data.length, buf4.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data, 0, n4)); + const n4: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf4).length); + const slice9 = rt.byteSliceFrom(buf4); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice9, 0, n4), rt.byteSliceRange(data, 0, n4)); const v4: rt.u64 = rt.u64FromBeBytes(buf4); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64LowerHex(v4, f), (f: rt.Formatter) => rt.u64UpperHex(v4, f)]; put(out, rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rt.fmtSpec({ alternate: true }, args8[2]), " ", rt.fmtSpec({ alternate: true }, args8[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rt.fmtSpec({ alternate: true }, args8[1]), " ", rt.fmtSpec({ width: 3 }, args8[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.u64Display(v4, f))); } else if (_4 === 4) { const buf5: Uint8Array = rt.bytes(16); - const n5: rt.usize = rt.min(data.length, buf5.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data, 0, n5)); + const n5: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf5).length); + const slice8 = rt.byteSliceFrom(buf5); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice8, 0, n5), rt.byteSliceRange(data, 0, n5)); const v5: rt.u128 = rt.u128FromBeBytes(buf5); const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128LowerHex(v5, f), (f: rt.Formatter) => rt.u128UpperHex(v5, f)]; put(out, rt.fmtFormat([args10[0], " ", args10[1], " ", rt.fmtSpec({ width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args10[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args10[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args10[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args10[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args10[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args10[0]), "|", args10[2], " ", args10[3], " ", rt.fmtSpec({ alternate: true }, args10[2]), " ", rt.fmtSpec({ alternate: true }, args10[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args10[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args10[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args10[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args10[3]), "|", rt.fmtSpec({ alternate: true }, args10[1]), " ", rt.fmtSpec({ width: 3 }, args10[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.u128Display(v5, f))); } else if (_4 === 5) { const buf6: Uint8Array = rt.bytes(4); - const n6: rt.usize = rt.min(data.length, buf6.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data, 0, n6)); + const n6: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf6).length); + const slice7 = rt.byteSliceFrom(buf6); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice7, 0, n6), rt.byteSliceRange(data, 0, n6)); const v6: rt.usize = rt.usizeFromBeBytes(buf6); const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeLowerHex(v6, f), (f: rt.Formatter) => rt.usizeUpperHex(v6, f)]; put(out, rt.fmtFormat([args12[0], " ", args12[1], " ", rt.fmtSpec({ width: 5 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args12[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args12[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args12[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args12[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args12[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args12[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args12[0]), "|", args12[2], " ", args12[3], " ", rt.fmtSpec({ alternate: true }, args12[2]), " ", rt.fmtSpec({ alternate: true }, args12[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args12[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args12[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args12[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args12[3]), "|", rt.fmtSpec({ alternate: true }, args12[1]), " ", rt.fmtSpec({ width: 3 }, args12[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v6, f))); } else if (_4 === 6) { const buf7: Uint8Array = Uint8Array.of(0); - const n7: rt.usize = rt.min(data.length, buf7.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data, 0, n7)); + const n7: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf7).length); + const slice6 = rt.byteSliceFrom(buf7); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice6, 0, n7), rt.byteSliceRange(data, 0, n7)); const v7: rt.i8 = rt.i8FromBeBytes(buf7); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8LowerHex(v7, f), (f: rt.Formatter) => rt.i8UpperHex(v7, f)]; put(out, rt.fmtFormat([args14[0], " ", args14[1], " ", rt.fmtSpec({ width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rt.fmtSpec({ alternate: true }, args14[2]), " ", rt.fmtSpec({ alternate: true }, args14[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rt.fmtSpec({ alternate: true }, args14[1]), " ", rt.fmtSpec({ width: 3 }, args14[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.i8Display(v7, f))); } else if (_4 === 7) { const buf8: Uint8Array = rt.bytes(2); - const n8: rt.usize = rt.min(data.length, buf8.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data, 0, n8)); + const n8: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf8).length); + const slice5 = rt.byteSliceFrom(buf8); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice5, 0, n8), rt.byteSliceRange(data, 0, n8)); const v8: rt.i16 = rt.i16FromBeBytes(buf8); const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16LowerHex(v8, f), (f: rt.Formatter) => rt.i16UpperHex(v8, f)]; put(out, rt.fmtFormat([args16[0], " ", args16[1], " ", rt.fmtSpec({ width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args16[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args16[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args16[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args16[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args16[0]), "|", args16[2], " ", args16[3], " ", rt.fmtSpec({ alternate: true }, args16[2]), " ", rt.fmtSpec({ alternate: true }, args16[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args16[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args16[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args16[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args16[3]), "|", rt.fmtSpec({ alternate: true }, args16[1]), " ", rt.fmtSpec({ width: 3 }, args16[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.i16Display(v8, f))); } else if (_4 === 8) { const buf9: Uint8Array = rt.bytes(4); - const n9: rt.usize = rt.min(data.length, buf9.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data, 0, n9)); + const n9: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf9).length); + const slice4 = rt.byteSliceFrom(buf9); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice4, 0, n9), rt.byteSliceRange(data, 0, n9)); const v9: rt.i32 = rt.i32FromBeBytes(buf9); const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32LowerHex(v9, f), (f: rt.Formatter) => rt.i32UpperHex(v9, f)]; put(out, rt.fmtFormat([args18[0], " ", args18[1], " ", rt.fmtSpec({ width: 5 }, args18[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args18[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args18[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args18[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args18[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args18[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args18[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args18[0]), "|", args18[2], " ", args18[3], " ", rt.fmtSpec({ alternate: true }, args18[2]), " ", rt.fmtSpec({ alternate: true }, args18[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args18[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args18[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args18[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args18[3]), "|", rt.fmtSpec({ alternate: true }, args18[1]), " ", rt.fmtSpec({ width: 3 }, args18[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.i32Display(v9, f))); } else if (_4 === 9) { const buf10: Uint8Array = rt.bytes(8); - const n10: rt.usize = rt.min(data.length, buf10.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data, 0, n10)); + const n10: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf10).length); + const slice3 = rt.byteSliceFrom(buf10); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice3, 0, n10), rt.byteSliceRange(data, 0, n10)); const v10: rt.i64 = rt.i64FromBeBytes(buf10); const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64LowerHex(v10, f), (f: rt.Formatter) => rt.i64UpperHex(v10, f)]; put(out, rt.fmtFormat([args20[0], " ", args20[1], " ", rt.fmtSpec({ width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rt.fmtSpec({ alternate: true }, args20[2]), " ", rt.fmtSpec({ alternate: true }, args20[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rt.fmtSpec({ alternate: true }, args20[1]), " ", rt.fmtSpec({ width: 3 }, args20[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.i64Display(v10, f))); } else if (_4 === 10) { const buf11: Uint8Array = rt.bytes(16); - const n11: rt.usize = rt.min(data.length, buf11.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data, 0, n11)); + const n11: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf11).length); + const slice2 = rt.byteSliceFrom(buf11); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice2, 0, n11), rt.byteSliceRange(data, 0, n11)); const v11: rt.i128 = rt.i128FromBeBytes(buf11); const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128LowerHex(v11, f), (f: rt.Formatter) => rt.i128UpperHex(v11, f)]; put(out, rt.fmtFormat([args22[0], " ", args22[1], " ", rt.fmtSpec({ width: 5 }, args22[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args22[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args22[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args22[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args22[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args22[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args22[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args22[0]), "|", args22[2], " ", args22[3], " ", rt.fmtSpec({ alternate: true }, args22[2]), " ", rt.fmtSpec({ alternate: true }, args22[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args22[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args22[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args22[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args22[3]), "|", rt.fmtSpec({ alternate: true }, args22[1]), " ", rt.fmtSpec({ width: 3 }, args22[1])])); put(out, rt.fmtToString((f: rt.Formatter) => rt.i128Display(v11, f))); } else { const buf12: Uint8Array = rt.bytes(4); - const n12: rt.usize = rt.min(data.length, buf12.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data, 0, n12)); + const n12: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf12).length); + const slice = rt.byteSliceFrom(buf12); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n12), rt.byteSliceRange(data, 0, n12)); const v12: rt.isize = rt.isizeFromBeBytes(buf12); const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeLowerHex(v12, f), (f: rt.Formatter) => rt.isizeUpperHex(v12, f)]; put(out, rt.fmtFormat([args24[0], " ", args24[1], " ", rt.fmtSpec({ width: 5 }, args24[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args24[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args24[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args24[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args24[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args24[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args24[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args24[0]), "|", args24[2], " ", args24[3], " ", rt.fmtSpec({ alternate: true }, args24[2]), " ", rt.fmtSpec({ alternate: true }, args24[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args24[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args24[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args24[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args24[3]), "|", rt.fmtSpec({ alternate: true }, args24[1]), " ", rt.fmtSpec({ width: 3 }, args24[1])])); @@ -127,9 +139,9 @@ export function ints(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Strings padded and escaped, and bytes that may not be UTF-8. */ -export function strings(data: Uint8Array, out: rt.ByteVec): void { +export function strings(data: rt.ByteSlice, out: rt.ByteVec): void { let flag!: boolean; - const iterS: Uint8Array = rt.sliceRange(data, 0, rt.min(data.length, 3)); + const iterS: Uint8Array = rt.byteSliceView(rt.byteSliceRange(data, 0, rt.min(data.length, 3))); let iterI: number = 0; while (true) { const _9: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -147,7 +159,7 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { const args2: rt.Fmt[] = [_31, (f: rt.Formatter) => rt.fmtStr(arg2, f)]; put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ width: 8 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 8 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 8 }, args2[0]), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ width: 12 }, args2[1]), "|", rt.fmtSpec({ alternate: true }, args2[1]), "|{", args2[0], "}"])); } - const _36: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(data)); + const _36: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(data)); if (_36.ok) { const arg5 = _36.value; const _48: rt.Fmt = (f: rt.Formatter) => rt.fmtStr(arg5, f); @@ -161,7 +173,7 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { const args6: rt.Fmt[] = [_61, (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(arg4, f)]; put(out, rt.fmtFormat([args6[0], " ", args6[1], " ", rt.fmtSpec({ alternate: true }, args6[1]), " ", rt.fmtSpec({ align: ">", width: 80 }, args6[0])])); } - const _66: rt.u8 | undefined = rt.sliceFirst(data); + const _66: rt.u8 | undefined = rt.byteSliceFirst(data); b3: { if (_66 !== undefined) { if (rt.u8Rem(_66, 2) === 0) { @@ -189,13 +201,13 @@ export function strings(data: Uint8Array, out: rt.ByteVec): void { } } -export function nested(data: Uint8Array): Nested.Nested { +export function nested(data: rt.ByteSlice): Nested.Nested { let _22!: Shape.Shape; let _49!: Pair.Pair | undefined; let _61!: rt.Result; let _90!: Kind.Kind; const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); + return rt.optionUnwrapOr(rt.byteSliceGet(data, i), 0); }; const _5: rt.usize = rt.usizeRem(at(0) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028 ", "͸􏿽", "😀 🇦", "゙゚ン", "{}"].length); if (!(_5 < 14)) { @@ -211,7 +223,7 @@ export function nested(data: Uint8Array): Nested.Nested { } else { _22 = { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rt.u16, height: 9 } as Shape.Shape; } - const _35: rt.ByteVec = rt.sliceToByteVec(rt.sliceRange(data, 0, rt.min(data.length, 4))); + const _35: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 0, rt.min(data.length, 4))); const _40: Pair.Pair[] = [{ _0: at(4), _1: -1 }, { _0: 2, _1: { hi: -0x80000000, lo: 0 } as rt.i64 }].map(copy$Pair$2); if (!(rt.u8Rem(at(5), 2) === 0)) { _49 = undefined; @@ -234,15 +246,15 @@ export function nested(data: Uint8Array): Nested.Nested { } else if (_91 === 1) { _90 = { tag: "One", _0: at(11) } as Kind.Kind; } else { - _90 = { tag: "Many", count: 2, items: rt.sliceToByteVec(Uint8Array.of(at(11), at(12))) } as Kind.Kind; + _90 = { tag: "Many", count: 2, items: rt.byteSliceToByteVec(rt.byteSliceFrom(Uint8Array.of(at(11), at(12)))) } as Kind.Kind; } return { name: _3, point: _15, shape: _22, tags: _35, pairs: _40, maybe: _49, none: _60, result: _61, list: _73, tuple: _80, single: _84, empty: _88, unit: undefined, boxed: _90 }; } /** Derived `Debug` of every shape, compact and pretty, with options passed to fields. */ -export function derived(data: Uint8Array, out: rt.ByteVec): void { +export function derived(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); + return rt.optionUnwrapOr(rt.byteSliceGet(data, i), 0); }; const value: Nested.Nested = nested(data); const arg = ([value] as [Nested.Nested])[0]; @@ -274,9 +286,9 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(arg5, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f))]; put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args14[0])])); const words: rt.u16[] = [at(5) as rt.u16, 65535]; - const _153: rt.u8 | undefined = rt.sliceFirst(data); - const _155: rt.u8 | undefined = rt.sliceGet(data, 100); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(data, f, rt.u8Display), (f: rt.Formatter) => rt.fmtList(words, f, rt.u16Display), (f: rt.Formatter) => rt.fmtOption(_153, f, rt.u8Display), (f: rt.Formatter) => rt.fmtOption(_155, f, rt.u8Display)]; + const _153: rt.u8 | undefined = rt.byteSliceFirst(data); + const _155: rt.u8 | undefined = rt.byteSliceGet(data, 100); + const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(data), f, rt.u8Display), (f: rt.Formatter) => rt.fmtList(words, f, rt.u16Display), (f: rt.Formatter) => rt.fmtOption(_153, f, rt.u8Display), (f: rt.Formatter) => rt.fmtOption(_155, f, rt.u8Display)]; put(out, rt.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]])); const arg6 = {}; const _177: rt.Fmt = (f: rt.Formatter) => Braced.fmt$Debug(arg6, f); @@ -287,14 +299,14 @@ export function derived(data: Uint8Array, out: rt.ByteVec): void { const arg9 = {}; const args18: rt.Fmt[] = [_177, _178, _179, (f: rt.Formatter) => Bare.fmt$Debug(arg9, f)]; put(out, rt.fmtFormat([args18[0], " ", rt.fmtSpec({ alternate: true }, args18[1]), " ", args18[2], " ", rt.fmtSpec({ alternate: true }, args18[3])])); - rt.byteVecExtendFromSlice(out, Uint8Array.of(Braced.eq$PartialEq({}, {}) ? 1 : 0, Bare.eq$PartialEq({}, {}) ? 1 : 0)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(Braced.eq$PartialEq({}, {}) ? 1 : 0, Bare.eq$PartialEq({}, {}) ? 1 : 0))); } /** Written `Display` and `Debug`, and a `Display` that fails inside `format!`. */ -export function written(data: Uint8Array, out: rt.ByteVec): void { +export function written(data: rt.ByteSlice, out: rt.ByteVec): void { let _100!: rt.u8 | undefined; const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); + return rt.optionUnwrapOr(rt.byteSliceGet(data, i), 0); }; const hex: Hex.Hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; const args2: rt.Fmt[] = [(f: rt.Formatter) => Hex.fmt$Display(hex, f), (f: rt.Formatter) => Hex.fmt$Debug(hex, f)]; @@ -338,15 +350,15 @@ export function written(data: Uint8Array, out: rt.ByteVec): void { } /** Panics, each with the message native Rust formats. */ -export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { +export function panics(kind: rt.u8, rest: rt.ByteSlice, out: rt.ByteVec): void { let r!: rt.Result; let r2!: rt.Result; let r4!: rt.Result; let r5!: rt.Result; - const n: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(rest), 0); + const n: rt.u8 = rt.optionUnwrapOr(rt.byteSliceFirst(rest), 0); const _7: rt.u8 = rt.u8Rem(kind, 20); if (_7 === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.fmtList(rest, f, rt.u8Display)]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(rest), f, rt.u8Display)]; rt.panicFmt(["bad ", args2[0], ": ", args2[1]]); } else if (_7 === 1) { const _27: rt.Fmt = (f: rt.Formatter) => rt.u8LowerHex(n, f); @@ -386,7 +398,7 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { if (rt.u8Rem(n, 2) === 0) { r = rt.Err({ tag: "One", _0: n } as Kind.Kind); } else { - r = rt.Err({ tag: "Many", count: 1, items: rt.sliceToByteVec(Uint8Array.of(n)) } as Kind.Kind); + r = rt.Err({ tag: "Many", count: 1, items: rt.byteSliceToByteVec(rt.byteSliceFrom(Uint8Array.of(n))) } as Kind.Kind); } const _100: rt.u8 = rt.resultUnwrap(r, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$Debug(value, f)); put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(_100, f))); @@ -402,7 +414,7 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { const _121: rt.u8 = rt.resultUnwrapErr(rt.Ok({ x: n as rt.i32, y: 0 }), (value: Point.Point, f: rt.Formatter) => Point.fmt$Debug(value, f)); put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(_121, f))); } else if (_7 === 10) { - const missing: rt.u8 | undefined = rt.sliceGet(rest, 200); + const missing: rt.u8 | undefined = rt.byteSliceGet(rest, 200); const arg9 = ([n] as [rt.u8])[0]; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg9, f)]; const _129: rt.u8 = rt.optionExpect(missing, rt.fmtFormat(["missing ", args10[0]])); @@ -424,22 +436,22 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { const _173: [rt.usize, rt.usize] = [rt.u8Rem(n, 8) as rt.usize, rt.u8Div(n, 32) as rt.usize]; const start: rt.usize = _173[0]; const end: rt.usize = _173[1]; - const _189: Uint8Array = rt.sliceRange(rest, start); - [_189, rt.sliceRange(rest, start, end)] as [Uint8Array, Uint8Array]; - const _196: rt.Fmt = (f: rt.Formatter) => rt.fmtList(_189, f, rt.u8Display); - const arg5 = rt.sliceRange(rest, start, end); - const args16: rt.Fmt[] = [_196, (f: rt.Formatter) => rt.fmtList(arg5, f, rt.u8Display)]; + const _189: rt.ByteSlice = rt.byteSliceRange(rest, start); + [_189, rt.byteSliceRange(rest, start, end)] as [rt.ByteSlice, rt.ByteSlice]; + const _196: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_189), f, rt.u8Display); + const arg5 = rt.byteSliceRange(rest, start, end); + const args16: rt.Fmt[] = [_196, (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg5), f, rt.u8Display)]; put(out, rt.fmtFormat([args16[0], " ", args16[1]])); } else if (_7 === 15) { const buf: Uint8Array = rt.bytes(3); - const _202: Uint8Array = buf; + const _202: rt.ByteSlice = rt.byteSliceFrom(buf); const part3 = rt.min(rest.length, 4); - rt.sliceCopyFromSlice(_202, rt.sliceRange(rest, 0, part3)); + rt.byteSliceCopyFromSlice(_202, rt.byteSliceRange(rest, 0, part3)); const arg4 = ([buf] as [Uint8Array])[0]; const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(arg4, f, rt.u8Display)]; put(out, rt.fmtFormat([args18[0]])); } else if (_7 === 16) { - const _221: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(rest)); + const _221: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(rest)); if (_221.ok) { const _225: rt.u8 = rt.stringLen(_221.value) & 0xff; r4 = rt.Ok(_225); @@ -453,16 +465,16 @@ export function panics(kind: rt.u8, rest: Uint8Array, out: rt.ByteVec): void { const buf2: Uint8Array = Uint8Array.of(1, 2, 3, 4); const part = rt.u8Rem(n, 6) as rt.usize; const part2 = rt.u8Rem(rt.u8Div(n, 6), 6) as rt.usize; - const dest: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.sliceGet(rest, 1), 0) as rt.usize, 4); - const _244: Uint8Array = buf2; - rt.sliceCopyWithin(_244, part, part2, dest); + const dest: rt.usize = rt.usizeRem(rt.optionUnwrapOr(rt.byteSliceGet(rest, 1), 0) as rt.usize, 4); + const _244: rt.ByteSlice = rt.byteSliceFrom(buf2); + rt.byteSliceCopyWithin(_244, part, part2, dest); const arg3 = ([buf2] as [Uint8Array])[0]; const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Display)]; put(out, rt.fmtFormat([args20[0]])); } else if (_7 === 18) { const _271: rt.usize = rt.u8Rem(n, 8) as rt.usize; rt.idx(rest, _271); - const arg2 = rest[_271]; + const arg2 = rest.data[rest.start + _271]; put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg2, f))); } else { if (!(rt.u8Rem(n, 2) === 0)) { diff --git a/ts/fixtures/lang/expected/generics.Wrap.ts b/ts/fixtures/lang/expected/generics.Wrap.ts index 648aa9f7b..e16db3957 100644 --- a/ts/fixtures/lang/expected/generics.Wrap.ts +++ b/ts/fixtures/lang/expected/generics.Wrap.ts @@ -196,13 +196,13 @@ export function area$Area_Shape(self: Wrap): rt.u64 { /** A default method, monomorphized for each type. */ export function describe$Area_Meters(self: Wrap, out: rt.ByteVec): void { rt.byteVecPush(out, 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(area$Area_Meters(self))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(area$Area_Meters(self)))); } /** A default method, monomorphized for each type. */ export function describe$Area_Shape(self: Wrap, out: rt.ByteVec): void { rt.byteVecPush(out, 4); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(area$Area_Shape(self))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(area$Area_Shape(self)))); } //# sourceMappingURL=generics.Wrap.ts.map diff --git a/ts/fixtures/lang/expected/generics.ts b/ts/fixtures/lang/expected/generics.ts index 4c480c11d..0b4093292 100644 --- a/ts/fixtures/lang/expected/generics.ts +++ b/ts/fixtures/lang/expected/generics.ts @@ -12,9 +12,9 @@ import * as Point from "./shapes.Point.ts"; import type * as Shape from "./shapes.Shape.ts"; /** Each method once per instance: `Wrap` of a struct, an enum, a number, and itself. */ -export function methods(data: Uint8Array, out: rt.ByteVec): void { +export function methods(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); + return rt.optionUnwrapOr(rt.byteSliceGet(data, i), 0); }; const point: Wrap.Wrap = copy$Wrap_Point(Wrap.new$Point({ x: at(0) as rt.i32, y: -2 })); Wrap.bump$Point(point); @@ -29,11 +29,11 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { const arg = ([nested] as [Wrap.Wrap>])[0]; const args4: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$Debug_Wrap_Pair(arg, f)]; put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(Wrap.double$u8(byte))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(Wrap.double$u8(byte)))); rt.byteVecPush(out, Wrap.get$u8(byte)); rt.byteVecPush(out, Wrap.get$Pair(Wrap.get$Wrap_Pair(nested))._0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(Wrap.scaled$Meters(meters))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(Wrap.scaled$Shape(shape))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(Wrap.scaled$Meters(meters)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(Wrap.scaled$Shape(shape)))); Wrap.describe$Area_Meters(meters, out); Wrap.describe$Area_Shape(shape, out); const mapped: Wrap.Wrap = Wrap.map$u8_Pair_methods_closure1(byte, (b: rt.u8): Pair.Pair => { @@ -67,7 +67,7 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { list.value.push(_171); Wrap.bump$Vec_u16(list); const none: Wrap.Wrap = new Wrap.Wrap({ value: undefined, count: 0 }); - const some: Wrap.Wrap = Wrap.new$Option_u8(rt.sliceGet(data, 11)); + const some: Wrap.Wrap = Wrap.new$Option_u8(rt.byteSliceGet(data, 11)); const err: Wrap.Wrap> = new Wrap.Wrap({ value: rt.Err({ tag: "Dot" } as Shape.Shape), count: 2 }); const _193: rt.u8 = rt.optionUnwrapOr(Wrap.get$Option_u8(none), some.count); const args10: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$Debug_Vec_u16(list, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(none, f), (f: rt.Formatter) => Wrap.fmt$Debug_Option_u8(some, f), (f: rt.Formatter) => Wrap.fmt$Debug_Result_u8_Shape(err, f), (f: rt.Formatter) => rt.u8Display(_193, f)]; @@ -78,7 +78,7 @@ export function methods(data: Uint8Array, out: rt.ByteVec): void { const arg5 = Tagged.first$Either_u8_u16_i16(tagged); const args12: rt.Fmt[] = [_241, (f: rt.Formatter) => rt.fmtOption(arg5, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$Debug_i16(value, f))]; put(out, rt.fmtFormat([args12[0], " ", args12[1]])); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(tagged.inner.value)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(tagged.inner.value))); rt.byteVecPush(out, rt.optionUnwrapOr(Either.left$u8_u16(tagged.key), 0)); } diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index fe4115a13..3d9d0d683 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -12,121 +12,121 @@ import { copies, order, discriminants, loops, patterns, closures, library, flows import { strs } from "./strs.ts"; /** Run one case. */ -export function run(input: Uint8Array): rt.ByteVec { +export function run(input: rt.ByteSlice): rt.ByteVec { const out: rt.ByteVec = new rt.ByteVec(); if (!(input.length >= 2)) { return out; } - const _10: [rt.u8, rt.u8] = [input[0], input[1]]; + const _10: [rt.u8, rt.u8] = [input.data[input.start], input.data[input.start + 1]]; const op: rt.u8 = _10[0]; const kind: rt.u8 = _10[1]; const _14: rt.u8 = rt.u8Rem(op, 44); if (_14 === 0) { - u8Op(kind, input.subarray(2, input.length - 0), out); + u8Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 1) { - u16Op(kind, input.subarray(2, input.length - 0), out); + u16Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 2) { - u32Op(kind, input.subarray(2, input.length - 0), out); + u32Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 3) { - u64Op(kind, input.subarray(2, input.length - 0), out); + u64Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 4) { - u128Op(kind, input.subarray(2, input.length - 0), out); + u128Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 5) { - usizeOp(kind, input.subarray(2, input.length - 0), out); + usizeOp(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 6) { - i8Op(kind, input.subarray(2, input.length - 0), out); + i8Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 7) { - i16Op(kind, input.subarray(2, input.length - 0), out); + i16Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 8) { - i32Op(kind, input.subarray(2, input.length - 0), out); + i32Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 9) { - i64Op(kind, input.subarray(2, input.length - 0), out); + i64Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 10) { - i128Op(kind, input.subarray(2, input.length - 0), out); + i128Op(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 11) { - isizeOp(kind, input.subarray(2, input.length - 0), out); + isizeOp(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 12) { const _28: rt.u8 = rt.u8Rem(kind, 6); if (_28 === 0) { - i8Neg(input.subarray(2, input.length - 0), out); + i8Neg(rt.byteSliceRange(input, 2), out); } else if (_28 === 1) { - i16Neg(input.subarray(2, input.length - 0), out); + i16Neg(rt.byteSliceRange(input, 2), out); } else if (_28 === 2) { - i32Neg(input.subarray(2, input.length - 0), out); + i32Neg(rt.byteSliceRange(input, 2), out); } else if (_28 === 3) { - i64Neg(input.subarray(2, input.length - 0), out); + i64Neg(rt.byteSliceRange(input, 2), out); } else if (_28 === 4) { - i128Neg(input.subarray(2, input.length - 0), out); + i128Neg(rt.byteSliceRange(input, 2), out); } else { - isizeNeg(input.subarray(2, input.length - 0), out); + isizeNeg(rt.byteSliceRange(input, 2), out); } } else if (_14 === 13) { - const _36: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(input.subarray(2, input.length - 0)); + const _36: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(rt.byteSliceRange(input, 2)); if (_36 === undefined) { - cast(kind, rt.u8Div(kind, 12), input.subarray(2, input.length - 0), out); + cast(kind, rt.u8Div(kind, 12), rt.byteSliceRange(input, 2), out); } else { cast(kind, _36[0], _36[1], out); } } else if (_14 === 14) { - convert(input.subarray(2, input.length - 0), out); + convert(rt.byteSliceRange(input, 2), out); } else if (_14 === 15) { - copies(input.subarray(2, input.length - 0), out); + copies(rt.byteSliceRange(input, 2), out); } else if (_14 === 16) { - loops(input.subarray(2, input.length - 0), out); + loops(rt.byteSliceRange(input, 2), out); } else if (_14 === 17) { - patterns(input.subarray(2, input.length - 0), out); + patterns(rt.byteSliceRange(input, 2), out); } else if (_14 === 18) { - closures(input.subarray(2, input.length - 0), out); + closures(rt.byteSliceRange(input, 2), out); } else if (_14 === 19) { - discriminants(input.subarray(2, input.length - 0), out); + discriminants(rt.byteSliceRange(input, 2), out); } else if (_14 === 20) { - library(input.subarray(2, input.length - 0), out); + library(rt.byteSliceRange(input, 2), out); } else if (_14 === 21) { - ints(kind, input.subarray(2, input.length - 0), out); + ints(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 22) { - strings(input.subarray(2, input.length - 0), out); + strings(rt.byteSliceRange(input, 2), out); } else if (_14 === 23) { - derived(input.subarray(2, input.length - 0), out); + derived(rt.byteSliceRange(input, 2), out); } else if (_14 === 24) { - written(input.subarray(2, input.length - 0), out); + written(rt.byteSliceRange(input, 2), out); } else if (_14 === 25) { - panics(kind, input.subarray(2, input.length - 0), out); + panics(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 26) { - methods(input.subarray(2, input.length - 0), out); + methods(rt.byteSliceRange(input, 2), out); } else if (_14 === 27) { - adaptors(kind, input.subarray(2, input.length - 0), out); + adaptors(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 28) { - consumers(kind, input.subarray(2, input.length - 0), out); + consumers(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 29) { - ranges(input.subarray(2, input.length - 0), out); + ranges(rt.byteSliceRange(input, 2), out); } else if (_14 === 30) { - options(input.subarray(2, input.length - 0), out); + options(rt.byteSliceRange(input, 2), out); } else if (_14 === 31) { - own(input.subarray(2, input.length - 0), out); + own(rt.byteSliceRange(input, 2), out); } else if (_14 === 32) { - values(input.subarray(2, input.length - 0), out); + values(rt.byteSliceRange(input, 2), out); } else if (_14 === 33) { - order(input.subarray(2, input.length - 0), out); + order(rt.byteSliceRange(input, 2), out); } else if (_14 === 34) { - hashMaps(kind, input.subarray(2, input.length - 0), out); + hashMaps(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 35) { - sets(kind, input.subarray(2, input.length - 0), out); + sets(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 36) { - btreeMaps(kind, input.subarray(2, input.length - 0), out); + btreeMaps(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 37) { - deques(input.subarray(2, input.length - 0), out); + deques(rt.byteSliceRange(input, 2), out); } else if (_14 === 38) { - flows(input.subarray(2, input.length - 0), out); + flows(rt.byteSliceRange(input, 2), out); } else if (_14 === 39) { - keys(kind, input.subarray(2, input.length - 0), out); + keys(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 40) { - chars(kind, input.subarray(2, input.length - 0), out); + chars(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 41) { - strs(kind, input.subarray(2, input.length - 0), out); + strs(kind, rt.byteSliceRange(input, 2), out); } else if (_14 === 42) { - vecs(input.subarray(2, input.length - 0), out); + vecs(rt.byteSliceRange(input, 2), out); } else { - stores(input.subarray(2, input.length - 0), out); + stores(rt.byteSliceRange(input, 2), out); } return out; } diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index d0dc26415..507285105 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -3,9 +3,9 @@ import * as rt from "./rt.ts"; /** Apply operation `op` to operands taken from `data`. */ -export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function u8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.u8) => void = (out2: rt.ByteVec, v: rt.u8): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v as rt.u128))); rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v)) === v ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.u8 | undefined) => void = (out3: rt.ByteVec, v2: rt.u8 | undefined): void => { @@ -14,24 +14,26 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.u8 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); } }; const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.u8, Uint8Array] = [rt.u8FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.u8, rt.ByteSlice] = [rt.u8FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.u8 = _6[0]; const buf2: Uint8Array = Uint8Array.of(0); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.u8 = rt.u8FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.u8, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.u8, rt.ByteSlice]; const b: rt.u8 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 8); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 8); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u8Add(a, b); @@ -84,9 +86,9 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u8WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u8LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u8LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u8LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u8LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -120,9 +122,9 @@ export function u8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function u16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.u16) => void = (out2: rt.ByteVec, v: rt.u16): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v as rt.u128))); rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v)) === v ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.u16 | undefined) => void = (out3: rt.ByteVec, v2: rt.u16 | undefined): void => { @@ -131,24 +133,26 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.u16 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); } }; const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.u16, Uint8Array] = [rt.u16FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.u16, rt.ByteSlice] = [rt.u16FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.u16 = _6[0]; const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.u16 = rt.u16FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.u16, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.u16, rt.ByteSlice]; const b: rt.u16 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 16); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 16); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u16Add(a, b); @@ -201,9 +205,9 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u16WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u16LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u16LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u16LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u16LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -237,9 +241,9 @@ export function u16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function u32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.u32) => void = (out2: rt.ByteVec, v: rt.u32): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v as rt.u128))); rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v)) === v ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.u32 | undefined) => void = (out3: rt.ByteVec, v2: rt.u32 | undefined): void => { @@ -248,24 +252,26 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.u32 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); } }; const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.u32, Uint8Array] = [rt.u32FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.u32, rt.ByteSlice] = [rt.u32FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.u32 = _6[0]; const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.u32 = rt.u32FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.u32, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.u32, rt.ByteSlice]; const b: rt.u32 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 32); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 32); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u32Add(a, b); @@ -318,9 +324,9 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u32WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -354,9 +360,9 @@ export function u32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function u64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.u64) => void = (out2: rt.ByteVec, v: rt.u64): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(rt.u128Cast(v))); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(v)))); rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v)), v) ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.u64 | undefined) => void = (out3: rt.ByteVec, v2: rt.u64 | undefined): void => { @@ -365,24 +371,26 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.u64 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(rt.u128Cast(v3))); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(v3)))); } }; const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.u64, Uint8Array] = [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.u64, rt.ByteSlice] = [rt.u64FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.u64 = _6[0]; const buf2: Uint8Array = rt.bytes(8); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.u64 = rt.u64FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.u64, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.u64, rt.ByteSlice]; const b: rt.u64 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 64); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 64); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u64Add(a, b); @@ -435,9 +443,9 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u64WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u64LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u64LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u64LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u64LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.u64Max(a, b); _50(out, part2); @@ -471,9 +479,9 @@ export function u64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function u128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.u128) => void = (out2: rt.ByteVec, v: rt.u128): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v))); rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v)), v) ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.u128 | undefined) => void = (out3: rt.ByteVec, v2: rt.u128 | undefined): void => { @@ -482,24 +490,26 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.u128 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v3))); } }; const buf: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.u128, Uint8Array] = [rt.u128FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.u128, rt.ByteSlice] = [rt.u128FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.u128 = _6[0]; const buf2: Uint8Array = rt.bytes(16); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.u128 = rt.u128FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.u128, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.u128, rt.ByteSlice]; const b: rt.u128 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 128); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 128); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.u128Add(a, b); @@ -552,9 +562,9 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.u128WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u128LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u128LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u128LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u128LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.u128Max(a, b); _50(out, part2); @@ -588,9 +598,9 @@ export function u128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function usizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.usize) => void = (out2: rt.ByteVec, v: rt.usize): void => { - rt.byteVecExtendFromSlice(out2, rt.u128ToBeBytes(v as rt.u128)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v as rt.u128))); rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v)) === v ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.usize | undefined) => void = (out3: rt.ByteVec, v2: rt.usize | undefined): void => { @@ -599,24 +609,26 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.usize = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.u128ToBeBytes(v3 as rt.u128)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); } }; const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.usize, Uint8Array] = [rt.usizeFromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.usize, rt.ByteSlice] = [rt.usizeFromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.usize = _6[0]; const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.usize = rt.usizeFromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.usize, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.usize, rt.ByteSlice]; const b: rt.usize = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 32); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 32); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.usizeAdd(a, b); @@ -669,9 +681,9 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.usizeWrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.usizeLeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.usizeLeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.usizeLeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.usizeLeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -705,9 +717,9 @@ export function usizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function i8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.i8) => void = (out2: rt.ByteVec, v: rt.i8): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v as rt.i128))); rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v)) === v ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.i8 | undefined) => void = (out3: rt.ByteVec, v2: rt.i8 | undefined): void => { @@ -716,24 +728,26 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.i8 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); } }; const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.i8, Uint8Array] = [rt.i8FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.i8, rt.ByteSlice] = [rt.i8FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.i8 = _6[0]; const buf2: Uint8Array = Uint8Array.of(0); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.i8 = rt.i8FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.i8, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.i8, rt.ByteSlice]; const b: rt.i8 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 8); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 8); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i8Add(a, b); @@ -786,9 +800,9 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i8WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i8LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i8LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i8LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i8LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -822,9 +836,9 @@ export function i8Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function i16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.i16) => void = (out2: rt.ByteVec, v: rt.i16): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v as rt.i128))); rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v)) === v ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.i16 | undefined) => void = (out3: rt.ByteVec, v2: rt.i16 | undefined): void => { @@ -833,24 +847,26 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.i16 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); } }; const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.i16, Uint8Array] = [rt.i16FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.i16, rt.ByteSlice] = [rt.i16FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.i16 = _6[0]; const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.i16 = rt.i16FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.i16, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.i16, rt.ByteSlice]; const b: rt.i16 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 16); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 16); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i16Add(a, b); @@ -903,9 +919,9 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i16WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i16LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i16LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i16LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i16LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -939,9 +955,9 @@ export function i16Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function i32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.i32) => void = (out2: rt.ByteVec, v: rt.i32): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v as rt.i128))); rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v)) === v ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.i32 | undefined) => void = (out3: rt.ByteVec, v2: rt.i32 | undefined): void => { @@ -950,24 +966,26 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.i32 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); } }; const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.i32, Uint8Array] = [rt.i32FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.i32, rt.ByteSlice] = [rt.i32FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.i32 = _6[0]; const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.i32 = rt.i32FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.i32, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.i32, rt.ByteSlice]; const b: rt.i32 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 32); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 32); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i32Add(a, b); @@ -1020,9 +1038,9 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i32WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i32LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i32LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i32LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i32LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -1056,9 +1074,9 @@ export function i32Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function i64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.i64) => void = (out2: rt.ByteVec, v: rt.i64): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(rt.i128Cast(v))); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(v)))); rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v)), v) ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.i64 | undefined) => void = (out3: rt.ByteVec, v2: rt.i64 | undefined): void => { @@ -1067,24 +1085,26 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.i64 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(rt.i128Cast(v3))); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(v3)))); } }; const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.i64, Uint8Array] = [rt.i64FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.i64, rt.ByteSlice] = [rt.i64FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.i64 = _6[0]; const buf2: Uint8Array = rt.bytes(8); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.i64 = rt.i64FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.i64, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.i64, rt.ByteSlice]; const b: rt.i64 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 64); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 64); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i64Add(a, b); @@ -1137,9 +1157,9 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i64WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i64LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i64LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i64LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i64LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.i64Max(a, b); _50(out, part2); @@ -1173,9 +1193,9 @@ export function i64Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function i128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.i128) => void = (out2: rt.ByteVec, v: rt.i128): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v))); rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v)), v) ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.i128 | undefined) => void = (out3: rt.ByteVec, v2: rt.i128 | undefined): void => { @@ -1184,24 +1204,26 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.i128 = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v3))); } }; const buf: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.i128, Uint8Array] = [rt.i128FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.i128, rt.ByteSlice] = [rt.i128FromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.i128 = _6[0]; const buf2: Uint8Array = rt.bytes(16); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.i128 = rt.i128FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.i128, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.i128, rt.ByteSlice]; const b: rt.i128 = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 128); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 128); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.i128Add(a, b); @@ -1254,9 +1276,9 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.i128WrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i128LeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i128LeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.i128LeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i128LeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.i128Max(a, b); _50(out, part2); @@ -1290,9 +1312,9 @@ export function i128Op(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Apply operation `op` to operands taken from `data`. */ -export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function isizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _50: (a0: rt.ByteVec, a1: rt.isize) => void = (out2: rt.ByteVec, v: rt.isize): void => { - rt.byteVecExtendFromSlice(out2, rt.i128ToBeBytes(v as rt.i128)); + rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v as rt.i128))); rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v)) === v ? 1 : 0); }; const _51: (a0: rt.ByteVec, a1: rt.isize | undefined) => void = (out3: rt.ByteVec, v2: rt.isize | undefined): void => { @@ -1301,24 +1323,26 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { const v3: rt.isize = v2; rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.i128ToBeBytes(v3 as rt.i128)); + rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); } }; const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _6: [rt.isize, Uint8Array] = [rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _6: [rt.isize, rt.ByteSlice] = [rt.isizeFromBeBytes(buf), rt.byteSliceRange(data, n)]; const a: rt.isize = _6[0]; const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _33: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_33, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _33: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_33, rt.byteSliceRange(slice3, 0, n2)); const _38: rt.isize = rt.isizeFromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - [_38, rt.sliceRange(slice2, n2)] as [rt.isize, Uint8Array]; + const slice4 = rt.byteSliceRange(data, n); + [_38, rt.byteSliceRange(slice4, n2)] as [rt.isize, rt.ByteSlice]; const b: rt.isize = _38; - const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.sliceFirst(rt.sliceRange(slice2, n2)), 0) as rt.u32, 2 * 32); + const shift: rt.u32 = rt.u32Rem(rt.optionUnwrapOr(rt.byteSliceFirst(rt.byteSliceRange(slice4, n2)), 0) as rt.u32, 2 * 32); const _52: rt.u8 = rt.u8Rem(op, 25); if (_52 === 0) { const part16 = rt.isizeAdd(a, b); @@ -1371,9 +1395,9 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { const part3 = rt.isizeWrappingSub(a, b); _50(out, part3); } else if (_52 === 18) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.isizeLeadingOnes(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.isizeLeadingOnes(a)))); } else if (_52 === 19) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.isizeLeadingZeros(a))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.isizeLeadingZeros(a)))); } else if (_52 === 20) { const part2 = rt.max(a, b); _50(out, part2); @@ -1407,776 +1431,796 @@ export function isizeOp(op: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** Negate, which overflows at the minimum. */ -export function i8Neg(data: Uint8Array, out: rt.ByteVec): void { +export function i8Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i8Neg(([rt.i8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i8, Uint8Array])[0]) as rt.i128)); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i8Neg(([rt.i8FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i8, rt.ByteSlice])[0]) as rt.i128))); } /** Negate, which overflows at the minimum. */ -export function i16Neg(data: Uint8Array, out: rt.ByteVec): void { +export function i16Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i16Neg(([rt.i16FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i16, Uint8Array])[0]) as rt.i128)); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i16Neg(([rt.i16FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i16, rt.ByteSlice])[0]) as rt.i128))); } /** Negate, which overflows at the minimum. */ -export function i32Neg(data: Uint8Array, out: rt.ByteVec): void { +export function i32Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i32Neg(([rt.i32FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i32, Uint8Array])[0]) as rt.i128)); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i32Neg(([rt.i32FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i32, rt.ByteSlice])[0]) as rt.i128))); } /** Negate, which overflows at the minimum. */ -export function i64Neg(data: Uint8Array, out: rt.ByteVec): void { +export function i64Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(([rt.i64FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i64, Uint8Array])[0])))); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(([rt.i64FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i64, rt.ByteSlice])[0]))))); } /** Negate, which overflows at the minimum. */ -export function i128Neg(data: Uint8Array, out: rt.ByteVec): void { +export function i128Neg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.i128Neg(([rt.i128FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.i128, Uint8Array])[0]))); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Neg(([rt.i128FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i128, rt.ByteSlice])[0])))); } /** Negate, which overflows at the minimum. */ -export function isizeNeg(data: Uint8Array, out: rt.ByteVec): void { +export function isizeNeg(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(rt.isizeNeg(([rt.isizeFromBeBytes(buf), rt.sliceRange(data, n)] as [rt.isize, Uint8Array])[0]) as rt.i128)); + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.isizeNeg(([rt.isizeFromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.isize, rt.ByteSlice])[0]) as rt.i128))); } /** Cast a value of type `from` to type `to`, both indexes into the twelve types. */ -export function cast(from: rt.u8, to: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function cast(from: rt.u8, to: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _5: rt.u8 = rt.u8Rem(from, 12); if (_5 === 0) { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const v: rt.u8 = ([rt.u8FromBeBytes(buf), rt.sliceRange(data, n)] as [rt.u8, Uint8Array])[0]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice12 = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice12, 0, n), rt.byteSliceRange(data, 0, n)); + const v: rt.u8 = ([rt.u8FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.u8, rt.ByteSlice])[0]; const _25: rt.u8 = rt.u8Rem(to, 12); if (_25 === 0) { const v2: rt.u8 = v; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v2)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v2))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v2, f)))); } else if (_25 === 1) { const v3: rt.u16 = v as rt.u16; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v3)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v3))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v3, f)))); } else if (_25 === 2) { const v4: rt.u32 = v as rt.u32; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v4)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v4))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v4, f)))); } else if (_25 === 3) { const v5: rt.u64 = v as rt.u64; - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v5)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v5))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v5, f)))); } else if (_25 === 4) { const v6: rt.u128 = v as rt.u128; - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v6)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v6))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v6, f)))); } else if (_25 === 5) { const v7: rt.usize = v as rt.usize; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v7)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v7))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v7, f)))); } else if (_25 === 6) { const v8: rt.i8 = (v << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v8)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v8))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v8, f)))); } else if (_25 === 7) { const v9: rt.i16 = v as rt.i16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v9)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v9))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v9, f)))); } else if (_25 === 8) { const v10: rt.i32 = v as rt.i32; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v10)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v10))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v10, f)))); } else if (_25 === 9) { const v11: rt.i64 = v as rt.i64; - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v11)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v11))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v11, f)))); } else if (_25 === 10) { const v12: rt.i128 = v as rt.i128; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v12)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v12))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v12, f)))); } else { const v13: rt.isize = v as rt.isize; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v13)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v13))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v13, f)))); } } else if (_5 === 1) { const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(data.length, buf2.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf2, 0, n2), rt.sliceRange(data, 0, n2)); - const v14: rt.u16 = ([rt.u16FromBeBytes(buf2), rt.sliceRange(data, n2)] as [rt.u16, Uint8Array])[0]; + const n2: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf2).length); + const slice11 = rt.byteSliceFrom(buf2); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice11, 0, n2), rt.byteSliceRange(data, 0, n2)); + const v14: rt.u16 = ([rt.u16FromBeBytes(buf2), rt.byteSliceRange(data, n2)] as [rt.u16, rt.ByteSlice])[0]; const _165: rt.u8 = rt.u8Rem(to, 12); if (_165 === 0) { const v15: rt.u8 = v14 & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v15)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v15))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v15, f)))); } else if (_165 === 1) { const v16: rt.u16 = v14; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v16)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v16))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v16, f)))); } else if (_165 === 2) { const v17: rt.u32 = v14 as rt.u32; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v17)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v17))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v17, f)))); } else if (_165 === 3) { const v18: rt.u64 = v14 as rt.u64; - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v18)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v18))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v18, f)))); } else if (_165 === 4) { const v19: rt.u128 = v14 as rt.u128; - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v19)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v19))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v19, f)))); } else if (_165 === 5) { const v20: rt.usize = v14 as rt.usize; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v20)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v20))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v20, f)))); } else if (_165 === 6) { const v21: rt.i8 = (v14 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v21)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v21))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v21, f)))); } else if (_165 === 7) { const v22: rt.i16 = (v14 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v22)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v22))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v22, f)))); } else if (_165 === 8) { const v23: rt.i32 = v14 as rt.i32; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v23)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v23))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v23, f)))); } else if (_165 === 9) { const v24: rt.i64 = v14 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v24)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v24))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v24, f)))); } else if (_165 === 10) { const v25: rt.i128 = v14 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v25)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v25))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v25, f)))); } else { const v26: rt.isize = v14 as rt.isize; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v26)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v26))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v26, f)))); } } else if (_5 === 2) { const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(data.length, buf3.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf3, 0, n3), rt.sliceRange(data, 0, n3)); - const v27: rt.u32 = ([rt.u32FromBeBytes(buf3), rt.sliceRange(data, n3)] as [rt.u32, Uint8Array])[0]; + const n3: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf3).length); + const slice10 = rt.byteSliceFrom(buf3); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice10, 0, n3), rt.byteSliceRange(data, 0, n3)); + const v27: rt.u32 = ([rt.u32FromBeBytes(buf3), rt.byteSliceRange(data, n3)] as [rt.u32, rt.ByteSlice])[0]; const _305: rt.u8 = rt.u8Rem(to, 12); if (_305 === 0) { const v28: rt.u8 = v27 & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v28)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v28))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v28, f)))); } else if (_305 === 1) { const v29: rt.u16 = v27 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v29)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v29))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v29, f)))); } else if (_305 === 2) { const v30: rt.u32 = v27; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v30)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v30))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v30, f)))); } else if (_305 === 3) { const v31: rt.u64 = v27 as rt.u64; - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v31)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v31))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v31, f)))); } else if (_305 === 4) { const v32: rt.u128 = v27 as rt.u128; - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v32)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v32))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v32, f)))); } else if (_305 === 5) { const v33: rt.usize = v27 as rt.usize; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v33)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v33))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v33, f)))); } else if (_305 === 6) { const v34: rt.i8 = (v27 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v34)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v34))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v34, f)))); } else if (_305 === 7) { const v35: rt.i16 = (v27 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v35)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v35))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v35, f)))); } else if (_305 === 8) { const v36: rt.i32 = v27 | 0; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v36)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v36))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v36, f)))); } else if (_305 === 9) { const v37: rt.i64 = v27 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v37)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v37))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v37, f)))); } else if (_305 === 10) { const v38: rt.i128 = v27 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v38)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v38))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v38, f)))); } else { const v39: rt.isize = v27 | 0; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v39)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v39))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v39, f)))); } } else if (_5 === 3) { const buf4: Uint8Array = rt.bytes(8); - const n4: rt.usize = rt.min(data.length, buf4.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf4, 0, n4), rt.sliceRange(data, 0, n4)); - const v40: rt.u64 = ([rt.u64FromBeBytes(buf4), rt.sliceRange(data, n4)] as [rt.u64, Uint8Array])[0]; + const n4: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf4).length); + const slice9 = rt.byteSliceFrom(buf4); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice9, 0, n4), rt.byteSliceRange(data, 0, n4)); + const v40: rt.u64 = ([rt.u64FromBeBytes(buf4), rt.byteSliceRange(data, n4)] as [rt.u64, rt.ByteSlice])[0]; const _445: rt.u8 = rt.u8Rem(to, 12); if (_445 === 0) { const v41: rt.u8 = rt.u64Low(v40) & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v41)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v41))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v41, f)))); } else if (_445 === 1) { const v42: rt.u16 = rt.u64Low(v40) & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v42)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v42))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v42, f)))); } else if (_445 === 2) { const v43: rt.u32 = rt.u64Low(v40); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v43)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v43))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v43, f)))); } else if (_445 === 3) { const v44: rt.u64 = v40; - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v44)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v44))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v44, f)))); } else if (_445 === 4) { const v45: rt.u128 = rt.u128Cast(v40); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v45)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v45))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v45, f)))); } else if (_445 === 5) { const v46: rt.usize = rt.u64Low(v40); - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v46)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v46))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v46, f)))); } else if (_445 === 6) { const v47: rt.i8 = (rt.u64Low(v40) << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v47)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v47))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v47, f)))); } else if (_445 === 7) { const v48: rt.i16 = (rt.u64Low(v40) << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v48)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v48))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v48, f)))); } else if (_445 === 8) { const v49: rt.i32 = rt.u64Low(v40) | 0; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v49)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v49))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v49, f)))); } else if (_445 === 9) { const v50: rt.i64 = rt.i64Cast(v40); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v50)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v50))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v50, f)))); } else if (_445 === 10) { const v51: rt.i128 = rt.i128Cast(v40); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v51)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v51))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v51, f)))); } else { const v52: rt.isize = rt.u64Low(v40) | 0; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v52)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v52))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v52, f)))); } } else if (_5 === 4) { const buf5: Uint8Array = rt.bytes(16); - const n5: rt.usize = rt.min(data.length, buf5.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf5, 0, n5), rt.sliceRange(data, 0, n5)); - const v53: rt.u128 = ([rt.u128FromBeBytes(buf5), rt.sliceRange(data, n5)] as [rt.u128, Uint8Array])[0]; + const n5: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf5).length); + const slice8 = rt.byteSliceFrom(buf5); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice8, 0, n5), rt.byteSliceRange(data, 0, n5)); + const v53: rt.u128 = ([rt.u128FromBeBytes(buf5), rt.byteSliceRange(data, n5)] as [rt.u128, rt.ByteSlice])[0]; const _585: rt.u8 = rt.u8Rem(to, 12); if (_585 === 0) { const v54: rt.u8 = rt.u128Low(v53) & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v54)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v54))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v54, f)))); } else if (_585 === 1) { const v55: rt.u16 = rt.u128Low(v53) & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v55)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v55))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v55, f)))); } else if (_585 === 2) { const v56: rt.u32 = rt.u128Low(v53); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v56)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v56))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v56, f)))); } else if (_585 === 3) { const v57: rt.u64 = rt.u64Cast(v53); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v57)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v57))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v57, f)))); } else if (_585 === 4) { const v58: rt.u128 = v53; - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v58)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v58))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v58, f)))); } else if (_585 === 5) { const v59: rt.usize = rt.u128Low(v53); - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v59)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v59))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v59, f)))); } else if (_585 === 6) { const v60: rt.i8 = (rt.u128Low(v53) << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v60)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v60))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v60, f)))); } else if (_585 === 7) { const v61: rt.i16 = (rt.u128Low(v53) << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v61)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v61))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v61, f)))); } else if (_585 === 8) { const v62: rt.i32 = rt.u128Low(v53) | 0; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v62)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v62))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v62, f)))); } else if (_585 === 9) { const v63: rt.i64 = rt.i64Cast(v53); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v63)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v63))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v63, f)))); } else if (_585 === 10) { const v64: rt.i128 = rt.i128Cast(v53); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v64)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v64))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v64, f)))); } else { const v65: rt.isize = rt.u128Low(v53) | 0; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v65)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v65))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v65, f)))); } } else if (_5 === 5) { const buf6: Uint8Array = rt.bytes(4); - const n6: rt.usize = rt.min(data.length, buf6.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf6, 0, n6), rt.sliceRange(data, 0, n6)); - const v66: rt.usize = ([rt.usizeFromBeBytes(buf6), rt.sliceRange(data, n6)] as [rt.usize, Uint8Array])[0]; + const n6: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf6).length); + const slice7 = rt.byteSliceFrom(buf6); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice7, 0, n6), rt.byteSliceRange(data, 0, n6)); + const v66: rt.usize = ([rt.usizeFromBeBytes(buf6), rt.byteSliceRange(data, n6)] as [rt.usize, rt.ByteSlice])[0]; const _725: rt.u8 = rt.u8Rem(to, 12); if (_725 === 0) { const v67: rt.u8 = v66 & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v67)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v67))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v67, f)))); } else if (_725 === 1) { const v68: rt.u16 = v66 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v68)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v68))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v68, f)))); } else if (_725 === 2) { const v69: rt.u32 = v66 as rt.u32; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v69)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v69))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v69, f)))); } else if (_725 === 3) { const v70: rt.u64 = v66 as rt.u64; - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v70)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v70))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v70, f)))); } else if (_725 === 4) { const v71: rt.u128 = v66 as rt.u128; - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v71)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v71))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v71, f)))); } else if (_725 === 5) { const v72: rt.usize = v66; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v72)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v72))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v72, f)))); } else if (_725 === 6) { const v73: rt.i8 = (v66 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v73)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v73))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v73, f)))); } else if (_725 === 7) { const v74: rt.i16 = (v66 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v74)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v74))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v74, f)))); } else if (_725 === 8) { const v75: rt.i32 = v66 | 0; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v75)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v75))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v75, f)))); } else if (_725 === 9) { const v76: rt.i64 = v66 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v76)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v76))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v76, f)))); } else if (_725 === 10) { const v77: rt.i128 = v66 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v77)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v77))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v77, f)))); } else { const v78: rt.isize = v66 | 0; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v78)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v78))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v78, f)))); } } else if (_5 === 6) { const buf7: Uint8Array = Uint8Array.of(0); - const n7: rt.usize = rt.min(data.length, buf7.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf7, 0, n7), rt.sliceRange(data, 0, n7)); - const v79: rt.i8 = ([rt.i8FromBeBytes(buf7), rt.sliceRange(data, n7)] as [rt.i8, Uint8Array])[0]; + const n7: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf7).length); + const slice6 = rt.byteSliceFrom(buf7); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice6, 0, n7), rt.byteSliceRange(data, 0, n7)); + const v79: rt.i8 = ([rt.i8FromBeBytes(buf7), rt.byteSliceRange(data, n7)] as [rt.i8, rt.ByteSlice])[0]; const _865: rt.u8 = rt.u8Rem(to, 12); if (_865 === 0) { const v80: rt.u8 = v79 & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v80)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v80))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v80, f)))); } else if (_865 === 1) { const v81: rt.u16 = v79 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v81)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v81))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v81, f)))); } else if (_865 === 2) { const v82: rt.u32 = v79 >>> 0; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v82)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v82))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v82, f)))); } else if (_865 === 3) { const v83: rt.u64 = rt.u64Cast(v79); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v83)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v83))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v83, f)))); } else if (_865 === 4) { const v84: rt.u128 = rt.u128Cast(v79); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v84)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v84))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v84, f)))); } else if (_865 === 5) { const v85: rt.usize = v79 >>> 0; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v85)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v85))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v85, f)))); } else if (_865 === 6) { const v86: rt.i8 = v79; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v86)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v86))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v86, f)))); } else if (_865 === 7) { const v87: rt.i16 = v79 as rt.i16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v87)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v87))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v87, f)))); } else if (_865 === 8) { const v88: rt.i32 = v79 as rt.i32; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v88)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v88))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v88, f)))); } else if (_865 === 9) { const v89: rt.i64 = v79 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v89)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v89))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v89, f)))); } else if (_865 === 10) { const v90: rt.i128 = v79 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v90)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v90))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v90, f)))); } else { const v91: rt.isize = v79 as rt.isize; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v91)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v91))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v91, f)))); } } else if (_5 === 7) { const buf8: Uint8Array = rt.bytes(2); - const n8: rt.usize = rt.min(data.length, buf8.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf8, 0, n8), rt.sliceRange(data, 0, n8)); - const v92: rt.i16 = ([rt.i16FromBeBytes(buf8), rt.sliceRange(data, n8)] as [rt.i16, Uint8Array])[0]; + const n8: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf8).length); + const slice5 = rt.byteSliceFrom(buf8); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice5, 0, n8), rt.byteSliceRange(data, 0, n8)); + const v92: rt.i16 = ([rt.i16FromBeBytes(buf8), rt.byteSliceRange(data, n8)] as [rt.i16, rt.ByteSlice])[0]; const _1005: rt.u8 = rt.u8Rem(to, 12); if (_1005 === 0) { const v93: rt.u8 = v92 & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v93)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v93))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v93, f)))); } else if (_1005 === 1) { const v94: rt.u16 = v92 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v94)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v94))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v94, f)))); } else if (_1005 === 2) { const v95: rt.u32 = v92 >>> 0; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v95)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v95))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v95, f)))); } else if (_1005 === 3) { const v96: rt.u64 = rt.u64Cast(v92); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v96)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v96))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v96, f)))); } else if (_1005 === 4) { const v97: rt.u128 = rt.u128Cast(v92); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v97)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v97))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v97, f)))); } else if (_1005 === 5) { const v98: rt.usize = v92 >>> 0; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v98)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v98))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v98, f)))); } else if (_1005 === 6) { const v99: rt.i8 = (v92 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v99)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v99))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v99, f)))); } else if (_1005 === 7) { const v100: rt.i16 = v92; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v100)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v100))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v100, f)))); } else if (_1005 === 8) { const v101: rt.i32 = v92 as rt.i32; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v101)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v101))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v101, f)))); } else if (_1005 === 9) { const v102: rt.i64 = v92 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v102)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v102))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v102, f)))); } else if (_1005 === 10) { const v103: rt.i128 = v92 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v103)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v103))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v103, f)))); } else { const v104: rt.isize = v92 as rt.isize; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v104)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v104))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v104, f)))); } } else if (_5 === 8) { const buf9: Uint8Array = rt.bytes(4); - const n9: rt.usize = rt.min(data.length, buf9.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf9, 0, n9), rt.sliceRange(data, 0, n9)); - const v105: rt.i32 = ([rt.i32FromBeBytes(buf9), rt.sliceRange(data, n9)] as [rt.i32, Uint8Array])[0]; + const n9: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf9).length); + const slice4 = rt.byteSliceFrom(buf9); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice4, 0, n9), rt.byteSliceRange(data, 0, n9)); + const v105: rt.i32 = ([rt.i32FromBeBytes(buf9), rt.byteSliceRange(data, n9)] as [rt.i32, rt.ByteSlice])[0]; const _1145: rt.u8 = rt.u8Rem(to, 12); if (_1145 === 0) { const v106: rt.u8 = v105 & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v106)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v106))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v106, f)))); } else if (_1145 === 1) { const v107: rt.u16 = v105 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v107)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v107))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v107, f)))); } else if (_1145 === 2) { const v108: rt.u32 = v105 >>> 0; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v108)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v108))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v108, f)))); } else if (_1145 === 3) { const v109: rt.u64 = rt.u64Cast(v105); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v109)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v109))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v109, f)))); } else if (_1145 === 4) { const v110: rt.u128 = rt.u128Cast(v105); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v110)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v110))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v110, f)))); } else if (_1145 === 5) { const v111: rt.usize = v105 >>> 0; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v111)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v111))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v111, f)))); } else if (_1145 === 6) { const v112: rt.i8 = (v105 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v112)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v112))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v112, f)))); } else if (_1145 === 7) { const v113: rt.i16 = (v105 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v113)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v113))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v113, f)))); } else if (_1145 === 8) { const v114: rt.i32 = v105; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v114)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v114))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v114, f)))); } else if (_1145 === 9) { const v115: rt.i64 = v105 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v115)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v115))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v115, f)))); } else if (_1145 === 10) { const v116: rt.i128 = v105 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v116)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v116))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v116, f)))); } else { const v117: rt.isize = v105 as rt.isize; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v117)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v117))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v117, f)))); } } else if (_5 === 9) { const buf10: Uint8Array = rt.bytes(8); - const n10: rt.usize = rt.min(data.length, buf10.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf10, 0, n10), rt.sliceRange(data, 0, n10)); - const v118: rt.i64 = ([rt.i64FromBeBytes(buf10), rt.sliceRange(data, n10)] as [rt.i64, Uint8Array])[0]; + const n10: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf10).length); + const slice3 = rt.byteSliceFrom(buf10); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice3, 0, n10), rt.byteSliceRange(data, 0, n10)); + const v118: rt.i64 = ([rt.i64FromBeBytes(buf10), rt.byteSliceRange(data, n10)] as [rt.i64, rt.ByteSlice])[0]; const _1285: rt.u8 = rt.u8Rem(to, 12); if (_1285 === 0) { const v119: rt.u8 = rt.i64Low(v118) & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v119)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v119))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v119, f)))); } else if (_1285 === 1) { const v120: rt.u16 = rt.i64Low(v118) & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v120)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v120))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v120, f)))); } else if (_1285 === 2) { const v121: rt.u32 = rt.i64Low(v118); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v121)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v121))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v121, f)))); } else if (_1285 === 3) { const v122: rt.u64 = rt.u64Cast(v118); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v122)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v122))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v122, f)))); } else if (_1285 === 4) { const v123: rt.u128 = rt.u128Cast(v118); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v123)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v123))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v123, f)))); } else if (_1285 === 5) { const v124: rt.usize = rt.i64Low(v118); - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v124)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v124))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v124, f)))); } else if (_1285 === 6) { const v125: rt.i8 = (rt.i64Low(v118) << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v125)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v125))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v125, f)))); } else if (_1285 === 7) { const v126: rt.i16 = (rt.i64Low(v118) << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v126)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v126))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v126, f)))); } else if (_1285 === 8) { const v127: rt.i32 = rt.i64Low(v118) | 0; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v127)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v127))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v127, f)))); } else if (_1285 === 9) { const v128: rt.i64 = v118; - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v128)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v128))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v128, f)))); } else if (_1285 === 10) { const v129: rt.i128 = rt.i128Cast(v118); - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v129)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v129))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v129, f)))); } else { const v130: rt.isize = rt.i64Low(v118) | 0; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v130)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v130))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v130, f)))); } } else if (_5 === 10) { const buf11: Uint8Array = rt.bytes(16); - const n11: rt.usize = rt.min(data.length, buf11.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf11, 0, n11), rt.sliceRange(data, 0, n11)); - const v131: rt.i128 = ([rt.i128FromBeBytes(buf11), rt.sliceRange(data, n11)] as [rt.i128, Uint8Array])[0]; + const n11: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf11).length); + const slice2 = rt.byteSliceFrom(buf11); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice2, 0, n11), rt.byteSliceRange(data, 0, n11)); + const v131: rt.i128 = ([rt.i128FromBeBytes(buf11), rt.byteSliceRange(data, n11)] as [rt.i128, rt.ByteSlice])[0]; const _1425: rt.u8 = rt.u8Rem(to, 12); if (_1425 === 0) { const v132: rt.u8 = rt.i128Low(v131) & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v132)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v132))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v132, f)))); } else if (_1425 === 1) { const v133: rt.u16 = rt.i128Low(v131) & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v133)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v133))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v133, f)))); } else if (_1425 === 2) { const v134: rt.u32 = rt.i128Low(v131); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v134)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v134))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v134, f)))); } else if (_1425 === 3) { const v135: rt.u64 = rt.u64Cast(v131); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v135)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v135))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v135, f)))); } else if (_1425 === 4) { const v136: rt.u128 = rt.u128Cast(v131); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v136)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v136))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v136, f)))); } else if (_1425 === 5) { const v137: rt.usize = rt.i128Low(v131); - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v137)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v137))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v137, f)))); } else if (_1425 === 6) { const v138: rt.i8 = (rt.i128Low(v131) << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v138)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v138))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v138, f)))); } else if (_1425 === 7) { const v139: rt.i16 = (rt.i128Low(v131) << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v139)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v139))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v139, f)))); } else if (_1425 === 8) { const v140: rt.i32 = rt.i128Low(v131) | 0; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v140)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v140))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v140, f)))); } else if (_1425 === 9) { const v141: rt.i64 = rt.i64Cast(v131); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v141)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v141))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v141, f)))); } else if (_1425 === 10) { const v142: rt.i128 = v131; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v142)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v142))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v142, f)))); } else { const v143: rt.isize = rt.i128Low(v131) | 0; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v143)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v143))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v143, f)))); } } else { const buf12: Uint8Array = rt.bytes(4); - const n12: rt.usize = rt.min(data.length, buf12.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf12, 0, n12), rt.sliceRange(data, 0, n12)); - const v144: rt.isize = ([rt.isizeFromBeBytes(buf12), rt.sliceRange(data, n12)] as [rt.isize, Uint8Array])[0]; + const n12: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf12).length); + const slice = rt.byteSliceFrom(buf12); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n12), rt.byteSliceRange(data, 0, n12)); + const v144: rt.isize = ([rt.isizeFromBeBytes(buf12), rt.byteSliceRange(data, n12)] as [rt.isize, rt.ByteSlice])[0]; const _1565: rt.u8 = rt.u8Rem(to, 12); if (_1565 === 0) { const v145: rt.u8 = v144 & 0xff; - rt.byteVecExtendFromSlice(out, rt.u8ToBeBytes(v145)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v145))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v145, f)))); } else if (_1565 === 1) { const v146: rt.u16 = v144 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(v146)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v146))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v146, f)))); } else if (_1565 === 2) { const v147: rt.u32 = v144 >>> 0; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(v147)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v147))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v147, f)))); } else if (_1565 === 3) { const v148: rt.u64 = rt.u64Cast(v144); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(v148)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v148))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v148, f)))); } else if (_1565 === 4) { const v149: rt.u128 = rt.u128Cast(v144); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(v149)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v149))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v149, f)))); } else if (_1565 === 5) { const v150: rt.usize = v144 >>> 0; - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(v150)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v150))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v150, f)))); } else if (_1565 === 6) { const v151: rt.i8 = (v144 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(v151)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v151))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v151, f)))); } else if (_1565 === 7) { const v152: rt.i16 = (v144 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(v152)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v152))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v152, f)))); } else if (_1565 === 8) { const v153: rt.i32 = v144 as rt.i32; - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(v153)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v153))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v153, f)))); } else if (_1565 === 9) { const v154: rt.i64 = v144 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(v154)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v154))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v154, f)))); } else if (_1565 === 10) { const v155: rt.i128 = v144 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.i128ToBeBytes(v155)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v155))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v155, f)))); } else { const v156: rt.isize = v144; - rt.byteVecExtendFromSlice(out, rt.isizeToBeBytes(v156)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v156))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v156, f)))); } } } /** Conversions that check, and ones that cannot fail. */ -export function convert(data: Uint8Array, out: rt.ByteVec): void { +export function convert(data: rt.ByteSlice, out: rt.ByteVec): void { const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, buf.length); - rt.sliceCopyFromSlice(rt.sliceRange(buf, 0, n), rt.sliceRange(data, 0, n)); - const _5: [rt.u64, Uint8Array] = [rt.u64FromBeBytes(buf), rt.sliceRange(data, n)]; + const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); + const slice = rt.byteSliceFrom(buf); + rt.byteSliceCopyFromSlice(rt.byteSliceRange(slice, 0, n), rt.byteSliceRange(data, 0, n)); + const _5: [rt.u64, rt.ByteSlice] = [rt.u64FromBeBytes(buf), rt.byteSliceRange(data, n)]; const wide: rt.u64 = _5[0]; const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(rt.sliceRange(data, n).length, buf2.length); - const _31: Uint8Array = rt.sliceRange(buf2, 0, n2); - const slice = rt.sliceRange(data, n); - rt.sliceCopyFromSlice(_31, rt.sliceRange(slice, 0, n2)); + const n2: rt.usize = rt.min(rt.byteSliceRange(data, n).length, rt.byteSliceFrom(buf2).length); + const slice2 = rt.byteSliceFrom(buf2); + const _31: rt.ByteSlice = rt.byteSliceRange(slice2, 0, n2); + const slice3 = rt.byteSliceRange(data, n); + rt.byteSliceCopyFromSlice(_31, rt.byteSliceRange(slice3, 0, n2)); const _36: rt.i32 = rt.i32FromBeBytes(buf2); - const slice2 = rt.sliceRange(data, n); - const signed: rt.i32 = ([_36, rt.sliceRange(slice2, n2)] as [rt.i32, Uint8Array])[0]; + const slice4 = rt.byteSliceRange(data, n); + const signed: rt.i32 = ([_36, rt.byteSliceRange(slice4, n2)] as [rt.i32, rt.ByteSlice])[0]; rt.byteVecPush(out, rt.u8TryFrom(wide).ok ? 1 : 0); const _46: rt.Result = rt.u32TryFrom(wide); if (_46.ok) { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(_46.value)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_46.value))); } else { rt.byteVecPush(out, 255); } const _53: rt.Result = rt.usizeTryFrom(signed); if (_53.ok) { - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(_53.value)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(_53.value))); } else { rt.byteVecPush(out, 254); } const _60: rt.Result = rt.i8TryFrom(signed); if (_60.ok) { - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes(_60.value)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(_60.value))); } else { rt.byteVecPush(out, 253); } const widened: rt.u64 = (rt.u64Low(wide) & 0xffff) as rt.u64; const into: rt.i64 = signed as rt.i64; - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(widened)); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(into)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(widened))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(into))); rt.byteVecPush(out, rt.u8Add(true ? 1 : 0, false ? 1 : 0)); const _86: Uint8Array = rt.u32ToBeBytes(signed >>> 0); const a: rt.u8 = _86[0]; const b: rt.u8 = _86[1]; const c: rt.u8 = _86[2]; const d: rt.u8 = _86[3]; - rt.byteVecExtendFromSlice(out, rt.i8ToBeBytes((a << 24) >> 24)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes((a << 8) | b)); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes((((a << 8) | b) << 16) >> 16)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(((a << 24) | (b << 16) | (c << 8) | d) >>> 0)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(((b & 63) << 16) | (c << 8) | d)); - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes((a << 24) | (c << 8) | d)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(0)); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64FromBeBytes(Uint8Array.of(d, c, b, a, a, b, c, d)))); - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(rt.i32FromBeBytes(Uint8Array.of(d, c, b, a)))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(fromHalves(rt.u64Low(rt.u64Shr(wide, 32)), rt.u64Low(wide)))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64FromHalves((rt.u64Low(rt.u64Shr(wide, 40)) & 0xff) as rt.u32, (rt.u64Low(wide) & 0xffff) as rt.u32))); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(2147483647)); - rt.byteVecExtendFromSlice(out, rt.usizeToBeBytes(134217728)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes((a << 24) >> 24))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes((a << 8) | b))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((a << 8) | b) << 16) >> 16))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(((a << 24) | (b << 16) | (c << 8) | d) >>> 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(((b & 63) << 16) | (c << 8) | d))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((a << 24) | (c << 8) | d))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64FromBeBytes(Uint8Array.of(d, c, b, a, a, b, c, d))))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(rt.i32FromBeBytes(Uint8Array.of(d, c, b, a))))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(fromHalves(rt.u64Low(rt.u64Shr(wide, 32)), rt.u64Low(wide))))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64FromHalves((rt.u64Low(rt.u64Shr(wide, 40)) & 0xff) as rt.u32, (rt.u64Low(wide) & 0xffff) as rt.u32)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(2147483647))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(134217728))); } /** A `u64` from its high and low 32 bits, as moq-net's varints join them. */ diff --git a/ts/fixtures/lang/expected/iters.Doubled.ts b/ts/fixtures/lang/expected/iters.Doubled.ts index 6ef494301..a2b191f33 100644 --- a/ts/fixtures/lang/expected/iters.Doubled.ts +++ b/ts/fixtures/lang/expected/iters.Doubled.ts @@ -4,12 +4,12 @@ import * as rt from "./rt.ts"; /** Each byte doubled, as a `Debug` list built from an iterator. */ export interface Doubled { - _0: Uint8Array; + _0: rt.ByteSlice; } export function fmt$Debug(self: Doubled, f: rt.Formatter): rt.Result { const _5: rt.DebugList = rt.fmtDebugList(f); - const _6: rt.Iter = rt.iterMap(rt.iterSlice(self._0), (_2: rt.u8): rt.u16 => { + const _6: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(self._0)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 2); }); return rt.debugListFinish(rt.debugListEntries(_5, _6, rt.u16Display)); diff --git a/ts/fixtures/lang/expected/iters.Gaps.ts b/ts/fixtures/lang/expected/iters.Gaps.ts index 08c1ba8d4..a24b3a125 100644 --- a/ts/fixtures/lang/expected/iters.Gaps.ts +++ b/ts/fixtures/lang/expected/iters.Gaps.ts @@ -4,12 +4,12 @@ import * as rt from "./rt.ts"; /** Every byte, or `None` where it is zero. */ export interface Gaps { - data: Uint8Array; + data: rt.ByteSlice; at: rt.usize; } export function next$Iterator(self: Gaps): rt.u8 | undefined | rt.Done { - const _3: rt.u8 | undefined = rt.sliceGet(self.data, self.at); + const _3: rt.u8 | undefined = rt.byteSliceGet(self.data, self.at); if (_3 !== undefined) { const b: rt.u8 = _3; self.at = rt.usizeAdd(self.at, 1); diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 685b5970f..92d8897c7 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -13,16 +13,16 @@ import * as Tag from "./iters.Tag.ts"; import * as Wrapper from "./iters.Wrapper.ts"; /** Adaptor chains over the input bytes, each consumed one way. */ -export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { b0: { const _4: rt.u8 = rt.u8Rem(kind, 8); if (_4 === 0) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFilter(rt.iterMap(rt.iterSlice(data), (_216: rt.u8): rt.u8 => { + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): rt.u8 => { return rt.u8Div(_216, 2); }), (b11: rt.u8): boolean => { return rt.u8Rem(b11, 3) !== 0; })))); - const iterS: rt.u16[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(data), (_217: rt.u8): rt.u16 | undefined => { + const iterS: rt.u16[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_217: rt.u8): rt.u16 | undefined => { const b12: rt.u8 = _217; return rt.thenSome(b12 < 100, rt.u16Mul(b12 as rt.u16, 200)); })); @@ -32,11 +32,11 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { if (_18 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_18)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_18))); } } else { if (_4 === 1) { - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(data)), 1), 2); + const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), 1), 2); while (true) { const _32: [rt.usize, rt.u8] | rt.Done = iter2.next(); if (_32 === rt.DONE) { @@ -47,7 +47,7 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, i & 0xff); rt.byteVecPush(out, b); } - const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterTake(rt.iterEnumerate(rt.iterRev(rt.iterSlice(data))), 3); + const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterTake(rt.iterEnumerate(rt.iterRev(rt.iterSlice(rt.byteSliceView(data)))), 3); while (true) { const _46: [rt.usize, rt.u8] | rt.Done = iter3.next(); if (_46 === rt.DONE) { @@ -57,37 +57,37 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } } if (_4 === 2) { - const _56: [Uint8Array, Uint8Array] = rt.sliceSplitAt(data, rt.usizeDiv(data.length, 2)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(_56[0]), rt.iterRev(rt.iterSlice(_56[1]))), (_215: [rt.u8, rt.u8]): rt.u8 => { + const _56: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(data, rt.usizeDiv(data.length, 2)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(rt.byteSliceView(_56[0])), rt.iterRev(rt.iterSlice(rt.byteSliceView(_56[1])))), (_215: [rt.u8, rt.u8]): rt.u8 => { return _215[0] ^ _215[1]; })))); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(_56[0]), rt.iterSlice(_56[1])))))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(rt.byteSliceView(_56[0])), rt.iterSlice(rt.byteSliceView(_56[1]))))))); } else if (_4 === 3) { - const taken: rt.ByteVec = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(data), (_212: rt.u8): boolean => { + const taken: rt.ByteVec = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): boolean => { return _212 !== 0; })); - const skipped: rt.ByteVec = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(data), (_213: rt.u8): boolean => { + const skipped: rt.ByteVec = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): boolean => { return _213 < 128; })); - const mapped: rt.ByteVec = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(data), (_214: rt.u8): rt.u8 | undefined => { + const mapped: rt.ByteVec = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): rt.u8 | undefined => { return rt.u8CheckedAdd(_214, 64); })); rt.byteVecPush(out, taken.length & 0xff); rt.byteVecPush(out, skipped.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecView(mapped)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(mapped)); } else if (_4 === 4) { const words: rt.ByteVec[] = chunksByZero$ChunksByZero_u8s(data); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { - return rt.iterRev(rt.iterSlice(rt.byteVecView(w))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { + return rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w)))); })))); rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterMap(rt.iterSlice(words), (w2: rt.ByteVec): rt.Iter => { - return rt.iterMap(rt.iterSlice(rt.byteVecView(w2)), (_211: rt.u8): rt.u8 => { + return rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w2))), (_211: rt.u8): rt.u8 => { return rt.u8WrappingAdd(_211, 3); }); })))); } else { if (_4 === 5) { - const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(data)); + const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _118: rt.u8 | rt.Done = it.next(); if (_118 !== rt.DONE) { @@ -110,8 +110,8 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } } if (_4 === 6) { - const it2: rt.Iter = rt.iterSlice(data); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterTake(it2, 2)))); + const it2: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(it2, 2)))); rt.byteVecPush(out, it2.len() & 0xff); const _152: rt.u8 | undefined = rt.iterToOption(it2.nextBack()); if (_152 === undefined) { @@ -119,9 +119,9 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } else { rt.byteVecPush(out, _152); } - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3)))); } else { - const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Uint8Array => { + const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Uint8Array => { const b3: rt.u8 = _2; return Uint8Array.of(b3, ~b3 & 0xff); })); @@ -136,15 +136,15 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { if (_187 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, _187); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(_187)); } const v2: rt.u16[] = []; - const _196: rt.Iter = rt.iterMap(rt.iterSlice(data), (_22: rt.u8): rt.u16 => { + const _196: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.u16 => { return rt.u16Add(_22 as rt.u16, 1); }); rt.iterExtend(v2, _196); rt.byteVecPush(out, v2.length & 0xff); - rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(data), (_24: rt.u8): boolean => { + rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): boolean => { return _24 > 128; })); } @@ -154,10 +154,10 @@ export function adaptors(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { } /** The runs between zero bytes. */ -export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { +export function chunksByZero$ChunksByZero_u8s(self: rt.ByteSlice): rt.ByteVec[] { const words: rt.ByteVec[] = []; let word: rt.ByteVec = new rt.ByteVec(); - const iterS: Uint8Array = self; + const iterS: Uint8Array = rt.byteSliceView(self); let iterI: number = 0; while (true) { const _6: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -179,32 +179,32 @@ export function chunksByZero$ChunksByZero_u8s(self: Uint8Array): rt.ByteVec[] { } /** Consumers, and how far each reads: `log` records every item a closure sees. */ -export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function consumers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.ByteVec = new rt.ByteVec(); const _5: rt.u8 = rt.u8Rem(kind, 6); if (_5 === 0) { - const _9: rt.Iter = rt.iterInspect(rt.iterSlice(data), (_228: rt.u8): void => { + const _9: rt.Iter = rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_228: rt.u8): void => { rt.byteVecPush(log, _228); }); rt.byteVecPush(out, rt.iterAny(_9, (_229: rt.u8): boolean => { return _229 > 240; }) ? 1 : 0); - const _17: rt.Iter = rt.iterSlice(data); + const _17: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.byteVecPush(out, rt.iterAll(_17, (_230: rt.u8): boolean => { return _230 !== 0; }) ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.iterSlice(data)) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(data), (_231: rt.u8): boolean => { + rt.byteVecPush(out, rt.iterCount(rt.iterSlice(rt.byteSliceView(data))) & 0xff); + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_231: rt.u8): boolean => { return rt.u8Rem(_231, 2) === 0; })) & 0xff); } else if (_5 === 1) { - const _31: rt.Iter = rt.iterInspect(rt.iterSlice(data), (_220: rt.u8): void => { + const _31: rt.Iter = rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_220: rt.u8): void => { rt.byteVecPush(log, _220); }); rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFind(_31, (_221: rt.u8): boolean => { return rt.u8Rem(_221, 7) === 3; }), 255)); - const _40: rt.Iter = rt.iterSlice(data); + const _40: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterFindMap(_40, (_222: rt.u8): rt.u8 | undefined => { const b14: rt.u8 = _222; if (!(b14 > 80)) { @@ -212,23 +212,23 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } return rt.u8CheckedMul(b14, 3); }), 0)); - const _45: rt.Iter = rt.iterSlice(data); + const _45: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.byteVecPush(out, rt.optionMapOr(rt.iterPosition(_45, (_223: rt.u8): boolean => { return _223 === 64; }), 255, (p: rt.usize): rt.u8 => { return p & 0xff; })); - const short: Uint8Array = rt.sliceRange(data, rt.usizeDiv(data.length, 2)); - rt.byteVecPush(out, rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSlice(data), (_224: rt.u8): rt.u8 => { + const short: rt.ByteSlice = rt.byteSliceRange(data, rt.usizeDiv(data.length, 2)); + rt.byteVecPush(out, rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_224: rt.u8): rt.u8 => { const b16: rt.u8 = _224; rt.byteVecPush(log, b16); return b16; - }), rt.iterSlice(short), true)) & 0xff); - const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_225: rt.u8): rt.u8 => { + }), rt.iterSlice(rt.byteSliceView(short)), true)) & 0xff); + const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_225: rt.u8): rt.u8 => { const b17: rt.u8 = _225; rt.byteVecPush(log, ~b17 & 0xff); return b17; - }), rt.iterSlice(short), true); + }), rt.iterSlice(rt.byteSliceView(short)), true); while (true) { const _69: [rt.u8, rt.u8] | rt.Done = iter.next(); if (_69 === rt.DONE) { @@ -236,11 +236,11 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } rt.byteVecPush(out, _69[0] ^ _69[1]); } - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_226: rt.u8): void => { + const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_226: rt.u8): void => { rt.byteVecPush(log, _226); }), (b19: rt.u8): rt.u8 => { return b19; - }), rt.iterSlice(short)); + }), rt.iterSlice(rt.byteSliceView(short))); while (true) { const _85: [rt.u8, rt.u8] | rt.Done = iter2.next(); if (_85 === rt.DONE) { @@ -248,9 +248,9 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } rt.byteVecPush(out, _85[0] ^ _85[1]); } - const back: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(data), (_227: rt.u8): rt.u8 => { + const back: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_227: rt.u8): rt.u8 => { return rotateFree$RotateFree_u8(_227); - }), rt.iterSlice(short), true); + }), rt.iterSlice(rt.byteSliceView(short)), true); const _97: [rt.u8, rt.u8] | undefined = rt.iterToOption(back.nextBack()); if (_97 !== undefined) { const a3: rt.u8 = _97[0]; @@ -260,18 +260,18 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void } rt.byteVecPush(out, back.len() & 0xff); } else if (_5 === 2) { - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMax(rt.iterSlice(data)), 0)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMin(rt.iterSlice(data)), 255)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterSlice(data), (_218: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMax(rt.iterSlice(rt.byteSliceView(data))), 0)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMin(rt.iterSlice(rt.byteSliceView(data))), 255)); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterSlice(rt.byteSliceView(data)), (_218: rt.u8): rt.u8 => { return rt.u8Rem(_218, 16); }), 238)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMinByKey(rt.iterSlice(data), (_219: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterMinByKey(rt.iterSlice(rt.byteSliceView(data)), (_219: rt.u8): rt.u8 => { return rt.u8Div(_219, 16); }), 238)); - rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterLast(rt.iterSlice(data)), 221)); - const _140: rt.Iter = rt.iterSlice(data); + rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterLast(rt.iterSlice(rt.byteSliceView(data))), 221)); + const _140: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_140, 3), 204)); - const it: rt.Iter = rt.iterSlice(data); + const it: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); const _147: rt.Iter = rt.iterTake(it, rt.usizeRem(data.length, 3)); rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterToOption(_147.nthBackItem(1)), 187)); rt.byteVecPush(out, it.len() & 0xff); @@ -279,24 +279,24 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_162, 2), 187)); rt.byteVecPush(out, it.len() & 0xff); } else if (_5 === 3) { - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(data), (_214: rt.u8): rt.u64 => { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): rt.u64 => { return rt.u64Mul(_214 as rt.u64, 1103823438081); - }), rt.u64Add, 0))); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(data), 0, (acc: rt.u32, _34: rt.u8): rt.u32 => { + }), rt.u64Add, 0)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(rt.byteSliceView(data)), 0, (acc: rt.u32, _34: rt.u8): rt.u32 => { const b8: rt.u8 = _34; const _510: rt.u32 = (acc << 3) >>> 0; return rt.u32WrappingAdd(_510, ((b8 as rt.u32) ^ acc) >>> 0); - }))); - rt.iterForEach(rt.iterSlice(data), (_216: rt.u8): void => { + })))); + rt.iterForEach(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): void => { rt.byteVecPush(log, rotateFree$RotateFree_u8(_216)); }); } else if (_5 === 4) { - rt.byteVecPush(out, rt.iterSum(rt.iterSlice(data), rt.u8Add, 0)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.iterProduct(rt.iterMap(rt.iterSlice(data), (_213: rt.u8): rt.u16 => { + rt.byteVecPush(out, rt.iterSum(rt.iterSlice(rt.byteSliceView(data)), rt.u8Add, 0)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.iterProduct(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): rt.u16 => { return rt.u16Add(rt.u16Rem(_213 as rt.u16, 4), 1); - }), rt.u16Mul, 1))); + }), rt.u16Mul, 1)))); } else { - const parsed: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): rt.Result => { + const parsed: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Result => { const b3: rt.u8 = _2; if (!(b3 < 240)) { return rt.Err(b3); @@ -304,11 +304,11 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void return rt.Ok(b3); }), (values__: rt.Iter) => rt.iterToByteVec(values__)); if (parsed.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecView(parsed.value)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(parsed.value)); } else { rt.byteVecPush(out, parsed.error); } - rt.byteVecPush(out, rt.optionMapOr(rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(data), (_24: rt.u8): void => { + rt.byteVecPush(out, rt.optionMapOr(rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): void => { rt.byteVecPush(log, _24); }), (_29: rt.u8): rt.u16 | undefined => { const b5: rt.u8 = _29; @@ -317,7 +317,7 @@ export function consumers(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void return v2.length & 0xff; })); } - rt.byteVecExtendFromSlice(out, rt.byteVecView(log)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log)); } export function rotateFree$RotateFree_u8(self: rt.u8): rt.u8 { @@ -325,9 +325,9 @@ export function rotateFree$RotateFree_u8(self: rt.u8): rt.u8 { } /** Ranges as values and as iterators. */ -export function ranges(data: Uint8Array, out: rt.ByteVec): void { - const a: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const b: rt.u8 = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); +export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { + const a: rt.u8 = rt.optionUnwrapOr(rt.byteSliceFirst(data), 0); + const b: rt.u8 = rt.optionUnwrapOr(rt.byteSliceGet(data, 1), 0); const range: rt.Range = new rt.Range(a, b); rt.byteVecPush(out, a); rt.byteVecPush(out, b); @@ -354,7 +354,7 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { } const _56: rt.Range = new rt.Range(a, b); rt.byteVecPush(out, rt.optionUnwrapOr(rt.iterNth(_56, 5), 238)); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step)))); const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); @@ -400,22 +400,22 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { return _23 === 0; })) & 0xff); rt.byteVecPush(out, rt.rangeIsEmpty(wide) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0)))); const edge: rt.u64 = rt.u64Add(rt.u64Sub({ hi: 0x200000, lo: 0 } as rt.u64, 2), rt.u64Rem(a as rt.u64, 4)); const past: rt.Range = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); const _223: rt.usize = rt.usizeRem(b as rt.usize, 3); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _223), 0))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(past, _223), 0)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterToOption(past.nextBack()), 0)))); const _240: rt.RangeInclusive = new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step); const _243: rt.usize = rt.usizeRem(b as rt.usize, 5); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_240, _243), 0))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Rem(a as rt.u64, 3)), { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Step), (n4: rt.u64): rt.u64 => { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterNth(_240, _243), 0)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Rem(a as rt.u64, 3)), { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Step), (n4: rt.u64): rt.u64 => { return rt.u64Rem(n4, 7); - }), rt.u64Add, 0))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { + }), rt.u64Add, 0)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.optionUnwrapOr(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { return _24; - }), 0))); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 1), rt.i64Add(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 1), rt.i64Step)), 0))); + }), 0)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(rt.optionUnwrapOr(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 1), rt.i64Add(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 1), rt.i64Step)), 0)))); const iterS: rt.u32[] = rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8))); let iterI: number = 0; while (true) { @@ -432,7 +432,7 @@ export function ranges(data: Uint8Array, out: rt.ByteVec): void { * Struct update syntax on std's ranges: the fields written run before the base, and * the rest are read from it. */ -export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function updates(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let _29!: rt.u8; const base: rt.Range = new rt.Range(a, b); rt.byteVecPush(out, 208); @@ -441,7 +441,7 @@ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): const made: rt.Range = new rt.Range(rt.rangeClone(base).start, _7); const _14: rt.Range = rt.rangeClone(base); const whole: rt.Range = new rt.Range(_14.start, _14.end); - rt.byteVecExtendFromSlice(out, Uint8Array.of(made.start, _7, whole.start, whole.end)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(made.start, _7, whole.start, whole.end))); let iterStart: rt.u8 = rt.u8Div(a, 2); const iterEnd: rt.u8 = base.end; while ((_29 = iterStart++) < iterEnd) { @@ -459,18 +459,18 @@ export function updates(a: rt.u8, b: rt.u8, data: Uint8Array, out: rt.ByteVec): rt.byteVecPush(out, 210); rt.byteVecPush(out, 211); rt.byteVecPush(out, 212); - rt.byteVecExtendFromSlice(out, rt.sliceRange(data, from, rt.rangeClone(all).end)); + rt.byteVecExtendFromSlice(out, rt.byteSliceRange(data, from, rt.rangeClone(all).end)); rt.byteVecPush(out, 213); - rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + rt.byteVecPush(out, rt.byteSliceRange(data, 0).length & 0xff); rt.byteVecPush(out, 214); - rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); + rt.byteVecPush(out, rt.byteSliceRange(data, 0).length & 0xff); fullRange(out); - rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); - rt.byteVecPush(out, rt.sliceRange(data, 0).length & 0xff); - const copied: rt.ByteVec = rt.sliceToByteVec(data); - const _76: Uint8Array = rt.byteVecView(copied); - rt.sliceCopyWithin(_76, 0, to, 0); - rt.byteVecExtendFromSlice(out, rt.byteVecView(copied)); + rt.byteVecPush(out, rt.byteSliceRange(data, 0).length & 0xff); + rt.byteVecPush(out, rt.byteSliceRange(data, 0).length & 0xff); + const copied: rt.ByteVec = rt.byteSliceToByteVec(data); + const _76: rt.ByteSlice = rt.byteVecSlice(copied); + rt.byteSliceCopyWithin(_76, 0, to, 0); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(copied)); } /** `..`, logging that it was made. */ @@ -479,15 +479,15 @@ export function fullRange(out: rt.ByteVec): undefined { } /** Iterators of `Option`, which keep each `None` apart from their end. */ -export function options(data: Uint8Array, out: rt.ByteVec): void { - const all: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (b2: rt.u8): rt.u8 | undefined => { +export function options(data: rt.ByteSlice, out: rt.ByteVec): void { + const all: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b2: rt.u8): rt.u8 | undefined => { if (!(rt.u8Rem(b2, 3) === 0)) { return b2; } return undefined; })); rt.byteVecPush(out, all.length & 0xff); - const iter: rt.Iter = rt.iterMap(rt.iterSlice(data), (b3: rt.u8): rt.u8 | undefined => { + const iter: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b3: rt.u8): rt.u8 | undefined => { if (!(rt.u8Rem(b3, 3) === 0)) { return b3; } @@ -505,7 +505,7 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, item); } } - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(data), (b4: rt.u8): rt.u8 | undefined => { + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b4: rt.u8): rt.u8 | undefined => { if (!(rt.u8Rem(b4, 3) === 0)) { return b4; } @@ -514,13 +514,13 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { return o !== undefined; })) & 0xff); - rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(data), (b5: rt.u8): rt.u8 | undefined => { + rt.byteVecPush(out, rt.optionUnwrapOr(second$Map_Iter_u8_options_closure0(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b5: rt.u8): rt.u8 | undefined => { if (!(rt.u8Rem(b5, 3) === 0)) { return b5; } return undefined; })), 205)); - const first: rt.u8 | undefined = rt.sliceFirst(data); + const first: rt.u8 | undefined = rt.byteSliceFirst(data); const iter2: rt.Iter = rt.iterChain(rt.iterOption(first), rt.iterOnce(153)); while (true) { const _49: rt.u8 | rt.Done = iter2.next(); @@ -533,7 +533,7 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { rt.iterEmpty(); rt.iterExtendBytes(out, rt.iterChain(_57, rt.iterEmpty())); let n: rt.u8 = 0; - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { n = rt.u8Add(n, 1); return rt.thenSome(n < 4, n); })))); @@ -563,9 +563,9 @@ export function second$Map_Iter_u8_options_closure0(items: rt.Iter Countdown.next$Iterator(it)), (n3: rt.u8): rt.u64 => { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n3: rt.u8): rt.u64 => { return rt.u64Div(rt.u64Mul(n3 as rt.u64, 1000), 7); - }), rt.u64Add, 0))); + }), rt.u64Add, 0)))); const down: Countdown.Countdown = { left, step }; while (true) { const _26: rt.u8 | rt.Done = Countdown.next$Iterator(down); @@ -589,32 +589,32 @@ export function own(data: Uint8Array, out: rt.ByteVec): void { } } rt.byteVecPush(out, down.left); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(data) }, (it: Evens.Evens) => Evens.next$Iterator(it))))); - const byRef: Evens.Evens = { inner: rt.iterSlice(rt.sliceRange(data, rt.min(data.length, 1))) }; - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(rt.byteSliceView(data)) }, (it: Evens.Evens) => Evens.next$Iterator(it))))); + const byRef: Evens.Evens = { inner: rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, rt.min(data.length, 1)))) }; + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2)))); rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it))) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecView(rt.iterToByteVec(rt.iterFrom(new Halving.Halving({ value: left }), (it: Halving.Halving) => Halving.next$Iterator_u8(it))))); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 4294967297) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(new Halving.Halving({ value: left }), (it: Halving.Halving) => Halving.next$Iterator_u8(it))))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving({ value: rt.u64Mul(left as rt.u64, 4294967297) }), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0)))); } /** * The last two bytes of `data`, as a `slice::Iter` made from the second argument: a * `for` must iterate it, not the first. */ -export function tail(_head: Uint8Array, data: Uint8Array): rt.Iter { - return rt.iterSlice(rt.sliceRange(data, rt.usizeSaturatingSub(data.length, 2))); +export function tail(_head: rt.ByteSlice, data: rt.ByteSlice): rt.Iter { + return rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, rt.usizeSaturatingSub(data.length, 2)))); } /** The odd bytes, from a function returning `impl Iterator`. */ -export function odds(data: Uint8Array): rt.Iter { - return rt.iterFilter(rt.iterSlice(data), (b: rt.u8): boolean => { +export function odds(data: rt.ByteSlice): rt.Iter { + return rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (b: rt.u8): boolean => { return rt.u8Rem(b, 2) === 1; }); } /** Iterators as values: returned, stored, and printed. */ -export function values(data: Uint8Array, out: rt.ByteVec): void { - const iter: rt.Iter = tail(Uint8Array.of(1, 2, 3), data); +export function values(data: rt.ByteSlice, out: rt.ByteVec): void { + const iter: rt.Iter = tail(rt.byteSliceFrom(Uint8Array.of(1, 2, 3)), data); while (true) { const _8: rt.u8 | rt.Done = iter.next(); if (_8 === rt.DONE) { @@ -622,7 +622,7 @@ export function values(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, _8); } - const held: Held.Held = { it: rt.iterSlice(data) }; + const held: Held.Held = { it: rt.iterSlice(rt.byteSliceView(data)) }; rt.byteVecPush(out, Held.skipOne(held)); const iter2: rt.Iter = odds(data); while (true) { @@ -632,15 +632,15 @@ export function values(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, _21); } - [{ _0: data }, { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }] as [Doubled.Doubled, Doubled.Doubled]; + [{ _0: data }, { _0: rt.byteSliceRange(data, 0, rt.min(data.length, 2)) }] as [Doubled.Doubled, Doubled.Doubled]; const arg = { _0: data }; const _39: rt.Fmt = (f: rt.Formatter) => Doubled.fmt$Debug(arg, f); - const arg2 = { _0: rt.sliceRange(data, 0, rt.min(data.length, 2)) }; + const arg2 = { _0: rt.byteSliceRange(data, 0, rt.min(data.length, 2)) }; const args2: rt.Fmt[] = [_39, (f: rt.Formatter) => Doubled.fmt$Debug(arg2, f)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1])]))); - const tags: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_2: rt.u8): Tag.Tag => { + const tags: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Tag.Tag => { const b3: rt.u8 = _2; - return { bytes: rt.sliceToByteVec(Uint8Array.of(b3, ~b3 & 0xff)) }; + return { bytes: rt.byteSliceToByteVec(rt.byteSliceFrom(Uint8Array.of(b3, ~b3 & 0xff))) }; })); const cloned: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone)); const iter3: rt.Iter = rt.iterSlice(cloned); @@ -657,9 +657,9 @@ export function values(data: Uint8Array, out: rt.ByteVec): void { if (_74 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteVecView(_74.bytes)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_74.bytes)); } - const bumps: Bumped.Bumped[] = rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_22: rt.u8): Bumped.Bumped => { + const bumps: Bumped.Bumped[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): Bumped.Bumped => { return { _0: _22 }; })); rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), Bumped.clone$Clone), (b5: Bumped.Bumped): rt.u8 => { @@ -668,7 +668,7 @@ export function values(data: Uint8Array, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), copy$Bumped), (b6: Bumped.Bumped): rt.u8 => { return b6._0; })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(data), (_23: rt.u8): Wrapper.Wrapper => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): Wrapper.Wrapper => { return new Wrapper.Wrapper({ _0: _23 }); }))), Wrapper.clone$Clone_Bumped), (w: Wrapper.Wrapper): rt.u8 => { return w._0._0; diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 9b901b0d4..94663b96b 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -168,8 +168,8 @@ export function find$String_str(keys_: string[], q: string): rt.u8 { } /** The index of the first of `keys` that borrows as `q`. */ -export function find$u8_u8(keys_: Uint8Array, q: rt.u8): rt.u8 { - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(keys_)); +export function find$u8_u8(keys_: rt.ByteSlice, q: rt.u8): rt.u8 { + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(keys_))); while (true) { const _7: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_7 === rt.DONE) { @@ -184,7 +184,7 @@ export function find$u8_u8(keys_: Uint8Array, q: rt.u8): rt.u8 { } /** Run one case. */ -export function keys(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { options(data, out); @@ -223,7 +223,7 @@ export function seen(k: rt.u8, hop_: Hop.Hop | undefined, horizon: Horizon.Horiz * Borrows compared, ordered, and hashed as what they point at, through one reference * or two, shared or mutable. */ -export function borrows(data: Uint8Array, out: rt.ByteVec): void { +export function borrows(data: rt.ByteSlice, out: rt.ByteVec): void { let _7!: rt.usize; let m!: Name.Name; let n!: Name.Name; @@ -236,9 +236,9 @@ export function borrows(data: Uint8Array, out: rt.ByteVec): void { const i: rt.usize = _7; const _15: rt.usize = rt.usizeSub(i, 1); rt.idx(data, _15); - const _14: rt.u8 = data[_15]; + const _14: rt.u8 = data.data[data.start + _15]; rt.idx(data, i); - const _13: [rt.u8, rt.u8] = [_14, data[i]]; + const _13: [rt.u8, rt.u8] = [_14, data.data[data.start + i]]; const c: rt.u8 = _14; const d: rt.u8 = _13[1]; const _24: [Hop.Hop | undefined, Hop.Hop | undefined] = [hop(c), hop(d)]; @@ -296,7 +296,7 @@ export function borrows(data: Uint8Array, out: rt.ByteVec): void { } /** `Option`s compared, ordered, and hashed, alone and in keys. */ -export function options(data: Uint8Array, out: rt.ByteVec): void { +export function options(data: rt.ByteSlice, out: rt.ByteVec): void { let _10!: rt.usize; let m!: rt.Arc; let n!: rt.Arc; @@ -315,9 +315,9 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { const i: rt.usize = _10; const _18: rt.usize = rt.usizeSub(i, 1); rt.idx(data, _18); - const _17: rt.u8 = data[_18]; + const _17: rt.u8 = data.data[data.start + _18]; rt.idx(data, i); - const _16: [rt.u8, rt.u8] = [_17, data[i]]; + const _16: [rt.u8, rt.u8] = [_17, data.data[data.start + i]]; const c: rt.u8 = _17; const d: rt.u8 = _16[1]; const _27: [Hop.Hop | undefined, Hop.Hop | undefined] = [hop(c), hop(d)]; @@ -404,9 +404,9 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { break; } rt.byteVecPush(out, _310[0][0]); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(_310[0][1].exclude, 0, (h4: Hop.Hop): rt.u64 => { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.optionMapOr(_310[0][1].exclude, 0, (h4: Hop.Hop): rt.u64 => { return h4._0; - }))); + })))); rt.byteVecPush(out, (_310[0][1].exclude !== undefined ? 1 : 0) | (((_310[0][1].local ? 1 : 0) << 1) & 0xff)); rt.byteVecPush(out, _310[1]); rt.byteVecPush(out, rt.hashIndex(hashed, [_310[0][0], copy$Horizon(_310[0][1])] as [rt.u8, Horizon.Horizon])); @@ -445,7 +445,7 @@ export function options(data: Uint8Array, out: rt.ByteVec): void { } /** `Arc`s compared, ordered, and hashed as what they hold, and borrowed as it. */ -export function arcs(data: Uint8Array, out: rt.ByteVec): void { +export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { let _7!: rt.usize; let a!: Name.Name; let b!: Name.Name; @@ -468,10 +468,10 @@ export function arcs(data: Uint8Array, out: rt.ByteVec): void { const i: rt.usize = _7; const _16: rt.usize = rt.usizeSub(i, 1); rt.idx(data, _16); - _14 = name(data[_16]); + _14 = name(data.data[data.start + _16]); unwind = 81; rt.idx(data, i); - const _20: Name.Name = name(data[i]); + const _20: Name.Name = name(data.data[data.start + i]); unwind = 84; _166 = true; a = _14; @@ -486,7 +486,7 @@ export function arcs(data: Uint8Array, out: rt.ByteVec): void { const _102: string = b.text.value; rt.byteVecPush(out, text === _102 ? 1 : 0); rt.idx(data, i); - const _106: rt.usize = rt.usizeRem(data[i] as rt.usize, ["", "a", "ab", "", "￿", "𐀀"].length); + const _106: rt.usize = rt.usizeRem(data.data[data.start + i] as rt.usize, ["", "a", "ab", "", "￿", "𐀀"].length); if (!(_106 < 6)) { rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _106); } @@ -507,7 +507,7 @@ export function arcs(data: Uint8Array, out: rt.ByteVec): void { _165 = false; _166 = false; } - const _130: rt.u8 | undefined = rt.sliceFirst(data); + const _130: rt.u8 | undefined = rt.byteSliceFirst(data); if (_130 !== undefined) { rt.byteVecPush(out, find$u8_u8(data, _130)); } @@ -595,14 +595,14 @@ export function arcs(data: Uint8Array, out: rt.ByteVec): void { * give: numbers, a wide number, and a tuple, by keys JS compares and by keys found * through their hash. */ -export function places(data: Uint8Array, out: rt.ByteVec): void { +export function places(data: rt.ByteSlice, out: rt.ByteVec): void { let _154!: rt.usize; let _257!: rt.u8; const counts: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; const wide: rt.HashMap = rt.hashNew() as rt.HashMap; const hops: rt.HashMap = rt.hashNew(rt.hashing(Hop.hash$Hash_DefaultHasher, Hop.eq$PartialEq)) as rt.HashMap; const pairs: rt.BTreeMap = rt.btreeNew(Hop.cmp$Ord) as rt.BTreeMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(data)); + const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _11: [rt.usize, rt.u8] | rt.Done = iter.next(); if (_11 === rt.DONE) { @@ -698,7 +698,7 @@ export function places(data: Uint8Array, out: rt.ByteVec): void { const j: rt.usize = _154; const _159: rt.usize = rt.usizeRem(j, data.length); rt.idx(data, _159); - const b2: rt.u8 = data[_159]; + const b2: rt.u8 = data.data[data.start + _159]; const _167: rt.u16 = rt.u16Mul(j & 0xffff, 37) ^ b2 as rt.u16; const place15 = rt.entryOrInsertMut(rt.entry(tree, _167), j & 0xffff); place15.v = rt.u16WrappingAdd(place15.v, b2 as rt.u16); @@ -709,8 +709,8 @@ export function places(data: Uint8Array, out: rt.ByteVec): void { if (_179 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_179[0])); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(_179[1])); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_179[0]))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_179[1]))); } const touchy: rt.BTreeMap = rt.btreeNew(Touchy.cmp$Ord) as rt.BTreeMap; const place16 = rt.entryOrInsertWithMut(rt.entry(touchy, { _0: data.length & 0xff }), (): rt.u8 => { @@ -746,12 +746,12 @@ export function places(data: Uint8Array, out: rt.ByteVec): void { break; } rt.byteVecPush(out, _241[0]); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(_241[1] as rt.u32)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_241[1] as rt.u32))); } let iterStart2: rt.u8 = 0; const iterEnd2: rt.u8 = 7; while ((_257 = iterStart2++) < iterEnd2) { - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionUnwrapOr(rt.hashGet(wide, _257), 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.optionUnwrapOr(rt.hashGet(wide, _257), 0)))); } const iter6: rt.Range = new rt.Range(0, 6, rt.u64Step); while (true) { @@ -759,7 +759,7 @@ export function places(data: Uint8Array, out: rt.ByteVec): void { if (_273 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(rt.optionUnwrapOr(rt.hashGet(hops, { _0: _273 }), 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.optionUnwrapOr(rt.hashGet(hops, { _0: _273 }), 0)))); } const iter7: rt.Iter<[Hop.Hop, [rt.u8, rt.u8]]> = rt.btreeIter(pairs); while (true) { diff --git a/ts/fixtures/lang/expected/shapes.Meters.ts b/ts/fixtures/lang/expected/shapes.Meters.ts index 343a34b72..b47801fd7 100644 --- a/ts/fixtures/lang/expected/shapes.Meters.ts +++ b/ts/fixtures/lang/expected/shapes.Meters.ts @@ -14,7 +14,7 @@ export function area$Area(self: Meters): rt.u64 { /** A default method, monomorphized for each type. */ export function describe$Area(self: Meters, out: rt.ByteVec): void { rt.byteVecPush(out, 170); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(self._0)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(self._0))); } //# sourceMappingURL=shapes.Meters.ts.map diff --git a/ts/fixtures/lang/expected/shapes.Shape.ts b/ts/fixtures/lang/expected/shapes.Shape.ts index 5fd6e2a69..2286a800d 100644 --- a/ts/fixtures/lang/expected/shapes.Shape.ts +++ b/ts/fixtures/lang/expected/shapes.Shape.ts @@ -32,7 +32,7 @@ export type Shape = /** A default method, monomorphized for each type. */ export function describe$Area(self: Shape, out: rt.ByteVec): void { rt.byteVecPush(out, 4); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(area$Area(self))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(area$Area(self)))); } export function area$Area(self: Shape): rt.u64 { diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 6514cebdf..c237a75b9 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -64,12 +64,12 @@ export function dir(byte: rt.u8): Dir.Dir | undefined { return undefined; } -export function shape(data: Uint8Array): Shape.Shape { - const _4: [rt.u8, Uint8Array] | undefined = rt.sliceSplitFirst(data); +export function shape(data: rt.ByteSlice): Shape.Shape { + const _4: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); if (_4 !== undefined) { const kind: rt.u8 = _4[0]; const at: (a0: rt.usize) => rt.i32 = (i: rt.usize): rt.i32 => { - return rt.i32Sub(rt.optionUnwrapOr(rt.sliceGet(_4[1], i), 0) as rt.i32, 128); + return rt.i32Sub(rt.optionUnwrapOr(rt.byteSliceGet(_4[1], i), 0) as rt.i32, 128); }; const _7: rt.u8 = rt.u8Rem(kind, 3); if (_7 === 0) { @@ -78,17 +78,17 @@ export function shape(data: Uint8Array): Shape.Shape { if (_7 === 1) { return { tag: "Line", _0: Point.new(at(0), at(1)), _1: Point.new(at(2), at(3)) } as Shape.Shape; } - return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.sliceGet(_4[1], 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.sliceGet(_4[1], 3), 0) as rt.u16 } as Shape.Shape; + return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(rt.optionUnwrapOr(rt.byteSliceGet(_4[1], 2), 0) as rt.u16, 300), height: rt.optionUnwrapOr(rt.byteSliceGet(_4[1], 3), 0) as rt.u16 } as Shape.Shape; } return { tag: "Dot" } as Shape.Shape; } /** `Copy` aggregates: a copy changes apart from its original. */ -export function copies(data: Uint8Array, out: rt.ByteVec): void { +export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { let _211!: Uint8Array; let poll!: rt.Poll; let _246!: rt.u8; - const p: Point.Point = Point.new(rt.optionUnwrapOr(rt.sliceFirst(data), 0) as rt.i32, 7); + const p: Point.Point = Point.new(rt.optionUnwrapOr(rt.byteSliceFirst(data), 0) as rt.i32, 7); const q: Point.Point = copy$Point(p); const _9: rt.i32 = rt.i32Add(q.x, 100); q.x = _9; @@ -121,7 +121,7 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { if (_42 === rt.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(_42)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(_42))); } rt.byteVecPush(out, saved[1]); rt.byteVecPush(out, pair[1]); @@ -137,7 +137,7 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { const old: Point.Point = old2; const _71: rt.u8 = a.x & 0xff; const _73: rt.u8 = b.x & 0xff; - rt.byteVecExtendFromSlice(out, Uint8Array.of(_71, _73, old.x & 0xff)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_71, _73, old.x & 0xff))); const boxed: Moved.Moved = { _0: data.length & 0xff, _1: 0 }; const _81: rt.u16 = rt.u16Add(boxed._1, 1); const _257: Moved.Moved = boxed; @@ -145,23 +145,23 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { const _83: rt.u16 = rt.u16Add(boxed._1, 2); const _254: Moved.Moved = boxed; _254._1 = _83; - rt.byteVecExtendFromSlice(out, Uint8Array.of(boxed._0)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(boxed._1)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(boxed._0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(boxed._1))); let n: rt.u32 = data.length as rt.u32; const both: [rt.u32, rt.u32] = [n, n]; n = 9; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n)))); const word: Uint8Array = Uint8Array.of(0, 0, 0, data.length & 0xff); const converted: rt.u32 = rt.u32FromBeBytes(word); word[0] = 9; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32)))); const cell: Uint8Array = Uint8Array.of(data.length & 0xff); rt.byteVecPush(out, writeThenRead(copy$u8s(cell), cell)); const source: Uint8Array = Uint8Array.of(data.length & 0xff); const returned: Uint8Array = same(copy$u8s(source)); source[0] = 9; const _145: rt.u8 = returned[0]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(_145, source[0])); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_145, source[0]))); rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); const marked: boolean = mark(out, 1) === 0; mark(out, 2); @@ -171,16 +171,16 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { opt = undefined; const taken: Meters.Meters | undefined = taken2; rt.byteVecPush(out, opt === undefined ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.optionMapOr(taken, 0, (m: Meters.Meters): rt.u64 => { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.optionMapOr(taken, 0, (m: Meters.Meters): rt.u64 => { return m._0; - }))); + })))); const res: rt.Result = rt.Ok(p); const first: Point.Point = copy$Point(rt.resultUnwrap(res, rt.u8Display)); first.x = 2; const fail: rt.Result = rt.Err(copy$Point(q)); const err: Point.Point = copy$Point(rt.resultUnwrapErr(fail, rt.u8Display)); err.y = 3; - rt.byteVecExtendFromSlice(out, Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Display).y & 0xff)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Display).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Display).y & 0xff))); const shape_: Shape.Shape = copy$Shape(shape(data)); const before: Shape.Shape = copy$Shape(shape_); if (shape_.tag !== "Dot") { @@ -211,7 +211,7 @@ export function copies(data: Uint8Array, out: rt.ByteVec): void { const _222: rt.u8 = corner.y & 0xff; _211 = Uint8Array.of(_220, _222, width & 0xff); } - rt.byteVecExtendFromSlice(out, _211); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(_211)); } if (rt.usizeRem(data.length, 2) === 0) { poll = rt.Pending; @@ -253,14 +253,14 @@ export function bump(slot: rt.Mutex): void { * `Copy` aggregates holding shared references: a copy has its own values, and shares * what its references point at with the original's. */ -export function shares(data: Uint8Array, out: rt.ByteVec): void { +export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { let res!: rt.Result<[rt.Mutex, rt.u8], rt.u8>; let n!: rt.u8; let arc!: rt.Arc; let flow!: rt.Result>; let unwind: number = 0; try { - const a: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + const a: rt.u8 = rt.optionUnwrapOr(rt.byteSliceFirst(data), 0); const slot: rt.Mutex = new rt.Mutex(a); const other: rt.Mutex = new rt.Mutex(0); const pair: [rt.Mutex, rt.u8] = [slot, a]; @@ -268,7 +268,7 @@ export function shares(data: Uint8Array, out: rt.ByteVec): void { copy[1] = rt.u8WrappingAdd(copy[1], 1); bump(copy[0]); bump(slot); - rt.byteVecExtendFromSlice(out, Uint8Array.of(a, copy[1])); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, copy[1]))); const refs: rt.Mutex[] = [slot, other]; const copy2: rt.Mutex[] = copy$Mutex_u8s(refs); bump(copy2[0]); @@ -325,7 +325,7 @@ export function shares(data: Uint8Array, out: rt.ByteVec): void { const copy5: Lens.Lens = copy$Lens(lens); copy5.n = rt.u8WrappingAdd(copy5.n, 4); bump(copy5.slot); - rt.byteVecExtendFromSlice(out, Uint8Array.of(a, copy5.n)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, copy5.n))); rt.byteVecPush(out, lensBumped(lens)); const iterS: Lens.Lens[] = Array.from({ length: 2 }, (): Lens.Lens => { return copy$Lens(lens); @@ -373,16 +373,16 @@ export function shares(data: Uint8Array, out: rt.ByteVec): void { const by: rt.i32 = movedBy(copy$Point(source.at), { held: source }); const part: rt.i32 = partMovedThenRead(copy$Held(source), source.at); const _172: rt.u8 = kept.at.x & 0xff; - rt.byteVecExtendFromSlice(out, Uint8Array.of(_172, read & 0xff, by & 0xff, part & 0xff, source.at.x & 0xff)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_172, read & 0xff, by & 0xff, part & 0xff, source.at.x & 0xff))); unwind = 117; const bytes: Uint8Array = Uint8Array.of(a, 1); rt.byteVecPush(out, unsizedCopy(bytes)); rt.byteVecPush(out, bytes[0]); - const at: rt.usize = rt.optionMapOr(rt.sliceGet(data, 1), 0, (_22: rt.u8): rt.usize => { + const at: rt.usize = rt.optionMapOr(rt.byteSliceGet(data, 1), 0, (_22: rt.u8): rt.usize => { return rt.usizeRem(_22 as rt.usize, 3); }); - rt.byteVecPush(out, writeAt(bytes, at, a)); - rt.byteVecExtendFromSlice(out, bytes); + rt.byteVecPush(out, writeAt(rt.byteSliceFrom(bytes), at, a)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); const points: Point.Point[] = rt.vecFromElem(copy$Point(Point.new(a as rt.i32, 0)), 2, copy$Point); unwind = 114; movedAt(points, at); @@ -391,7 +391,7 @@ export function shares(data: Uint8Array, out: rt.ByteVec): void { const at3 = rt.idx(points, 1); const _210: rt.u8 = points[at3].x & 0xff; const at4 = rt.idx(points, 1); - rt.byteVecExtendFromSlice(out, Uint8Array.of(_206, _210, points[at4].y & 0xff)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_206, _210, points[at4].y & 0xff))); unwind = 0; rt.drop(arc); } catch (e) { @@ -407,30 +407,30 @@ export function shares(data: Uint8Array, out: rt.ByteVec): void { * `live[at]`, written with `b`, then changed through its first byte, and through a * reborrow that may move past it: an index past the end panics as native Rust does. */ -export function writeAt(live: Uint8Array, at: rt.usize, b: rt.u8): rt.u8 { +export function writeAt(live: rt.ByteSlice, at: rt.usize, b: rt.u8): rt.u8 { rt.idx(live, at); - live[at] = b; + live.data[live.start + at] = b; rt.idx(live, at); - const _7: rt.u8 = rt.u8WrappingAdd(live[at], 1); + const _7: rt.u8 = rt.u8WrappingAdd(live.data[live.start + at], 1); rt.idx(live, 0); - live[0] = live[0] ^ _7; - let rest: Uint8Array = live; + live.data[live.start] = live.data[live.start] ^ _7; + let rest: rt.ByteSlice = live; if (rt.u8Rem(b, 2) === 0) { - const _21: Uint8Array = rest; - rest = rt.sliceRange(_21, 1); + const _21: rt.ByteSlice = rest; + rest = rt.byteSliceRange(_21, 1); } const _27: rt.usize = rest.length; if (!(0 < _27)) { rt.panic("index out of bounds: the len is " + _27 + " but the index is " + 0); } - const _23: rt.u8 = rt.u8WrappingAdd(rest[0], 3); + const _23: rt.u8 = rt.u8WrappingAdd(rest.data[rest.start], 3); const _31: rt.usize = rest.length; if (!(0 < _31)) { rt.panic("index out of bounds: the len is " + _31 + " but the index is " + 0); } - rest[0] = _23; + rest.data[rest.start] = _23; rt.idx(live, at); - return live[at]; + return live.data[live.start + at]; } /** @@ -469,14 +469,14 @@ export function partMovedThenRead(copy: Held.Held, at: Point.Point): rt.i32 { } /** `copy[0]`, read after `live`, its source unsized, changes. */ -export function sliceChangedThenRead(copy: Uint8Array, live: Uint8Array): rt.u8 { - rt.sliceCopyFromSlice(live, Uint8Array.of(9, 9)); +export function sliceChangedThenRead(copy: Uint8Array, live: rt.ByteSlice): rt.u8 { + rt.byteSliceCopyFromSlice(live, rt.byteSliceFrom(Uint8Array.of(9, 9))); return copy[0]; } /** `src[0]` as it was, read after a call changes it through a slice. */ export function unsizedCopy(src: Uint8Array): rt.u8 { - return sliceChangedThenRead(copy$u8s(src), src); + return sliceChangedThenRead(copy$u8s(src), rt.byteSliceFrom(src)); } /** `copy.x`, read after `by` moves what it holds right by one. */ @@ -536,11 +536,11 @@ export function mark(out: rt.ByteVec, b: rt.u8): rt.usize { * Aggregates written with their fields out of declaration order evaluate them as * written: each field logs as it runs. */ -export function order(data: Uint8Array, out: rt.ByteVec): void { +export function order(data: rt.ByteSlice, out: rt.ByteVec): void { let taken!: Shape.Shape; let _75!: rt.usize; const at: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return rt.optionUnwrapOr(rt.sliceGet(data, i2), 0); + return rt.optionUnwrapOr(rt.byteSliceGet(data, i2), 0); }; const _5: rt.u16 = mark(out, at(0)) & 0xffff; const _10: rt.u16 = mark(out, at(1)) & 0xffff; @@ -578,13 +578,13 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { sum = rt.usizeAdd(sum, _75); } const len: rt.usize = data.length; - const _83: Uint8Array = logged(data, out); + const _83: rt.ByteSlice = logged(data, out); const _85: rt.usize = rt.min(mark(out, 14), len); const _87: rt.usize = rt.usizeDiv(rt.min(mark(out, 15), len), 2); - const _82: Uint8Array = rt.sliceRange(_83, _87, _85); + const _82: rt.ByteSlice = rt.byteSliceRange(_83, _87, _85); const _102: Shape.Shape = taken; const _103: rt.usize = sum; - const args2: rt.Fmt[] = [(f: rt.Formatter) => Shape.fmt$Debug(rect, f), (f: rt.Formatter) => Shape.fmt$Debug(line, f), (f: rt.Formatter) => Pair.fmt$Debug(pair, f), (f: rt.Formatter) => Point.fmt$Debug(read, f), (f: rt.Formatter) => Moved.fmt$Debug(updated, f), (f: rt.Formatter) => Shape.fmt$Debug(_102, f), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.usizeDisplay(_63, f), (f: rt.Formatter) => rt.usizeDisplay(_103, f), (f: rt.Formatter) => rt.fmtList(_82, f, rt.u8Display)]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => Shape.fmt$Debug(rect, f), (f: rt.Formatter) => Shape.fmt$Debug(line, f), (f: rt.Formatter) => Pair.fmt$Debug(pair, f), (f: rt.Formatter) => Point.fmt$Debug(read, f), (f: rt.Formatter) => Moved.fmt$Debug(updated, f), (f: rt.Formatter) => Shape.fmt$Debug(_102, f), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.usizeDisplay(_63, f), (f: rt.Formatter) => rt.usizeDisplay(_103, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_82), f, rt.u8Display)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]))); indexed(data, out); } @@ -594,29 +594,28 @@ export function order(data: Uint8Array, out: rt.ByteVec): void { * evaluate what comes before those first: each logs as it runs, or changes what an * earlier operand read. */ -export function indexed(data: Uint8Array, out: rt.ByteVec): void { +export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return rt.optionUnwrapOr(rt.sliceGet(data, i), 0); + return rt.optionUnwrapOr(rt.byteSliceGet(data, i), 0); }; const _7: rt.ByteVec = listed(out, at(0)); rt.byteVecPush(out, 225); - const slice = rt.byteVecView(_7); - const at2 = rt.idx(slice, 1); - const first: rt.u8 = slice[at2]; + const at2 = rt.idx(_7, 1); + const first: rt.u8 = _7.data[at2]; const bytes: Uint8Array = Uint8Array.of(at(1), at(2), at(3), 4); - const _23: Uint8Array = loggedMut(bytes, out); + const _23: rt.ByteSlice = loggedMut(rt.byteSliceFrom(bytes), out); rt.byteVecPush(out, 227); rt.byteVecPush(out, 228); - rt.sliceCopyWithin(_23, 1, 3, 0); - const _30: Uint8Array = loggedMut(bytes, out); + rt.byteSliceCopyWithin(_23, 1, 3, 0); + const _30: rt.ByteSlice = loggedMut(rt.byteSliceFrom(bytes), out); rt.byteVecPush(out, 229); - rt.sliceCopyWithin(_30, 2, _30.length, 1); - const _36: Uint8Array = loggedMut(bytes, out); - rt.sliceCopyWithin(_36, 3, _36.length, 0); - const _41: Uint8Array = logged(bytes, out); + rt.byteSliceCopyWithin(_30, 2, _30.length, 1); + const _36: rt.ByteSlice = loggedMut(rt.byteSliceFrom(bytes), out); + rt.byteSliceCopyWithin(_36, 3, _36.length, 0); + const _41: rt.ByteSlice = logged(rt.byteSliceFrom(bytes), out); rt.byteVecPush(out, 230); rt.idx(_41, 1); - const second: rt.u8 = _41[1]; + const second: rt.u8 = _41.data[_41.start + 1]; let f: (a0: rt.u8) => rt.u8 = halve; const _50: (a0: rt.u8) => rt.u8 = f; f = twice; @@ -627,18 +626,33 @@ export function indexed(data: Uint8Array, out: rt.ByteVec): void { n = rt.u8WrappingAdd(n, 1); slots[0] = rt.u8Add(slots[0], _58); const _68: rt.u8 = f(1); - rt.byteVecExtendFromSlice(out, Uint8Array.of(first, second, called, _68, slots[0], n)); - rt.byteVecExtendFromSlice(out, bytes); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first, second, called, _68, slots[0], n))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); + const _79: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(data, rt.usizeDiv(data.length, 2)); + ends([_79[0], _79[1]], out); +} + +/** Each part's length and first byte. */ +export function ends(parts: rt.ByteSlice[], out: rt.ByteVec): void { + const iterS: rt.ByteSlice[] = parts; + let iterI: number = 0; + while (true) { + const _5: rt.ByteSlice | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; + if (_5 === rt.DONE) { + break; + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_5.length & 0xff, rt.optionUnwrapOr(rt.byteSliceFirst(_5), 0)))); + } } /** A vector of `b`, logging that it was made. */ export function listed(out: rt.ByteVec, b: rt.u8): rt.ByteVec { rt.byteVecPush(out, 224); - return rt.sliceToByteVec(Uint8Array.of(b, b ^ 1)); + return rt.byteSliceToByteVec(rt.byteSliceFrom(Uint8Array.of(b, b ^ 1))); } /** `s`, logging that it was read. */ -export function loggedMut(s: Uint8Array, out: rt.ByteVec): Uint8Array { +export function loggedMut(s: rt.ByteSlice, out: rt.ByteVec): rt.ByteSlice { rt.byteVecPush(out, 226); return s; } @@ -652,7 +666,7 @@ export function twice(b: rt.u8): rt.u8 { } /** `data`, logging that it was read. */ -export function logged(data: Uint8Array, out: rt.ByteVec): Uint8Array { +export function logged(data: rt.ByteSlice, out: rt.ByteVec): rt.ByteSlice { rt.byteVecPush(out, 238); return data; } @@ -671,10 +685,10 @@ export function reset(m: Moved.Moved): rt.u16 { } /** Fieldless enums cast to every width, past their discriminant's range and sign. */ -export function discriminants(data: Uint8Array, out: rt.ByteVec): void { +export function discriminants(data: rt.ByteSlice, out: rt.ByteVec): void { let wide!: Wide.Wide; let signed!: Signed.Signed; - const iterS: Uint8Array = data; + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -700,13 +714,13 @@ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, { Low: 1, High: 300, Top: 65535 }[wide] & 0xff); rt.byteVecPush(out, (({ Low: 1, High: 300, Top: 65535 }[wide] << 24) >> 24) & 0xff); - rt.byteVecExtendFromSlice(out, rt.i16ToBeBytes(({ Low: 1, High: 300, Top: 65535 }[wide] << 16) >> 16)); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide] as rt.u64)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(({ Low: 1, High: 300, Top: 65535 }[wide] << 16) >> 16))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide] as rt.u64))); rt.byteVecPush(out, { Neg: -1, Min: -128, Pos: 100 }[signed] & 0xff); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] & 0xffff)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] >>> 0)); - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] as rt.i64)); - rt.byteVecExtendFromSlice(out, rt.u128ToBeBytes(rt.u128Cast({ Neg: -1, Min: -128, Pos: 100 }[signed]))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] & 0xffff))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] >>> 0))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] as rt.i64))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast({ Neg: -1, Min: -128, Pos: 100 }[signed])))); } } @@ -714,7 +728,7 @@ export function discriminants(data: Uint8Array, out: rt.ByteVec): void { * Loops: labeled, `while let`, ranges, values out of `break`, loops that end a function, * and values of type `!`. */ -export function loops(data: Uint8Array, out: rt.ByteVec): void { +export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { let _24!: rt.usize; let _34!: rt.usize; let steps!: rt.u8; @@ -730,7 +744,7 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { } } }; - const stack: rt.ByteVec = rt.sliceToByteVec(data); + const stack: rt.ByteVec = rt.byteSliceToByteVec(data); let popped: rt.u32 = 0; while (true) { const _5: rt.u8 | undefined = rt.byteVecPop(stack); @@ -746,7 +760,7 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { break; } } - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(popped)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(popped))); let found: [rt.usize, rt.usize] | undefined = undefined; let iterStart: rt.usize = 0; const iterEnd: rt.usize = data.length; @@ -760,11 +774,11 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { } const j: rt.usize = _34; rt.idx(data, i); - const _39: rt.u8 = data[i]; + const _39: rt.u8 = data.data[data.start + i]; rt.idx(data, j); - if (!(_39 === data[j])) { + if (!(_39 === data.data[data.start + j])) { rt.idx(data, j); - if (data[j] === 0) { + if (data.data[data.start + j] === 0) { continue l3; } } else { @@ -778,7 +792,7 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { } else { const i2: rt.usize = found[0]; const j2: rt.usize = found[1]; - rt.byteVecExtendFromSlice(out, Uint8Array.of(i2 & 0xff, j2 & 0xff)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(i2 & 0xff, j2 & 0xff))); } let n: rt.u64 = data.length as rt.u64; b6: { @@ -818,10 +832,10 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { r.end = r.start; const second: rt.i32 | undefined = r.start < r.end ? r.start++ : undefined; if (first !== undefined) { - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(first)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(first))); } if (second !== undefined) { - rt.byteVecExtendFromSlice(out, rt.i32ToBeBytes(second)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(second))); } let iterStart3: rt.i32 = lo; const iterEnd3: rt.i32 = 2; @@ -834,9 +848,9 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, _136 & 0xff); } rt.byteVecPush(out, firstRepeat(data)); - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(tailBreak(data))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(tailBreak(data)))); rt.byteVecPush(out, armLoop(data)); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(position$u8(data, 0) as rt.u32)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(position$u8(data, 0) as rt.u32))); rt.byteVecPush(out, _158(rt.u8Mul(data.length & 0xff, 7))); drain(data, out); rt.byteVecPush(out, returnedLoop(data)); @@ -848,7 +862,7 @@ export function loops(data: Uint8Array, out: rt.ByteVec): void { * Values of type `!` where a value goes, triggered by the first two bytes so most * inputs run every case to its end. */ -export function diverging(data: Uint8Array, out: rt.ByteVec): void { +export function diverging(data: rt.ByteSlice, out: rt.ByteVec): void { const _15: (a0: rt.u8) => rt.u8 = (b2: rt.u8): rt.u8 => { if (!(b2 === 253)) { return rt.u8Div(b2, 3); @@ -857,8 +871,8 @@ export function diverging(data: Uint8Array, out: rt.ByteVec): void { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; rt.panicFmt(["closure ", args2[0]]); }; - const head: Uint8Array = rt.sliceRange(data, 0, rt.min(data.length, 2)); - const b: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(head), 0); + const head: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 2)); + const b: rt.u8 = rt.optionUnwrapOr(rt.byteSliceFirst(head), 0); rt.byteVecPush(out, returnedNever(b, data.length)); rt.byteVecPush(out, brokenNever(head)); rt.byteVecPush(out, _15(b)); @@ -976,17 +990,17 @@ export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { } /** A `return` of a `match` that guards, whose arms fall through to the next. */ -export function guardedReturn(data: Uint8Array): rt.u8 { +export function guardedReturn(data: rt.ByteSlice): rt.u8 { if (!((data.length === 0))) { if (data.length === 2) { - const a: rt.u8 = data[0]; - const b: rt.u8 = data[1]; + const a: rt.u8 = data.data[data.start]; + const b: rt.u8 = data.data[data.start + 1]; if (a > b) { return rt.u8Sub(a, b); } } if (data.length >= 1) { - if (data[0] > 128) { + if (data.data[data.start] > 128) { return 1; } } @@ -996,12 +1010,12 @@ export function guardedReturn(data: Uint8Array): rt.u8 { } /** A loop ending the function, left by `break` with values that never exist. */ -export function brokenNever(data: Uint8Array): rt.u8 { +export function brokenNever(data: rt.ByteSlice): rt.u8 { let i: rt.usize = 0; while (!(i >= data.length)) { const _6: rt.usize = i; rt.idx(data, _6); - const value = data[_6]; + const value = data.data[data.start + _6]; if (value === 251) { const arg = ([i] as [rt.usize])[0]; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; @@ -1009,7 +1023,7 @@ export function brokenNever(data: Uint8Array): rt.u8 { } else if (value === 252) { const _19: rt.usize = i; rt.idx(data, _19); - bail(data[_19]); + bail(data.data[data.start + _19]); } else { if (value === 0) { return i & 0xff; @@ -1024,12 +1038,12 @@ export function brokenNever(data: Uint8Array): rt.u8 { * Values that never exist where a value is needed: bound, and passed. A loop that * only `return` leaves gives the function's result. */ -export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { +export function boundNever(data: rt.ByteSlice, _out: rt.ByteVec): rt.u8 { let i: rt.usize = 0; while (!(i >= data.length)) { const _8: rt.usize = i; rt.idx(data, _8); - const value = data[_8]; + const value = data.data[data.start + _8]; if (value === 239) { const arg = ([i] as [rt.usize])[0]; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; @@ -1037,7 +1051,7 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { } else if (value === 240) { const _22: rt.usize = i; rt.idx(data, _22); - bail(data[_22]); + bail(data.data[data.start + _22]); } else { if (value === 0) { return i & 0xff; @@ -1048,7 +1062,7 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { if (!(i >= data.length)) { const _32: rt.usize = i; rt.idx(data, _32); - if (data[_32] < 128) { + if (data.data[data.start + _32] < 128) { break; } } else { @@ -1064,15 +1078,15 @@ export function boundNever(data: Uint8Array, _out: rt.ByteVec): rt.u8 { } /** Loops that `break` ending a guarded `match` arm and an `if let` chain branch. */ -export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { +export function branchLoops(data: rt.ByteSlice, out: rt.ByteVec): void { let i: rt.usize = 0; l1: while (rt.usizeAdd(i, 1) < data.length) { - const w: Uint8Array = rt.sliceRange(data, i, rt.usizeAdd(i, 2)); + const w: rt.ByteSlice = rt.byteSliceRange(data, i, rt.usizeAdd(i, 2)); b2: { i = rt.usizeAdd(i, 2); if (w.length === 2) { - const a: rt.u8 = w[0]; - const b: rt.u8 = w[1]; + const a: rt.u8 = w.data[w.start]; + const b: rt.u8 = w.data[w.start + 1]; if (a > b) { let n: rt.u8 = a; while (true) { @@ -1086,12 +1100,12 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { } } if (w.length >= 1) { - rt.byteVecPush(out, w[0]); + rt.byteVecPush(out, w.data[w.start]); } } if (w.length === 2) { - if (rt.u8Rem(w[0], 3) === rt.u8Rem(w[1], 3)) { - let n2: rt.u8 = w[0]; + if (rt.u8Rem(w.data[w.start], 3) === rt.u8Rem(w.data[w.start + 1], 3)) { + let n2: rt.u8 = w.data[w.start]; while (true) { n2 = rt.u8Div(n2, 2); rt.byteVecPush(out, n2); @@ -1106,10 +1120,10 @@ export function branchLoops(data: Uint8Array, out: rt.ByteVec): void { } /** A loop that only `return` leaves, returned itself, around loops that `break`. */ -export function returnedLoop(data: Uint8Array): rt.u8 { +export function returnedLoop(data: rt.ByteSlice): rt.u8 { let i: rt.usize = 0; while (!(i >= data.length)) { - const iterS: Uint8Array = rt.sliceRange(data, i); + const iterS: Uint8Array = rt.byteSliceView(rt.byteSliceRange(data, i)); let iterI: number = 0; while (true) { const _11: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1131,25 +1145,25 @@ export function returnedLoop(data: Uint8Array): rt.u8 { } /** A loop that ends the function, left only by `return` from nested scopes. */ -export function firstRepeat(data: Uint8Array): rt.u8 { +export function firstRepeat(data: rt.ByteSlice): rt.u8 { let i: rt.usize = 0; l2: while (!(i >= data.length)) { let j: rt.usize = rt.usizeAdd(i, 1); while (j < data.length) { const _14: rt.usize = j; rt.idx(data, _14); - if (!(data[_14] === 0)) { + if (!(data.data[data.start + _14] === 0)) { const _21: rt.usize = i; rt.idx(data, _21); - const _20: rt.u8 = data[_21]; + const _20: rt.u8 = data.data[data.start + _21]; const _25: rt.usize = j; rt.idx(data, _25); - if (!(_20 === data[_25])) { + if (!(_20 === data.data[data.start + _25])) { j = rt.usizeAdd(j, 1); } else { const _29: rt.usize = j; rt.idx(data, _29); - return data[_29] ^ (i & 0xff); + return data.data[data.start + _29] ^ (i & 0xff); } } else { i = rt.usizeAdd(j, 1); @@ -1162,20 +1176,20 @@ export function firstRepeat(data: Uint8Array): rt.u8 { } /** A loop that ends the function, left by `break` with a value from nested scopes. */ -export function tailBreak(data: Uint8Array): rt.u16 { +export function tailBreak(data: rt.ByteSlice): rt.u16 { let i: rt.usize = 0; l2: while (true) { if (!(i >= data.length)) { const _7: rt.usize = i; rt.idx(data, _7); - const b: rt.u8 = data[_7]; + const b: rt.u8 = data.data[data.start + _7]; i = rt.usizeAdd(i, 1); const _11: rt.u8 = rt.u8Rem(b, 4); if (_11 === 0) { continue; } if (_11 === 1) { - const iterS: Uint8Array = rt.sliceRange(data, i); + const iterS: Uint8Array = rt.byteSliceView(rt.byteSliceRange(data, i)); let iterI: number = 0; while (true) { const _18: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1211,9 +1225,9 @@ export function tailBreak(data: Uint8Array): rt.u16 { } /** A loop that only `return` leaves, in a `match` arm that needs a value. */ -export function armLoop(data: Uint8Array): rt.u8 { +export function armLoop(data: rt.ByteSlice): rt.u8 { let k: rt.usize = 0; - const _3: rt.u8 | undefined = rt.sliceFirst(data); + const _3: rt.u8 | undefined = rt.byteSliceFirst(data); if (_3 !== undefined) { if (_3 >= 128) { return rt.u8Div(_3, 2); @@ -1222,25 +1236,25 @@ export function armLoop(data: Uint8Array): rt.u8 { while (!(k >= data.length)) { const _13: rt.usize = k; rt.idx(data, _13); - if (!(data[_13] >= 128)) { + if (!(data.data[data.start + _13] >= 128)) { k = rt.usizeAdd(k, 1); } else { const _17: rt.usize = k; rt.idx(data, _17); - return rt.u8Sub(data[_17], 128); + return rt.u8Sub(data.data[data.start + _17], 128); } } return 238; } /** A generic function ending in a loop. */ -export function position$u8(items: Uint8Array, want: rt.u8): rt.usize { +export function position$u8(items: rt.ByteSlice, want: rt.u8): rt.usize { let i: rt.usize = 0; while (true) { if (!(i === items.length)) { const _9: rt.usize = i; rt.idx(items, _9); - if (!((items[_9] === want))) { + if (!((items.data[items.start + _9] === want))) { i = rt.usizeAdd(i, 1); } else { return i; @@ -1252,18 +1266,18 @@ export function position$u8(items: Uint8Array, want: rt.u8): rt.usize { } /** A unit function ending in a loop. */ -export function drain(data: Uint8Array, out: rt.ByteVec): void { +export function drain(data: rt.ByteSlice, out: rt.ByteVec): void { let i: rt.usize = 0; while (!(i >= data.length)) { const _10: rt.usize = i; rt.idx(data, _10); - rt.byteVecPush(out, data[_10] ^ 90); + rt.byteVecPush(out, data.data[data.start + _10] ^ 90); i = rt.usizeAdd(i, 2); } } /** Patterns: slices, ranges, guards that bind, `@` bindings, and let chains. */ -export function patterns(data: Uint8Array, out: rt.ByteVec): void { +export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { let class_!: rt.u8; let area!: rt.i64; let either!: rt.Result; @@ -1272,19 +1286,19 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { if (!(data.length === 1)) { if (!(data.length >= 2)) { rt.unreachable(undefined); - } else if (!((data[0] === data[data.length - 1]))) { - rt.byteVecPush(out, data[0] ^ data[1]); - rt.byteVecPush(out, data.subarray(2, data.length - 0).length & 0xff); + } else if (!((data.data[data.start] === data.data[data.start + (data.length - 1)]))) { + rt.byteVecPush(out, data.data[data.start] ^ data.data[data.start + 1]); + rt.byteVecPush(out, rt.byteSliceRange(data, 2).length & 0xff); } else { rt.byteVecPush(out, 2); } } else { - rt.byteVecPush(out, data[0]); + rt.byteVecPush(out, data.data[data.start]); } } else { rt.byteVecPush(out, 0); } - const iterS: Uint8Array = rt.sliceRange(data, 0, rt.min(data.length, 4)); + const iterS: Uint8Array = rt.byteSliceView(rt.byteSliceRange(data, 0, rt.min(data.length, 4))); let iterI: number = 0; while (true) { const _33: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1323,10 +1337,10 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { } b6: { if (data.length >= 2) { - const _56: Dir.Dir | undefined = dir(data[0]); + const _56: Dir.Dir | undefined = dir(data.data[data.start]); if (_56 !== undefined) { const d: Dir.Dir = _56; - if (data[1] > 10) { + if (data.data[data.start + 1] > 10) { rt.byteVecPush(out, from$From_Dir_u8(d)); break b6; } @@ -1358,7 +1372,7 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { } area = 0; } - rt.byteVecExtendFromSlice(out, rt.i64ToBeBytes(area)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(area))); if (!(rt.usizeRem(data.length, 2) === 0)) { either = rt.Err(160); } else { @@ -1370,15 +1384,15 @@ export function patterns(data: Uint8Array, out: rt.ByteVec): void { v = either.error; } rt.byteVecPush(out, v); - rt.byteVecPush(out, rt.u8Add(Uint8Array.of().length & 0xff, rt.iterSum(rt.iterSlice(Uint8Array.of()), rt.u8Add, 0))); + rt.byteVecPush(out, rt.u8Add(rt.byteSliceFrom(Uint8Array.of()).length & 0xff, rt.iterSum(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of()))), rt.u8Add, 0))); const bytes: Uint8Array = Uint8Array.of(data.length & 0xff, 1, 2); bytes.subarray(1, 3)[0] = 9; - rt.byteVecExtendFromSlice(out, bytes); - rt.byteVecExtendFromSlice(out, rt.u64ToBeBytes(rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64 }], out)))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64Add(total$Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$Meters([{ _0: 3 }, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64 }], out))))); const parsed: rt.Result = rt.Ok(data.length & 0xff); const a2: rt.u8 = (parsed as { ok: true; value: rt.u8 }).value; const b3: rt.u8 = (parsed as { ok: true; value: rt.u8 }).value; - rt.byteVecExtendFromSlice(out, Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2))); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a2, b3, (parsed as { ok: true; value: rt.u8 }).value, early(a2)))); const arg = ([parsed] as [rt.Result])[0]; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(arg, f, rt.u8Display, (value: Void.Void, f: rt.Formatter) => Void.fmt$Debug(value, f))]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); @@ -1390,12 +1404,12 @@ export function early(n: rt.u8): rt.u8 { } /** Closures capturing by reference and by move, and functions as values. */ -export function closures(data: Uint8Array, out: rt.ByteVec): void { +export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { let sum: rt.u32 = 0; const add: (a0: rt.u8) => void = (v: rt.u8): void => { sum = rt.u32Add(sum, v as rt.u32); }; - const iterS: Uint8Array = data; + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _8: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1404,23 +1418,23 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { } add(_8); } - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(sum)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(sum))); const base: rt.u32 = data.length as rt.u32; const captured = base; - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(apply$closures_closure1((v2: rt.u32): rt.u32 => { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(apply$closures_closure1((v2: rt.u32): rt.u32 => { return rt.u32Add(rt.u32Mul(v2, 3), captured); - }, sum))); + }, sum)))); let n: rt.u32 = base; const captured2 = n; n = rt.u32Add(n, 10); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.u32Add(((): rt.u32 => { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(((): rt.u32 => { return rt.u32Add(captured2, 1); - })(), n))); + })(), n)))); const whole: Uint8Array = Uint8Array.of(data.length & 0xff); overwrite(whole); rt.byteVecPush(out, whole[0]); const parsed: Array = []; - const iterS2: Uint8Array = data; + const iterS2: Uint8Array = rt.byteSliceView(data); let iterI2: number = 0; while (true) { const _53: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; @@ -1441,7 +1455,7 @@ export function closures(data: Uint8Array, out: rt.ByteVec): void { const _70: rt.u8 = rt.optionUnwrapOr(rt.optionMap(_64, from$From_Dir_u8), 0); rt.byteVecPush(tags, _70); } - rt.byteVecExtendFromSlice(out, rt.byteVecView(tags)); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(tags)); } /** Replaces `a` whole from a closure. */ @@ -1457,7 +1471,7 @@ export function apply$closures_closure1(f: (a0: rt.u32) => rt.u32, v: rt.u32): r } /** Options, results, `?`, and strings. */ -export function library(data: Uint8Array, out: rt.ByteVec): void { +export function library(data: rt.ByteSlice, out: rt.ByteVec): void { let parsed!: rt.Result; const _3: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => { const _4: rt.u8 | undefined = rt.u8CheckedAdd(a2, b2); @@ -1489,8 +1503,8 @@ export function library(data: Uint8Array, out: rt.ByteVec): void { const residual: rt.Result = _132; return rt.Err(from$From_Dir_u8((residual as { ok: false; error: Dir.Dir }).error)); }; - const a: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); - const b: rt.u8 = rt.optionUnwrapOr(rt.sliceGet(data, 1), 0); + const a: rt.u8 = rt.optionUnwrapOr(rt.byteSliceFirst(data), 0); + const b: rt.u8 = rt.optionUnwrapOr(rt.byteSliceGet(data, 1), 0); rt.byteVecPush(out, rt.optionUnwrapOr(_3(a, b), 255)); if (a === 0) { parsed = rt.Err("zero"); @@ -1503,25 +1517,25 @@ export function library(data: Uint8Array, out: rt.ByteVec): void { return rt.stringLen(e2) & 0xff; }); if (mapped.ok) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(0, mapped.value)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, mapped.value))); } else { - rt.byteVecExtendFromSlice(out, Uint8Array.of(1, mapped.error)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(1, mapped.error))); } const _32: rt.Poll> = _30(b); if (_32 !== rt.Pending) { if (_32.ok) { - rt.byteVecExtendFromSlice(out, Uint8Array.of(2, _32.value)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(2, _32.value))); } else { - rt.byteVecExtendFromSlice(out, Uint8Array.of(3, _32.error)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(3, _32.error))); } } else { rt.byteVecPush(out, 4); } - const _45: rt.Result = rt.stringFromUtf8(rt.sliceToByteVec(data)); + const _45: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(data)); if (_45.ok) { const s: string = _45.value; rt.byteVecPush(out, 1); - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(rt.stringLen(s) as rt.u32)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.stringLen(s) as rt.u32))); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); } else { rt.byteVecPush(out, 0); @@ -1562,12 +1576,12 @@ export function polled(x: rt.u8): rt.Poll; let option!: rt.u8 | undefined; let _113!: boolean; let total: rt.u16 = 0; - const iterS: Uint8Array = data; + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _7: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -1576,7 +1590,7 @@ export function flows(data: Uint8Array, out: rt.ByteVec): void { } const x: rt.u8 = _7; const flow: rt.Result = step(total, x); - rt.byteVecExtendFromSlice(out, Uint8Array.of(!flow.ok ? 1 : 0, flow.ok ? 1 : 0)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(!flow.ok ? 1 : 0, flow.ok ? 1 : 0))); if (flow.ok) { total = flow.value; } else if (flow.error === undefined) { @@ -1595,8 +1609,8 @@ export function flows(data: Uint8Array, out: rt.ByteVec): void { rt.byteVecPush(out, 0); } } - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(total)); - const a: rt.u8 = rt.optionUnwrapOr(rt.sliceFirst(data), 0); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(total))); + const a: rt.u8 = rt.optionUnwrapOr(rt.byteSliceFirst(data), 0); if (rt.u8Rem(a, 3) === 0) { result = rt.Err(a); } else { @@ -1604,7 +1618,7 @@ export function flows(data: Uint8Array, out: rt.ByteVec): void { } rt.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { - rt.byteVecExtendFromSlice(out, rt.u16ToBeBytes(result.value)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(result.value))); } else { rt.byteVecPush(out, (result as { ok: false; error: rt.u8 }).error); } @@ -1634,11 +1648,11 @@ export function flows(data: Uint8Array, out: rt.ByteVec): void { } const flow3: rt.Result = _93; if (flow3.ok) { - rt.byteVecExtendFromSlice(out, flow3.value); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(flow3.value)); } } const slot: rt.Mutex = new rt.Mutex(undefined); - const iterS2: Uint8Array = data; + const iterS2: Uint8Array = rt.byteSliceView(data); let iterI2: number = 0; while (true) { const _106: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index 039300678..06d8d4442 100644 --- a/ts/fixtures/lang/expected/strs.ts +++ b/ts/fixtures/lang/expected/strs.ts @@ -5,9 +5,9 @@ import { put } from "./fmt.ts"; import * as Named from "./strs.Named.ts"; /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: Uint8Array): string { +export function text(data: rt.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = data; + const iterS: Uint8Array = rt.byteSliceView(data); let iterI: number = 0; while (true) { const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; @@ -23,8 +23,8 @@ export function text(data: Uint8Array): string { } /** Whether the `i`th step reads from the back: by the byte's high bit. */ -export function fromBack(data: Uint8Array, i: rt.usize): boolean { - const _3: rt.u8 | undefined = rt.sliceGet(data, i); +export function fromBack(data: rt.ByteSlice, i: rt.usize): boolean { + const _3: rt.u8 | undefined = rt.byteSliceGet(data, i); if (_3 !== undefined) { if ((_3 & 128) !== 0) { return true; @@ -37,7 +37,7 @@ export function putChar(out: rt.ByteVec, c: rt.char | undefined): void { if (c === undefined) { rt.byteVecPush(out, 255); } else { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(c as rt.u32)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(c as rt.u32))); } } @@ -45,7 +45,7 @@ export function putOffset(out: rt.ByteVec, i: rt.usize | undefined): void { if (i === undefined) { rt.byteVecPush(out, 254); } else { - rt.byteVecExtendFromSlice(out, rt.u32ToBeBytes(i as rt.u32)); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(i as rt.u32))); } } @@ -63,7 +63,7 @@ export function putSeen(out: rt.ByteVec, seen: rt.char[]): void { rt.byteVecPush(out, 253); } -export function strs(kind: rt.u8, data: Uint8Array, out: rt.ByteVec): void { +export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let c!: rt.char | undefined; let part!: string | undefined; let part3!: string | undefined; diff --git a/ts/fixtures/lang/src/shapes.rs b/ts/fixtures/lang/src/shapes.rs index 9990ff6b0..ea7acd9ec 100644 --- a/ts/fixtures/lang/src/shapes.rs +++ b/ts/fixtures/lang/src/shapes.rs @@ -611,6 +611,17 @@ fn indexed(data: &[u8], out: &mut Vec) { }] += n; out.extend_from_slice(&[first, second, called, f(1), slots[0], n]); out.extend_from_slice(&bytes); + // An array of byte slices unsized to a slice of them. + let (head, tail) = data.split_at(data.len() / 2); + ends(&[head, tail], out); +} + +/// Each part's length and first byte. +#[inline(never)] +fn ends(parts: &[&[u8]], out: &mut Vec) { + for part in parts { + out.extend_from_slice(&[part.len() as u8, part.first().copied().unwrap_or(0)]); + } } /// A vector of `b`, logging that it was made. diff --git a/ts/fixtures/reject/census.md b/ts/fixtures/reject/census.md index d3a7f38f9..006ab4684 100644 --- a/ts/fixtures/reject/census.md +++ b/ts/fixtures/reject/census.md @@ -1,7 +1,7 @@ # Census of `reject-fixture` -- Refusals: 72 -- Function instances: 59 +- Refusals: 74 +- Function instances: 61 - Generic functions no instance reached, lowered over their type parameters: 2 ## By construct @@ -9,9 +9,9 @@ | Count | Construct | First | | ---: | --- | --- | | 7 | an assignment through a reference to `_` | fixtures/reject/src/lib.rs:16:2 | +| 7 | unsupported call to `_` | fixtures/reject/src/lib.rs:32:4 | | 6 | `_` is not supported: its `None` and `Some` would both be `undefined` | fixtures/reject/src/lib.rs:27:15 | | 6 | `_`: a JS value of `_` is a copy, so a reference can't change it | fixtures/reject/src/lib.rs:15:13 | -| 6 | unsupported call to `_` | fixtures/reject/src/lib.rs:32:4 | | 4 | replacing the value behind a reference to `_` | fixtures/reject/src/lib.rs:107:2 | | 4 | unsupported type `_` | fixtures/reject/src/lib.rs:6:14 | | 3 | an iterator that owns `_`, which drops, which is not supported yet | fixtures/reject/src/lib.rs:55:2 | @@ -31,6 +31,7 @@ | 1 | `_`, which is not supported yet | fixtures/reject/src/lib.rs:325:9 | | 1 | a `_` cast from `_` to `_` | fixtures/reject/src/lib.rs:118:2 | | 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | fixtures/reject/src/lib.rs:199:51 | +| 1 | a coercion to `_` | fixtures/reject/src/lib.rs:372:2 | | 1 | a constant of type `_` | fixtures/reject/src/lib.rs:102:2 | | 1 | a copy of a closure that changes what it captured | fixtures/reject/src/lib.rs:283:14 | | 1 | a mutable borrow of a subslice of `_`, which JS would copy, having no views | fixtures/reject/src/lib.rs:258:13 | @@ -59,13 +60,14 @@ The type or module each refused type or path belongs to. | 4 | `std::string::String` | fixtures/reject/src/lib.rs:94:16 | | 4 | `std::vec::Vec` | fixtures/reject/src/lib.rs:55:2 | | 4 | `u32` | fixtures/reject/src/lib.rs:15:13 | +| 3 | `std::sync::Arc` | fixtures/reject/src/lib.rs:123:2 | | 2 | `Iterator` | fixtures/reject/src/lib.rs:166:2 | | 2 | `Meters` | fixtures/reject/src/lib.rs:107:2 | | 2 | `Poll` | fixtures/reject/src/lib.rs:127:20 | | 2 | `std::collections::HashMap` | fixtures/reject/src/lib.rs:294:6 | | 2 | `std::option::Option` | fixtures/reject/src/lib.rs:294:6 | | 2 | `std::pin::Pin` | fixtures/reject/src/lib.rs:143:2 | -| 2 | `std::sync::Arc` | fixtures/reject/src/lib.rs:123:2 | +| 2 | `std::slice` | fixtures/reject/src/lib.rs:32:4 | | 1 | `DoubleEndedIterator` | fixtures/reject/src/lib.rs:186:1 | | 1 | `FusedIterator` | fixtures/reject/src/lib.rs:240:1 | | 1 | `HashMap` | fixtures/reject/src/lib.rs:317:6 | @@ -82,8 +84,7 @@ The type or module each refused type or path belongs to. | 1 | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:289:7 | | 1 | `std::ops::Range` | fixtures/reject/src/lib.rs:207:8 | | 1 | `std::slice::Iter` | fixtures/reject/src/lib.rs:153:11 | -| 1 | `std::slice` | fixtures/reject/src/lib.rs:32:4 | -| 1 | `std::str` | fixtures/reject/src/lib.rs:372:4 | +| 1 | `std::str` | fixtures/reject/src/lib.rs:382:4 | | 1 | `std::sync::MutexGuard` | fixtures/reject/src/lib.rs:148:2 | | 1 | `u64` | fixtures/reject/src/lib.rs:118:2 | | 1 | `{async closure}` | fixtures/reject/src/lib.rs:74:2 | @@ -109,6 +110,7 @@ The type or module each refused type or path belongs to. | 1 | `_`, which is not supported yet | `Hasher::write` | fixtures/reject/src/lib.rs:325:9 | | 1 | a `_` cast from `_` to `_` | `IntToFloat`, `u64`, `f64` | fixtures/reject/src/lib.rs:118:2 | | 1 | a `zip` of `_`, whose closures std calls one item further through `next` than through `fold` | `std::iter::Chain` | fixtures/reject/src/lib.rs:199:51 | +| 1 | a coercion to `_` | `std::sync::Arc` | fixtures/reject/src/lib.rs:372:2 | | 1 | a constant of type `_` | `&u8` | fixtures/reject/src/lib.rs:102:2 | | 1 | a field of `_` | `std::ops::RangeFrom` | fixtures/reject/src/lib.rs:289:48 | | 1 | a field of `_` | `std::ops::RangeTo` | fixtures/reject/src/lib.rs:289:7 | @@ -129,13 +131,14 @@ The type or module each refused type or path belongs to. | 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::fold` | fixtures/reject/src/lib.rs:166:2 | | 1 | overriding `_`, which std's adaptors call in place of `next` or beside it | `Iterator::size_hint` | fixtures/reject/src/lib.rs:220:2 | | 1 | replacing the value behind a reference to `_` | `[u8; 1]` | fixtures/reject/src/lib.rs:272:22 | -| 1 | replacing the value behind a reference to `_` | `std::string::String` | fixtures/reject/src/lib.rs:367:4 | +| 1 | replacing the value behind a reference to `_` | `std::string::String` | fixtures/reject/src/lib.rs:377:4 | | 1 | unsupported call to `_` | `::cycle` | fixtures/reject/src/lib.rs:153:11 | | 1 | unsupported call to `_` | `::write_fmt` | fixtures/reject/src/lib.rs:96:10 | | 1 | unsupported call to `_` | `std::mem::size_of_val` | fixtures/reject/src/lib.rs:48:18 | | 1 | unsupported call to `_` | `std::ops::Range::contains` | fixtures/reject/src/lib.rs:207:8 | +| 1 | unsupported call to `_` | `std::slice::copy_within` | fixtures/reject/src/lib.rs:367:4 | | 1 | unsupported call to `_` | `std::slice::sort` | fixtures/reject/src/lib.rs:32:4 | -| 1 | unsupported call to `_` | `std::str::split` | fixtures/reject/src/lib.rs:372:4 | +| 1 | unsupported call to `_` | `std::str::split` | fixtures/reject/src/lib.rs:382:4 | | 1 | unsupported type `_` | `dyn std::ops::Fn(u8) -> u8` | fixtures/reject/src/lib.rs:10:16 | ## Spans @@ -152,6 +155,18 @@ The type or module each refused type or path belongs to. +
unsupported call to `_` (7) + +- fixtures/reject/src/lib.rs:32:4: unsupported call to `std::slice::::sort` +- fixtures/reject/src/lib.rs:48:18: unsupported call to `std::mem::size_of_val::` +- fixtures/reject/src/lib.rs:96:10: unsupported call to `::write_fmt` +- fixtures/reject/src/lib.rs:153:11: unsupported call to ` as std::iter::Iterator>::cycle` +- fixtures/reject/src/lib.rs:207:8: unsupported call to `std::ops::Range::::contains::` +- fixtures/reject/src/lib.rs:367:4: unsupported call to `core::slice::::copy_within::>` +- fixtures/reject/src/lib.rs:382:4: unsupported call to `core::str::::split::<&str>` + +
+
`_` is not supported: its `None` and `Some` would both be `undefined` (6) - fixtures/reject/src/lib.rs:27:15: `Option>` is not supported: its `None` and `Some` would both be `undefined` @@ -170,18 +185,7 @@ The type or module each refused type or path belongs to. - fixtures/reject/src/lib.rs:64:10: `&mut u8`: a JS value of `u8` is a copy, so a reference can't change it - fixtures/reject/src/lib.rs:94:16: `&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it - fixtures/reject/src/lib.rs:359:29: `&mut u8`: a JS value of `u8` is a copy, so a reference can't change it -- fixtures/reject/src/lib.rs:366:15: `&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it - -
- -
unsupported call to `_` (6) - -- fixtures/reject/src/lib.rs:32:4: unsupported call to `std::slice::::sort` -- fixtures/reject/src/lib.rs:48:18: unsupported call to `std::mem::size_of_val::` -- fixtures/reject/src/lib.rs:96:10: unsupported call to `::write_fmt` -- fixtures/reject/src/lib.rs:153:11: unsupported call to ` as std::iter::Iterator>::cycle` -- fixtures/reject/src/lib.rs:207:8: unsupported call to `std::ops::Range::::contains::` -- fixtures/reject/src/lib.rs:372:4: unsupported call to `core::str::::split::<&str>` +- fixtures/reject/src/lib.rs:376:15: `&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it
@@ -190,7 +194,7 @@ The type or module each refused type or path belongs to. - fixtures/reject/src/lib.rs:107:2: replacing the value behind a reference to `Meters` - fixtures/reject/src/lib.rs:111:2: replacing the value behind a reference to `Meters` - fixtures/reject/src/lib.rs:272:22: replacing the value behind a reference to `[u8; 1]` -- fixtures/reject/src/lib.rs:367:4: replacing the value behind a reference to `std::string::String` +- fixtures/reject/src/lib.rs:377:4: replacing the value behind a reference to `std::string::String` @@ -312,6 +316,12 @@ The type or module each refused type or path belongs to. +
a coercion to `_` (1) + +- fixtures/reject/src/lib.rs:372:2: a coercion to `std::sync::Arc<[u8]>` + +
+
a constant of type `_` (1) - fixtures/reject/src/lib.rs:102:2: a constant of type `&u8` diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index b6a68c922..18d649881 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -59,9 +59,11 @@ a field of `std::ops::RangeFrom` at fixtures/reject/src/lib.rs:289:48 hashing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:299:52 comparing `std::vec::Vec` as a key, which is not supported yet at fixtures/reject/src/lib.rs:299:52 `HashMap::contains_key` of `std::collections::HashMap` by `u8`, which is not supported yet at fixtures/reject/src/lib.rs:317:6 -`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:366:15 -replacing the value behind a reference to `std::string::String` at fixtures/reject/src/lib.rs:367:4 -unsupported call to `core::str::::split::<&str>` at fixtures/reject/src/lib.rs:372:4 +unsupported call to `core::slice::::copy_within::>` at fixtures/reject/src/lib.rs:367:4 +a coercion to `std::sync::Arc<[u8]>` at fixtures/reject/src/lib.rs:372:2 +`&mut std::string::String`: a JS value of `std::string::String` is a copy, so a reference can't change it at fixtures/reject/src/lib.rs:376:15 +replacing the value behind a reference to `std::string::String` at fixtures/reject/src/lib.rs:377:4 +unsupported call to `core::str::::split::<&str>` at fixtures/reject/src/lib.rs:382:4 overriding `Iterator::fold`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:166:2 an iterator of the crate implementing `DoubleEndedIterator`, which is not supported yet at fixtures/reject/src/lib.rs:186:1 overriding `Iterator::size_hint`, which std's adaptors call in place of `next` or beside it at fixtures/reject/src/lib.rs:220:2 diff --git a/ts/fixtures/reject/src/lib.rs b/ts/fixtures/reject/src/lib.rs index b1a225835..c08ac00f4 100644 --- a/ts/fixtures/reject/src/lib.rs +++ b/ts/fixtures/reject/src/lib.rs @@ -362,6 +362,16 @@ pub fn passed(map: &mut std::collections::HashMap) -> u8 { }) } +/// JS's `copyWithin` would share each tuple, which Rust copies. +pub fn shifted(v: &mut [(u8, u8)]) { + v.copy_within(0..1, 1); +} + +/// An `Arc`'s bytes would need a `ByteSlice` made inside it. +pub fn shared(b: std::sync::Arc<[u8; 2]>) -> std::sync::Arc<[u8]> { + b +} + /// A `String` pushed to through a parameter, whose JS value is the caller's copy. pub fn pushed(s: &mut String) { s.push('a'); diff --git a/ts/fixtures/reject/ts.toml b/ts/fixtures/reject/ts.toml index 06dae69ed..28b23a24f 100644 --- a/ts/fixtures/reject/ts.toml +++ b/ts/fixtures/reject/ts.toml @@ -42,6 +42,8 @@ roots = [ "byte_keys", "borrowed", "raw_keys", + "shifted", + "shared", "pushed", "split_str", "missing", diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 020543a35..19f75e51f 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -1193,7 +1193,7 @@ export function hashed(log: Log.Log, id: rt.u32, at: rt.u8): void { }; const tally: (a0: string) => void = (what: string): void => { const text: rt.ByteVec = Log.text(sink); - const sum: rt.u32 = rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteVecView(text)), (_2: rt.u8): rt.u32 => { + const sum: rt.u32 = rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(text))), (_2: rt.u8): rt.u32 => { return _2 as rt.u32; }), rt.u32Add, 0); const _15: rt.usize = text.length; diff --git a/ts/fixtures/task/expected/log.Log.ts b/ts/fixtures/task/expected/log.Log.ts index c662d6fcf..9f7bf2bf0 100644 --- a/ts/fixtures/task/expected/log.Log.ts +++ b/ts/fixtures/task/expected/log.Log.ts @@ -40,7 +40,7 @@ export function text(self: Log): rt.ByteVec { if (_13 === rt.DONE) { return out; } - const _19: Uint8Array = rt.stringAsBytes(_13); + const _19: rt.ByteSlice = rt.stringAsBytes(_13); rt.byteVecExtendFromSlice(out, _19); rt.byteVecPush(out, 10); } diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index 5486fe8f6..690dfc41f 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -198,7 +198,7 @@ export function thenSome(cond: boolean, value: T, drop?: (value: T) => void): return undefined; } -// Slices, which are `Uint8Array` views for bytes and arrays otherwise. +// Slices: arrays, but for bytes, which are `ByteSlice`s. /** A bounds-checked index into a slice. */ export function idx(slice: { readonly length: number }, index: number): number { @@ -211,33 +211,38 @@ export function at(slice: ArrayLike, index: number): T { return slice[idx(slice, index)]; } -/** `&s[start..end]`, with `end` defaulting to the length. */ -export function sliceRange(s: S, start: number, end: number = s.length): S { - if (start > s.length) panic(`range start index ${start} out of range for slice of length ${s.length}`); - if (end > s.length) panic(`range end index ${end} out of range for slice of length ${s.length}`); +/** Panic unless `start..end` is in a slice of `length`, as std's range checks do. */ +function rangeCheck(length: number, start: number, end: number): void { + if (start > length) panic(`range start index ${start} out of range for slice of length ${length}`); + if (end > length) panic(`range end index ${end} out of range for slice of length ${length}`); if (start > end) panic(`slice index starts at ${start} but ends at ${end}`); - return (s instanceof Uint8Array ? s.subarray(start, end) : s.slice(start, end)) as S; +} + +/** `&s[start..end]`, with `end` defaulting to the length. */ +export function sliceRange(s: T[], start: number, end: number = s.length): T[] { + rangeCheck(s.length, start, end); + return s.slice(start, end); } /** `split_first`: the first element and the rest, or `undefined` if empty. */ -export function sliceSplitFirst(s: S): [S[number], S] | undefined { - return s.length === 0 ? undefined : [s[0], sliceRange(s, 1)]; +export function sliceSplitFirst(s: T[]): [T, T[]] | undefined { + return s.length === 0 ? undefined : [s[0], s.slice(1)]; } /** `split_first_chunk`: the first `n` elements and the rest, or `undefined` if shorter. */ -export function sliceSplitFirstChunk(s: S, n: number): [S, S] | undefined { - return s.length < n ? undefined : [sliceRange(s, 0, n), sliceRange(s, n)]; +export function sliceSplitFirstChunk(s: T[], n: number): [T[], T[]] | undefined { + return s.length < n ? undefined : [s.slice(0, n), s.slice(n)]; } /** `split_at`, panicking past the length. */ -export function sliceSplitAt(s: S, n: number): [S, S] { +export function sliceSplitAt(s: T[], n: number): [T[], T[]] { if (n > s.length) panic("mid > len"); - return [sliceRange(s, 0, n), sliceRange(s, n)]; + return [s.slice(0, n), s.slice(n)]; } /** `split_at_checked`: the halves, or `undefined` past the length. */ -export function sliceSplitAtChecked(s: S, n: number): [S, S] | undefined { - return n > s.length ? undefined : [sliceRange(s, 0, n), sliceRange(s, n)]; +export function sliceSplitAtChecked(s: T[], n: number): [T[], T[]] | undefined { + return n > s.length ? undefined : [s.slice(0, n), s.slice(n)]; } /** `first`: the first element, or `undefined` if empty. */ @@ -250,26 +255,104 @@ export function sliceGet(s: ArrayLike, index: number): T | undefined { return index < s.length ? s[index] : undefined; } +/** + * `&[u8]` and `&mut [u8]`: `length` bytes of `data` from `start`. It never changes, so a + * split makes another, which costs an object where a `Uint8Array` view costs several + * times as much. + */ +export class ByteSlice { + readonly data: Uint8Array; + readonly start: number; + readonly length: number; + + constructor(data: Uint8Array, start: number, length: number) { + this.data = data; + this.start = start; + this.length = length; + } +} + +/** All of `bytes` as a slice, as `&[u8; N]` coerces to `&[u8]`. */ +export function byteSliceFrom(bytes: Uint8Array): ByteSlice { + return new ByteSlice(bytes, 0, bytes.length); +} + +/** A view of the bytes, for what reads a `Uint8Array`. */ +export function byteSliceView(s: ByteSlice): Uint8Array { + return s.data.subarray(s.start, s.start + s.length); +} + +/** `&s[start..end]`, with `end` defaulting to the length. */ +export function byteSliceRange(s: ByteSlice, start: number, end: number = s.length): ByteSlice { + rangeCheck(s.length, start, end); + return new ByteSlice(s.data, s.start + start, end - start); +} + +/** `split_first`: the first byte and the rest, or `undefined` if empty. */ +export function byteSliceSplitFirst(s: ByteSlice): [number, ByteSlice] | undefined { + return s.length === 0 ? undefined : [s.data[s.start], new ByteSlice(s.data, s.start + 1, s.length - 1)]; +} + +/** `split_first_chunk`: the first `n` bytes, as an array, and the rest, or `undefined` if shorter. */ +export function byteSliceSplitFirstChunk(s: ByteSlice, n: number): [Uint8Array, ByteSlice] | undefined { + if (s.length < n) return undefined; + return [s.data.subarray(s.start, s.start + n), new ByteSlice(s.data, s.start + n, s.length - n)]; +} + +/** `split_at`, panicking past the length. */ +export function byteSliceSplitAt(s: ByteSlice, n: number): [ByteSlice, ByteSlice] { + if (n > s.length) panic("mid > len"); + return [new ByteSlice(s.data, s.start, n), new ByteSlice(s.data, s.start + n, s.length - n)]; +} + +/** `split_at_checked`: the halves, or `undefined` past the length. */ +export function byteSliceSplitAtChecked(s: ByteSlice, n: number): [ByteSlice, ByteSlice] | undefined { + if (n > s.length) return undefined; + return [new ByteSlice(s.data, s.start, n), new ByteSlice(s.data, s.start + n, s.length - n)]; +} + +/** `first`: the first byte, or `undefined` if empty. */ +export function byteSliceFirst(s: ByteSlice): number | undefined { + return s.length === 0 ? undefined : s.data[s.start]; +} + +/** `get`: the byte at `index`, or `undefined` past the end. */ +export function byteSliceGet(s: ByteSlice, index: number): number | undefined { + return index < s.length ? s.data[s.start + index] : undefined; +} + +/** Copy `src` into `dst` at `at`; a few bytes copy faster than a view of them is made. */ +function copyBytes(dst: Uint8Array, at: number, src: Uint8Array, start: number, length: number): void { + if (length <= 16) { + for (let i = 0; i < length; i++) dst[at + i] = src[start + i]; + } else { + dst.set(src.subarray(start, start + length), at); + } +} + /** `copy_from_slice`, panicking if the lengths differ. */ -export function sliceCopyFromSlice(dst: Uint8Array, src: Uint8Array): void { +export function byteSliceCopyFromSlice(dst: ByteSlice, src: ByteSlice): void { if (dst.length !== src.length) { panic(`copy_from_slice: source slice length (${src.length}) does not match destination slice length (${dst.length})`); } - dst.set(src); + copyBytes(dst.data, dst.start, src.data, src.start, src.length); } /** `copy_within`: `s[start..end]` copied to index `dest`, panicking out of bounds. */ -export function sliceCopyWithin(s: Uint8Array, start: number, end: number, dest: number): void { +export function byteSliceCopyWithin(s: ByteSlice, start: number, end: number, dest: number): void { // `slice::range` checks the end first, then `range` reports the rest. if (end > s.length) panic(`range end index ${end} out of range for slice of length ${s.length}`); - sliceRange(s, start, end); + rangeCheck(s.length, start, end); if (dest > s.length - (end - start)) panic("dest is out of bounds"); - s.copyWithin(dest, start, end); + s.data.copyWithin(s.start + dest, s.start + start, s.start + end); } /** `to_vec` of bytes. */ -export function sliceToByteVec(s: Uint8Array): ByteVec { - return byteVecFrom(s); +export function byteSliceToByteVec(s: ByteSlice): ByteVec { + const v = new ByteVec(s.length); + copyBytes(v.data, 0, s.data, s.start, s.length); + v.length = s.length; + return v; } /** `vec![value; n]`: `n - 1` clones of `value`, in order, then `value` itself; `clone` is `undefined` where a clone is the value. */ @@ -343,6 +426,11 @@ export function byteVecView(v: ByteVec): Uint8Array { return v.data.subarray(0, v.length); } +/** The bytes, as `Vec`'s `Deref` borrows them, which a later push may detach. */ +export function byteVecSlice(v: ByteVec): ByteSlice { + return new ByteSlice(v.data, 0, v.length); +} + /** `Vec::push`. */ export function byteVecPush(v: ByteVec, byte: number): void { reserve(v, 1); @@ -355,10 +443,10 @@ export function byteVecPop(v: ByteVec): number | undefined { } /** `Vec::extend_from_slice`. */ -export function byteVecExtendFromSlice(v: ByteVec, bytes: Uint8Array): void { - reserve(v, bytes.length); - v.data.set(bytes, v.length); - v.length += bytes.length; +export function byteVecExtendFromSlice(v: ByteVec, s: ByteSlice): void { + reserve(v, s.length); + copyBytes(v.data, v.length, s.data, s.start, s.length); + v.length += s.length; } /** `Vec::truncate`. */ @@ -426,8 +514,8 @@ export function stringFromUtf8(bytes: ByteVec): Result { } /** `str::as_bytes`: its UTF-8 bytes. */ -export function stringAsBytes(s: string): Uint8Array { - return encoder.encode(s); +export function stringAsBytes(s: string): ByteSlice { + return byteSliceFrom(encoder.encode(s)); } /** `str::len`: its length in UTF-8 bytes. */ diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index 83e8b3c7c..7520820ad 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -62,7 +62,10 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { .map(|(t, v)| self.value(t, v, span)) .collect(); match elem.kind() { - ty::Uint(ty::UintTy::U8) => Expr::ident("Uint8Array").member("of").call(items), + ty::Uint(ty::UintTy::U8) => Expr::rt( + "byteSliceFrom", + vec![Expr::ident("Uint8Array").member("of").call(items)], + ), _ => Expr::Array(items), } } diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 6442fd86c..2320ed028 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -242,7 +242,7 @@ pub fn std_impl<'tcx>( } ty::Array(elem, _) | ty::Slice(elem) if tr == Trait::Debug => { let item = b.fmt_fn(tr, *elem, span); - rt("list", vec![value, f, item]) + rt("list", vec![library::elements(value, ty), f, item]) } // A `&dyn Debug` is already a function writing its value. ty::Dynamic(preds, ..) if preds.principal_def_id().and_then(|did| Trait::of(tcx, did)) == Some(tr) => { @@ -254,7 +254,7 @@ pub fn std_impl<'tcx>( (Std::Box, _) => b.fmt_call(tr, args.type_at(0), value, f, span), (Std::Vec, Trait::Debug) => { let item = b.fmt_fn(tr, args.type_at(0), span); - rt("list", vec![library::vec_view(value, ty), f, item]) + rt("list", vec![library::elements(value, ty), f, item]) } (Std::Option, Trait::Debug) => { let some = b.fmt_fn(tr, args.type_at(0), span); diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index c180f8d50..c6c2078fe 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -132,9 +132,9 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp }); } match ty.peel_refs().kind() { - ty::Slice(_) | ty::Array(..) => Some(Expr::rt("iterSlice", vec![value])), + ty::Slice(_) | ty::Array(..) => Some(Expr::rt("iterSlice", vec![library::elements(value, ty)])), ty::Adt(adt, args) => match Std::of(tcx, adt.did())? { - Std::Vec => Some(Expr::rt("iterSlice", vec![library::vec_view(value, ty)])), + Std::Vec => Some(Expr::rt("iterSlice", vec![library::elements(value, ty)])), Std::Option => { option_ok(b, args.type_at(0), span); Some(Expr::rt("iterOption", vec![value])) @@ -197,7 +197,9 @@ pub fn call<'tcx>( // Where iterators come from. match (owner, name) { ("slice", "iter" | "iter_mut") => { - return Some(Expr::rt("iterSlice", args)); + let s = args.pop()?; + let s = library::elements(s, Ty::new_slice(tcx, targ(0)?)); + return Some(Expr::rt("iterSlice", vec![s])); } ("Option", "iter" | "iter_mut") => { option_ok(b, targ(0)?, span); diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 9ed7b8a1e..8bacb3fde 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -624,26 +624,33 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec Expr::rt("thenSome", values) } - // Slices. + // Slices, whose byte functions take an `rt.ByteSlice`. ("slice", "len") => args.pop()?.member("length"), ("slice", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), - ("slice", "split_first") => rt2(args, "slice", "splitFirst"), - ("slice", "split_at") => rt2(args, "slice", "splitAt"), - ("slice", "split_at_checked") => rt2(args, "slice", "splitAtChecked"), - ("slice", "first") => rt2(args, "slice", "first"), - ("slice", "get") if Int::of(targ(gargs, 1)).is_some() => rt2(args, "slice", "get"), + ("slice", "split_first" | "split_at" | "split_at_checked" | "first" | "get") + if name != "get" || Int::of(targ(gargs, 1)).is_some() => + { + let of = match is_u8(targ(gargs, 0)) { + true => "byteSlice", + false => "slice", + }; + rt2(args, of, &super::camel(&name)) + } ("slice", "split_first_chunk") => { let n = gargs.consts().next()?.try_to_target_usize(tcx)?; let mut values = args; values.push(Expr::lit(n.to_string())); - Expr::rt("sliceSplitFirstChunk", values) + match is_u8(targ(gargs, 0)) { + true => Expr::rt("byteSliceSplitFirstChunk", values), + false => Expr::rt("sliceSplitFirstChunk", values), + } } - ("slice", "copy_from_slice") if is_u8(targ(gargs, 0)) => rt2(args, "slice", "copyFromSlice"), + ("slice", "copy_from_slice") if is_u8(targ(gargs, 0)) => rt2(args, "byteSlice", "copyFromSlice"), ("slice", "to_vec") => { let elem = targ(gargs, 0); let values = args; match is_u8(elem) { - true => Expr::rt("sliceToByteVec", values), + true => Expr::rt("byteSliceToByteVec", values), false if b.t.is_copy(elem) => { let slice = values.into_iter().next()?; match b.t.copy_fn(elem, span) { @@ -661,7 +668,13 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec let elem = targ(gargs, 0); let value = args.pop()?; if is_u8(elem) { - return Some(Expr::rt("byteVecFrom", vec![value])); + // A boxed `[u8]` is an `rt.ByteSlice`; `vec![a, b]`'s `[u8; N]` is a `Uint8Array`. + let f = if name == "into_vec" { + "byteSliceToByteVec" + } else { + "byteVecFrom" + }; + return Some(Expr::rt(f, vec![value])); } match (b.t.copy_fn(elem, span), value) { (None, value) => value, @@ -986,14 +999,32 @@ fn primitive(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Char) } -/// A `Vec`'s elements as a slice: a view of a byte vector, or the array itself. +/// A `Vec`'s elements as a slice: an `rt.ByteSlice` of a byte vector, or the array itself. pub fn vec_view(v: Expr, ty: Ty<'_>) -> Expr { let elem = match ty.peel_refs().kind() { ty::Adt(_, args) => args.type_at(0), _ => ty, }; match elem.kind() { - ty::Uint(ty::UintTy::U8) => Expr::rt("byteVecView", vec![v]), + ty::Uint(ty::UintTy::U8) => Expr::rt("byteVecSlice", vec![v]), + _ => v, + } +} + +/// The elements of a slice, array, or `Vec`, a `ty`, as a JS array or `Uint8Array`: a +/// view of a byte slice's or byte vector's, which the runtime's iterators and formatting +/// index. +pub fn elements(v: Expr, ty: Ty<'_>) -> Expr { + match ty.peel_refs().kind() { + ty::Slice(elem) if matches!(elem.kind(), ty::Uint(ty::UintTy::U8)) => Expr::rt("byteSliceView", vec![v]), + ty::Adt(_, args) + if args + .types() + .next() + .is_some_and(|t| matches!(t.kind(), ty::Uint(ty::UintTy::U8))) => + { + Expr::rt("byteVecView", vec![v]) + } _ => v, } } @@ -1016,9 +1047,10 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option Int::of(ty)?.lit(0), ty::Char => Expr::lit("0"), ty::Ref(_, inner, _) => match inner.kind() { - ty::Slice(elem) if matches!(elem.kind(), ty::Uint(ty::UintTy::U8)) => { - Expr::New(Box::new(Expr::ident("Uint8Array")), vec![Expr::lit("0")]) - } + ty::Slice(elem) if matches!(elem.kind(), ty::Uint(ty::UintTy::U8)) => Expr::rt( + "byteSliceFrom", + vec![Expr::New(Box::new(Expr::ident("Uint8Array")), vec![Expr::lit("0")])], + ), ty::Slice(_) => Expr::Array(Vec::new()), ty::Str => Expr::Str(String::new()), _ => return None, diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index f507a5f54..ae837fc84 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -331,13 +331,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.slots[local] = Slot::Alias(Some(place)); Some(None) } - ("slice", "copy_within") => { + // Of bytes only: JS's `copyWithin` would share a `Copy` aggregate Rust copies. + ("slice", "copy_within") if targ(0).is_some_and(|t| matches!(t.kind(), ty::Uint(ty::UintTy::U8))) => { let s = self.operand(&args[0].node, span, out); let s = self.path(s, "slice", out); let (start, end) = self.range_bounds(&args[1].node, targ(1)?, span, out)?; let end = end.unwrap_or_else(|| s.clone().member("length")); let dest = self.operand(&args[2].node, span, out); - done(Expr::rt("sliceCopyWithin", vec![s, start, end, dest]), true) + done(Expr::rt("byteSliceCopyWithin", vec![s, start, end, dest]), true) } // An integer from an array of bytes made in place: its bytes shifted, no array made. (int, "from_be_bytes") if let Some(int) = int_named(int) => { @@ -653,19 +654,21 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let container = gargs.type_at(0); let index_ty = gargs.type_at(1); let elem_ty = elem(self.tcx, container)?; + let bytes = matches!(elem_ty.kind(), ty::Uint(ty::UintTy::U8)); let base = self.operand(&args[0].node, span, out); - let base = match container.kind() { - ty::Adt(..) => library::vec_view(base, container), - _ => base, - }; match Int::of(index_ty) { Some(_) => { + // A `Vec`'s element is its storage's, a byte vector's in `data`. let base = self.path(base, "slice", out); let i = self.operand(&args[1].node, span, out); let i = self.path(i, "index", out); let checked = Expr::rt("idx", vec![base.clone(), i]); let checked = self.path(checked, "at", out); - let place = base.index(checked); + let place = match container.kind() { + ty::Adt(..) if bytes => base.member("data").index(checked), + _ if super::place::byte_slice(container) => super::place::byte_at(base, checked), + _ => base.index(checked), + }; // The reference reads and writes the element where it is. if let Some(local) = dest.as_local() && self.defs[local] == 1 @@ -684,10 +687,19 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // The range's bounds are taken apart before the slice is read, while they are // still held back. let (start, end) = self.range_bounds(&args[1].node, index_ty, span, out)?; + let base = match container.kind() { + ty::Adt(..) => library::vec_view(base, container), + ty::Array(..) if bytes => Expr::rt("byteSliceFrom", vec![base]), + _ => base, + }; let base = self.path(base, "slice", out); let mut values = vec![base, start]; values.extend(end); - Some(Some((Expr::rt("sliceRange", values), true))) + let range = match bytes { + true => "byteSliceRange", + false => "sliceRange", + }; + Some(Some((Expr::rt(range, values), true))) } } } @@ -734,8 +746,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn items(&mut self, value: Expr, ty: Ty<'tcx>, span: Span) -> Option { let tcx = self.tcx; match ty.peel_refs().kind() { - ty::Slice(_) | ty::Array(..) => Some(value), - ty::Adt(adt, _) if Std::of(tcx, adt.did()) == Some(Std::Vec) => Some(library::vec_view(value, ty)), + ty::Slice(_) | ty::Array(..) => Some(library::elements(value, ty)), + ty::Adt(adt, _) if Std::of(tcx, adt.did()) == Some(Std::Vec) => Some(library::elements(value, ty)), _ => crate::lower::iter::into_iter(self.b, ty, value, span), } } diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index b8716bf6c..261f74f4c 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -120,22 +120,45 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } ProjectionElem::Index(index) => { let i = self.local_expr(index, span); - e = e.index(i); + e = match byte_slice(ty) { + true => { + let base = self.path(e, "slice", out); + byte_at(base, i) + } + false => e.index(i), + }; } ProjectionElem::ConstantIndex { offset, min_length: _, from_end, } => { - e = match from_end { - false => e.index(Expr::lit(offset.to_string())), - true => { - let base = self.path(e, "slice", out); - let len = base.clone().member("length"); - base.index(len.binary("-", Expr::lit(offset.to_string()))) - } + let base = match from_end || byte_slice(ty) { + true => self.path(e, "slice", out), + false => e, + }; + let i = match from_end { + false => Expr::lit(offset.to_string()), + true => base.clone().member("length").binary("-", Expr::lit(offset.to_string())), + }; + e = match byte_slice(ty) { + true => byte_at(base, i), + false => base.index(i), }; } + // A slice pattern's rest: `[a, rest @ ..]`. + ProjectionElem::Subslice { + from, + to, + from_end: true, + } if byte_slice(ty) => { + let base = self.path(e, "slice", out); + let mut values = vec![base.clone(), Expr::lit(from.to_string())]; + if to != 0 { + values.push(base.member("length").binary("-", Expr::lit(to.to_string()))); + } + e = Expr::rt("byteSliceRange", values); + } ProjectionElem::Subslice { from, to, from_end } => { let elem_ty = match ty.kind() { ty::Array(elem, _) | ty::Slice(elem) => *elem, @@ -580,7 +603,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }, ty::Slice(elem) if matches!(elem.kind(), ty::Uint(ty::UintTy::U8)) => { let items = bytes.iter().map(|b| Expr::lit(b.to_string())).collect(); - Expr::ident("Uint8Array").member("of").call(items) + Expr::rt( + "byteSliceFrom", + vec![Expr::ident("Uint8Array").member("of").call(items)], + ) } _ => self.err(span, format!("a slice constant of type `{ty}`")), } @@ -639,6 +665,20 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } +/// Whether `ty` is `[u8]`, which is an `rt.ByteSlice`. +pub fn byte_slice(ty: Ty<'_>) -> bool { + matches!(ty.kind(), ty::Slice(elem) if matches!(elem.kind(), ty::Uint(ty::UintTy::U8))) +} + +/// Byte `i` of `slice`, an `rt.ByteSlice` that reading twice reads the same. +pub fn byte_at(slice: Expr, i: Expr) -> Expr { + let at = match &i { + Expr::Lit(text) if text == "0" => slice.clone().member("start"), + _ => slice.clone().member("start").binary("+", i), + }; + slice.member("data").index(at) +} + /// Whether `ty` is a struct of one field that JS represents as that field: a wrapper /// around a pointer, such as the `ResumeTy` and `NonNull` an async body passes its /// context in. diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 58354df10..24d5900d8 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -187,6 +187,16 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.b.fmt_value(tr, from, value, span, out) } PointerCoercion::Unsize if self.b.trait_object(to) => self.err(span, format!("a coercion to `{to}`")), + // An array's bytes, as a slice of all of it. + PointerCoercion::Unsize if unsized_to(from, to).is_some_and(super::place::byte_slice) => { + match to.builtin_deref(true) { + Some(pointee) if super::place::byte_slice(pointee) => { + let value = self.operand(op, span, out); + Expr::rt("byteSliceFrom", vec![value]) + } + _ => self.err(span, format!("a coercion to `{to}`")), + } + } PointerCoercion::Unsize | PointerCoercion::ReifyFnPointer(_) | PointerCoercion::ClosureFnPointer(_) => { self.operand(op, span, out) } @@ -467,6 +477,19 @@ pub(super) fn context_like<'tcx>(fx: &Fx<'_, '_, '_, 'tcx>, ty: Ty<'tcx>) -> boo } } +/// The part of `to` that unsizing `from` makes unsized, such as `[T]` from `[T; N]`. +fn unsized_to<'tcx>(from: Ty<'tcx>, to: Ty<'tcx>) -> Option> { + match (from.kind(), to.kind()) { + _ if from == to => None, + (ty::Array(..), ty::Slice(_)) | (_, ty::Dynamic(..)) => Some(to), + (ty::Ref(_, a, _) | ty::RawPtr(a, _), ty::Ref(_, b, _) | ty::RawPtr(b, _)) => unsized_to(*a, *b), + (ty::Adt(a, a_args), ty::Adt(b, b_args)) if a.did() == b.did() => { + a_args.types().zip(b_args.types()).find_map(|(a, b)| unsized_to(a, b)) + } + _ => None, + } +} + /// Whether evaluating `rvalue` can do or throw anything. pub fn effect<'tcx>(rvalue: &Rvalue<'tcx>, fx: &Fx<'_, '_, '_, 'tcx>) -> bool { match rvalue { diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs index 82adb926c..8265a06e6 100644 --- a/ts/src/lower/mir/step.rs +++ b/ts/src/lower/mir/step.rs @@ -304,8 +304,12 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { let ty = self.mir.local_decls[local].ty; let span = self.local_span(local); match array_iter(self.tcx, ty) { + // What `library::elements` makes of the slice: a view of bytes. Some(item) => [ - self.b.t.held_ty(Ty::new_slice(self.tcx, item), span), + match item.kind() { + ty::Uint(ty::UintTy::U8) => Type::Builtin("Uint8Array"), + _ => self.b.t.held_ty(Ty::new_slice(self.tcx, item), span), + }, Type::Builtin("number"), ], None => { diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 7f3020dc8..51ae507ed 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -871,10 +871,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Type::Builtin("unknown") } ty::Ref(_, inner, _) => self.ty(*inner, span), - ty::Array(elem, _) | ty::Slice(elem) => match elem.kind() { + ty::Array(elem, _) => match elem.kind() { ty::Uint(ty::UintTy::U8) => Type::Builtin("Uint8Array"), _ => Type::Array(Box::new(self.ty(*elem, span))), }, + ty::Slice(elem) => match elem.kind() { + ty::Uint(ty::UintTy::U8) => Type::Rt("ByteSlice", vec![]), + _ => Type::Array(Box::new(self.ty(*elem, span))), + }, ty::Param(param) => Type::Param(param.name.to_string()), ty::FnDef(..) | ty::FnPtr(..) => { let sig = tcx.instantiate_bound_regions_with_erased(ty.fn_sig(tcx)); diff --git a/ts/tests/differential.ts b/ts/tests/differential.ts index 4b2e1ceaf..b7c12d6ab 100644 --- a/ts/tests/differential.ts +++ b/ts/tests/differential.ts @@ -6,13 +6,14 @@ // `wide` adds a sweep of the `lang` fixture's 64- and 128-bit cases over operands that // random bytes rarely make: every pair of values next to a power of two. // -// A harness, or a hand-written caller wrapping one, exports `run(input: Uint8Array): +// A harness, or a hand-written caller wrapping one, exports `run(input: rt.ByteSlice): // Vec`, and may export `cases`, inputs it names, which run with the generated ones. // The wasm build exports `input`, `run`, and `output` around the crate's entry, which // `wasm.ts` calls. A panic traps natively and throws `Panic` in // TypeScript, and the two agree only if their messages do. import { readFile } from "node:fs/promises"; +import { dirname, join } from "node:path"; import { pathToFileURL } from "node:url"; import { Wasm } from "./wasm.ts"; @@ -24,11 +25,13 @@ if (!wasmPath || !harnessPath) throw new Error("usage: differential.ts Decoder.u8(Decoder.new(buf, { tag: "Quic" })); +export const run = (buf: Uint8Array) => Decoder.u8(Decoder.new(rt.byteSliceFrom(buf), { tag: "Quic" })); "#; /// Bun's and esbuild's tree-shaken bundles of [`SHAKE`] keep the functions it calls and @@ -250,15 +251,16 @@ fn shake(out: &Path) { let want = [ // The runtime's. "Err", + "ByteSlice", "Ok", "Panic", + "byteSliceFrom", + "byteSliceSplitAtChecked", "checked", "clamp", "idx", "max", "panic", - "sliceRange", - "sliceSplitAtChecked", "u32SaturatingAdd", "u32Sub", "usizeSaturatingAdd", @@ -395,7 +397,8 @@ import {{ harness }} from {harness:?}; export {{ cases }} from {harness:?}; const fixture = {{ Pending: rt.Pending, u64: {{ of: rt.u64Of }}, Log, Channel, Guard, sum, drain, blocks, drops }}; -export const run = harness(fixture); +const script = harness(fixture); +export const run = (input: rt.ByteSlice) => script(rt.byteSliceView(input)); export const unwind = harness(fixture, true); "# );