ms-toollib 1.5.15-alpha → 1.5.16-alpha

package/ms_toollib.d.ts

@@ -95,6 +95,95 @@ export class AvfVideo {
     set current_time(value: number);
 }
 
+export class BaseVideo {
+    free(): void;
+    [Symbol.dispose](): void;
+    is_valid(): number;
+    loss_then_open_all_mine(): void;
+    constructor(board: any, cell_pixel_size: number);
+    reset(row: number, column: number, pix_size: number): void;
+    set_board(board: any): void;
+    step(e: string, x: number, y: number): void;
+    step_game_state(e: string): void;
+    win_then_flag_all_mine(): void;
+    readonly bbbv: number;
+    readonly bbbv_s: number;
+    readonly bbbv_solved: number;
+    readonly ce: number;
+    readonly ce_s: number;
+    readonly cell0: number;
+    readonly cell1: number;
+    readonly cell2: number;
+    readonly cell3: number;
+    readonly cell4: number;
+    readonly cell5: number;
+    readonly cell6: number;
+    readonly cell7: number;
+    readonly cell8: number;
+    checksum: Uint8Array;
+    readonly cl: number;
+    readonly cl_s: number;
+    readonly column: number;
+    readonly corr: number;
+    country: string;
+    current_event_id: number;
+    readonly dce: number;
+    readonly double: number;
+    readonly double_s: number;
+    readonly end_time: bigint;
+    readonly etime: number;
+    readonly events: any;
+    readonly flag: number;
+    readonly flag_s: number;
+    readonly game_board: any;
+    readonly game_board_poss: any;
+    readonly game_board_state: number;
+    readonly hzini: number;
+    readonly ioe: number;
+    readonly is_completed: boolean;
+    is_fair: boolean;
+    is_official: boolean;
+    readonly isl: number;
+    readonly lce: number;
+    readonly left: number;
+    readonly left_s: number;
+    readonly level: number;
+    readonly mine_num: number;
+    mode: number;
+    readonly mouse_state: number;
+    readonly op: number;
+    readonly path: number;
+    pix_size: number;
+    player_identifier: string;
+    readonly pluck: number;
+    readonly qg: number;
+    race_identifier: string;
+    readonly raw_data: Uint8Array;
+    readonly rce: number;
+    readonly right: number;
+    readonly right_s: number;
+    readonly row: number;
+    readonly rqp: number;
+    readonly rtime: number;
+    readonly rtime_ms: number;
+    software: string;
+    readonly start_time: bigint;
+    readonly stnb: number;
+    readonly thrp: number;
+    readonly time: number;
+    unique_identifier: string;
+    readonly video_end_time: number;
+    readonly video_start_time: number;
+    readonly x_y: CursorPos;
+    readonly zini: number;
+    set current_time(value: number);
+    set device_uuid(value: Uint8Array);
+    set use_auto_replay(value: boolean);
+    set use_cursor_pos_lim(value: boolean);
+    set use_question(value: boolean);
+    set video_playing_pix_size(value: number);
+}
+
 export class Board {
     free(): void;
     [Symbol.dispose](): void;

package/ms_toollib.js

@@ -673,6 +673,726 @@ class AvfVideo {
 if (Symbol.dispose) AvfVideo.prototype[Symbol.dispose] = AvfVideo.prototype.free;
 exports.AvfVideo = AvfVideo;
 
+class BaseVideo {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BaseVideoFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_basevideo_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get bbbv() {
+        const ret = wasm.basevideo_get_bbbv(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get bbbv_s() {
+        const ret = wasm.basevideo_get_bbbv_s(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get bbbv_solved() {
+        const ret = wasm.basevideo_get_bbbv_solved(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get ce() {
+        const ret = wasm.basevideo_get_ce(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get ce_s() {
+        const ret = wasm.basevideo_get_ce_s(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get cell0() {
+        const ret = wasm.basevideo_get_cell0(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cell1() {
+        const ret = wasm.basevideo_get_cell1(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cell2() {
+        const ret = wasm.basevideo_get_cell2(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cell3() {
+        const ret = wasm.basevideo_get_cell3(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cell4() {
+        const ret = wasm.basevideo_get_cell4(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cell5() {
+        const ret = wasm.basevideo_get_cell5(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cell6() {
+        const ret = wasm.basevideo_get_cell6(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cell7() {
+        const ret = wasm.basevideo_get_cell7(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cell8() {
+        const ret = wasm.basevideo_get_cell8(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get checksum() {
+        const ret = wasm.basevideo_get_checksum(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get cl() {
+        const ret = wasm.basevideo_get_cl(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get cl_s() {
+        const ret = wasm.basevideo_get_cl_s(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get column() {
+        const ret = wasm.basevideo_get_column(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get corr() {
+        const ret = wasm.basevideo_get_corr(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get country() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.basevideo_get_country(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get current_event_id() {
+        const ret = wasm.basevideo_get_current_event_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get dce() {
+        const ret = wasm.basevideo_get_dce(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get double() {
+        const ret = wasm.basevideo_get_double(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get double_s() {
+        const ret = wasm.basevideo_get_double_s(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get end_time() {
+        const ret = wasm.basevideo_get_end_time(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get etime() {
+        const ret = wasm.basevideo_get_etime(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {any}
+     */
+    get events() {
+        const ret = wasm.basevideo_get_events(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get flag() {
+        const ret = wasm.basevideo_get_flag(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get flag_s() {
+        const ret = wasm.basevideo_get_flag_s(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {any}
+     */
+    get game_board() {
+        const ret = wasm.basevideo_get_game_board(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {any}
+     */
+    get game_board_poss() {
+        const ret = wasm.basevideo_get_game_board_poss(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get game_board_state() {
+        const ret = wasm.basevideo_get_game_board_state(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get hzini() {
+        const ret = wasm.basevideo_get_hzini(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get ioe() {
+        const ret = wasm.basevideo_get_ioe(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get is_completed() {
+        const ret = wasm.basevideo_get_is_completed(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get is_fair() {
+        const ret = wasm.basevideo_get_is_fair(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get is_official() {
+        const ret = wasm.basevideo_get_is_official(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get isl() {
+        const ret = wasm.basevideo_get_isl(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get lce() {
+        const ret = wasm.basevideo_get_lce(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get left() {
+        const ret = wasm.basevideo_get_left(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get left_s() {
+        const ret = wasm.basevideo_get_left_s(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get level() {
+        const ret = wasm.basevideo_get_level(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get mine_num() {
+        const ret = wasm.basevideo_get_mine_num(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get mode() {
+        const ret = wasm.basevideo_get_mode(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get mouse_state() {
+        const ret = wasm.basevideo_get_mouse_state(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get op() {
+        const ret = wasm.basevideo_get_op(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get path() {
+        const ret = wasm.basevideo_get_path(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get pix_size() {
+        const ret = wasm.basevideo_get_pix_size(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get player_identifier() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.basevideo_get_player_identifier(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get pluck() {
+        const ret = wasm.basevideo_get_pluck(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get qg() {
+        const ret = wasm.basevideo_get_qg(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get race_identifier() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.basevideo_get_race_identifier(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get raw_data() {
+        const ret = wasm.basevideo_get_raw_data(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get rce() {
+        const ret = wasm.basevideo_get_rce(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get right() {
+        const ret = wasm.basevideo_get_right(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get right_s() {
+        const ret = wasm.basevideo_get_right_s(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get row() {
+        const ret = wasm.basevideo_get_row(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get rqp() {
+        const ret = wasm.basevideo_get_rqp(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get rtime() {
+        const ret = wasm.basevideo_get_rtime(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get rtime_ms() {
+        const ret = wasm.basevideo_get_rtime_ms(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    get software() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.basevideo_get_software(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {bigint}
+     */
+    get start_time() {
+        const ret = wasm.basevideo_get_start_time(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get stnb() {
+        const ret = wasm.basevideo_get_stnb(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get thrp() {
+        const ret = wasm.basevideo_get_thrp(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get time() {
+        const ret = wasm.basevideo_get_time(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get unique_identifier() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.basevideo_get_unique_identifier(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get video_end_time() {
+        const ret = wasm.basevideo_get_video_end_time(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get video_start_time() {
+        const ret = wasm.basevideo_get_video_start_time(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {CursorPos}
+     */
+    get x_y() {
+        const ret = wasm.basevideo_get_x_y(this.__wbg_ptr);
+        return CursorPos.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get zini() {
+        const ret = wasm.basevideo_get_zini(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    is_valid() {
+        const ret = wasm.basevideo_is_valid(this.__wbg_ptr);
+        return ret;
+    }
+    loss_then_open_all_mine() {
+        wasm.basevideo_loss_then_open_all_mine(this.__wbg_ptr);
+    }
+    /**
+     * @param {any} board
+     * @param {number} cell_pixel_size
+     */
+    constructor(board, cell_pixel_size) {
+        const ret = wasm.basevideo_new(board, cell_pixel_size);
+        this.__wbg_ptr = ret;
+        BaseVideoFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} row
+     * @param {number} column
+     * @param {number} pix_size
+     */
+    reset(row, column, pix_size) {
+        wasm.basevideo_reset(this.__wbg_ptr, row, column, pix_size);
+    }
+    /**
+     * @param {any} board
+     */
+    set_board(board) {
+        wasm.basevideo_set_board(this.__wbg_ptr, board);
+    }
+    /**
+     * @param {Uint8Array} checksum
+     */
+    set checksum(checksum) {
+        const ptr0 = passArray8ToWasm0(checksum, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.basevideo_set_checksum(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} country
+     */
+    set country(country) {
+        const ptr0 = passStringToWasm0(country, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.basevideo_set_country(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {number} id
+     */
+    set current_event_id(id) {
+        wasm.basevideo_set_current_event_id(this.__wbg_ptr, id);
+    }
+    /**
+     * @param {number} time
+     */
+    set current_time(time) {
+        wasm.basevideo_set_current_time(this.__wbg_ptr, time);
+    }
+    /**
+     * @param {Uint8Array} device_uuid
+     */
+    set device_uuid(device_uuid) {
+        const ptr0 = passArray8ToWasm0(device_uuid, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.basevideo_set_device_uuid(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} is_fair
+     */
+    set is_fair(is_fair) {
+        wasm.basevideo_set_is_fair(this.__wbg_ptr, is_fair);
+    }
+    /**
+     * @param {boolean} is_official
+     */
+    set is_official(is_official) {
+        wasm.basevideo_set_is_official(this.__wbg_ptr, is_official);
+    }
+    /**
+     * @param {number} mode
+     */
+    set mode(mode) {
+        wasm.basevideo_set_mode(this.__wbg_ptr, mode);
+    }
+    /**
+     * @param {number} pix_size
+     */
+    set pix_size(pix_size) {
+        wasm.basevideo_set_pix_size(this.__wbg_ptr, pix_size);
+    }
+    /**
+     * @param {string} player_identifier
+     */
+    set player_identifier(player_identifier) {
+        const ptr0 = passStringToWasm0(player_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.basevideo_set_player_identifier(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} race_identifier
+     */
+    set race_identifier(race_identifier) {
+        const ptr0 = passStringToWasm0(race_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.basevideo_set_race_identifier(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} software
+     */
+    set software(software) {
+        const ptr0 = passStringToWasm0(software, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.basevideo_set_software(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} unique_identifier
+     */
+    set unique_identifier(unique_identifier) {
+        const ptr0 = passStringToWasm0(unique_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.basevideo_set_unique_identifier(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} use_auto_replay
+     */
+    set use_auto_replay(use_auto_replay) {
+        wasm.basevideo_set_use_auto_replay(this.__wbg_ptr, use_auto_replay);
+    }
+    /**
+     * @param {boolean} use_cursor_pos_lim
+     */
+    set use_cursor_pos_lim(use_cursor_pos_lim) {
+        wasm.basevideo_set_use_cursor_pos_lim(this.__wbg_ptr, use_cursor_pos_lim);
+    }
+    /**
+     * @param {boolean} use_question
+     */
+    set use_question(use_question) {
+        wasm.basevideo_set_use_question(this.__wbg_ptr, use_question);
+    }
+    /**
+     * @param {number} pix_size
+     */
+    set video_playing_pix_size(pix_size) {
+        wasm.basevideo_set_video_playing_pix_size(this.__wbg_ptr, pix_size);
+    }
+    /**
+     * @param {string} e
+     * @param {number} x
+     * @param {number} y
+     */
+    step(e, x, y) {
+        const ptr0 = passStringToWasm0(e, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.basevideo_step(this.__wbg_ptr, ptr0, len0, x, y);
+    }
+    /**
+     * @param {string} e
+     */
+    step_game_state(e) {
+        const ptr0 = passStringToWasm0(e, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.basevideo_step_game_state(this.__wbg_ptr, ptr0, len0);
+    }
+    win_then_flag_all_mine() {
+        wasm.basevideo_win_then_flag_all_mine(this.__wbg_ptr);
+    }
+}
+if (Symbol.dispose) BaseVideo.prototype[Symbol.dispose] = BaseVideo.prototype.free;
+exports.BaseVideo = BaseVideo;
+
 class Board {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -3839,6 +4559,18 @@ function __wbg_get_imports() {
             const ret = arg0.node;
             return ret;
         },
+        __wbg_now_86c0d4ba3fa605b8: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_now_e7c6795a7f81e10f: function(arg0) {
+            const ret = arg0.now();
+            return ret;
+        },
+        __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
+            const ret = arg0.performance;
+            return ret;
+        },
         __wbg_process_44c7a14e11e9f69e: function(arg0) {
             const ret = arg0.process;
             return ret;
@@ -3929,6 +4661,9 @@ function __wbg_get_imports() {
 const AvfVideoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_avfvideo_free(ptr, 1));
+const BaseVideoFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_basevideo_free(ptr, 1));
 const BoardFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_board_free(ptr, 1));

package/package.json

@@ -3,7 +3,7 @@
   "collaborators": [
     "eee555 <50390200+eee555@users.noreply.github.com>"
   ],
-  "version": "1.5.15-alpha",
+  "version": "1.5.16-alpha",
   "repository": {
     "type": "git",
     "url": "https://github.com/eee555/ms-toollib"