rhodonite 0.4.2 → 0.5.2

package/dist/esm/foundation/misc/Cache.d.ts

@@ -0,0 +1,19 @@
+export declare class Cache<K, V> {
+    private __set;
+    private __weakMap;
+    constructor();
+    /**
+     * set key and value
+     * @param key a key
+     * @param value a value
+     * @returns true: succeed to set value, false: not set (already exists)
+     */
+    set(key: K, value: V): boolean;
+    /**
+     * return the boolean value whether it have the key or not
+     * @param key
+     * @returns Whether it have the key or not.
+     */
+    has(key: K): boolean;
+    size(): number;
+}

package/dist/esm/foundation/misc/DataUtil.d.ts

@@ -1,38 +1,42 @@
-import { Byte, Size } from '../../types/CommonTypes';
-import { GltfLoadOption } from '../../types/glTF';
-export default class DataUtil {
-    static crc32table: string[];
-    static isNode(): boolean;
-    static btoa(str: string): string;
-    static atob(str: string): string;
-    static dataUriToArrayBuffer(dataUri: string): ArrayBuffer;
-    static arrayBufferToString(arrayBuffer: ArrayBuffer): string;
-    static uint8ArrayToString(uint8Array: Uint8Array): string;
-    static stringToBase64(str: string): string;
-    static base64ToArrayBuffer(base64: string): ArrayBufferLike;
-    static UInt8ArrayToDataURL(uint8array: Uint8Array, width: number, height: number): string;
-    static loadResourceAsync(resourceUri: string, isBinary: boolean, resolveCallback: Function, rejectCallback: Function): Promise<any>;
-    static toCRC32(str: string): number;
-    static accessBinaryAsImage(bufferViewIndex: number, json: any, buffer: ArrayBuffer | Uint8Array, mimeType: string): string;
-    static createBlobImageUriFromUint8Array(uint8Array: Uint8Array, mimeType: string): string;
-    static takeBufferViewAsUint8Array(json: any, bufferViewIndex: number, buffer: ArrayBuffer | Uint8Array): Uint8Array;
-    static accessArrayBufferAsImage(arrayBuffer: ArrayBuffer | Uint8Array, imageType: string): string;
-    static uint8ArrayToStringInner(uint8: Uint8Array): string;
-    static getImageType(imageType: string): string;
-    static getMimeTypeFromExtension(extension: string): string;
-    static getExtension(fileName: string): string;
-    static createUint8ArrayFromBufferViewInfo(json: any, bufferViewIndex: number, buffer: ArrayBuffer | Uint8Array): Uint8Array;
-    static createImageFromUri(uri: string, mimeType: string): Promise<HTMLImageElement>;
-    static createDefaultGltfOptions(): GltfLoadOption;
-    static fetchArrayBuffer(uri: string): Promise<ArrayBuffer>;
-    static getResizedCanvas(image: HTMLImageElement, maxSize: Size): [HTMLCanvasElement, Size, Size];
-    static detectTransparentPixelExistence(image: HTMLImageElement | HTMLCanvasElement | ImageData, threshold?: number): boolean;
-    /**
-     * get a value nearest power of two.
-     *
-     * @param x texture size.
-     * @returns a value nearest power of two.
-     */
-    static getNearestPowerOfTwo(x: number): number;
-    static calcPaddingBytes(originalByteLength: Byte, byteAlign: Byte): number;
-}
+import { Byte, Size } from '../../types/CommonTypes';
+import { GltfLoadOption } from '../../types/glTF';
+export default class DataUtil {
+    static crc32table: string[];
+    static isNode(): boolean;
+    static btoa(str: string): string;
+    static atob(str: string): string;
+    static dataUriToArrayBuffer(dataUri: string): ArrayBuffer;
+    static arrayBufferToString(arrayBuffer: ArrayBuffer): string;
+    static uint8ArrayToString(uint8Array: Uint8Array): string;
+    static stringToBase64(str: string): string;
+    static base64ToArrayBuffer(base64: string): ArrayBufferLike;
+    static UInt8ArrayToDataURL(uint8array: Uint8Array, width: number, height: number): string;
+    static loadResourceAsync(resourceUri: string, isBinary: boolean, resolveCallback: Function, rejectCallback: Function): Promise<any>;
+    static toCRC32(str: string): number;
+    static accessBinaryAsImage(bufferViewIndex: number, json: any, buffer: ArrayBuffer | Uint8Array, mimeType: string): string;
+    static createBlobImageUriFromUint8Array(uint8Array: Uint8Array, mimeType: string): string;
+    static takeBufferViewAsUint8Array(json: any, bufferViewIndex: number, buffer: ArrayBuffer | Uint8Array): Uint8Array;
+    static accessArrayBufferAsImage(arrayBuffer: ArrayBuffer | Uint8Array, imageType: string): string;
+    static uint8ArrayToStringInner(uint8: Uint8Array): string;
+    static getImageType(imageType: string): string;
+    static getMimeTypeFromExtension(extension: string): string;
+    static getExtension(fileName: string): string;
+    static createUint8ArrayFromBufferViewInfo(json: any, bufferViewIndex: number, buffer: ArrayBuffer | Uint8Array): Uint8Array;
+    static createImageFromUri(uri: string, mimeType: string): Promise<HTMLImageElement>;
+    static createDefaultGltfOptions(): GltfLoadOption;
+    static fetchArrayBuffer(uri: string): Promise<ArrayBuffer>;
+    static getResizedCanvas(image: HTMLImageElement, maxSize: Size): [HTMLCanvasElement, Size, Size];
+    static detectTransparentPixelExistence(image: HTMLImageElement | HTMLCanvasElement | ImageData, threshold?: number): boolean;
+    /**
+     * get a value nearest power of two.
+     *
+     * @param x texture size.
+     * @returns a value nearest power of two.
+     */
+    static getNearestPowerOfTwo(x: number): number;
+    static calcPaddingBytes(originalByteLength: Byte, byteAlign: Byte): number;
+    static normalizedInt8ArrayToFloat32Array(from: Int8Array | number[]): Float32Array;
+    static normalizedUint8ArrayToFloat32Array(from: Uint8Array | number[]): Float32Array;
+    static normalizedInt16ArrayToFloat32Array(from: Int16Array | number[]): Float32Array;
+    static normalizedUint16ArrayToFloat32Array(from: Uint16Array | number[]): Float32Array;
+}

