@prospective.co/procss 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prospective.co/procss",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "A simple CSS parsing and transformation framework.",
   "repository": {
     "type": "git",

package/src/ast/ruleset/mod.rs

@@ -32,7 +32,7 @@ use crate::transform::TransformCss;
 ///     color: red;
 /// }
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct SelectorRuleset<'a, T>(pub Selector<'a>, pub Vec<T>);
 
 impl<'a, T: RenderCss> RenderCss for SelectorRuleset<'a, T> {
@@ -95,7 +95,7 @@ impl<'a> RenderCss for QualRule<'a> {
 ///     font-family: "My Font";
 /// };
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct QualRuleset<'a, T>(pub QualRule<'a>, pub Vec<T>);
 
 impl<'a, T: RenderCss> RenderCss for QualRuleset<'a, T> {
@@ -139,7 +139,7 @@ impl<'a, T: TransformCss<U>, U> TransformCss<U> for QualRuleset<'a, T> {
 ///     }
 /// }
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct QualNestedRuleset<'a, T>(pub QualRule<'a>, pub Vec<Ruleset<'a, T>>);
 
 impl<'a, T: RenderCss> RenderCss for QualNestedRuleset<'a, T> {
@@ -194,7 +194,7 @@ where
 /// }
 /// ```
 #[allow(clippy::enum_variant_names)]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub enum Ruleset<'a, T> {
     SelectorRuleset(SelectorRuleset<'a, T>),
     QualRule(QualRule<'a>),

package/src/ast/ruleset/rule.rs

@@ -24,7 +24,7 @@ use crate::render::RenderCss;
 use crate::transform::TransformCss;
 
 /// A CSS rule, of the form `xxx: yyy` (delimited by `;` in a ruleset).
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct Rule<'a> {
     pub property: Cow<'a, str>,
     pub value: Cow<'a, str>,

package/src/ast/token/space.rs

@@ -31,14 +31,30 @@ impl NeedsWhitespaceStringExt for str {
     fn needs_pre_ws(&self) -> bool {
         self.chars()
             .next()
-            .map(|x| x.is_ascii_alphanumeric() || x == '-' || x == '_' || x == '%' || x == '+')
+            .map(|x| {
+                x.is_ascii_alphanumeric()
+                    || x == '-'
+                    || x == '_'
+                    || x == '%'
+                    || x == '+'
+                    || x == '"'
+                    || x == '\''
+            })
             .unwrap_or_default()
     }
 
     fn needs_post_ws(&self) -> bool {
         self.chars()
             .last()
-            .map(|x| x.is_ascii_alphanumeric() || x == '-' || x == '_' || x == '%' || x == '+')
+            .map(|x| {
+                x.is_ascii_alphanumeric()
+                    || x == '"'
+                    || x == '\''
+                    || x == '-'
+                    || x == '_'
+                    || x == '%'
+                    || x == '+'
+            })
             .unwrap_or_default()
     }
 }
@@ -57,18 +73,6 @@ pub fn trim_whitespace(s: &str, f: &mut std::fmt::Formatter<'_>) {
     });
 }
 
-// pub fn trim_whitespace(s: &str, f: &mut std::fmt::Formatter<'_>) {
-//     let mut flag = false;
-//     s.split_whitespace().for_each(|w| {
-//         if flag {
-//             write!(f, " ").unwrap();
-//         }
-
-//         flag = flag || !w.is_empty();
-//         write!(f, "{}", w).unwrap();
-//     });
-// }
-
 fn parse_comment<'a, E>(input: &'a str) -> IResult<&'a str, (), E>
 where
     E: ParseError<&'a str>,

package/src/ast/tree_ruleset.rs

@@ -28,7 +28,7 @@ use crate::transform::TransformCss;
 /// A tree node which expresses a recursive `T` over `Ruleset<T>`.  Using this
 /// struct in place of `Rule` allows nested CSS selectors that can be later
 /// flattened.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub enum TreeRule<'a> {
     Rule(Rule<'a>),
     Ruleset(TreeRuleset<'a>),

package/src/ast.rs

@@ -41,7 +41,7 @@ use crate::transformers;
 /// A non-nested "flat" CSS representation, suitable for browser output. The
 /// [`Css`] AST is typically generated via the
 /// [`crate::ast::Tree::flatten_tree`] method.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct Css<'a>(pub Vec<FlatRuleset<'a>>);
 
 impl<'a> Css<'a> {
@@ -67,7 +67,7 @@ impl<'a> Css<'a> {
     }
 
     /// Iterate over the immediate children of this Tree (non-recursive).
-    pub fn iter(&self) -> impl Iterator<Item = &'_ FlatRuleset<'a>> {
+    pub fn iter(&self) -> impl DoubleEndedIterator<Item = &'_ FlatRuleset<'a>> {
         self.0.iter()
     }
 }
@@ -97,7 +97,7 @@ impl<'a> RenderCss for Css<'a> {
 /// [`RenderCss`] if this is needed, though this output can't be read by
 /// browsers and is not identical to the input since whitespace has been
 /// discarded.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct Tree<'a>(pub Vec<TreeRuleset<'a>>);
 
 impl<'a> Tree<'a> {

package/src/builder.rs

@@ -81,8 +81,9 @@ impl<'a> BuildCss<'a> {
             self.trees.insert(path, tree);
         }
 
-        let dep_trees = self.trees.clone();
-        for (path, tree) in self.trees.iter_mut() {
+        for path in self.paths.iter() {
+            let dep_trees = self.trees.clone();
+            let tree = self.trees.get_mut(path.as_path()).unwrap();
             transformers::apply_import(&dep_trees)(tree);
             transformers::apply_mixin(tree);
             transformers::apply_var(tree);
@@ -92,7 +93,10 @@ impl<'a> BuildCss<'a> {
         for (path, css) in self.css.iter_mut() {
             let srcdir = utils::join_paths(&self.rootdir, path);
             transformers::inline_url(&srcdir.to_string_lossy())(css);
-            transformers::dedupe(css);
+            transformers::merge_siblings(css);
+            transformers::remove_mixin(css);
+            transformers::remove_var(css);
+            transformers::deduplicate(css);
         }
 
         Ok(CompiledCss(self))

package/src/lib.rs

@@ -58,8 +58,10 @@
 //!
 //! let mut ast = procss::parse(test).unwrap();
 //! transformers::apply_mixin(&mut ast);
-//! let flat = ast.flatten_tree().as_css_string();
-//! assert_eq!(flat, "div{color:red;}");
+//! let mut flat = ast.flatten_tree();
+//! transformers::remove_mixin(&mut flat);
+//! let css = flat.as_css_string();
+//! assert_eq!(css, "div{color:red;}");
 //! ```
 //!
 //! For coordinating large builds on a tree of CSS files, the [`BuildCss`]

package/src/main.rs

@@ -36,4 +36,6 @@ fn main() {
 }
 
 #[cfg(target_arch = "wasm32")]
-fn main() {}
+fn main() {
+    std::panic::set_hook(Box::new(console_error_panic_hook::hook));
+}

package/src/transformers/apply_mixin.rs

@@ -20,7 +20,7 @@ use crate::ast::*;
 /// # Example
 ///
 /// ```
-/// # use procss::{parse, transformers::apply_mixin, RenderCss};
+/// # use procss::{parse, transformers::apply_mixin, transformers::remove_mixin, RenderCss};
 /// let css = "
 /// @mixin test {
 ///     opacity: 0;
@@ -32,21 +32,21 @@ use crate::ast::*;
 /// ";
 /// let mut tree = parse(css).unwrap();
 /// apply_mixin(&mut tree);
-/// let css = tree.flatten_tree().as_css_string();
+/// let mut flat = tree.flatten_tree();
+/// remove_mixin(&mut flat);
+/// let css = flat.as_css_string();
 /// assert_eq!(css, "div.open{color:red;}div.open{opacity:0;}");
 /// ```
 pub fn apply_mixin<'a>(tree: &mut Tree<'a>) {
     let mut mixins: HashMap<&'a str, Vec<TreeRule<'a>>> = HashMap::new();
     tree.transform(|ruleset| {
-        if let Ruleset::QualRuleset(crate::ast::QualRuleset(QualRule(name, Some(val)), props)) = ruleset {
-            if *name == "mixin"  {
+        if let Ruleset::QualRuleset(crate::ast::QualRuleset(QualRule(name, Some(val)), props)) =
+            ruleset
+        {
+            if *name == "mixin" {
                 mixins.insert(val.trim(), props.clone());
             }
         }
-
-        if matches!(ruleset,  Ruleset::QualRuleset(QualRuleset(QualRule(name, _), _)) if *name == "mixin") {
-            *ruleset = Ruleset::SelectorRuleset(SelectorRuleset(Selector::default(), vec![]))
-        }
     });
 
     let mut count = 5;

package/src/transformers/apply_var.rs

@@ -17,17 +17,11 @@ use crate::ast::*;
 pub fn apply_var<'a>(tree: &mut Tree<'a>) {
     let mut mixins: HashMap<&'a str, &'a str> = HashMap::new();
     tree.transform(|ruleset| {
-        let mut is_mixin = false;
         if let Ruleset::QualRule(QualRule(name, Some(val))) = ruleset {
             if let Some(val) = val.strip_prefix(':') {
                 mixins.insert(name, val);
-                is_mixin = true;
             }
         }
-
-        if is_mixin {
-            *ruleset = Ruleset::QualRuleset(QualRuleset(QualRule("", None), vec![]))
-        }
     });
 
     let mut mixins = mixins.iter().collect::<Vec<_>>();

package/src/transformers/deduplicate.rs

@@ -0,0 +1,27 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use std::collections::HashSet;
+
+use crate::ast::Ruleset::{self};
+use crate::ast::*;
+
+pub fn deduplicate(css: &mut Css) {
+    let mut seen: HashSet<&Ruleset<'_, Rule<'_>>> = HashSet::default();
+    let res = css
+        .iter()
+        .rev()
+        .filter(|x| seen.insert(*x))
+        .rev()
+        .cloned()
+        .collect();
+    *css = crate::ast::Css(res);
+}

package/src/transformers/filter_refs.rs

@@ -14,14 +14,12 @@ use crate::ast::*;
 
 pub fn filter_refs(tree: &mut Tree) {
     *tree = Tree(
-        tree.iter()
-            .cloned()
-            .filter(|y| match y {
+        tree.iter().filter(|&y| match y {
                 Ruleset::SelectorRuleset(_) => false,
                 Ruleset::QualRule(_) => true,
                 Ruleset::QualRuleset(_) => true,
                 Ruleset::QualNestedRuleset(_) => true,
-            })
+            }).cloned()
             .collect(),
     )
 }

package/src/transformers/{dedupe.rs → merge_siblings.rs}

@@ -9,10 +9,12 @@
 // │                                                                           │
 // └───────────────────────────────────────────────────────────────────────────┘
 
+use std::collections::HashSet;
+
 use crate::ast::Ruleset::{self};
 use crate::ast::*;
 
-pub fn dedupe(css: &mut Css) {
+pub fn merge_siblings(css: &mut Css) {
     let mut res = vec![];
     let reduced = css.iter().cloned().reduce(|x, y| match (x, y) {
         (Ruleset::QualRule(x), Ruleset::QualRule(y)) if x == y => Ruleset::QualRule(x),
@@ -31,5 +33,7 @@ pub fn dedupe(css: &mut Css) {
         res.push(reduced.clone());
     }
 
+    let mut seen: HashSet<&Ruleset<'_, Rule<'_>>> = HashSet::default();
+    let res = res.iter().filter(|x| seen.insert(*x)).cloned().collect();
     *css = crate::ast::Css(res)
 }

package/src/transformers/mod.rs

@@ -29,15 +29,21 @@
 mod apply_import;
 mod apply_mixin;
 mod apply_var;
-mod dedupe;
+mod deduplicate;
 mod filter_refs;
 mod flat_self;
 mod inline_url;
+mod merge_siblings;
+mod remove_mixin;
+mod remove_var;
 
 pub use self::apply_import::apply_import;
 pub use self::apply_mixin::apply_mixin;
 pub use self::apply_var::apply_var;
-pub use self::dedupe::dedupe;
+pub use self::deduplicate::deduplicate;
 pub use self::filter_refs::filter_refs;
 pub(crate) use self::flat_self::flat_self;
 pub use self::inline_url::inline_url;
+pub use self::merge_siblings::merge_siblings;
+pub use self::remove_mixin::remove_mixin;
+pub use self::remove_var::remove_var;

package/src/transformers/remove_mixin.rs

@@ -0,0 +1,29 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use crate::ast::Ruleset::{self};
+use crate::ast::*;
+
+pub fn remove_mixin(css: &mut Css) {
+    let reduced = css
+        .iter()
+        .filter(|&x| {
+            !matches!(
+                x,
+                Ruleset::QualRule(QualRule("mixin", _))
+                    | Ruleset::QualNestedRuleset(QualNestedRuleset(QualRule("mixin", _), _))
+                    | Ruleset::QualRuleset(QualRuleset(QualRule("mixin", _), _))
+            )
+        })
+        .cloned();
+
+    *css = crate::ast::Css(reduced.collect())
+}

package/src/transformers/remove_var.rs

@@ -0,0 +1,27 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use crate::ast::Ruleset::{self};
+use crate::ast::*;
+
+pub fn remove_var(css: &mut Css) {
+    let reduced = css
+        .iter()
+        .filter(|&ruleset| match ruleset {
+            Ruleset::QualRule(QualRule(name, Some(val))) if val.strip_prefix(':').is_some() => {
+                false
+            }
+            _ => true,
+        })
+        .cloned();
+
+    *css = crate::ast::Css(reduced.collect())
+}

package/target/cjs/procss.js

@@ -4,43 +4,30 @@ let wasm;
 const { readFileSync } = require(`fs`);
 const { TextDecoder, TextEncoder } = require(`util`);
 
-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;
-}
-
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 
 cachedTextDecoder.decode();
 
-let cachedUint8Memory0 = new Uint8Array();
+let cachedUint8Memory0 = null;
 
 function getUint8Memory0() {
-    if (cachedUint8Memory0.byteLength === 0) {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
         cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
     }
     return cachedUint8Memory0;
 }
 
 function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
     return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }
 
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);
     const idx = heap_next;
@@ -50,6 +37,20 @@ function addHeapObject(obj) {
     return idx;
 }
 
+function getObject(idx) { return heap[idx]; }
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
 let WASM_VECTOR_LEN = 0;
 
 let cachedTextEncoder = new TextEncoder('utf-8');
@@ -71,14 +72,14 @@ function passStringToWasm0(arg, malloc, realloc) {
 
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length);
+        const ptr = malloc(buf.length, 1) >>> 0;
         getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
         WASM_VECTOR_LEN = buf.length;
         return ptr;
     }
 
     let len = arg.length;
-    let ptr = malloc(len);
+    let ptr = malloc(len, 1) >>> 0;
 
     const mem = getUint8Memory0();
 
@@ -94,7 +95,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         if (offset !== 0) {
             arg = arg.slice(offset);
         }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
         const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
         const ret = encodeString(arg, view);
 
@@ -105,17 +106,17 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-let cachedInt32Memory0 = new Int32Array();
+let cachedInt32Memory0 = null;
 
 function getInt32Memory0() {
-    if (cachedInt32Memory0.byteLength === 0) {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
         cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
     }
     return cachedInt32Memory0;
 }
 
 function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1);
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8Memory0().set(arg, ptr / 1);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
@@ -134,16 +135,9 @@ function handleError(f, args) {
 */
 class BuildCss {
 
-    static __wrap(ptr) {
-        const obj = Object.create(BuildCss.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -159,7 +153,8 @@ class BuildCss {
         const ptr0 = passStringToWasm0(rootdir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.buildcss_new(ptr0, len0);
-        return BuildCss.__wrap(ret);
+        this.__wbg_ptr = ret >>> 0;
+        return this;
     }
     /**
     * @param {string} path
@@ -170,7 +165,7 @@ class BuildCss {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        wasm.buildcss_add(this.ptr, ptr0, len0, ptr1, len1);
+        wasm.buildcss_add(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     }
     /**
     * @returns {any}
@@ -178,7 +173,7 @@ class BuildCss {
     compile() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.buildcss_compile(retptr, this.ptr);
+            wasm.buildcss_compile(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -193,42 +188,89 @@ class BuildCss {
 }
 module.exports.BuildCss = BuildCss;
 
-module.exports.__wbg_readFileSync_05b78d1dec4f3f83 = function() { return handleError(function (arg0, arg1, arg2) {
-    const ret = readFileSync(getStringFromWasm0(arg1, arg2));
-    const ptr0 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    getInt32Memory0()[arg0 / 4 + 1] = len0;
-    getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-}, arguments) };
+module.exports.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+};
+
+module.exports.__wbg_new_abda76e883ba8a5f = function() {
+    const ret = new Error();
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+module.exports.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
 
 module.exports.__wbindgen_object_drop_ref = function(arg0) {
     takeObject(arg0);
 };
 
-module.exports.__wbindgen_error_new = function(arg0, arg1) {
-    const ret = new Error(getStringFromWasm0(arg0, arg1));
-    return addHeapObject(ret);
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
 };
 
-module.exports.__wbg_new_268f7b7dd3430798 = function() {
+module.exports.__wbindgen_is_string = function(arg0) {
+    const ret = typeof(getObject(arg0)) === 'string';
+    return ret;
+};
+
+module.exports.__wbg_new_1b94180eeb48f2a2 = function() {
     const ret = new Map();
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_string_new = function(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
+module.exports.__wbg_set_3355b9f2d3092e3b = function(arg0, arg1, arg2) {
+    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_set_933729cf5b66ac11 = function(arg0, arg1, arg2) {
-    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+module.exports.__wbg_new_c728d68b8b34487e = function() {
+    const ret = new Object();
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_throw = function(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
+module.exports.__wbindgen_error_new = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
 };
 
+module.exports.__wbg_String_91fba7ded13ba54c = function(arg0, arg1) {
+    const ret = String(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+module.exports.__wbg_set_20cbc34131e76824 = function(arg0, arg1, arg2) {
+    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+};
+
+module.exports.__wbg_readFileSync_8fc702e6693b9168 = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = readFileSync(getStringFromWasm0(arg1, arg2));
+    const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+}, arguments) };
+
 const path = require('path').join(__dirname, 'procss_bg.wasm');
 const bytes = require('fs').readFileSync(path);
 

package/target/cjs/procss_bg.wasm.d.ts

@@ -6,8 +6,9 @@ export function __wbg_buildcss_free(a: number): void;
 export function buildcss_new(a: number, b: number): number;
 export function buildcss_add(a: number, b: number, c: number, d: number, e: number): void;
 export function buildcss_compile(a: number, b: number): void;
-export function __wbindgen_malloc(a: number): number;
-export function __wbindgen_realloc(a: number, b: number, c: number): number;
+export function __wbindgen_free(a: number, b: number, c: number): void;
+export function __wbindgen_malloc(a: number, b: number): number;
+export function __wbindgen_realloc(a: number, b: number, c: number, d: number): number;
 export function __wbindgen_add_to_stack_pointer(a: number): number;
 export function __wbindgen_exn_store(a: number): void;
 export function __wbindgen_start(): void;

package/target/esm/procss.d.ts

@@ -30,8 +30,9 @@ export interface InitOutput {
   readonly buildcss_new: (a: number, b: number) => number;
   readonly buildcss_add: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly buildcss_compile: (a: number, b: number) => void;
-  readonly __wbindgen_malloc: (a: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
   readonly __wbindgen_exn_store: (a: number) => void;
   readonly __wbindgen_start: () => void;
@@ -56,4 +57,4 @@ export function initSync(module: SyncInitInput): InitOutput;
 *
 * @returns {Promise<InitOutput>}
 */
-export default function init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
+export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;

package/target/esm/procss.js

@@ -2,43 +2,30 @@ import { readFileSync } from 'fs';
 
 let wasm;
 
-const heap = new Array(32).fill(undefined);
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
-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;
-}
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
 
-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 = new Uint8Array();
+let cachedUint8Memory0 = null;
 
 function getUint8Memory0() {
-    if (cachedUint8Memory0.byteLength === 0) {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
         cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
     }
     return cachedUint8Memory0;
 }
 
 function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
     return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }
 
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);
     const idx = heap_next;
@@ -48,9 +35,23 @@ function addHeapObject(obj) {
     return idx;
 }
 
+function getObject(idx) { return heap[idx]; }
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
 let WASM_VECTOR_LEN = 0;
 
-const cachedTextEncoder = new TextEncoder('utf-8');
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
 
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
     ? function (arg, view) {
@@ -69,14 +70,14 @@ function passStringToWasm0(arg, malloc, realloc) {
 
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length);
+        const ptr = malloc(buf.length, 1) >>> 0;
         getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
         WASM_VECTOR_LEN = buf.length;
         return ptr;
     }
 
     let len = arg.length;
-    let ptr = malloc(len);
+    let ptr = malloc(len, 1) >>> 0;
 
     const mem = getUint8Memory0();
 
@@ -92,7 +93,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         if (offset !== 0) {
             arg = arg.slice(offset);
         }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
         const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
         const ret = encodeString(arg, view);
 
@@ -103,17 +104,17 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-let cachedInt32Memory0 = new Int32Array();
+let cachedInt32Memory0 = null;
 
 function getInt32Memory0() {
-    if (cachedInt32Memory0.byteLength === 0) {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
         cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
     }
     return cachedInt32Memory0;
 }
 
 function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1);
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8Memory0().set(arg, ptr / 1);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
@@ -132,16 +133,9 @@ function handleError(f, args) {
 */
 export class BuildCss {
 
-    static __wrap(ptr) {
-        const obj = Object.create(BuildCss.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
 
         return ptr;
     }
@@ -157,7 +151,8 @@ export class BuildCss {
         const ptr0 = passStringToWasm0(rootdir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.buildcss_new(ptr0, len0);
-        return BuildCss.__wrap(ret);
+        this.__wbg_ptr = ret >>> 0;
+        return this;
     }
     /**
     * @param {string} path
@@ -168,7 +163,7 @@ export class BuildCss {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        wasm.buildcss_add(this.ptr, ptr0, len0, ptr1, len1);
+        wasm.buildcss_add(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     }
     /**
     * @returns {any}
@@ -176,7 +171,7 @@ export class BuildCss {
     compile() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.buildcss_compile(retptr, this.ptr);
+            wasm.buildcss_compile(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -190,7 +185,7 @@ export class BuildCss {
     }
 }
 
-async function load(module, imports) {
+async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
@@ -221,60 +216,102 @@ async function load(module, imports) {
     }
 }
 
-function getImports() {
+function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_readFileSync_05b78d1dec4f3f83 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = readFileSync(getStringFromWasm0(arg1, arg2));
-        const ptr0 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
-    }, arguments) };
-    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
-        takeObject(arg0);
+    imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
     };
-    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
-        const ret = new Error(getStringFromWasm0(arg0, arg1));
+    imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
+        const ret = new Error();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_268f7b7dd3430798 = function() {
-        const ret = new Map();
-        return addHeapObject(ret);
+    imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
+        const ret = getObject(arg1).stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
     imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_933729cf5b66ac11 = function(arg0, arg1, arg2) {
-        const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
     };
     imports.wbg.__wbindgen_throw = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
+    imports.wbg.__wbindgen_is_string = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbg_new_1b94180eeb48f2a2 = function() {
+        const ret = new Map();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_3355b9f2d3092e3b = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_c728d68b8b34487e = function() {
+        const ret = new Object();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_String_91fba7ded13ba54c = function(arg0, arg1) {
+        const ret = String(getObject(arg1));
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+    };
+    imports.wbg.__wbg_set_20cbc34131e76824 = function(arg0, arg1, arg2) {
+        getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_readFileSync_8fc702e6693b9168 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = readFileSync(getStringFromWasm0(arg1, arg2));
+        const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+    }, arguments) };
 
     return imports;
 }
 
-function initMemory(imports, maybe_memory) {
+function __wbg_init_memory(imports, maybe_memory) {
 
 }
 
-function finalizeInit(instance, module) {
+function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
-    init.__wbindgen_wasm_module = module;
-    cachedInt32Memory0 = new Int32Array();
-    cachedUint8Memory0 = new Uint8Array();
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedInt32Memory0 = null;
+    cachedUint8Memory0 = null;
 
     wasm.__wbindgen_start();
     return wasm;
 }
 
 function initSync(module) {
-    const imports = getImports();
+    if (wasm !== undefined) return wasm;
 
-    initMemory(imports);
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
 
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
@@ -282,25 +319,27 @@ function initSync(module) {
 
     const instance = new WebAssembly.Instance(module, imports);
 
-    return finalizeInit(instance, module);
+    return __wbg_finalize_init(instance, module);
 }
 
-async function init(input) {
+async function __wbg_init(input) {
+    if (wasm !== undefined) return wasm;
+
     if (typeof input === 'undefined') {
         input = new URL('procss_bg.wasm', import.meta.url);
     }
-    const imports = getImports();
+    const imports = __wbg_get_imports();
 
     if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
         input = fetch(input);
     }
 
-    initMemory(imports);
+    __wbg_init_memory(imports);
 
-    const { instance, module } = await load(await input, imports);
+    const { instance, module } = await __wbg_load(await input, imports);
 
-    return finalizeInit(instance, module);
+    return __wbg_finalize_init(instance, module);
 }
 
 export { initSync }
-export default init;
+export default __wbg_init;

package/target/esm/procss_bg.wasm.d.ts

@@ -6,8 +6,9 @@ export function __wbg_buildcss_free(a: number): void;
 export function buildcss_new(a: number, b: number): number;
 export function buildcss_add(a: number, b: number, c: number, d: number, e: number): void;
 export function buildcss_compile(a: number, b: number): void;
-export function __wbindgen_malloc(a: number): number;
-export function __wbindgen_realloc(a: number, b: number, c: number): number;
+export function __wbindgen_free(a: number, b: number, c: number): void;
+export function __wbindgen_malloc(a: number, b: number): number;
+export function __wbindgen_realloc(a: number, b: number, c: number, d: number): number;
 export function __wbindgen_add_to_stack_pointer(a: number): number;
 export function __wbindgen_exn_store(a: number): void;
 export function __wbindgen_start(): void;