3e:null 3f:["$","title",null,{"children":"Circular Arrays | Job van der Zwan | Observable"}] 45:Tae9,# Circular Arrays Did you know that JavaScript's arrays are actually [double-ended queues](https://en.wikipedia.org/wiki/Double-ended_queue)? Basically, [`push()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) and [`pop()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) add to the back of an array, and [`unshift()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) and [`shift()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) let you add and remove elements at the front. Ok, yeah, that was probably one of the first things you learned when you learned how to use arrays in JavaScript. But did you know that the `unshift()` and `shift()` operations aren't particularly optimized? In short, if you add to the front of an array, all items in the array are moved forward by one. Which is pretty slow if the array is large. [See also this StackOverflow answer](https://stackoverflow.com/questions/44031591/performance-of-array-push-vs-array-unshift). However, I have a use-case where I need to do a lot of shift/unshift operations on potentially really large arrays. So I decided to implement my own circular buffer approach. And in particular I needed integers, so I decided to implement `TypedArray` versions too. If you ever had a situation where *maybe* a `TypedArray` with `push()`, `pop()`, `unshift()` and `shift()` methods would have been convenient, these classes might be what you're looking for. Implemented: - `CircularArray.from([...])` - `CircularArray.push(...args)` - `CircularArray.pop()` - `CircularArray.unshift(...args)` - `CircularArray.shift()` - `CircularArray.slice(begin, end)` - `CircularArray.map((value, index) => { ... })` - `CircularArray.filter((value, index) => { ... })` - `CircularArray.mapFilter(callback, begin = 0, end = this.length)` Most of these behave exactly like their `Array` equivalents. A new addition is `mapFilter`, which is a convenience method that can replace chained calls to `.map`, `.filter` and `.slice`, avoiding the allocation of intermediate arrays that are immediately discarded (a common pattern for me, and one that is especially costly if you use typed arrays). The `callback` is passed a `SKIP` symbol as its first argument. To filter out an element, return this `SKIP` symbol. Example: ```js // extract `obj.value` from a given section of a circular // array, but filter out undefined entries of `obj`. const callback = (SKIP, obj) => obj ? obj.value : SKIP; const values = cArray.mapFilter(array, callback, begin, end); ``` On top of this, `CircularArray` implements an iterator, meaning `for ... of` and spread operators just work:46:T157c,// The TypedArray versions of CircularArray are // pretty much the same as the above bit of code, // but without value kind tests (because TypedArray) // and no Array.push calls (also because TypedArray). // Since the code is identical for all of them except // for the particular TypedArray constructor being used, // we use a function to generate the prototypes. function makeCircularPrototype(arrayConstructor, name) { // Using a computed property lets us give a custom name // to a generated prototype. const { [name]: circularTA } = { [name]: function (length, capacity) { if (length === undefined) length = 0; if (!Number.isInteger(length) || length < 0) throw new Error("length must be a positive integer"); // Force capacity to a power of two, because using bitmasks for modulo is faster if (capacity === undefined) capacity = Math.max(16, 2 ** Math.ceil(Math.log2(length + 1))); else capacity = 2 ** (Math.ceil(Math.log2(capacity))); if (!Number.isInteger(capacity) || capacity < length) throw new Error("Initial capacity must be a positive integer equal or greater to length"); const data = new arrayConstructor(capacity); this.data = data; this.length = length; this.offset = 0; } }; circularTA.from = function (array) { const cta = new circularTA(array.length); for (let i = 0; i < array.length; i++) { cta.data[i] = array[i]; } return cta; }; Object.assign(circularTA.prototype, { push(...args) { if (args.length === 0) args = [0]; this.maybeGrow(args.length); let { length } = this; const mod = this.data.length - 1; for (const val of args) { this.data[(this.offset + length++) & mod] = val; } return (this.length += args.length); }, unshift(...args) { if (args.length === 0) args = [0]; this.maybeGrow(args.length); const offset = this.offset + this.data.length - args.length; this.offset = offset; const mod = this.data.length - 1; for (let i = 0, { data } = this; i < args.length; i++) { data[(i + offset) & mod] = args[i]; } return (this.length += args.length); }, pop() { if (this.length > 0) { const idx = (this.offset + --this.length) & (this.data.length - 1); const val = this.data[idx]; this.maybeShrink(); return val; } }, shift() { if (this.length > 0) { const val = this.data[this.offset]; this.offset = (this.offset + 1) & (this.data.length - 1); this.length--; this.maybeShrink(); return val; } }, slice(begin = 0, end = this.length) { begin = Math.max(begin | 0, 0); end = Math.min(end | 0, this.length); const ret = []; const { offset, data } = this; const mod = data.length - 1; for (let i = begin; i < end; i++) { ret.push(data[(i + offset) & mod]); } return circularTA.from(ret); }, // copy a typed array from the data sliceTA(begin = 0, end = this.length) { begin = Math.max(begin | 0, 0); end = Math.min(end | 0, this.length); const ret = []; const { offset, data } = this; const mod = data.length - 1; for (let i = begin; i < end; i++) { ret.push(data[(i + offset) & mod]); } return arrayConstructor.from(ret); }, map(callback) { const ret = []; const { offset, length, data } = this; const mod = data.length - 1; for (let i = 0; i < length; i++) { ret.push(callback(data[(i + offset) & mod], i)); } return circularTA.from(ret); }, filter(callback) { const ret = []; const { offset, length, data } = this; const mod = data.length - 1; for (let i = 0; i < length; i++) { const val = data[(i + offset) & mod]; if (callback(val, i)) ret.push(val); } return circularTA.from(ret); }, mapFilter( callback, begin = 0, end = this.length ) { const ret = []; const { offset, data } = this; const mod = data.length - 1; const SKIP = Symbol("mapFilter.SKIP"); for (let i = begin; i < end; i++) { const v = callback(SKIP, data[(i + offset) & mod], i); if (v !== SKIP) ret.push(/** @type {R} */ v); } return circularTA.from(ret); }, maybeGrow(newLength) { if (newLength + this.length > this.data.length) { const { data, length, offset } = this; const nData = new arrayConstructor(data.length * 2); const mod = data.length - 1; for (let i = 0; i < length; i++) { nData[i] = data[(i + offset) & mod]; } this.data = nData; this.offset = 0; } }, maybeShrink() { const capacity = this.data.length; if (this.length < (3 * capacity) / 8 && capacity > 16) { const { data, length, offset } = this; const nData = new arrayConstructor(capacity >> 1); const mod = capacity - 1; for (let i = 0; i < length; i++) { nData[i] = data[(i + offset) & mod]; } this.data = nData; this.offset = 0; } }, [Symbol.iterator]: function* () { const { data, length, offset } = this; const mod = data.length - 1; for (let i = 0; i < length; i++) { yield data[(i + offset) & mod]; } } }); return circularTA; }47:T1a8e,class CircularArray { constructor(...args) { // TODO: switch to constructor(length, ) instantiation method // TODO: clean up + don't skip holey arrays in push/unshift const capacity = Math.max(16, 2 ** Math.ceil(Math.log2(args.length + 1))); // assume all elements are of the same type as the first argument // See also: https://v8.dev/blog/elements-kinds const valKind = args.length > 0 ? args[0] : 0; const data = [valKind]; let i = 1; // fill up array with initial values while (i < args.length) data.push(args[i++]); // fill remaining capacity with same type of element as first value while (i++ < capacity) { data.push(valKind); } // Note: we don't bother storing the capacity, // as it will be equivalent to data.length this.data = data; this.length = args.length; this.offset = 0; this.autoshrink = true; } static from(array) { return new this(...array); } push(...args) { if (args.length === 0) return 0; this.maybeGrow(args.length); let i = this.offset + this.length; const mod = this.data.length - 1; // TODO: let version to not skip holes in the array for (const val of args) { this.data[i++ & mod] = val; } return (this.length += args.length); } unshift(...args) { if (args.length === 0) return 0; this.maybeGrow(args.length); const mod = this.data.length - 1; const offset = (this.offset - args.length + this.data.length) & mod; this.offset = offset; for (let i = offset; i < args.length + offset; i++) { this.data[i & mod] = args[i]; } return (this.length += args.length); } pop() { if (this.length > 0) { // Note: we're not overwriting the removed element, so this // is NOT a secure implementation of a circular buffer! // 1. we need the last element of the buffer (so length-1), // *and* we need to shrink the length by one because // we're removing that element. So we might as well // do --this.length to inline that operation. // 2. capacity is always a power of two, so instead of using // modulo we can us a bitmask: by subtracting one from // the capacity (data.length) we get a 0b111... mask. const idx = (--this.length + this.offset) & (this.data.length - 1); const val = this.data[idx]; if (this.autoshrink) this.maybeShrink(); return val; } } shift() { if (this.length > 0) { // Note: we're not overwriting the removed element, so this // is NOT a secure implementation of a circular buffer! // We have to: // - return the first element of the buffer (so this.offset) // - "remove" it from the buffer by: // - increasing the offset by one // - decreasing the length by one const val = this.data[this.offset]; this.offset = (this.offset + 1) & (this.data.length - 1); this.length--; if (this.autoshrink) this.maybeShrink(); return val; } } slice(begin = 0, end = this.length) { begin = Math.max(begin | 0, 0); end = Math.min(end | 0, this.length); if (begin >= end) return new CircularArray(); const ret = []; const { offset, data } = this; const mod = data.length - 1; for (let i = begin; i < end; i++) { ret.push(data[(i + offset) & mod]); } return CircularArray.from(ret); } map(callback) { const ret = []; const { offset, length, data } = this; const mod = data.length - 1; for (let i = 0; i < length; i++) { ret.push(callback(data[(i + offset) & mod], i, this)); } return CircularArray.from(ret); } filter(callback) { const ret = []; const { offset, length, data } = this; const mod = data.length - 1; for (let i = 0; i < length; i++) { const val = data[(i + offset) & mod]; if (callback(val, i, this)) ret.push(val); } return CircularArray.from(ret); } /** * Convenience function to replace chained calls to `.map`, * `.filter` and `.slice`, avoiding the allocation of * intermediate arrays that are immediately discarded. * * The `callback` is passed a `SKIP` symbol as its first * argument. To filter out an element, return this SKIP * symbol. Example: * * ```js * // extract `obj.value` from a given section of a circular * // array, but filter out undefined entries of `obj`. * const callback = (SKIP, obj) => obj ? obj.value : SKIP; * const values = cArray.mapFilter(array, callback, begin, end); * ``` */ mapFilter(callback, begin = 0, end = this.length) { const ret = []; const { offset, data } = this; const mod = data.length - 1; const SKIP = Symbol("mapFilter.SKIP"); for (let i = begin; i < end; i++) { const v = callback(SKIP, data[(i + offset) & mod], i); if (v !== SKIP) ret.push(v); } return CircularArray.from(ret); } maybeGrow(addedLength) { if (addedLength + this.length > this.data.length) { // We have to grow our backing array to be able to // hold more data. We double its size whenever // it is filled to capacity. let { data, length, offset } = this; const capacity = data.length; const valKind = data[offset]; for (let i = 0; i < offset; i++) { data.push(valKind); } for (let i = offset; i < capacity; i++) { data.push(data[i]); } offset += capacity; } } maybeShrink() { // We wish to shrink the backing array if the buffer gets too small, // but we also want to avoid the situation where a poorly timed // alternating push/pop will trigger constant re-allocation of // the backing array. So instead of shrinking the array at // half capacity (mimicking the doubling of growing // the backing array in push) we shrink at 3/8 capacity, but shrink // capacity in half. This results in the new buffer being 3/4 // full, reducing the odds of this disastrous re-allocation, // while maintaining the fast bitmasked modulo behavior. if (this.length < (this.data.length * 0.375 && this.data.length > 16)) { const { data, length, offset } = this; const valKind = data[offset]; const nData = [valKind]; const mod = data.length - 1; for (let i = 1; i < length; i++) { nData.push(data[(i + offset) & mod]); } for (let i = length; i < data.length >> 1; i++) { nData.push(valKind); } this.data = nData; this.offset = 0; } } *[Symbol.iterator]() { const { data, length, offset } = this; const mod = data.length - 1; for (let i = 0; i < length; i++) { yield data[(i + offset) & mod]; } } }48:[] 43:{"id":"ae1ab4fb13c9b294","slug":"circular-buffers","title":"Circular Arrays","thumbnail":"b3d8f51672cb38e7678afc7f118395d7b934cf19bc5f29766ca9b293d29eaa5e","access_level":"unlisted","create_time":"$D2021-05-16T20:37:36.632Z","update_time":"$D2023-10-03T13:17:59.940Z","view_time":null,"first_public_time":null,"has_unpublished_edits":null,"fork":false,"stars":1,"starred":false,"owner":{"type":"team","id":"3f83172cfde1e56a","login":"jobleonard","name":"Job van der Zwan","avatar_url":"https://avatars-next.observableusercontent.com/808373580aa09723ceabb9cb31d01ea6db287280b59eaa63618e259f5d28dd71","tier":"starter_2024","bio":"Tinkering with code and algorithms for fun"},"version":402,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"d36034ddfb454bdd","login":"jobleonard","name":"Job van der Zwan","avatar_url":"https://avatars-next.observableusercontent.com/808373580aa09723ceabb9cb31d01ea6db287280b59eaa63618e259f5d28dd71","tier":null,"bio":"Tinkering with code and algorithms for fun"}],"members":[{"type":"individual","id":"d36034ddfb454bdd","login":"jobleonard","name":"Job van der Zwan","avatar_url":"https://avatars-next.observableusercontent.com/808373580aa09723ceabb9cb31d01ea6db287280b59eaa63618e259f5d28dd71","tier":null,"role":"editor"},{"type":"individual","id":"07362516b5994994","login":"mootari","name":"Fabian Iwand","avatar_url":"https://avatars-next.observableusercontent.com/0d7defa821f38094c03bad23b9b360a5364e6e97e21fc238c39ddc48db7994ad","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Circular Arrays","cells":[{"id":0,"value":"$45","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":167,"value":"{\n const cArray = CircularArray.from([-3, -2, -1]);\n for (let i = 0; i < 64; i++) {\n cArray.push(i);\n cArray.shift();\n }\n return {\n cArray,\n array: [...cArray] // convert to plain array\n };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":173,"value":"Most JavaScript engines are *really* good at optimizing arrays to fit the data type, so `CirculraArray` should be good enough in most cases. Sometimes however you might want to use a `TypedArray` instead. For convenience, specialized forms exist for each array type:\n\n- `CircularF64`\n- `CircularF32`\n- `CircularI32`\n- `CircularU32`\n- `CircularI16`\n- `CircularU16`\n- `CircularI8`\n- `CircularU8`\n- `CircularU8c`\n\nThey are equivalent to the `CircularArray` version except for the type of backing array (and hence the type of data that they can contain).\n\nTo use any of these circular arrays in your notebooks, either import them individually when needed, or import the following single `Circular` object what contains all of them:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":9,"value":"Circular = ({\n Array: CircularArray,\n F64: CircularF64,\n F32: CircularF32,\n I32: CircularI32,\n U32: CircularU32,\n I16: CircularI16,\n U16: CircularU16,\n I8: CircularI8,\n U8: CircularU8,\n U8c: CircularU8c\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":275,"value":"new CircularArray(...[10, 2, 3])","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":374,"value":"$46","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":180,"value":"CircularF64 = makeCircularPrototype(Float64Array, \"CircularF64\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":182,"value":"CircularF32 = makeCircularPrototype(Float32Array, \"CircularF32\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":150,"value":"$47","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":184,"value":"CircularI32 = makeCircularPrototype(Int32Array, \"CircularI32\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":186,"value":"CircularU32 = makeCircularPrototype(Uint32Array, \"CircularU32\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":188,"value":"CircularI16 = makeCircularPrototype(Int16Array, \"CircularI16\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":191,"value":"CircularU16 = makeCircularPrototype(Uint16Array, \"CircularU16\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":193,"value":"CircularI8 = makeCircularPrototype(Int8Array, \"CircularI8\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":195,"value":"CircularU8 = makeCircularPrototype(Uint8Array, \"CircularU8\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":197,"value":"CircularU8c = makeCircularPrototype(Uint8ClampedArray, \"CircularU8c\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":305,"value":"({[Symbol.toStringTag]: 'foo'}).toString()","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":367,"value":"{\n const bytes = new Uint8Array(83086);\n for (let i = 0; i < bytes.length; i++) { bytes[i] = Math.random() * 256 | 0;}\n return CircularU8.from(bytes)\n}\n","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":19,"value":"{\n const t = CircularArray.from([4, 5, 6]);\n for (let i = 0; i < 16; i++) {\n t.push(i);\n }\n return { t, array: [...t] };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":33,"value":"{\n const t = new CircularArray(4, 5, 6);\n for (let i = 0; i < 63; i++) {\n t.shift();\n t.push(i);\n }\n return { t, splat: [...t] };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":44,"value":"{\n const t = new CircularArray(4, 5, 6);\n for (let i = 0; i < 64; i++) {\n t.unshift(i);\n }\n return t;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":46,"value":"{\n const t = new CircularArray(4, 5, 6);\n for (let i = 0; i < 32; i++) {\n t.push(i);\n t.push(i);\n t.unshift(-i);\n t.unshift(-i);\n t.shift();\n t.pop();\n }\n return { t, splat: [...t] };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":57,"value":"{\n const t = new CircularArray(4, 5, 6);\n for (let i = 0; i < 1024; i++) {\n t.push(i);\n }\n for (let i = 0; i < 1024; i++) {\n t.shift();\n }\n return { t, splat: [...t] };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":145,"value":"{\n const t = new CircularArray(-3, -2, -1);\n for (let i = 0; i < 1024; i++) {\n t.push(i);\n }\n const t2 = t.filter((v) => v & 1);\n const t3 = t2.map((v) => v / 2);\n const t4 = t3.slice(10, 20);\n return { t, t2, t3, t4 };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":133,"value":"{\n const t = new CircularF64(4, 5, 6);\n for (let i = 0; i < 1024; i++) {\n t.push(i / 3);\n }\n for (let i = 0; i < 1024; i++) {\n t.shift();\n }\n return { t, splat: [...t] };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":119,"value":"{\n const t = new CircularF32(4, 5, 6);\n for (let i = 0; i < 1024; i++) {\n t.push(i / 3);\n }\n for (let i = 0; i < 1024; i++) {\n t.shift();\n }\n return { t, splat: [...t] };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":101,"value":"{\n const t = new CircularU8(4);\n for (let i = 0; i < 1024; i++) {\n t.push(i);\n }\n for (let i = 0; i < 1024; i++) {\n t.shift();\n }\n return { t, splat: [...t] };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":112,"value":"{\n const t = new CircularU8c(4);\n for (let i = 0; i < 1024; i++) {\n t.push(i);\n }\n for (let i = 0; i < 1024; i++) {\n t.shift();\n }\n return { t, splat: [...t] };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W48","stdlib":"1"}} 44:"$43:body"