@cgtk/std 0.0.188 → 0.0.190

package/checks.d.ts

@@ -1,5 +1,6 @@
-import type { TypedArray, Pred, TPred, Optional, Numbers } from "./types";
+import type { TypedArray, BigIntArray, Pred, TPred, Optional, Numbers } from "./types";
 export declare const isTypedArray: (x: any) => x is TypedArray;
+export declare const isBigIntArray: (x: any) => x is BigIntArray;
 export declare const isUndefined: (x: any) => x is undefined;
 export declare const isNull: (x: any) => x is null;
 export declare const isDefined: <T>(x: Optional<T>) => x is T;

package/checks.js

@@ -4,6 +4,7 @@ export const isTypedArray = (x) => x && (x instanceof Uint8Array || x instanceof
     x instanceof Uint16Array || x instanceof Uint32Array ||
     x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
     x instanceof Float32Array || x instanceof Float64Array);
+export const isBigIntArray = (x) => x && (x instanceof BigUint64Array || x instanceof BigInt64Array);
 export const isUndefined = (x) => x === undefined;
 export const isNull = (x) => x === null;
 export const isDefined = (x) => !isUndefined(x);

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.190",
   "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];
@@ -34,7 +36,7 @@ export type Struct<T extends ReadonlyArray<Field<any>>> = Type & {
 export declare const isStruct: (t: any) => t is Struct<any>;
 export declare const struct: <T extends ReadonlyArray<Field<any>>>(fs: T, align?: number, offset?: number) => Struct<T>;
 export type View<T extends Type> = T extends Vec<infer C, any> ? C : T extends Array<infer S> ? View<S>[] : T extends Struct<infer F> ? {
-    [K in F[number] as K[0]]: K[1] extends Vec<infer C, infer N> ? (N extends 1 ? number : C) : View<K[1]>;
+    [K in F[number] as K[0]]: K[1] extends Vec<infer C, infer N> ? (N extends 1 ? (C extends TypedArray ? number : bigint) : C) : View<K[1]>;
 } : never;
 export declare const view: <T extends Vec<any, any> | Array<any> | Struct<any>>(t: T, buf?: ArrayBufferLike, offset?: number) => View<T>;
 export {};

package/struct.js

@@ -1,14 +1,16 @@
 import { align as _align } from "./math";
-import { isTypedArray } from "./checks";
+import { isTypedArray, isBigIntArray } from "./checks";
 const vec = (type) => (length = 1, align = type.BYTES_PER_ELEMENT) => ({
     type, align, length, size: type.BYTES_PER_ELEMENT * length,
 });
 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);
@@ -40,7 +42,7 @@ export const struct = (fs, align = 0, offset = 0) => {
 };
 const property = (value) => ({
     enumerable: true,
-    ...(isTypedArray(value) && value.length == 1 ? {
+    ...((isTypedArray(value) || isBigIntArray(value)) && value.length == 1 ? {
         get: () => value[0],
         set: (x) => value[0] = x,
     } : { value })

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>;