Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
@influxdata/flux-lsp-browser
Advanced tools
@influxdata/flux-lsp-browser - npm Package Compare versions
Comparing version 0.8.26 to 0.8.27
@@ -55,42 +55,1 @@ /* tslint:disable */ | ||
| } | ||
| export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module; | ||
| export interface InitOutput { | ||
| readonly memory: WebAssembly.Memory; | ||
| readonly initLog: () => void; | ||
| readonly parse: (a: number, b: number) => number; | ||
| readonly format_from_js_file: (a: number, b: number) => void; | ||
| readonly __wbg_lsp_free: (a: number) => void; | ||
| readonly lsp_new: () => number; | ||
| readonly lsp_onMessage: (a: number, b: number) => void; | ||
| readonly lsp_send: (a: number, b: number, c: number) => number; | ||
| readonly lsp_run: (a: number) => number; | ||
| readonly __wbindgen_malloc: (a: number) => number; | ||
| readonly __wbindgen_realloc: (a: number, b: number, c: number) => number; | ||
| readonly __wbindgen_export_2: WebAssembly.Table; | ||
| readonly _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h7feee449da9a7777: (a: number, b: number, c: number) => void; | ||
| readonly __wbindgen_add_to_stack_pointer: (a: number) => number; | ||
| readonly __wbindgen_free: (a: number, b: number) => void; | ||
| readonly __wbindgen_exn_store: (a: number) => void; | ||
| readonly wasm_bindgen__convert__closures__invoke2_mut__h1f7ab6749a812635: (a: number, b: number, c: number, d: number) => void; | ||
| } | ||
| /** | ||
| * Synchronously compiles the given `bytes` and instantiates the WebAssembly module. | ||
| * | ||
| * @param {BufferSource} bytes | ||
| * | ||
| * @returns {InitOutput} | ||
| */ | ||
| export function initSync(bytes: BufferSource): InitOutput; | ||
| /** | ||
| * If `module_or_path` is {RequestInfo} or {URL}, makes a request and | ||
| * for everything else, calls `WebAssembly.instantiate` directly. | ||
| * | ||
| * @param {InitInput | Promise<InitInput>} module_or_path | ||
| * | ||
| * @returns {Promise<InitOutput>} | ||
| */ | ||
| export default function init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>; |
@@ -1,500 +0,2 @@ | ||
| let wasm; | ||
| const heap = new Array(32).fill(undefined); | ||
| heap.push(undefined, null, true, false); | ||
| function getObject(idx) { return heap[idx]; } | ||
| let heap_next = heap.length; | ||
| function dropObject(idx) { | ||
| if (idx < 36) return; | ||
| heap[idx] = heap_next; | ||
| heap_next = idx; | ||
| } | ||
| function takeObject(idx) { | ||
| const ret = getObject(idx); | ||
| dropObject(idx); | ||
| return ret; | ||
| } | ||
| const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); | ||
| cachedTextDecoder.decode(); | ||
| let cachedUint8Memory0; | ||
| function getUint8Memory0() { | ||
| if (cachedUint8Memory0.byteLength === 0) { | ||
| cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); | ||
| } | ||
| return cachedUint8Memory0; | ||
| } | ||
| function getStringFromWasm0(ptr, len) { | ||
| return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); | ||
| } | ||
| function addHeapObject(obj) { | ||
| if (heap_next === heap.length) heap.push(heap.length + 1); | ||
| const idx = heap_next; | ||
| heap_next = heap[idx]; | ||
| heap[idx] = obj; | ||
| return idx; | ||
| } | ||
| let WASM_VECTOR_LEN = 0; | ||
| const cachedTextEncoder = new TextEncoder('utf-8'); | ||
| 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); | ||
| getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf); | ||
| WASM_VECTOR_LEN = buf.length; | ||
| return ptr; | ||
| } | ||
| let len = arg.length; | ||
| let ptr = malloc(len); | ||
| const mem = getUint8Memory0(); | ||
| 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); | ||
| const view = getUint8Memory0().subarray(ptr + offset, ptr + len); | ||
| const ret = encodeString(arg, view); | ||
| offset += ret.written; | ||
| } | ||
| WASM_VECTOR_LEN = offset; | ||
| return ptr; | ||
| } | ||
| let cachedInt32Memory0; | ||
| function getInt32Memory0() { | ||
| if (cachedInt32Memory0.byteLength === 0) { | ||
| cachedInt32Memory0 = new Int32Array(wasm.memory.buffer); | ||
| } | ||
| return cachedInt32Memory0; | ||
| } | ||
| function debugString(val) { | ||
| // primitive types | ||
| const type = typeof val; | ||
| if (type == 'number' || type == 'boolean' || val == null) { | ||
| return `${val}`; | ||
| } | ||
| if (type == 'string') { | ||
| return `"${val}"`; | ||
| } | ||
| if (type == 'symbol') { | ||
| const description = val.description; | ||
| if (description == null) { | ||
| return 'Symbol'; | ||
| } else { | ||
| return `Symbol(${description})`; | ||
| } | ||
| } | ||
| if (type == 'function') { | ||
| const name = val.name; | ||
| if (typeof name == 'string' && name.length > 0) { | ||
| return `Function(${name})`; | ||
| } else { | ||
| return 'Function'; | ||
| } | ||
| } | ||
| // objects | ||
| if (Array.isArray(val)) { | ||
| const length = val.length; | ||
| let debug = '['; | ||
| if (length > 0) { | ||
| debug += debugString(val[0]); | ||
| } | ||
| for(let i = 1; i < length; i++) { | ||
| debug += ', ' + debugString(val[i]); | ||
| } | ||
| debug += ']'; | ||
| return debug; | ||
| } | ||
| // Test for built-in | ||
| const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); | ||
| let className; | ||
| if (builtInMatches.length > 1) { | ||
| className = builtInMatches[1]; | ||
| } else { | ||
| // Failed to match the standard '[object ClassName]' | ||
| return toString.call(val); | ||
| } | ||
| if (className == 'Object') { | ||
| // we're a user defined class or Object | ||
| // JSON.stringify avoids problems with cycles, and is generally much | ||
| // easier than looping through ownProperties of `val`. | ||
| try { | ||
| return 'Object(' + JSON.stringify(val) + ')'; | ||
| } catch (_) { | ||
| return 'Object'; | ||
| } | ||
| } | ||
| // errors | ||
| if (val instanceof Error) { | ||
| return `${val.name}: ${val.message}\n${val.stack}`; | ||
| } | ||
| // TODO we could test for more things here, like `Set`s and `Map`s. | ||
| return className; | ||
| } | ||
| function makeMutClosure(arg0, arg1, dtor, f) { | ||
| const state = { a: arg0, b: arg1, cnt: 1, dtor }; | ||
| const real = (...args) => { | ||
| // First up with a closure we increment the internal reference | ||
| // count. This ensures that the Rust closure environment won't | ||
| // be deallocated while we're invoking it. | ||
| state.cnt++; | ||
| const a = state.a; | ||
| state.a = 0; | ||
| try { | ||
| return f(a, state.b, ...args); | ||
| } finally { | ||
| if (--state.cnt === 0) { | ||
| wasm.__wbindgen_export_2.get(state.dtor)(a, state.b); | ||
| } else { | ||
| state.a = a; | ||
| } | ||
| } | ||
| }; | ||
| real.original = state; | ||
| return real; | ||
| } | ||
| function __wbg_adapter_16(arg0, arg1, arg2) { | ||
| wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h7feee449da9a7777(arg0, arg1, addHeapObject(arg2)); | ||
| } | ||
| /** | ||
| * Initialize logging - this requires the "console_log" feature to function, | ||
| * as this library adds 180k to the wasm binary being shipped. | ||
| */ | ||
| export function initLog() { | ||
| wasm.initLog(); | ||
| } | ||
| /** | ||
| * Parse flux into an AST representation. The AST will be generated regardless | ||
| * of valid flux. As such, no error handling is needed. | ||
| * @param {string} script | ||
| * @returns {any} | ||
| */ | ||
| export function parse(script) { | ||
| const ptr0 = passStringToWasm0(script, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); | ||
| const len0 = WASM_VECTOR_LEN; | ||
| const ret = wasm.parse(ptr0, len0); | ||
| return takeObject(ret); | ||
| } | ||
| /** | ||
| * Format a flux script from AST. | ||
| * | ||
| * In the event that the flux is invalid syntax, an Err will be returned, | ||
| * which will translate into a JavaScript exception being thrown. | ||
| * @param {any} js_file | ||
| * @returns {string} | ||
| */ | ||
| export function format_from_js_file(js_file) { | ||
| try { | ||
| const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); | ||
| wasm.format_from_js_file(retptr, addHeapObject(js_file)); | ||
| var r0 = getInt32Memory0()[retptr / 4 + 0]; | ||
| var r1 = getInt32Memory0()[retptr / 4 + 1]; | ||
| var r2 = getInt32Memory0()[retptr / 4 + 2]; | ||
| var r3 = getInt32Memory0()[retptr / 4 + 3]; | ||
| var ptr0 = r0; | ||
| var len0 = r1; | ||
| if (r3) { | ||
| ptr0 = 0; len0 = 0; | ||
| throw takeObject(r2); | ||
| } | ||
| return getStringFromWasm0(ptr0, len0); | ||
| } finally { | ||
| wasm.__wbindgen_add_to_stack_pointer(16); | ||
| wasm.__wbindgen_free(ptr0, len0); | ||
| } | ||
| } | ||
| function handleError(f, args) { | ||
| try { | ||
| return f.apply(this, args); | ||
| } catch (e) { | ||
| wasm.__wbindgen_exn_store(addHeapObject(e)); | ||
| } | ||
| } | ||
| function __wbg_adapter_32(arg0, arg1, arg2, arg3) { | ||
| wasm.wasm_bindgen__convert__closures__invoke2_mut__h1f7ab6749a812635(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); | ||
| } | ||
| /** | ||
| * Lsp is the core lsp server interface. | ||
| */ | ||
| export class Lsp { | ||
| static __wrap(ptr) { | ||
| const obj = Object.create(Lsp.prototype); | ||
| obj.ptr = ptr; | ||
| return obj; | ||
| } | ||
| __destroy_into_raw() { | ||
| const ptr = this.ptr; | ||
| this.ptr = 0; | ||
| return ptr; | ||
| } | ||
| free() { | ||
| const ptr = this.__destroy_into_raw(); | ||
| wasm.__wbg_lsp_free(ptr); | ||
| } | ||
| /** | ||
| */ | ||
| constructor() { | ||
| const ret = wasm.lsp_new(); | ||
| return Lsp.__wrap(ret); | ||
| } | ||
| /** | ||
| * Attach a message handler to server messages. | ||
| * All handlers must be attached before server.run is called. | ||
| * @param {Function} func | ||
| */ | ||
| onMessage(func) { | ||
| wasm.lsp_onMessage(this.ptr, addHeapObject(func)); | ||
| } | ||
| /** | ||
| * Send a message to the server. | ||
| * @param {string} msg | ||
| * @returns {Promise<any>} | ||
| */ | ||
| send(msg) { | ||
| const ptr0 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); | ||
| const len0 = WASM_VECTOR_LEN; | ||
| const ret = wasm.lsp_send(this.ptr, ptr0, len0); | ||
| return takeObject(ret); | ||
| } | ||
| /** | ||
| * Run the server. | ||
| * | ||
| * Note: this will run for the lifetime of the server. It should not be | ||
| * `await`ed. However, as it returns a Promise, it's a good idea to attach | ||
| * handlers for completion and error. If the promise ever resolves, the server | ||
| * is no longer running, which may serve as a hint that attention is needed. | ||
| * @returns {Promise<any>} | ||
| */ | ||
| run() { | ||
| const ret = wasm.lsp_run(this.ptr); | ||
| return takeObject(ret); | ||
| } | ||
| } | ||
| async function 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 getImports() { | ||
| const imports = {}; | ||
| imports.wbg = {}; | ||
| imports.wbg.__wbindgen_object_drop_ref = function(arg0) { | ||
| takeObject(arg0); | ||
| }; | ||
| imports.wbg.__wbindgen_json_parse = function(arg0, arg1) { | ||
| const ret = JSON.parse(getStringFromWasm0(arg0, arg1)); | ||
| return addHeapObject(ret); | ||
| }; | ||
| imports.wbg.__wbindgen_json_serialize = function(arg0, arg1) { | ||
| const obj = getObject(arg1); | ||
| const ret = JSON.stringify(obj === undefined ? null : obj); | ||
| const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); | ||
| const len0 = WASM_VECTOR_LEN; | ||
| getInt32Memory0()[arg0 / 4 + 1] = len0; | ||
| getInt32Memory0()[arg0 / 4 + 0] = ptr0; | ||
| }; | ||
| imports.wbg.__wbindgen_string_new = function(arg0, arg1) { | ||
| const ret = getStringFromWasm0(arg0, arg1); | ||
| return addHeapObject(ret); | ||
| }; | ||
| imports.wbg.__wbg_new_693216e109162396 = function() { | ||
| const ret = new Error(); | ||
| return addHeapObject(ret); | ||
| }; | ||
| imports.wbg.__wbg_stack_0ddaca5d1abfb52f = function(arg0, arg1) { | ||
| const ret = getObject(arg1).stack; | ||
| const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); | ||
| const len0 = WASM_VECTOR_LEN; | ||
| getInt32Memory0()[arg0 / 4 + 1] = len0; | ||
| getInt32Memory0()[arg0 / 4 + 0] = ptr0; | ||
| }; | ||
| imports.wbg.__wbg_error_09919627ac0992f5 = function(arg0, arg1) { | ||
| try { | ||
| console.error(getStringFromWasm0(arg0, arg1)); | ||
| } finally { | ||
| wasm.__wbindgen_free(arg0, arg1); | ||
| } | ||
| }; | ||
| imports.wbg.__wbindgen_cb_drop = function(arg0) { | ||
| const obj = takeObject(arg0).original; | ||
| if (obj.cnt-- == 1) { | ||
| obj.a = 0; | ||
| return true; | ||
| } | ||
| const ret = false; | ||
| return ret; | ||
| }; | ||
| imports.wbg.__wbg_call_9855a4612eb496cb = function() { return handleError(function (arg0, arg1, arg2) { | ||
| const ret = getObject(arg0).call(getObject(arg1), getObject(arg2)); | ||
| return addHeapObject(ret); | ||
| }, arguments) }; | ||
| imports.wbg.__wbg_new_78403b138428b684 = function(arg0, arg1) { | ||
| try { | ||
| var state0 = {a: arg0, b: arg1}; | ||
| var cb0 = (arg0, arg1) => { | ||
| const a = state0.a; | ||
| state0.a = 0; | ||
| try { | ||
| return __wbg_adapter_32(a, state0.b, arg0, arg1); | ||
| } finally { | ||
| state0.a = a; | ||
| } | ||
| }; | ||
| const ret = new Promise(cb0); | ||
| return addHeapObject(ret); | ||
| } finally { | ||
| state0.a = state0.b = 0; | ||
| } | ||
| }; | ||
| imports.wbg.__wbg_resolve_f269ce174f88b294 = function(arg0) { | ||
| const ret = Promise.resolve(getObject(arg0)); | ||
| return addHeapObject(ret); | ||
| }; | ||
| imports.wbg.__wbg_then_1c698eedca15eed6 = function(arg0, arg1) { | ||
| const ret = getObject(arg0).then(getObject(arg1)); | ||
| return addHeapObject(ret); | ||
| }; | ||
| imports.wbg.__wbindgen_debug_string = function(arg0, arg1) { | ||
| const ret = debugString(getObject(arg1)); | ||
| const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); | ||
| const len0 = WASM_VECTOR_LEN; | ||
| getInt32Memory0()[arg0 / 4 + 1] = len0; | ||
| getInt32Memory0()[arg0 / 4 + 0] = ptr0; | ||
| }; | ||
| imports.wbg.__wbindgen_throw = function(arg0, arg1) { | ||
| throw new Error(getStringFromWasm0(arg0, arg1)); | ||
| }; | ||
| imports.wbg.__wbindgen_closure_wrapper10857 = function(arg0, arg1, arg2) { | ||
| const ret = makeMutClosure(arg0, arg1, 1556, __wbg_adapter_16); | ||
| return addHeapObject(ret); | ||
| }; | ||
| return imports; | ||
| } | ||
| function initMemory(imports, maybe_memory) { | ||
| } | ||
| function finalizeInit(instance, module) { | ||
| wasm = instance.exports; | ||
| init.__wbindgen_wasm_module = module; | ||
| cachedInt32Memory0 = new Int32Array(wasm.memory.buffer); | ||
| cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); | ||
| return wasm; | ||
| } | ||
| function initSync(bytes) { | ||
| const imports = getImports(); | ||
| initMemory(imports); | ||
| const module = new WebAssembly.Module(bytes); | ||
| const instance = new WebAssembly.Instance(module, imports); | ||
| return finalizeInit(instance, module); | ||
| } | ||
| async function init(input) { | ||
| if (typeof input === 'undefined') { | ||
| input = new URL('flux-lsp-browser_bg.wasm', import.meta.url); | ||
| } | ||
| const imports = getImports(); | ||
| if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) { | ||
| input = fetch(input); | ||
| } | ||
| initMemory(imports); | ||
| const { instance, module } = await load(await input, imports); | ||
| return finalizeInit(instance, module); | ||
| } | ||
| export { initSync } | ||
| export default init; | ||
| import * as wasm from "./flux-lsp-browser_bg.wasm"; | ||
| export * from "./flux-lsp-browser_bg.js"; |
@@ -7,3 +7,3 @@ { | ||
| "description": "LSP support for the flux language", | ||
| "version": "0.8.26", | ||
| "version": "0.8.27", | ||
| "license": "MIT", | ||
@@ -18,2 +18,3 @@ "repository": { | ||
| "flux-lsp-browser.js", | ||
| "flux-lsp-browser_bg.js", | ||
| "flux-lsp-browser.d.ts" | ||
@@ -20,0 +21,0 @@ ], |
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
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
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
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-0.1%
3652411
- Lines of code
- decreased by-17.27%
436
No dependency changes