@rhcp/mimir_transforms_web - npm Package Compare versions

Comparing version 0.1.3 to 0.2.0

mimir_transforms.d.ts

 /* tslint:disable */
 /* eslint-disable */
 /**
-* Replace invalid markdown headings such as '#Title' with '# Title' in a string.
+* Replace invalid markdown headings such as '#Title' and '# Title #' with CommonMark-compliant '# Title' in a string.
 * @param {string} input
@@ -22,2 +22,139 @@ * @returns {string}
 export function imageShortcode(input: string): string;
+/**
+* Pew pew.  Fix some Markdown syntax by giving HTML elements inside Markdown some breathing room.
+*
+* spaceInvader adds newlines around _top-level_ HTML elements.  This fixes many
+* php-markdown-extra conflicts with CommonMark, since CommonMark wants empty lines around many
+* markdown structures, lest they be considered part of the HTML block itself.
+*
+* Before:
+*
+* ```markdown
+* <hr>
+* # Heading
+* <marquee>WHEEEEEE</marquee>
+*  - item 1
+*  - item 2
+* ```
+*
+* After:
+*
+* ```markdown
+* <hr>
+*
+* # Heading
+*
+* <marquee>WHEEEEEE</marquee>
+*
+*  - item 1
+*  - item 2
+* ```
+* @param {string} input
+* @returns {string}
+*/
+export function spaceInvader(input: string): string;
+/**
+* Replace Windows newlines with UNIX newlines.
+* @param {string} input
+* @returns {string}
+*/
+export function newlines(input: string): string;
+/**
+* Adds <br> for each line break within Markdown paragraphs.  CommonMark usually (see @see) ignores
+* line breaks within paragraphs, but many Markdown engines render them as <br>.  This transform
+* adds <br> before each '\n' inside Markdown paragraphs.
+* @see https://commonmark.org/help/tutorial/03-paragraphs.html
+* @param {string} input
+* @returns {string}
+*/
+export function breakThings(input: string): string;
+/**
+* Fix table rendering.  This transform performs two changes to Markdown tables.
+*
+*  1. Balances the number of columns in the table head.  For example, this table with an
+*     unbalanced head:
+*     | Name | Value |
+*     | ---  | ---   | --- |
+*     Will be transformed to:
+*     | Name | Value |
+*     -|-
+*     So that it will render correctly in CommonMark-compliant environments.
+*  2. Ensures an empty line precedes the table.  In some Markdown engines, if a table is preceded
+*     by a paragraph with no intervening empty line, they will be treated as text within the
+*     paragraph instead of being rendered as a <table>.  This transform adds a preceding empty
+*     line if one is not already present.
+* @param {string} input
+* @returns {string}
+*/
+export function tableFlip(input: string): string;
+/**
+* Handler for `console.log` invocations.
+*
+* If a test is currently running it takes the `args` array and stringifies
+* it and appends it to the current output of the test. Otherwise it passes
+* the arguments to the original `console.log` function, psased as
+* `original`.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_log(args: Array<any>): void;
+/**
+* Handler for `console.debug` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_debug(args: Array<any>): void;
+/**
+* Handler for `console.info` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_info(args: Array<any>): void;
+/**
+* Handler for `console.warn` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_warn(args: Array<any>): void;
+/**
+* Handler for `console.error` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_error(args: Array<any>): void;
+/**
+* Runtime test harness support instantiated in JS.
+*
+* The node.js entry script instantiates a `Context` here which is used to
+* drive test execution.
+*/
+export class WasmBindgenTestContext {
+  free(): void;
+/**
+* Creates a new context ready to run tests.
+*
+* A `Context` is the main structure through which test execution is
+* coordinated, and this will collect output and results for all executed
+* tests.
+*/
+  constructor();
+/**
+* Inform this context about runtime arguments passed to the test
+* harness.
+*
+* Eventually this will be used to support flags, but for now it's just
+* used to support test filters.
+* @param {any[]} args
+*/
+  args(args: any[]): void;
+/**
+* Executes a list of tests, returning a promise representing their
+* eventual completion.
+*
+* This is the main entry point for executing tests. All the tests passed
+* in are the JS `Function` object that was plucked off the
+* `WebAssembly.Instance` exports list.
+*
+* The promise returned resolves to either `true` if all tests passed or
+* `false` if at least one test failed.
+* @param {any[]} tests
+* @returns {Promise<any>}
+*/
+  run(tests: any[]): Promise<any>;
+}
 
