@cgtk/std 0.0.188 → 0.0.189

package/http.d.ts

@@ -1,7 +1,7 @@
 export declare const assertStatus: (status: number) => (resp: Response) => void;
 export declare const contentLength: (response: Response) => number;
 export declare const toByteArray: (stream: ReadableStream<Uint8Array>) => Promise<Uint8Array<ArrayBufferLike>>;
-export declare const fetchBuffer: (url: string, init?: RequestInit) => Promise<Uint8Array<ArrayBufferLike>>;
+export declare const fetchBuffer: (url: string | URL | Request, init?: RequestInit) => Promise<Uint8Array<ArrayBufferLike>>;
 export declare const fetchText: (url: string, init?: RequestInit) => Promise<string>;
 export declare const fetchDOM: (url: string, init?: RequestInit) => Promise<HTMLElement>;
 export declare const fetchImage: (src: string) => Promise<HTMLImageElement>;

package/package.json

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

package/struct.d.ts

@@ -1,19 +1,21 @@
-import type { TypedArray, Fn } from "./types";
+import type { TypedArray, BigIntArray, Fn } from "./types";
 import type { Constructor } from "./typedarray";
 export interface Type {
     size: number;
     align: number;
 }
-export type Vec<T extends TypedArray, N extends number> = Type & {
+export type Vec<T extends TypedArray | BigIntArray, N extends number> = Type & {
     length: N;
     type: Constructor<T>;
 };
 export declare const u8: <N extends number = 1>(length?: N, align?: number) => Vec<Uint8Array<ArrayBufferLike>, N>;
 export declare const u16: <N extends number = 1>(length?: N, align?: number) => Vec<Uint16Array<ArrayBufferLike>, N>;
 export declare const u32: <N extends number = 1>(length?: N, align?: number) => Vec<Uint32Array<ArrayBufferLike>, N>;
+export declare const u64: <N extends number = 1>(length?: N, align?: number) => Vec<BigUint64Array<ArrayBufferLike>, N>;
 export declare const i8: <N extends number = 1>(length?: N, align?: number) => Vec<Int8Array<ArrayBufferLike>, N>;
 export declare const i16: <N extends number = 1>(length?: N, align?: number) => Vec<Int16Array<ArrayBufferLike>, N>;
 export declare const i32: <N extends number = 1>(length?: N, align?: number) => Vec<Int32Array<ArrayBufferLike>, N>;
+export declare const i64: <N extends number = 1>(length?: N, align?: number) => Vec<BigInt64Array<ArrayBufferLike>, N>;
 export declare const f16: <N extends number = 1>(length?: N, align?: number) => Vec<Float16Array<ArrayBufferLike>, N>;
 export declare const f32: <N extends number = 1>(length?: N, align?: number) => Vec<Float32Array<ArrayBufferLike>, N>;
 export declare const f64: <N extends number = 1>(length?: N, align?: number) => Vec<Float64Array<ArrayBufferLike>, N>;
@@ -24,7 +26,7 @@ export type Array<T extends Type> = Type & {
 };
 export declare const isArray: (t: any) => t is Array<any>;
 export declare const array: <T extends Type>(type: T, length: number, align?: number) => Array<T>;
-type Field<T extends Type> = readonly [name: string, type: T, aligb?: number];
+type Field<T extends Type> = readonly [name: string, type: T, align?: number];
 export type Struct<T extends ReadonlyArray<Field<any>>> = Type & {
     fields: {
         [K in T[number] as K[0]]: K[1];

package/struct.js

@@ -6,9 +6,11 @@ const vec = (type) => (length = 1, align = type.BYTES_PER_ELEMENT) => ({
 export const u8 = vec(Uint8Array);
 export const u16 = vec(Uint16Array);
 export const u32 = vec(Uint32Array);
+export const u64 = vec(BigUint64Array);
 export const i8 = vec(Int8Array);
 export const i16 = vec(Int16Array);
 export const i32 = vec(Int32Array);
+export const i64 = vec(BigInt64Array);
 export const f16 = vec(Float16Array);
 export const f32 = vec(Float32Array);
 export const f64 = vec(Float64Array);

package/typedarray.d.ts

@@ -1,10 +1,10 @@
-import type { Fn, FnV, TypedArray, BufferType, Numbers } from "./types";
-export interface Constructor<T extends TypedArray> {
+import type { Fn, FnV, TypedArray, BigIntArray, BufferType, Numbers } from "./types";
+export interface Constructor<T extends TypedArray | BigIntArray> {
     new (length: number): T;
     new (buffer: BufferType<T> | ArrayBufferLike, byteOffset?: number, length?: number): T;
     readonly BYTES_PER_ELEMENT: number;
-    of(...items: number[]): T;
-    from(arrayLike: ArrayLike<number>): T;
+    of(...items: number[] | bigint[]): T;
+    from(arrayLike: ArrayLike<number | bigint>): T;
 }
 export type View<T extends TypedArray> = FnV<[BufferType<T>?, number?], T>;
 export declare const view: <T extends TypedArray>(type: Constructor<T>, length: number) => View<T>;

package/types.d.ts

@@ -39,7 +39,8 @@ export type EntriesTuple<T, K extends UnionToTuple<keyof T> = UnionToTuple<keyof
     [I in keyof K]: K[I] extends keyof T ? [K[I], T[K[I]]] : never;
 };
 export type TypedArray<T extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<T> | Uint16Array<T> | Uint32Array<T> | Int8Array<T> | Int16Array<T> | Int32Array<T> | Float16Array<T> | Float32Array<T> | Float64Array<T>;
-export type BufferType<T extends TypedArray> = T extends TypedArray<infer S> ? S : never;
+export type BigIntArray<T extends ArrayBufferLike = ArrayBufferLike> = BigUint64Array<T> | BigInt64Array<T>;
+export type BufferType<T extends TypedArray | BigIntArray> = T extends TypedArray<infer S> ? S : T extends BigIntArray<infer S> ? S : never;
 export type Numbers = Array<number> | TypedArray;
 export type Eq<A, B = A> = FnV<[A, B], boolean>;
 export type Pred<T> = Fn<T, boolean>;