package/dist/esm/foundation/misc/EnumIO.d.ts

@@ -1,33 +1,33 @@
-export interface EnumIO {
-    readonly index: number;
-    readonly str: string;
-    readonly symbol: symbol;
-    toString(): string;
-    toJSON(): number;
-}
-export declare class EnumClass implements EnumIO {
-    readonly index: number;
-    readonly symbol: symbol;
-    readonly str: string;
-    private static __indices;
-    private static __strings;
-    constructor({ index, str, noCheckStrUnique, }: {
-        index: number;
-        str: string;
-        noCheckStrUnique?: boolean;
-    });
-    toString(): string;
-    toJSON(): number;
-}
-export declare function _from({ typeList, index, }: {
-    typeList: Array<EnumIO>;
-    index: number;
-}): EnumIO | undefined;
-export declare function _fromString({ typeList, str, }: {
-    typeList: Array<EnumIO>;
-    str: string;
-}): EnumIO | undefined;
-export declare function _fromStringCaseSensitively({ typeList, str, }: {
-    typeList: Array<EnumIO>;
-    str: string;
-}): EnumIO | undefined;
+export interface EnumIO {
+    readonly index: number;
+    readonly str: string;
+    readonly symbol: symbol;
+    toString(): string;
+    toJSON(): number;
+}
+export declare class EnumClass implements EnumIO {
+    readonly index: number;
+    readonly symbol: symbol;
+    readonly str: string;
+    private static __indices;
+    private static __strings;
+    constructor({ index, str, noCheckStrUnique, }: {
+        index: number;
+        str: string;
+        noCheckStrUnique?: boolean;
+    });
+    toString(): string;
+    toJSON(): number;
+}
+export declare function _from({ typeList, index, }: {
+    typeList: Array<EnumIO>;
+    index: number;
+}): EnumIO | undefined;
+export declare function _fromString({ typeList, str, }: {
+    typeList: Array<EnumIO>;
+    str: string;
+}): EnumIO | undefined;
+export declare function _fromStringCaseSensitively({ typeList, str, }: {
+    typeList: Array<EnumIO>;
+    str: string;
+}): EnumIO | undefined;