@@ -31,6 +168,24 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
   readonly imageShortcode: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly spaceInvader: (a: number, b: number, c: number) => void;
+  readonly newlines: (a: number, b: number, c: number) => void;
+  readonly breakThings: (a: number, b: number, c: number) => void;
+  readonly tableFlip: (a: number, b: number, c: number) => void;
+  readonly __wbg_wasmbindgentestcontext_free: (a: number) => void;
+  readonly wasmbindgentestcontext_new: () => number;
+  readonly wasmbindgentestcontext_args: (a: number, b: number, c: number) => void;
+  readonly wasmbindgentestcontext_run: (a: number, b: number, c: number) => number;
+  readonly __wbgtest_console_log: (a: number) => void;
+  readonly __wbgtest_console_debug: (a: number) => void;
+  readonly __wbgtest_console_info: (a: number) => void;
+  readonly __wbgtest_console_warn: (a: number) => void;
+  readonly __wbgtest_console_error: (a: number) => void;
   readonly __wbindgen_malloc: (a: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number) => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly wasm_bindgen__convert__closures__invoke1_mut__h3a4d52884c3c9722: (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 wasm_bindgen__convert__closures__invoke3_mut__h6a6c0665689d1f42: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly wasm_bindgen__convert__closures__invoke2_mut__h1f6298ab927f9790: (a: number, b: number, c: number, d: number) => void;
 }
@@ -37,0 +192,0 @@

mimir_transforms.js

@@ -24,2 +24,11 @@
 
+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;
@@ -89,2 +98,6 @@
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
 let cachedInt32Memory0 = new Int32Array();
@@ -106,4 +119,33 @@
 }
+
+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_18(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures__invoke1_mut__h3a4d52884c3c9722(arg0, arg1, addHeapObject(arg2));
+}
+
 /**
-* Replace invalid markdown headings such as '#Title' with '# Title' in a string.
+* Replace invalid markdown headings such as '#Title' and '# Title #' with CommonMark-compliant '# Title' in a string.
 * @param {string} input
@@ -168,11 +210,302 @@ * @returns {string}
 
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
+/**
+* Pew pew.  Fix some Markdown syntax by giving HTML elements inside Markdown some breathing room.
+*
+* spaceInvader adds newlines around _top-level_ HTML elements.  This fixes many
+* php-markdown-extra conflicts with CommonMark, since CommonMark wants empty lines around many
+* markdown structures, lest they be considered part of the HTML block itself.
+*
+* Before:
+*
+* ```markdown
+* <hr>
+* # Heading
+* <marquee>WHEEEEEE</marquee>
+*  - item 1
+*  - item 2
+* ```
+*
+* After:
+*
+* ```markdown
+* <hr>
+*
+* # Heading
+*
+* <marquee>WHEEEEEE</marquee>
+*
+*  - item 1
+*  - item 2
+* ```
+* @param {string} input
+* @returns {string}
+*/
+export function spaceInvader(input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.spaceInvader(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(r0, r1);
+    }
+}
 
-    heap[idx] = obj;
-    return idx;
+/**
+* Replace Windows newlines with UNIX newlines.
+* @param {string} input
+* @returns {string}
+*/
+export function newlines(input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.newlines(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(r0, r1);
+    }
 }
 
