Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
@mgtd/pcf-wasm
Advanced tools
@mgtd/pcf-wasm - npm Package Compare versions
Comparing version 0.1.3 to 0.1.4
@@ -8,6 +8,7 @@ { | ||
| ], | ||
| "version": "0.1.3", | ||
| "version": "0.1.4", | ||
| "files": [ | ||
| "pcf_wasm_bg.wasm", | ||
| "pcf_wasm.js", | ||
| "pcf_wasm_bg.js", | ||
| "pcf_wasm.d.ts" | ||
@@ -18,4 +19,5 @@ ], | ||
| "sideEffects": [ | ||
| "./pcf_wasm.js", | ||
| "./snippets/*" | ||
| ] | ||
| } |
@@ -10,33 +10,1 @@ /* tslint:disable */ | ||
| export function get_pc(board: bigint, sequence: string, allow_hold?: boolean): string; | ||
| export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module; | ||
| export interface InitOutput { | ||
| readonly memory: WebAssembly.Memory; | ||
| readonly get_pc: (a: number, b: number, c: number, d: number, e: number) => void; | ||
| readonly __wbindgen_add_to_stack_pointer: (a: number) => number; | ||
| readonly __wbindgen_malloc: (a: number, b: number) => number; | ||
| readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number; | ||
| readonly __wbindgen_free: (a: number, b: number, c: number) => void; | ||
| } | ||
| export type SyncInitInput = BufferSource | WebAssembly.Module; | ||
| /** | ||
| * Instantiates the given `module`, which can either be bytes or | ||
| * a precompiled `WebAssembly.Module`. | ||
| * | ||
| * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated. | ||
| * | ||
| * @returns {InitOutput} | ||
| */ | ||
| export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput; | ||
| /** | ||
| * If `module_or_path` is {RequestInfo} or {URL}, makes a request and | ||
| * for everything else, calls `WebAssembly.instantiate` directly. | ||
| * | ||
| * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated. | ||
| * | ||
| * @returns {Promise<InitOutput>} | ||
| */ | ||
| export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>; |
218
pcf_wasm.js
@@ -1,215 +0,5 @@ | ||
| let wasm; | ||
| let WASM_VECTOR_LEN = 0; | ||
| let cachedUint8ArrayMemory0 = null; | ||
| function getUint8ArrayMemory0() { | ||
| if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { | ||
| cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); | ||
| } | ||
| return cachedUint8ArrayMemory0; | ||
| } | ||
| const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } ); | ||
| const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' | ||
| ? function (arg, view) { | ||
| return cachedTextEncoder.encodeInto(arg, view); | ||
| } | ||
| : function (arg, view) { | ||
| const buf = cachedTextEncoder.encode(arg); | ||
| view.set(buf); | ||
| return { | ||
| read: arg.length, | ||
| written: buf.length | ||
| }; | ||
| }); | ||
| function passStringToWasm0(arg, malloc, realloc) { | ||
| if (realloc === undefined) { | ||
| const buf = cachedTextEncoder.encode(arg); | ||
| const ptr = malloc(buf.length, 1) >>> 0; | ||
| getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf); | ||
| WASM_VECTOR_LEN = buf.length; | ||
| return ptr; | ||
| } | ||
| let len = arg.length; | ||
| let ptr = malloc(len, 1) >>> 0; | ||
| const mem = getUint8ArrayMemory0(); | ||
| let offset = 0; | ||
| for (; offset < len; offset++) { | ||
| const code = arg.charCodeAt(offset); | ||
| if (code > 0x7F) break; | ||
| mem[ptr + offset] = code; | ||
| } | ||
| if (offset !== len) { | ||
| if (offset !== 0) { | ||
| arg = arg.slice(offset); | ||
| } | ||
| ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; | ||
| const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); | ||
| const ret = encodeString(arg, view); | ||
| offset += ret.written; | ||
| ptr = realloc(ptr, len, offset, 1) >>> 0; | ||
| } | ||
| WASM_VECTOR_LEN = offset; | ||
| return ptr; | ||
| } | ||
| function isLikeNone(x) { | ||
| return x === undefined || x === null; | ||
| } | ||
| let cachedDataViewMemory0 = null; | ||
| function getDataViewMemory0() { | ||
| if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) { | ||
| cachedDataViewMemory0 = new DataView(wasm.memory.buffer); | ||
| } | ||
| return cachedDataViewMemory0; | ||
| } | ||
| const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } ); | ||
| if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }; | ||
| function getStringFromWasm0(ptr, len) { | ||
| ptr = ptr >>> 0; | ||
| return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); | ||
| } | ||
| /** | ||
| * @param {bigint} board | ||
| * @param {string} sequence | ||
| * @param {boolean | undefined} [allow_hold] | ||
| * @returns {string} | ||
| */ | ||
| export function get_pc(board, sequence, allow_hold) { | ||
| let deferred2_0; | ||
| let deferred2_1; | ||
| try { | ||
| const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); | ||
| const ptr0 = passStringToWasm0(sequence, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); | ||
| const len0 = WASM_VECTOR_LEN; | ||
| wasm.get_pc(retptr, board, ptr0, len0, isLikeNone(allow_hold) ? 0xFFFFFF : allow_hold ? 1 : 0); | ||
| var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true); | ||
| var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true); | ||
| deferred2_0 = r0; | ||
| deferred2_1 = r1; | ||
| return getStringFromWasm0(r0, r1); | ||
| } finally { | ||
| wasm.__wbindgen_add_to_stack_pointer(16); | ||
| wasm.__wbindgen_free(deferred2_0, deferred2_1, 1); | ||
| } | ||
| } | ||
| async function __wbg_load(module, imports) { | ||
| if (typeof Response === 'function' && module instanceof Response) { | ||
| if (typeof WebAssembly.instantiateStreaming === 'function') { | ||
| try { | ||
| return await WebAssembly.instantiateStreaming(module, imports); | ||
| } catch (e) { | ||
| if (module.headers.get('Content-Type') != 'application/wasm') { | ||
| console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e); | ||
| } else { | ||
| throw e; | ||
| } | ||
| } | ||
| } | ||
| const bytes = await module.arrayBuffer(); | ||
| return await WebAssembly.instantiate(bytes, imports); | ||
| } else { | ||
| const instance = await WebAssembly.instantiate(module, imports); | ||
| if (instance instanceof WebAssembly.Instance) { | ||
| return { instance, module }; | ||
| } else { | ||
| return instance; | ||
| } | ||
| } | ||
| } | ||
| function __wbg_get_imports() { | ||
| const imports = {}; | ||
| imports.wbg = {}; | ||
| return imports; | ||
| } | ||
| function __wbg_init_memory(imports, memory) { | ||
| } | ||
| function __wbg_finalize_init(instance, module) { | ||
| wasm = instance.exports; | ||
| __wbg_init.__wbindgen_wasm_module = module; | ||
| cachedDataViewMemory0 = null; | ||
| cachedUint8ArrayMemory0 = null; | ||
| return wasm; | ||
| } | ||
| function initSync(module) { | ||
| if (wasm !== undefined) return wasm; | ||
| if (typeof module !== 'undefined' && Object.getPrototypeOf(module) === Object.prototype) | ||
| ({module} = module) | ||
| else | ||
| console.warn('using deprecated parameters for `initSync()`; pass a single object instead') | ||
| const imports = __wbg_get_imports(); | ||
| __wbg_init_memory(imports); | ||
| if (!(module instanceof WebAssembly.Module)) { | ||
| module = new WebAssembly.Module(module); | ||
| } | ||
| const instance = new WebAssembly.Instance(module, imports); | ||
| return __wbg_finalize_init(instance, module); | ||
| } | ||
| async function __wbg_init(module_or_path) { | ||
| if (wasm !== undefined) return wasm; | ||
| if (typeof module_or_path !== 'undefined' && Object.getPrototypeOf(module_or_path) === Object.prototype) | ||
| ({module_or_path} = module_or_path) | ||
| else | ||
| console.warn('using deprecated parameters for the initialization function; pass a single object instead') | ||
| if (typeof module_or_path === 'undefined') { | ||
| module_or_path = new URL('pcf_wasm_bg.wasm', import.meta.url); | ||
| } | ||
| const imports = __wbg_get_imports(); | ||
| if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) { | ||
| module_or_path = fetch(module_or_path); | ||
| } | ||
| __wbg_init_memory(imports); | ||
| const { instance, module } = await __wbg_load(await module_or_path, imports); | ||
| return __wbg_finalize_init(instance, module); | ||
| } | ||
| export { initSync }; | ||
| export default __wbg_init; | ||
| import * as wasm from "./pcf_wasm_bg.wasm"; | ||
| import { __wbg_set_wasm } from "./pcf_wasm_bg.js"; | ||
| __wbg_set_wasm(wasm); | ||
| export * from "./pcf_wasm_bg.js"; |
New alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Fixed alerts
Network access
Supply chain riskThis module accesses the network.
Found 1 instance in 1 package
Improved metrics
- Number of package files
- increased by20%
6
Worsened metrics
- Total package byte prevSize
- decreased by-6.52%
60046
- Lines of code
- decreased by-45%
110
No dependency changes