package/dist/esm/foundation/misc/Is.d.ts

@@ -1,26 +1,26 @@
-declare const IsImpl: {
-    defined(val: unknown, ...args: unknown[]): val is Object;
-    undefined(val: unknown, ...args: unknown[]): val is undefined;
-    null(val: unknown, ...args: unknown[]): val is null;
-    exist(val?: unknown, ...args: unknown[]): val is Object;
-    function(val: unknown, ...args: unknown[]): val is Function;
-    true(val: unknown, ...args: unknown[]): boolean;
-    false(val: unknown, ...args: unknown[]): boolean;
-};
-declare const IsNotImpl: {
-    defined(val: unknown, ...args: unknown[]): val is undefined;
-    undefined(val: unknown, ...args: unknown[]): val is Object;
-    null(val: unknown, ...args: unknown[]): val is Object;
-    exist(val?: unknown, ...args: unknown[]): val is null | undefined;
-    function(val: unknown, ...args: unknown[]): val is unknown;
-    true(val: unknown, ...args: unknown[]): boolean;
-    false(val: unknown, ...args: unknown[]): boolean;
-};
-declare type IsImplType = typeof IsImpl;
-interface IsType extends IsImplType {
-    not: typeof IsNotImpl;
-    all: typeof IsImpl;
-    any: typeof IsImpl;
-}
-export declare const Is: IsType;
-export {};
+declare const IsImpl: {
+    defined(val: unknown, ...args: unknown[]): val is Object;
+    undefined(val: unknown, ...args: unknown[]): val is undefined;
+    null(val: unknown, ...args: unknown[]): val is null;
+    exist(val?: unknown, ...args: unknown[]): val is Object;
+    function(val: unknown, ...args: unknown[]): val is Function;
+    true(val: unknown, ...args: unknown[]): boolean;
+    false(val: unknown, ...args: unknown[]): boolean;
+};
+declare const IsNotImpl: {
+    defined(val: unknown, ...args: unknown[]): val is undefined;
+    undefined(val: unknown, ...args: unknown[]): val is Object;
+    null(val: unknown, ...args: unknown[]): val is Object;
+    exist(val?: unknown, ...args: unknown[]): val is null | undefined;
+    function(val: unknown, ...args: unknown[]): val is unknown;
+    true(val: unknown, ...args: unknown[]): boolean;
+    false(val: unknown, ...args: unknown[]): boolean;
+};
+declare type IsImplType = typeof IsImpl;
+interface IsType extends IsImplType {
+    not: typeof IsNotImpl;
+    all: typeof IsImpl;
+    any: typeof IsImpl;
+}
+export declare const Is: IsType;
+export {};

package/dist/esm/foundation/misc/ManualCache.d.ts