+/**
+* Adds <br> for each line break within Markdown paragraphs.  CommonMark usually (see @see) ignores
+* line breaks within paragraphs, but many Markdown engines render them as <br>.  This transform
+* adds <br> before each '\n' inside Markdown paragraphs.
+* @see https://commonmark.org/help/tutorial/03-paragraphs.html
+* @param {string} input
+* @returns {string}
+*/
+export function breakThings(input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.breakThings(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(r0, r1);
+    }
+}
+
+/**
+* Fix table rendering.  This transform performs two changes to Markdown tables.
+*
+*  1. Balances the number of columns in the table head.  For example, this table with an
+*     unbalanced head:
+*     | Name | Value |
+*     | ---  | ---   | --- |
+*     Will be transformed to:
+*     | Name | Value |
+*     -|-
+*     So that it will render correctly in CommonMark-compliant environments.
+*  2. Ensures an empty line precedes the table.  In some Markdown engines, if a table is preceded
+*     by a paragraph with no intervening empty line, they will be treated as text within the
+*     paragraph instead of being rendered as a <table>.  This transform adds a preceding empty
+*     line if one is not already present.
+* @param {string} input
+* @returns {string}
+*/
+export function tableFlip(input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.tableFlip(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(r0, r1);
+    }
+}
+
+let cachedUint32Memory0 = new Uint32Array();
+
+function getUint32Memory0() {
+    if (cachedUint32Memory0.byteLength === 0) {
+        cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32Memory0;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4);
+    const mem = getUint32Memory0();
+    for (let i = 0; i < array.length; i++) {
+        mem[ptr / 4 + i] = addHeapObject(array[i]);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+let stack_pointer = 32;
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+/**
+* Handler for `console.log` invocations.
+*
+* If a test is currently running it takes the `args` array and stringifies
+* it and appends it to the current output of the test. Otherwise it passes
+* the arguments to the original `console.log` function, psased as
+* `original`.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_log(args) {
+    try {
+        wasm.__wbgtest_console_log(addBorrowedObject(args));
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+/**
+* Handler for `console.debug` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_debug(args) {
+    try {
+        wasm.__wbgtest_console_debug(addBorrowedObject(args));
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+/**
+* Handler for `console.info` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_info(args) {
+    try {
+        wasm.__wbgtest_console_info(addBorrowedObject(args));
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+/**
+* Handler for `console.warn` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_warn(args) {
+    try {
+        wasm.__wbgtest_console_warn(addBorrowedObject(args));
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+/**
+* Handler for `console.error` invocations. See above.
+* @param {Array<any>} args
+*/
+export function __wbgtest_console_error(args) {
+    try {
+        wasm.__wbgtest_console_error(addBorrowedObject(args));
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+function __wbg_adapter_58(arg0, arg1, arg2, arg3, arg4) {
+    wasm.wasm_bindgen__convert__closures__invoke3_mut__h6a6c0665689d1f42(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+function __wbg_adapter_71(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures__invoke2_mut__h1f6298ab927f9790(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+/**
+* Runtime test harness support instantiated in JS.
+*
+* The node.js entry script instantiates a `Context` here which is used to
+* drive test execution.
+*/
+export class WasmBindgenTestContext {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmBindgenTestContext.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_wasmbindgentestcontext_free(ptr);
+    }
+    /**
+    * Creates a new context ready to run tests.
+    *
+    * A `Context` is the main structure through which test execution is
+    * coordinated, and this will collect output and results for all executed
+    * tests.
+    */
+    constructor() {
+        const ret = wasm.wasmbindgentestcontext_new();
+        return WasmBindgenTestContext.__wrap(ret);
+    }
+    /**
+    * Inform this context about runtime arguments passed to the test
+    * harness.
+    *
+    * Eventually this will be used to support flags, but for now it's just
+    * used to support test filters.
+    * @param {any[]} args
+    */
+    args(args) {
+        const ptr0 = passArrayJsValueToWasm0(args, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmbindgentestcontext_args(this.ptr, ptr0, len0);
+    }
+    /**
+    * Executes a list of tests, returning a promise representing their
+    * eventual completion.
+    *
+    * This is the main entry point for executing tests. All the tests passed
+    * in are the JS `Function` object that was plucked off the
+    * `WebAssembly.Instance` exports list.
+    *
+    * The promise returned resolves to either `true` if all tests passed or
+    * `false` if at least one test failed.
+    * @param {any[]} tests
+    * @returns {Promise<any>}
+    */
+    run(tests) {
+        const ptr0 = passArrayJsValueToWasm0(tests, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmbindgentestcontext_run(this.ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+}
+
 async function load(module, imports) {
@@ -212,2 +545,68 @@ if (typeof Response === 'function' && module instanceof Response) {
     imports.wbg = {};
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbg_static_accessor_document_0187e21f53c04a48 = function() {
+        const ret = document;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getElementById_4c39186cc7ced742 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_settextcontent_344de5dc2a8e15ca = function(arg0, arg1, arg2) {
+        getObject(arg0).textContent = getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_textcontent_46a9e23ba5cbd900 = function(arg0, arg1) {
+        const ret = getObject(arg1).textContent;
+        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_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_stack_2ac21c4ea9c454f4 = function(arg0) {
+        const ret = getObject(arg0).stack;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_self_74338d9cb12c5d75 = function(arg0) {
+        const ret = getObject(arg0).self;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
+        const ret = getObject(arg0) === getObject(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_log_d59c74802fa44fe2 = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_stack_475ccfd121fab8c9 = 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_String_0713d2a3d2b5f6b1 = function(arg0, arg1) {
+        const ret = String(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_number_new = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
@@ -231,5 +630,101 @@ const ret = new Error();
     };
-    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
-        takeObject(arg0);
+    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_newnoargs_b5b063fc6c2f0376 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_call_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_forEach_ce1177df15902e0c = function(arg0, arg1, arg2) {
+        try {
+            var state0 = {a: arg1, b: arg2};
+            var cb0 = (arg0, arg1, arg2) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wbg_adapter_58(a, state0.b, arg0, arg1, arg2);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            getObject(arg0).forEach(cb0);
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_message_fe2af63ccc8985bc = function(arg0) {
+        const ret = getObject(arg0).message;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_name_48eda3ae6aa697ca = function(arg0) {
+        const ret = getObject(arg0).name;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_call_168da88779e35f61 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_new_9962f939219f1820 = 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_71(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_99fe17964f31ffc0 = function(arg0) {
+        const ret = Promise.resolve(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_then_11f7a54d67b4bfad = function(arg0, arg1) {
+        const ret = getObject(arg0).then(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_self_6d479506f72c6a71 = function() { return handleError(function () {
+        const ret = self.self;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_window_f2557cc78490aceb = function() { return handleError(function () {
+        const ret = window.window;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_globalThis_7f206bda628d5286 = function() { return handleError(function () {
+        const ret = globalThis.globalThis;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_global_ba75c50d1cf384f4 = function() { return handleError(function () {
+        const ret = global.global;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_closure_wrapper149 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 51, __wbg_adapter_18);
+        return addHeapObject(ret);
+    };
 
@@ -247,2 +742,3 @@ return imports;
     cachedInt32Memory0 = new Int32Array();
+    cachedUint32Memory0 = new Uint32Array();
     cachedUint8Memory0 = new Uint8Array();
@@ -249,0 +745,0 @@

package.json

@@ -7,3 +7,3 @@ {
   "description": "A WebAssembly build of Mimir transforms, suitable for use in Nodejs and browsers.",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "license": "MIT",
@@ -17,3 +17,5 @@ "files": [
   "types": "mimir_transforms.d.ts",
-  "sideEffects": false
+  "sideEffects": [
+    "./snippets/*"
+  ]
 }

README.md

@@ -11,2 +11,3 @@ # Mimir's transforms packaged for WebAssembly
 cargo install wasm-pack
+sudo dnf install chromedriver
 ```
@@ -13,0 +14,0 @@

New alerts

Major refactor

Supply chain risk

Package 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

Improved metrics

Total package byte prevSize

1497970

increased by42.25%

Lines of code

900

increased by227.27%

Number of lines in readme file

73

increased by1.39%

Worsened metrics

Number of medium supply chain risk alerts

2

increased by100%

No dependency changes