@cgtk/std 0.0.198 → 0.0.200

package/array.d.ts

@@ -18,3 +18,4 @@ export declare const unique: <T>(vals: T[], compareFn?: (a: T, b: T) => number)
     inverse: number[];
 };
 export declare const argsort: <T>(arr: T[], compareFn?: (a: T, b: T) => number) => number[];
+export declare const list: <T>(...xs: (T | boolean)[]) => T[];

package/array.js

@@ -37,3 +37,4 @@ export const argsort = (arr, compareFn = compare) => arr
     .map((x, i) => [x, i])
     .sort((a, b) => compareFn(a[0], b[0]))
     .map(x => x[1]);
+export const list = (...xs) => xs.filter(x => typeof x !== "boolean");

package/channel.d.ts

@@ -3,7 +3,6 @@ export interface Channel<T> {
     next: Fn<T>;
     on(next: Fn<T>, done?: Dispose): Dispose;
     done: Dispose;
-    stateful(f: Fn<T, Dispose>, done?: Dispose): Dispose;
     to<S>(f: Fn<Channel<T>, Channel<S>>): Channel<S>;
 }
 export declare const create: <T>(subs?: Set<{
@@ -20,8 +19,10 @@ export declare const map: <T, S>(f: Fn<T, S>, ch?: Channel<S>) => Fn<Channel<T>,
 export declare const filter: <T>(p: Pred<T>, ch?: Channel<T>) => Fn<Channel<T>, Channel<T>>;
 export declare const then: <T>(ch?: Channel<T>) => Fn<Channel<Promise<T>>, Channel<T>>;
 export declare const dedup: <T, S = T>(key?: Fn<T, S>, ch?: Channel<T>) => Fn<Channel<T>, Channel<T>>;
+export declare const swapping: () => <T>(c: Channel<T>) => Channel<T>;
 export declare const gen: <T>(f: FnV<[Fn<T>, Dispose], Dispose | void>, ch?: Channel<T>) => Channel<T>;
 export declare const reduce: <T, S>(f: FnV<[S, T], S>, a: S, ch?: Channel<S>) => (c: Channel<T>) => Channel<S>;
+export declare const clearing: <T>(c: Channel<T>) => Channel<T>;
 export declare const flatten: <T>(ch?: Channel<T>) => (cs: Channel<Channel<T>>) => Channel<T>;
 export declare const latest: <T>(ch?: Channel<T>) => (cs: Channel<Channel<T>>) => Channel<T>;
 export declare const microOn: <T>(ch?: Channel<T>) => Channel<T>;

package/channel.js

@@ -4,10 +4,6 @@ import { add } from "./set.js";
 const channel = (next, on, done = F.noop) => ({
     next, on, done,
     to(f) { return f(this); },
-    stateful(next, done = F.noop) {
-        const swap = F.swapping();
-        return on(swap(next), swap(done));
-    },
 });
 export const create = (subs = new Set()) => channel((x) => subs.forEach(s => s.next(x)), (next, done = F.noop) => {
     const del = add(subs, { next, done });
@@ -42,18 +38,26 @@ export const dedup = (key = F.identity, ch) => pipe(next => {
         x = k;
     };
 }, ch);
+export const swapping = () => (c) => {
+    const swap = F.swapping();
+    return channel(c.next, (next, done = F.noop) => c.on(swap(next), swap(done)), c.done);
+};
 export const gen = (f, ch = create()) => {
     let ended = false;
     let done = () => { ended = true; };
     done = F.forEach(f(ch.next, () => done()) ?? F.noop, ch.done);
     return ended ? channel(F.noop, F.constantly(F.noop)) : channel(ch.next, ch.on, done);
 };
-export const reduce = (f, a, ch = create()) => (c) => channel(F.noop, ch.on, c.on(F.scan(f, a), F.forEach(() => ch.next(a), ch.done)));
+export const reduce = (f, a, ch = create()) => (c) => channel(F.noop, (next, done = F.noop) => ch.on(next, F.forEach(() => next(a), done)), c.on(x => a = f(a, x), ch.done));
+export const clearing = (c) => {
+    let clear = F.noop;
+    return channel(c.next, (next, done = F.noop) => c.on(x => clear = next(x) ?? F.noop, F.forEach(() => clear(), done)), c.done);
+};
 export const flatten = (ch = create()) => (cs) => {
     const ds = new Set();
     return channel(ch.next, ch.on, cs.on(c => (ds.add(c.done), c.on(ch.next)), F.forEach(ch.done, () => ds.forEach(d => d()))));
 };
-export const latest = (ch = create()) => (cs) => channel(ch.next, ch.on, cs.stateful(c => c.on(ch.next, c.done), ch.done));
+export const latest = (ch = create()) => (cs) => channel(ch.next, ch.on, cs.to(swapping()).on(c => c.on(ch.next, c.done), ch.done));
 export const microOn = (ch = create()) => channel(ch.next, (next, done = F.noop) => {
     const ctrl = new AbortController();
     let off = () => (ctrl.abort(), done());

package/dom.d.ts

@@ -49,7 +49,7 @@ export declare const preventDefault: <T extends Event>(e: T) => void;
 export declare const loadImage: (img: HTMLImageElement, src: string) => Promise<HTMLImageElement>;
 export declare const pushState: (path: string, query?: RecordOf<string>, data?: any) => void;
 export declare const qs: (search?: string) => Maybe<RecordOf<string>>;
-export declare const imageData: (img: HTMLImageElement) => ImageData;
+export declare const imageData: (img: ImageBitmap) => ImageData;
 export type Child = ChildNode | string;
 export declare const append: (el: ParentNode, ...children: Child[]) => () => void;
 export type Attribs = Record<string, string | number | boolean>;

package/dom.js

@@ -41,9 +41,20 @@ export const qs = (search = location.search) => search.length > 0
     ? Object.fromEntries(new URLSearchParams(search).entries())
     : undefined;
 export const imageData = (img) => {
-    const ctx = new OffscreenCanvas(img.width, img.height).getContext("2d");
-    ctx.drawImage(img, 0, 0);
-    return ctx.getImageData(0, 0, img.width, img.height);
+    const canvas = new OffscreenCanvas(img.width, img.height);
+    const gl = canvas.getContext("webgl2");
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, img.width, img.height);
+    gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, img.width, img.height, gl.RGBA, gl.UNSIGNED_BYTE, img);
+    const fb = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+    const pixels = new Uint8ClampedArray(img.width * img.height * 4);
+    gl.readPixels(0, 0, img.width, img.height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+    gl.deleteFramebuffer(fb);
+    gl.deleteTexture(texture);
+    return new ImageData(pixels, img.width, img.height);
 };
 export const append = (el, ...children) => {
     const els = children.map(x => isString(x) ? document.createTextNode(x) : x);

package/fn.d.ts

@@ -2,7 +2,7 @@ import type { Fn, FnV, FnF, Pred, Last, Lazy, Dispose, Reactive, Promisified, Ma
 export declare const tee: <T>(f: Fn<T, void>) => Fn<T, T>;
 export declare const comp: <Fs extends Fn[]>(...fs: Fs) => (x: Fs[0] extends Fn<infer T> ? T : never) => Last<Fs> extends Fn<any, infer R> ? R : never;
 export declare const pipe: <T, Fs extends [Fn<T>, ...Fn[]]>(x: T, ...fs: Fs) => Last<Fs> extends Fn<any, infer R> ? R : never;
-export declare const forEach: <T, R = any>(...fs: Fn<T, R>[]) => (x: T) => void;
+export declare const forEach: <T extends any[], R = any>(...fs: FnV<T, R>[]) => (...x: T) => void;
 export declare const and: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
 export declare const or: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
 export declare const not: <T>(p: Pred<T>) => (x: T) => boolean;
@@ -18,13 +18,12 @@ export declare const before: <F extends Fn<void>>(f: F) => FnF;
 export declare const after: <F extends Fn<void>>(f: F) => FnF;
 export declare const filter: <T>(p: Pred<T>, f: Fn<T>) => (x: T) => void;
 export declare const scan: <T, S>(f: FnV<[S, T], S>, a: S) => Fn<T, S>;
-export declare const memoize: <T extends any[], K, V>(f: FnV<T, V>, key?: FnV<T, K>, cache?: Map<K, V>) => (...xs: T) => NonNullable<V>;
+export declare const memoize: <T extends any[], K, V>(f: FnV<T, V>, key?: FnV<T, K>, cache?: Map<K, V>) => (...xs: T) => V;
 export declare const abortable: <T = any>(f: Fn<AbortSignal>) => (reason?: T) => void;
 export declare const disposable: (f: Fn<Fn<Dispose, Dispose>>, disposes?: Set<Dispose>) => Dispose;
 export declare const swapping: () => <F extends FnV<any[], Dispose | void>>(f: F) => FnV<Parameters<F>, Dispose>;
 export declare const idemp: <F extends FnV<any[], Dispose | void>>(d: Fn<Dispose, Dispose>, f: F) => FnV<Parameters<F>, Dispose>;
 export declare const toggler: (f: Fn<void, Dispose>) => Fn<boolean, Dispose>;
-export declare const voidify: <F extends FnV>(f: F) => (...xs: Parameters<F>) => void;
 export declare const effectual: <T>(f: Reactive<T>, g: Fn<T>) => Dispose;
 export declare const promisify: <F extends FnV>(f: F) => (...xs: Parameters<F>) => Promisified<ReturnType<F>>;
 export declare const then: <T, F extends FnV<any, MaybePromise<any>>>(f: F, g?: Fn<Awaited<ReturnType<F>>, T>) => (...xs: Parameters<F>) => Promise<T>;

package/fn.js

@@ -4,7 +4,8 @@ import { isPromise } from "./checks.js";
 export const tee = f => x => (f(x), x);
 export const comp = (...fs) => (x) => fs.reduce((x, f) => f(x), x);
 export const pipe = (x, ...fs) => fs.reduce((x, f) => f(x), x);
-export const forEach = (...fs) => (x) => fs.forEach(f => f(x));
+// export const forEach = <T, R = any>(...fs: Fn<T, R>[]) => (x: T) => fs.forEach(f => f(x));
+export const forEach = (...fs) => (...x) => fs.forEach(f => f(...x));
 export const and = (...fs) => (x) => fs.reduce((a, f) => a && f(x), true);
 export const or = (...fs) => (x) => fs.reduce((a, f) => a || f(x), false);
 export const not = (p) => (x) => !p(x);
@@ -25,12 +26,7 @@ export const after = (f) => g => (...xs) => {
 export const filter = (p, f) => (x) => { if (p(x))
     f(x); };
 export const scan = (f, a) => (x) => a = f(a, x);
-export const memoize = (f, key = (...xs) => xs[0], cache = new Map()) => (...xs) => {
-    const k = key(...xs);
-    if (!cache.has(k))
-        cache.set(k, f(...xs));
-    return cache.get(k);
-};
+export const memoize = (f, key = (...xs) => xs[0], cache = new Map()) => (...xs) => cache.getOrInsertComputed(key(...xs), () => f(...xs));
 export const abortable = (f) => {
     const ctrl = new AbortController();
     f(ctrl.signal);
@@ -54,7 +50,6 @@ export const toggler = (f) => {
     const stop = () => cancel();
     return (x) => (stop(), (cancel = x ? f() : noop), stop);
 };
-export const voidify = (f) => (...xs) => { f(...xs); };
 export const effectual = (f, g) => disposable(d => d(f(idemp(d, g))));
 export const promisify = (f) => (...xs) => Async.promisify(f(...xs));
 export const then = (f, g = identity) => (...xs) => {

package/http.js

@@ -21,7 +21,7 @@ export const fetchImage = (src) => new Promise((resolve, reject) => {
 export const fetchImageBitmap = async (url, init) => fetch(url, init)
     .then(tee(assertStatus(200)))
     .then(resp => resp.blob())
-    .then(blob => createImageBitmap(blob, { colorSpaceConversion: "none" }));
+    .then(blob => createImageBitmap(blob, { colorSpaceConversion: "none", premultiplyAlpha: "none" }));
 export const fetchJSON = (url, init) => fetchText(url, init).then(JSON.parse);
 export const fetchDataUrl = (url, init) => fetch(url, init)
     .then(tee(assertStatus(200)))

package/map.d.ts

@@ -10,3 +10,4 @@ export declare const update: <K, V>(m: Map<K, V>, k: K, f: FnV<[V | undefined, K
 export declare const first: <K, V>(m: Map<K, V>) => Maybe<V>;
 export declare const shift: <K, V>(m: Map<K, V>) => Maybe<[K, V]>;
 export declare const reduce: <K, V, T>(m: Map<K, V>, f: FnV<[T, V, K, Map<K, V>], T>, a: T) => T;
+export declare const mapValues: <K, T, S>(m: Map<K, T>, f: FnV<[T, K], S>) => Map<K, S>;

package/map.js

@@ -33,3 +33,4 @@ export const shift = (m) => {
     return undefined;
 };
 export const reduce = (m, f, a) => (m.forEach((v, k) => a = f(a, v, k, m)), a);
+export const mapValues = (m, f) => new Map(m.entries().map(([k, v]) => [k, f(v, k)]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.198",
+  "version": "0.0.200",
   "type": "module",
   "main": "./index.js",
   "exports": {

package/rect.d.ts

@@ -1,5 +1,6 @@
 import type { Tuple } from "./types.js";
 export type Rect = Tuple<number, 4>;
 export declare const rect: (x: number, y: number, w: number, h: number) => Rect;
-export declare const vertical: (ratio: number[]) => (i: number) => ([x, _, w, h]: Rect) => Rect;
-export declare const horizontal: (ratio: number[]) => (i: number) => ([_, y, w, h]: Rect) => Rect;
+export declare const aspect: ([_x, _y, w, h]: Rect) => number;
+export declare const vsplit: (ratio: number[], [x, y, w, h]: Rect) => Rect[];
+export declare const hsplit: (ratio: number[], [x, y, w, h]: Rect) => Rect[];

package/rect.js

@@ -1,16 +1,14 @@
 import { add } from "./number.js";
+import { push, pop } from "./array.js";
 export const rect = (x, y, w, h) => [x, y, w, h];
-export const vertical = (ratio) => {
+export const aspect = ([_x, _y, w, h]) => w / h;
+export const vsplit = (ratio, [x, y, w, h]) => {
     const tot = ratio.reduce(add, 0);
-    const cum = [0];
-    ratio.forEach(x => cum.push(x / tot + cum[cum.length - 1]));
-    cum.pop();
-    return (i) => ([x, _, w, h]) => [x, cum[i] * h, w, ratio[i] / tot * h];
+    const cum = pop(ratio.reduce((a, x) => push(a, x / tot + a.at(-1)), [0]));
+    return ratio.map((r, i) => [x, y + cum[i] * h, w, r / tot * h]);
 };
-export const horizontal = (ratio) => {
+export const hsplit = (ratio, [x, y, w, h]) => {
     const tot = ratio.reduce(add, 0);
-    const cum = [0];
-    ratio.forEach(x => cum.push(x / tot + cum[cum.length - 1]));
-    cum.pop();
-    return (i) => ([_, y, w, h]) => [cum[i] * w, y, ratio[i] / tot * w, h];
+    const cum = pop(ratio.reduce((a, x) => push(a, x / tot + a.at(-1)), [0]));
+    return ratio.map((r, i) => [x + cum[i] * w, y, r / tot * w, h]);
 };

package/schedule.d.ts

@@ -2,7 +2,6 @@ import type { Dispose, Fn, FnV, Reactive } from './types.js';
 export declare const raf: Reactive<number>;
 export declare const timeout: (ms?: number) => Reactive<void>;
 export declare const schedule: <T>(s: Reactive<T>) => <F extends FnV>(f: F) => FnV<Parameters<F>, Dispose>;
-export declare const idempotent: <T>(s: Reactive<T>, d: Fn<Dispose, Dispose>) => <F extends FnV>(f: F) => FnV<Parameters<F>, Dispose>;
 export declare const debounce: <T>(sched?: Reactive<T>) => Reactive<T>;
 export declare const reset: <T>(sched?: Reactive<T>) => Reactive<T>;
 export declare const repeatedly: <T = number>(sched?: Reactive<T>) => (f: Fn<T, boolean | void>) => () => any;

package/schedule.js

@@ -1,9 +1,8 @@
 import { isUndefined, isDefined, counted } from './checks.js';
-import { comp, lazy, bind, apply, call, where, swapping, noop, abortable } from './fn.js';
+import { comp, lazy, bind, apply, call, where, noop, abortable } from './fn.js';
 export const raf = f => bind(cancelAnimationFrame, requestAnimationFrame(f));
 export const timeout = (ms = 0) => f => bind(clearTimeout, setTimeout(f, ms));
 export const schedule = (s) => (f) => call(comp(apply(bind((lazy), f)), s));
-export const idempotent = (s, d) => (f) => swapping()((...xs) => d(s(() => f(...xs))));
 export const debounce = (sched = raf) => {
     let cancel;
     const stop = () => { if (isDefined(cancel))

package/scope.d.ts

@@ -14,6 +14,5 @@ export declare const compose: <R extends Structure<Scope<any>>>(rs: R) => Scope<
 export declare const of: <T>(x: T, f: Fn<T, Dispose>) => Scope<T>;
 type Use = <T>(r: Scope<T>) => T;
 export declare const gen: <R>(f: FnV<[Use, Fn<Dispose, Dispose>], R>) => Scope<R>;
-export declare const consume: (f: Fn<Use, Dispose | void>) => Dispose;
 export declare const worker: (w: Worker) => Scope<Worker>;
 export {};

package/scope.js

@@ -29,13 +29,11 @@ export const compose = (rs) => {
         }
         return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
     };
-    const value = rec(rs);
-    return scope(value, F.forEach(...disposes));
+    return scope(rec(rs), F.forEach(...disposes));
 };
 export const of = (x, f) => scope(x, f(x));
 export const gen = (f) => {
     const res = new Set();
     return scope(f(r => (res.add(r.dispose), r.value), F.bind(add, res)), () => res.forEach(f => f()));
 };
-export const consume = (f) => F.disposable(use => use(f(r => (use(r.dispose), r.value)) ?? F.noop));
 export const worker = (w) => of(w, x => x.terminate.bind(x));

package/set.d.ts

@@ -1,2 +1,3 @@
 export declare const add: <T>(xs: Set<T>, x: T) => () => boolean;
 export declare const isEqual: <T>(a: Set<T>, b: Set<T>) => boolean;
+export declare const set: <T>(...xs: (T | boolean)[]) => Set<T>;

package/set.js

@@ -1,2 +1,4 @@
+import { list } from "./array.js";
 export const add = (xs, x) => (xs.add(x), () => xs.delete(x));
 export const isEqual = (a, b) => a.size == b.size && a.isSubsetOf(b) && b.isSubsetOf(a);
+export const set = (...xs) => new Set(list(...xs));

package/string.d.ts

@@ -6,4 +6,5 @@ export declare const objectURL: (data: Uint8Array<ArrayBuffer>, type: string) =>
 export declare const decode: (label?: string, opts?: TextDecoderOptions) => (x: Uint8Array, stream?: boolean) => string;
 export declare const readLine: (delims?: Set<number>) => (data: Uint8Array, offset?: number) => string;
 export declare const DATA_URL: RegExp;
-export declare const came2kebab: (s: string) => string;
+export declare const camelTo: (s: string, delim?: string) => string;
+export declare const join: (sep: string, ...xs: Array<string | undefined>) => string;

package/string.js

@@ -1,5 +1,6 @@
 import { EMPTY } from "./constants.js";
 import { seek } from "./array.js";
+import { isDefined } from "./checks.js";
 export const basename = (path) => path.split("/").at(-1) ?? "";
 export const dirname = (path) => {
     const parts = path.split("/");
@@ -27,4 +28,5 @@ export const readLine = (delims = new Set([0x0A])) => {
     };
 };
 export const DATA_URL = /^data:(?<mime>[\w/\-\+]+)?(;(?<params>[\w\-]+\=[^;,\s]+)*)?(;(?<encoding>base64))?,(?<data>.*)$/;
-export const came2kebab = (s) => s.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
+export const camelTo = (s, delim = "-") => s.replace(/[A-Z]/g, m => delim + m.toLowerCase());
+export const join = (sep, ...xs) => xs.filter(isDefined).join(sep);

package/treemap.js

@@ -1,6 +1,5 @@
 import { before } from "./fn.js";
 import { isDefined } from "./checks.js";
-import { EMPTY } from "./constants.js";
 export const treemap = () => {
     const nodes = new Set();
     const parents = new Map();
@@ -10,20 +9,17 @@ export const treemap = () => {
         const hasChanged = changed;
         if (hasChanged) {
             children.clear();
-            for (const k of nodes) {
+            nodes.forEach(k => {
                 const p = parents.get(k);
-                if (isDefined(p)) {
-                    if (!children.has(p))
-                        children.set(p, []);
-                    children.get(p).push(k);
-                }
-            }
+                if (isDefined(p))
+                    children.getOrInsert(p, []).push(k);
+            });
             changed = false;
         }
         return hasChanged;
     };
     const updated = before(update);
-    const getChildren = updated((key) => children.get(key) ?? EMPTY.LIST);
+    const getChildren = updated((key) => children.getOrInsert(key, []));
     const parent = updated((key) => parents.get(key));
     const roots = () => nodes.values().filter(k => !parents.has(k));
     return {

package/typedarray.d.ts

@@ -1,4 +1,4 @@
-import type { FnV, TypedArray, NumberArray, BufferType, Number } from "./types.js";
+import type { FnV, TypedArray, NumberArray, BufferType, Number, Tuple } from "./types.js";
 export interface Constructor<T extends TypedArray> {
     new (length: number): T;
     new (buffer: BufferType<T> | ArrayBufferLike, byteOffset?: number, length?: number): T;
@@ -24,7 +24,8 @@ export declare const ctor: <T extends TypedArray>(x: T) => Constructor<T>;
 export declare const emptyLike: <T extends TypedArray>(x: T) => T;
 export declare const set: <T extends TypedArray>(xs: T, x: ArrayLike<Number<T>> | T, i: number) => T;
 export declare const concat: <T extends TypedArray>(chunks: T[]) => T;
-export declare const iter: <T extends TypedArray>(data: T, size: number, stride?: number) => Generator<T>;
+export declare const extent: (arr: NumberArray) => Tuple<number, 2>;
+export declare const iter: <T extends TypedArray>(data: T, size: number, stride?: number, loop?: boolean) => Generator<T>;
 export declare const tile: (n: number) => (out: TypedArray, x: TypedArray) => TypedArray;
 export declare const tileEvery: (m: number, n: number) => <T extends TypedArray>(xs: T, out?: T) => T;
 export declare const strided: <T extends TypedArray>(data: T, size: number, stride?: number, out?: T) => T;

package/typedarray.js

@@ -1,6 +1,6 @@
 import { bind } from "./fn.js";
 import { zmap } from "./iterable.js";
-import { push } from "./array.js";
+import { push, tuple } from "./array.js";
 export const view = (type, length) => (buf = new ArrayBuffer(type.BYTES_PER_ELEMENT * length), offset = 0) => new type(buf, offset, length);
 export const u8 = bind((view), Uint8Array);
 export const u16 = bind((view), Uint16Array);
@@ -22,11 +22,32 @@ export const concat = (chunks) => {
     chunks.reduce((offset, chunk) => (out.set(chunk, offset), offset + chunk.length), 0);
     return out;
 };
-export const iter = function* (data, size, stride = size) {
+export const extent = (arr) => {
+    let min = Number.POSITIVE_INFINITY, max = Number.NEGATIVE_INFINITY;
+    arr.forEach(x => (min = Math.min(min, x), max = Math.max(max, x)));
+    return tuple(min, max);
+};
+export const iter = function* (data, size, stride = size, loop = false) {
     const C = ctor(data);
-    for (let i = 0, n = data.length; i < n - size + 1; i += stride) {
-        const offset = data.byteOffset + i * C.BYTES_PER_ELEMENT;
-        yield new C(data.buffer, offset, size);
+    if (loop) {
+        for (let i = 0, n = data.length; i < n; i += stride) {
+            if (i + size < n) {
+                const offset = data.byteOffset + i * C.BYTES_PER_ELEMENT;
+                yield new C(data.buffer, offset, size);
+            }
+            else {
+                const buf = new C(size);
+                for (let j = 0; j < size; j++)
+                    buf[j] = data[(i + j) % n];
+                yield buf;
+            }
+        }
+    }
+    else {
+        for (let i = 0, n = data.length; i < n - size + 1; i += stride) {
+            const offset = data.byteOffset + i * C.BYTES_PER_ELEMENT;
+            yield new C(data.buffer, offset, size);
+        }
     }
 };
 export const tile = (n) => (out, x) => {