@@ -0,0 +1,30 @@
+export declare class ManualCache<K, V> {
+    private __map;
+    private __weakMap;
+    constructor();
+    /**
+     * set key and value
+     * @param key the key for access
+     * @param value the value as a cache item
+     * @returns true: succeed to set value, false: not set (already exists)
+     */
+    set(key: K, value: V): boolean;
+    /**
+     * return the boolean value whether it have the key or not
+     * @param key the key for access
+     * @returns Whether it have the key or not.
+     */
+    has(key: K): boolean;
+    /**
+     * return the number of this cache items
+     * @returns the number of this cache items
+     */
+    size(): number;
+    /**
+     * return the value in the cache by the key
+     * @param key the key for access
+     * @returns the value in the cache by the key
+     */
+    get(key: K): V | undefined;
+    delete(key: K): boolean;
+}

package/dist/esm/foundation/misc/MiscUtil.d.ts

@@ -1,30 +1,37 @@
-import { Byte } from '../../types/CommonTypes';
-export declare const defaultValue: <T>(defaultValue: T, value?: T | undefined) => T;
-export declare const defaultValueWithCallback: <T>(callback: () => T, value?: T | undefined) => T;
-export declare const nullishToEmptyArray: <T>(value?: T[] | null | undefined) => T[];
-export declare const nullishToEmptyMap: <M, N>(value?: Map<M, N> | null | undefined) => Map<M, N>;
-interface CompareResult {
-    result: boolean;
-    greater: number;
-    less: number;
-}
-export declare const greaterThan: (it: number, than: number) => CompareResult;
-export declare const lessThan: (it: number, than: number) => CompareResult;
-export declare const addLineNumberToCode: (shaderString: string) => string;
-export declare const MiscUtil: Readonly<{
-    isMobile: () => boolean;
-    isIOS: () => boolean;
-    preventDefaultForDesktopOnly: (e: Event) => void;
-    isObject: (o: any) => boolean;
-    fillTemplate: (templateString: string, templateVars: string) => any;
-    isNode: () => boolean;
-    concatArrayBuffers: (segments: ArrayBuffer[], sizes: Byte[], offsets: Byte[], finalSize?: number | undefined) => ArrayBufferLike;
-    concatArrayBuffers2: ({ finalSize, srcs, srcsOffset, srcsCopySize, }: {
-        finalSize: Byte;
-        srcs: ArrayBuffer[];
-        srcsOffset: Byte[];
-        srcsCopySize: Byte[];
-    }) => ArrayBufferLike;
-    addLineNumberToCode: (shaderString: string) => string;
-}>;
-export {};
+import { Byte } from '../../types/CommonTypes';
+export declare const valueWithDefault: <T>({ value, defaultValue, }: {
+    value?: T | undefined;
+    defaultValue: T;
+}) => T;
+export declare const valueWithCompensation: <T>({ value, compensation, }: {
+    value?: T | undefined;
+    compensation: () => T;
+}) => T;
+export declare const nullishToEmptyArray: <T>(value?: T[] | null | undefined) => T[];
+export declare const nullishToEmptyMap: <M, N>(value?: Map<M, N> | null | undefined) => Map<M, N>;
+interface CompareResult {
+    result: boolean;
+    greater: number;
+    less: number;
+}
+export declare const greaterThan: (it: number, than: number) => CompareResult;
+export declare const lessThan: (it: number, than: number) => CompareResult;
+export declare const addLineNumberToCode: (shaderString: string) => string;
+export declare const MiscUtil: Readonly<{
+    isMobile: () => boolean;
+    isIOS: () => boolean;
+    isSafari: () => boolean;
+    preventDefaultForDesktopOnly: (e: Event) => void;
+    isObject: (o: any) => boolean;
+    fillTemplate: (templateString: string, templateVars: string) => any;
+    isNode: () => boolean;
+    concatArrayBuffers: (segments: ArrayBuffer[], sizes: Byte[], offsets: Byte[], finalSize?: number | undefined) => ArrayBufferLike;
+    concatArrayBuffers2: ({ finalSize, srcs, srcsOffset, srcsCopySize, }: {
+        finalSize: Byte;
+        srcs: ArrayBuffer[];
+        srcsOffset: Byte[];
+        srcsCopySize: Byte[];
+    }) => ArrayBufferLike;
+    addLineNumberToCode: (shaderString: string) => string;
+}>;
+export {};

package/dist/esm/foundation/misc/Option.d.ts

@@ -1,72 +1,72 @@
-export interface IOption<T> {
-    then<U>(f: (value: T) => IOption<U>): IOption<U>;
-    then(f: (value: T) => None): None;
-    getOrDefault(altValue: T): T;
-    getOrElse(f: (...vals: any) => T): T;
-    getOrError(): T;
-}
-export declare class Option<T> implements IOption<T> {
-    private value?;
-    set(val: T): void;
-    /**
-     * This method is essentially same to the Some::and_then() in Rust language
-     * @param f
-     */
-    then<U>(f: (value: T) => None): None;
-    then<U>(f: (value: T) => Some<U>): Some<U>;
-    /**
-     * @param altValue
-     * @returns
-     */
-    getOrDefault(altValue: T): T;
-    /**
-     * @param altValue
-     * @returns
-     */
-    getOrElse(f: (...vals: any) => T): T;
-    /**
-     * @returns
-     */
-    getOrError(): T;
-}
-/**
- * a class indicating that the included value exists.
- */
-export declare class Some<T> implements IOption<T> {
-    private value;
-    constructor(value: T);
-    /**
-     * This method is essentially same to the Some::and_then() in Rust language
-     * @param f
-     */
-    then<U>(f: (value: T) => None): None;
-    then<U>(f: (value: T) => Some<U>): Some<U>;
-    /**
-     * @deprecated use the 'get' method instead
-     * @param altValue
-     * @returns
-     */
-    getOrDefault(altValue: T): T;
-    /**
-     * @deprecated use the 'get' method instead
-     * @param altValue
-     * @returns
-     */
-    getOrElse(f: (value: T) => T): T;
-    /**
-     * @deprecated use the 'get' method instead
-     * @param altValue
-     * @returns
-     */
-    getOrError(): T;
-    get(): T;
-}
-/**
- * a class indicating no existence.
- */
-export declare class None implements IOption<never> {
-    then(): None;
-    getOrDefault<T>(value: T): T;
-    getOrElse(f: (...vals: any) => never): never;
-    getOrError(): never;
-}
+export interface IOption<T> {
+    then<U>(f: (value: T) => IOption<U>): IOption<U>;
+    then(f: (value: T) => None): None;
+    getOrDefault(altValue: T): T;
+    getOrElse(f: (...vals: any) => T): T;
+    getOrError(): T;
+}
+export declare class Option<T> implements IOption<T> {
+    private value?;
+    set(val: T): void;
+    /**
+     * This method is essentially same to the Some::and_then() in Rust language
+     * @param f
+     */
+    then<U>(f: (value: T) => None): None;
+    then<U>(f: (value: T) => Some<U>): Some<U>;
+    /**
+     * @param altValue
+     * @returns
+     */
+    getOrDefault(altValue: T): T;
+    /**
+     * @param altValue
+     * @returns
+     */
+    getOrElse(f: (...vals: any) => T): T;
+    /**
+     * @returns
+     */
+    getOrError(): T;
+}
+/**
+ * a class indicating that the included value exists.
+ */
+export declare class Some<T> implements IOption<T> {
+    private value;
+    constructor(value: T);
+    /**
+     * This method is essentially same to the Some::and_then() in Rust language
+     * @param f
+     */
+    then<U>(f: (value: T) => None): None;
+    then<U>(f: (value: T) => Some<U>): Some<U>;
+    /**
+     * @deprecated use the 'get' method instead
+     * @param altValue
+     * @returns
+     */
+    getOrDefault(altValue: T): T;
+    /**
+     * @deprecated use the 'get' method instead
+     * @param altValue
+     * @returns
+     */
+    getOrElse(f: (value: T) => T): T;
+    /**
+     * @deprecated use the 'get' method instead
+     * @param altValue
+     * @returns
+     */
+    getOrError(): T;
+    get(): T;
+}
+/**
+ * a class indicating no existence.
+ */
+export declare class None implements IOption<never> {
+    then(): None;
+    getOrDefault<T>(value: T): T;
+    getOrElse(f: (...vals: any) => never): never;
+    getOrError(): never;
+}

package/dist/esm/foundation/misc/Result.d.ts

@@ -1,40 +1,40 @@
-/**
- * An interface to handle the results in a unified manner,
- * regardless of whether they are successful or not.
- */
-export interface IResult<T, E> {
-    match<U, F>(thenFn: (value: T) => IResult<U, F>, catchFn: (value: E) => E): void;
-    then<U, F>(f: (value: T) => IResult<U, F>): IResult<U, F>;
-    catch(f: (value: E) => E): E;
-    getBoolean(): boolean;
-}
-declare abstract class Result<T, E> {
-    protected val: T | E;
-    constructor(val: T | E);
-    match<U, F>(thenFn: (value: T) => IResult<U, F>, catchFn: (value: E) => E): IResult<U, F> | E;
-}
-/**
- * a class indicating that the result is Ok (Succeeded).
- */
-export declare class Ok<T> extends Result<T, never> implements IResult<T, never> {
-    /**
-     * This method is essentially same to the Ok::and_then() in Rust language
-     * @param f
-     */
-    then<U, F>(f: (value: T) => IResult<U, F>): IResult<U, F>;
-    catch(f: (value: never) => never): never;
-    true(): true;
-    getBoolean(): true;
-    get(): T;
-}
-/**
- * a class indicating that the result is Error (Failed).
- */
-export declare class Err<E> extends Result<never, E> implements IResult<never, E> {
-    then<U, F>(f: (value: never) => IResult<U, F>): IResult<U, F>;
-    catch(f: (value: E) => E): E;
-    false(): false;
-    getBoolean(): false;
-    get(): E;
-}
-export {};
+/**
+ * An interface to handle the results in a unified manner,
+ * regardless of whether they are successful or not.
+ */
+export interface IResult<T, E> {
+    match<U, F>(thenFn: (value: T) => IResult<U, F>, catchFn: (value: E) => E): void;
+    then<U, F>(f: (value: T) => IResult<U, F>): IResult<U, F>;
+    catch(f: (value: E) => E): E;
+    getBoolean(): boolean;
+}
+declare abstract class Result<T, E> {
+    protected val: T | E;
+    constructor(val: T | E);
+    match<U, F>(thenFn: (value: T) => IResult<U, F>, catchFn: (value: E) => E): IResult<U, F> | E;
+}
+/**
+ * a class indicating that the result is Ok (Succeeded).
+ */
+export declare class Ok<T> extends Result<T, never> implements IResult<T, never> {
+    /**
+     * This method is essentially same to the Ok::and_then() in Rust language
+     * @param f
+     */
+    then<U, F>(f: (value: T) => IResult<U, F>): IResult<U, F>;
+    catch(f: (value: never) => never): never;
+    true(): true;
+    getBoolean(): true;
+    get(): T;
+}
+/**
+ * a class indicating that the result is Error (Failed).
+ */
+export declare class Err<E> extends Result<never, E> implements IResult<never, E> {
+    then<U, F>(f: (value: never) => IResult<U, F>): IResult<U, F>;
+    catch(f: (value: E) => E): E;
+    false(): false;
+    getBoolean(): false;
+    get(): E;
+}
+export {};

package/dist/esm/foundation/misc/RnPromise.d.ts

@@ -1,27 +1,27 @@
-declare type ResolveArg<T> = T | PromiseLike<T | undefined> | undefined;
-declare type PromiseFn<T> = (resolve: (value: ResolveArg<T>) => void, reject: (reason?: any) => void) => void;
-declare type OnFinallyFn = (() => void) | null | undefined;
-export declare type CallbackObj = {
-    promiseAllNum: number;
-    resolvedNum: number;
-    rejectedNum: number;
-    pendingNum: number;
-    processedPromises: any[];
-};
-export default class RnPromise<T> {
-    private __promise;
-    private __callback?;
-    name: string;
-    private __callbackObj;
-    constructor(promise: Promise<T>, callback?: Function);
-    constructor(fn: PromiseFn<T>, callback?: Function);
-    static resolve<T>(arg: any): RnPromise<any>;
-    static all(args: any[]): RnPromise<any[]>;
-    static allWithProgressCallback(promises: any[], callback: Function): RnPromise<[unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]>;
-    static race(args: any[]): RnPromise<any>;
-    then(onFulfilled?: any, onRejected?: any): RnPromise<void>;
-    catch(onRejected?: any): RnPromise<T | undefined>;
-    finally(onFinally?: OnFinallyFn): void;
-    static reject(e: Error): RnPromise<never>;
-}
-export {};
+declare type ResolveArg<T> = T | PromiseLike<T | undefined> | undefined;
+declare type PromiseFn<T> = (resolve: (value: ResolveArg<T>) => void, reject: (reason?: any) => void) => void;
+declare type OnFinallyFn = (() => void) | null | undefined;
+export declare type CallbackObj = {
+    promiseAllNum: number;
+    resolvedNum: number;
+    rejectedNum: number;
+    pendingNum: number;
+    processedPromises: any[];
+};
+export default class RnPromise<T> {
+    private __promise;
+    private __callback?;
+    name: string;
+    private __callbackObj;
+    constructor(promise: Promise<T>, callback?: Function);
+    constructor(fn: PromiseFn<T>, callback?: Function);
+    static resolve<T>(arg: any): RnPromise<any>;
+    static all(args: any[]): RnPromise<any[]>;
+    static allWithProgressCallback(promises: any[], callback: Function): RnPromise<[unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]>;
+    static race(args: any[]): RnPromise<any>;
+    then(onFulfilled?: any, onRejected?: any): RnPromise<void>;
+    catch(onRejected?: any): RnPromise<T | undefined>;
+    finally(onFinally?: OnFinallyFn): void;
+    static reject(e: Error): RnPromise<never>;
+}
+export {};

package/dist/esm/foundation/misc/Time.d.ts

@@ -1,16 +1,16 @@
-export default class Time {
-    private static __currentProcessBeginTime;
-    private static __lastProcessEndTime;
-    private static __lastTickTimeInterval;
-    private static __systemStartTime;
-    /**
-     * @private
-     */
-    static _processBegin(): void;
-    /**
-     * @private
-     */
-    static _processEnd(): void;
-    static get timeFromSystemStart(): number;
-    static get lastTickTimeInterval(): number;
-}
+export default class Time {
+    private static __currentProcessBeginTime;
+    private static __lastProcessEndTime;
+    private static __lastTickTimeInterval;
+    private static __systemStartTime;
+    /**
+     * @private
+     */
+    static _processBegin(): void;
+    /**
+     * @private
+     */
+    static _processEnd(): void;
+    static get timeFromSystemStart(): number;
+    static get lastTickTimeInterval(): number;
+}

package/dist/esm/foundation/physics/PhysicsStrategy.d.ts

@@ -1,2 +1,2 @@
-export default interface PhysicsStrategy {
-}
+export default interface PhysicsStrategy {
+}

package/dist/esm/foundation/physics/SphereCollider.d.ts

@@ -1,5 +1,5 @@
-import Vector3 from '../math/Vector3';
-export default class SphereCollider {
-    position: Vector3;
-    radius: number;
-}
+import Vector3 from '../math/Vector3';
+export default class SphereCollider {
+    position: Vector3;
+    radius: number;
+}