@meonode/canvas 2.0.2 → 2.0.3

package/dist/cjs/worker/render.worker.js

@@ -1,73 +1,70 @@
 'use strict';
 
-var worker_threads = require('worker_threads');
+var node_worker_threads = require('node:worker_threads');
+require('./comlink.setup.js');
 var root_canvas = require('../canvas/root.canvas.js');
+var Comlink = require('comlink');
+var nodeEndpoint = require('comlink/dist/esm/node-adapter.mjs');
 
-/**
- * Worker thread entry point for off-main-thread canvas rendering.
- *
- * Message protocol (main → worker):
- *   { type: 'render', taskId, props }                      — render and keep Canvas alive
- *   { type: 'call',   taskId, canvasId, method, args }     — call a method on a live Canvas
- *   { type: 'release', canvasId }                          — free Canvas from memory
- *
- * Responses (worker → main):
- *   WorkerRenderResponse  — render complete (includes pre-encoded PNG buffer)
- *   WorkerCallResponse    — method call result
- *   WorkerErrorResponse   — any failure
- */
-if (!worker_threads.parentPort) {
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var Comlink__namespace = /*#__PURE__*/_interopNamespaceDefault(Comlink);
+
+if (!node_worker_threads.parentPort) {
     throw new Error('[render.worker] Must be run as a worker thread');
 }
 const canvases = new Map();
 let nextCanvasId = 0;
-function reply(msg) {
-    worker_threads.parentPort.postMessage(msg);
-}
-worker_threads.parentPort.on('message', async (msg) => {
-    if (msg.type === 'render') {
-        try {
-            const canvas = await new root_canvas.RootNode(msg.props).render();
-            const canvasId = nextCanvasId++;
-            canvases.set(canvasId, canvas);
-            reply({ taskId: msg.taskId, canvasId, buffer: canvas.toBufferSync('png'), width: canvas.width, height: canvas.height });
-        }
-        catch (err) {
-            reply({ taskId: msg.taskId, error: String(err) });
-        }
-    }
-    else if (msg.type === 'call') {
-        const canvas = canvases.get(msg.canvasId);
+const api = {
+    async render(props) {
+        const canvas = await new root_canvas.RootNode(props).render();
+        const canvasId = nextCanvasId++;
+        canvases.set(canvasId, canvas);
+        const result = {
+            canvasId,
+            buffer: canvas.toBufferSync('png'),
+            width: canvas.width,
+            height: canvas.height,
+        };
+        return result;
+    },
+    async callOnCanvas(canvasId, method, args) {
+        const canvas = canvases.get(canvasId);
         if (!canvas) {
-            reply({ taskId: msg.taskId, error: `[render.worker] Canvas ${msg.canvasId} not found` });
-            return;
-        }
-        try {
-            let result;
-            switch (msg.method) {
-                case 'toBuffer':
-                    result = await canvas.toBuffer(...msg.args);
-                    break;
-                case 'toURL':
-                    result = await canvas.toURL(...msg.args);
-                    break;
-                case 'toFile':
-                    result = await canvas.toFile(...msg.args);
-                    break;
-                case 'toSharp':
-                    // Sharp instances can't be transferred across threads — serialize to buffer
-                    result = await canvas.toSharp(...msg.args).toBuffer();
-                    break;
-            }
-            reply({ taskId: msg.taskId, result });
+            throw new Error(`[render.worker] Canvas ${canvasId} not found`);
         }
-        catch (err) {
-            reply({ taskId: msg.taskId, error: String(err) });
+        switch (method) {
+            case 'toBuffer':
+                return canvas.toBuffer(...args);
+            case 'toURL':
+                return canvas.toURL(...args);
+            case 'toFile':
+                await canvas.toFile(...args);
+                return;
+            case 'toSharp':
+                return await canvas.toSharp(...args).toBuffer();
+            default:
+                throw new Error(`[render.worker] Unknown method: ${method}`);
         }
-    }
-    else {
-        // type === 'release'
-        canvases.delete(msg.canvasId);
-    }
-});
+    },
+    releaseCanvas(canvasId) {
+        canvases.delete(canvasId);
+    },
+};
+Comlink__namespace.expose(api, nodeEndpoint(node_worker_threads.parentPort));
 //# sourceMappingURL=render.worker.js.map

package/dist/cjs/worker/render.worker.js.map

@@ -1 +1 @@
-{"version":3,"file":"render.worker.js","sources":["../../../../../src/worker/render.worker.ts"],"sourcesContent":["/**\n * Worker thread entry point for off-main-thread canvas rendering.\n *\n * Message protocol (main → worker):\n *   { type: 'render', taskId, props }                      — render and keep Canvas alive\n *   { type: 'call',   taskId, canvasId, method, args }     — call a method on a live Canvas\n *   { type: 'release', canvasId }                          — free Canvas from memory\n *\n * Responses (worker → main):\n *   WorkerRenderResponse  — render complete (includes pre-encoded PNG buffer)\n *   WorkerCallResponse    — method call result\n *   WorkerErrorResponse   — any failure\n */\nimport { parentPort } from 'worker_threads'\nimport { RootNode } from '@/canvas/root.canvas.js'\nimport type { Canvas } from 'skia-canvas'\nimport type { WorkerRequest, WorkerRenderResponse, WorkerCallResponse, WorkerErrorResponse } from '@/worker/worker.types.js'\n\nif (!parentPort) {\n  throw new Error('[render.worker] Must be run as a worker thread')\n}\n\nconst canvases = new Map<number, Canvas>()\nlet nextCanvasId = 0\n\nfunction reply(msg: WorkerRenderResponse | WorkerCallResponse | WorkerErrorResponse) {\n  parentPort!.postMessage(msg)\n}\n\nparentPort.on('message', async (msg: WorkerRequest) => {\n  if (msg.type === 'render') {\n    try {\n      const canvas = await new RootNode(msg.props).render()\n      const canvasId = nextCanvasId++\n      canvases.set(canvasId, canvas)\n      reply({ taskId: msg.taskId, canvasId, buffer: canvas.toBufferSync('png'), width: canvas.width, height: canvas.height })\n    } catch (err) {\n      reply({ taskId: msg.taskId, error: String(err) })\n    }\n  } else if (msg.type === 'call') {\n    const canvas = canvases.get(msg.canvasId)\n    if (!canvas) {\n      reply({ taskId: msg.taskId, error: `[render.worker] Canvas ${msg.canvasId} not found` })\n      return\n    }\n    try {\n      let result: Buffer | string | void\n      switch (msg.method) {\n        case 'toBuffer':\n          result = await canvas.toBuffer(...msg.args)\n          break\n        case 'toURL':\n          result = await canvas.toURL(...msg.args)\n          break\n        case 'toFile':\n          result = await canvas.toFile(...msg.args)\n          break\n        case 'toSharp':\n          // Sharp instances can't be transferred across threads — serialize to buffer\n          result = await canvas.toSharp(...msg.args).toBuffer()\n          break\n      }\n      reply({ taskId: msg.taskId, result })\n    } catch (err) {\n      reply({ taskId: msg.taskId, error: String(err) })\n    }\n  } else {\n    // type === 'release'\n    canvases.delete(msg.canvasId)\n  }\n})\n"],"names":["parentPort","RootNode"],"mappings":";;;;;AAAA;;;;;;;;;;;;AAYG;AAMH,IAAI,CAACA,yBAAU,EAAE;AACf,IAAA,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC;AACnE;AAEA,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkB;AAC1C,IAAI,YAAY,GAAG,CAAC;AAEpB,SAAS,KAAK,CAAC,GAAoE,EAAA;AACjF,IAAAA,yBAAW,CAAC,WAAW,CAAC,GAAG,CAAC;AAC9B;AAEAA,yBAAU,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,GAAkB,KAAI;AACpD,IAAA,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE;AACzB,QAAA,IAAI;AACF,YAAA,MAAM,MAAM,GAAG,MAAM,IAAIC,oBAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE;AACrD,YAAA,MAAM,QAAQ,GAAG,YAAY,EAAE;AAC/B,YAAA,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC;AAC9B,YAAA,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;QACzH;QAAE,OAAO,GAAG,EAAE;AACZ,YAAA,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QACnD;IACF;AAAO,SAAA,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,EAAE;QAC9B,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC;QACzC,IAAI,CAAC,MAAM,EAAE;AACX,YAAA,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,0BAA0B,GAAG,CAAC,QAAQ,CAAA,UAAA,CAAY,EAAE,CAAC;YACxF;QACF;AACA,QAAA,IAAI;AACF,YAAA,IAAI,MAA8B;AAClC,YAAA,QAAQ,GAAG,CAAC,MAAM;AAChB,gBAAA,KAAK,UAAU;oBACb,MAAM,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC;oBAC3C;AACF,gBAAA,KAAK,OAAO;oBACV,MAAM,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC;oBACxC;AACF,gBAAA,KAAK,QAAQ;oBACX,MAAM,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC;oBACzC;AACF,gBAAA,KAAK,SAAS;;AAEZ,oBAAA,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE;oBACrD;;YAEJ,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QACvC;QAAE,OAAO,GAAG,EAAE;AACZ,YAAA,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QACnD;IACF;SAAO;;AAEL,QAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAC/B;AACF,CAAC,CAAC;;"}
+{"version":3,"file":"render.worker.js","sources":["../../../../../src/worker/render.worker.ts"],"sourcesContent":["import { parentPort } from 'node:worker_threads'\nimport { Comlink, nodeEndpoint } from '@/worker/comlink.setup.js'\nimport { RootNode } from '@/canvas/root.canvas.js'\nimport type { Canvas } from 'skia-canvas'\nimport type { WorkerAPI, RenderResult } from '@/worker/worker.types.js'\n\nif (!parentPort) {\n  throw new Error('[render.worker] Must be run as a worker thread')\n}\n\nconst canvases = new Map<number, Canvas>()\nlet nextCanvasId = 0\n\nconst api: WorkerAPI = {\n  async render(props) {\n    const canvas = await new RootNode(props).render()\n    const canvasId = nextCanvasId++\n    canvases.set(canvasId, canvas)\n    const result: RenderResult = {\n      canvasId,\n      buffer: canvas.toBufferSync('png'),\n      width: canvas.width,\n      height: canvas.height,\n    }\n    return result\n  },\n\n  async callOnCanvas(canvasId, method, args) {\n    const canvas = canvases.get(canvasId)\n    if (!canvas) {\n      throw new Error(`[render.worker] Canvas ${canvasId} not found`)\n    }\n    switch (method) {\n      case 'toBuffer':\n        return canvas.toBuffer(...(args as [any, any?]))\n      case 'toURL':\n        return canvas.toURL(...(args as [any, any?]))\n      case 'toFile':\n        await canvas.toFile(...(args as [string, any?]))\n        return\n      case 'toSharp':\n        return await canvas.toSharp(...(args as [any?])).toBuffer()\n      default:\n        throw new Error(`[render.worker] Unknown method: ${method}`)\n    }\n  },\n\n  releaseCanvas(canvasId) {\n    canvases.delete(canvasId)\n  },\n}\n\nComlink.expose(api, nodeEndpoint(parentPort))\n"],"names":["parentPort","RootNode","Comlink"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,IAAI,CAACA,8BAAU,EAAE;AACf,IAAA,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC;AACnE;AAEA,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkB;AAC1C,IAAI,YAAY,GAAG,CAAC;AAEpB,MAAM,GAAG,GAAc;IACrB,MAAM,MAAM,CAAC,KAAK,EAAA;QAChB,MAAM,MAAM,GAAG,MAAM,IAAIC,oBAAQ,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE;AACjD,QAAA,MAAM,QAAQ,GAAG,YAAY,EAAE;AAC/B,QAAA,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC;AAC9B,QAAA,MAAM,MAAM,GAAiB;YAC3B,QAAQ;AACR,YAAA,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC;YAClC,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,MAAM,EAAE,MAAM,CAAC,MAAM;SACtB;AACD,QAAA,OAAO,MAAM;IACf,CAAC;AAED,IAAA,MAAM,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAA;QACvC,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC;QACrC,IAAI,CAAC,MAAM,EAAE;AACX,YAAA,MAAM,IAAI,KAAK,CAAC,0BAA0B,QAAQ,CAAA,UAAA,CAAY,CAAC;QACjE;QACA,QAAQ,MAAM;AACZ,YAAA,KAAK,UAAU;AACb,gBAAA,OAAO,MAAM,CAAC,QAAQ,CAAC,GAAI,IAAoB,CAAC;AAClD,YAAA,KAAK,OAAO;AACV,gBAAA,OAAO,MAAM,CAAC,KAAK,CAAC,GAAI,IAAoB,CAAC;AAC/C,YAAA,KAAK,QAAQ;AACX,gBAAA,MAAM,MAAM,CAAC,MAAM,CAAC,GAAI,IAAuB,CAAC;gBAChD;AACF,YAAA,KAAK,SAAS;gBACZ,OAAO,MAAM,MAAM,CAAC,OAAO,CAAC,GAAI,IAAe,CAAC,CAAC,QAAQ,EAAE;AAC7D,YAAA;AACE,gBAAA,MAAM,IAAI,KAAK,CAAC,mCAAmC,MAAM,CAAA,CAAE,CAAC;;IAElE,CAAC;AAED,IAAA,aAAa,CAAC,QAAQ,EAAA;AACpB,QAAA,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC;IAC3B,CAAC;CACF;AAEDC,kBAAO,CAAC,MAAM,CAAC,GAAG,EAAE,YAAY,CAACF,8BAAU,CAAC,CAAC;;"}

package/dist/esm/canvas/canvas.helper.js

@@ -209,234 +209,5 @@ function parsePercentage(value, base) {
     }
     return 0;
 }
-/**
- * Pre-processes a RootProps descriptor tree on the main thread before postMessage.
- * Executes function props against available data, stores results as serializable fields,
- * then strips remaining functions as a safety net.
- */
-class WorkerPreProcessor {
-    static CHART_COLORS = ['#FF6384', '#36A2EB', '#FFCE56', '#4BC0C0', '#9966FF', '#FF9F40', '#C9CBCF'];
-    static process(props) {
-        const cloned = { ...props };
-        if (cloned.children) {
-            const childArray = Array.isArray(cloned.children) ? cloned.children : [cloned.children];
-            cloned.children = childArray.map(child => {
-                if (child && typeof child === 'object' && '__type' in child) {
-                    return this.processDescriptor(child);
-                }
-                return child;
-            });
-        }
-        return this.stripNonSerializable(cloned);
-    }
-    static processDescriptor(desc) {
-        if (desc.__type === 'Chart') {
-            return this.processChartDescriptor(desc);
-        }
-        if ('children' in desc && desc.children) {
-            return { ...desc, children: desc.children.map(c => this.processDescriptor(c)) };
-        }
-        return desc;
-    }
-    static processChartDescriptor(desc) {
-        const props = { ...desc.props };
-        const options = { ...(props.options || {}) };
-        const chartType = props.type;
-        const data = props.data;
-        // xAxisLabelFormatter
-        if (typeof options.xAxisLabelFormatter === 'function' && (chartType === 'bar' || chartType === 'line')) {
-            const cartData = data;
-            if (cartData.labels) {
-                options._preComputedXAxisLabels = cartData.labels.map((label, index) => {
-                    try {
-                        return options.xAxisLabelFormatter(label, index);
-                    }
-                    catch (err) {
-                        console.warn(`[WorkerPreProcessor] xAxisLabelFormatter threw for label "${label}" at index ${index}:`, err);
-                        return label;
-                    }
-                });
-            }
-            delete options.xAxisLabelFormatter;
-        }
-        // yAxisLabelFormatter
-        if (typeof options.yAxisLabelFormatter === 'function' && (chartType === 'bar' || chartType === 'line')) {
-            const cartData = data;
-            const maxValue = Math.max(...cartData.datasets.flatMap((d) => d.data));
-            const labels = [];
-            for (let i = 0; i <= 5; i++) {
-                const value = maxValue - (maxValue / 5) * i;
-                try {
-                    labels.push(options.yAxisLabelFormatter(value));
-                }
-                catch (err) {
-                    console.warn(`[WorkerPreProcessor] yAxisLabelFormatter threw for value ${value}:`, err);
-                    labels.push(String(value));
-                }
-            }
-            options._preComputedYAxisLabels = labels;
-            delete options.yAxisLabelFormatter;
-        }
-        // renderLegendItem
-        if (typeof options.renderLegendItem === 'function') {
-            if (chartType === 'bar' || chartType === 'line') {
-                const cartData = data;
-                options._preComputedLegendItems = cartData.datasets.map((item, index) => {
-                    const color = item.color || this.generateColor(index);
-                    try {
-                        const result = options.renderLegendItem({ item, index, color });
-                        return this.nodeToDescriptor(result);
-                    }
-                    catch (err) {
-                        console.warn(`[WorkerPreProcessor] renderLegendItem threw at index ${index}:`, err);
-                        return null;
-                    }
-                });
-            }
-            else {
-                const pieData = data;
-                options._preComputedLegendItems = pieData.map((item, index) => {
-                    const color = item.color || this.generateColor(index);
-                    try {
-                        const result = options.renderLegendItem({ item, index, color });
-                        return this.nodeToDescriptor(result);
-                    }
-                    catch (err) {
-                        console.warn(`[WorkerPreProcessor] renderLegendItem threw at index ${index}:`, err);
-                        return null;
-                    }
-                });
-            }
-            delete options.renderLegendItem;
-        }
-        // renderLabelItem
-        if (typeof options.renderLabelItem === 'function') {
-            if (chartType === 'bar' || chartType === 'line') {
-                const cartData = data;
-                options._preComputedLabelItems = cartData.labels.map((label, index) => {
-                    try {
-                        const result = options.renderLabelItem({ item: label, index });
-                        return this.nodeToDescriptor(result);
-                    }
-                    catch (err) {
-                        console.warn(`[WorkerPreProcessor] renderLabelItem threw at index ${index}:`, err);
-                        return null;
-                    }
-                });
-            }
-            else {
-                const pieData = data;
-                options._preComputedLabelItems = pieData.map((item, index) => {
-                    try {
-                        const result = options.renderLabelItem({ item, index });
-                        return this.nodeToDescriptor(result);
-                    }
-                    catch (err) {
-                        console.warn(`[WorkerPreProcessor] renderLabelItem threw at index ${index}:`, err);
-                        return null;
-                    }
-                });
-            }
-            delete options.renderLabelItem;
-        }
-        // renderValueItem
-        if (typeof options.renderValueItem === 'function' && (chartType === 'bar' || chartType === 'line')) {
-            const cartData = data;
-            options._preComputedValueItems = cartData.datasets.map((dataset, datasetIndex) => dataset.data.map((value, index) => {
-                try {
-                    const result = options.renderValueItem({ item: value, index, datasetIndex });
-                    return this.nodeToDescriptor(result);
-                }
-                catch (err) {
-                    console.warn(`[WorkerPreProcessor] renderValueItem threw at dataset ${datasetIndex}, index ${index}:`, err);
-                    return null;
-                }
-            }));
-            delete options.renderValueItem;
-        }
-        props.options = options;
-        return { ...desc, props };
-    }
-    /**
-     * Converts a BoxNode instance or CanvasElement to a CanvasElement.
-     * Public API functions (Box(), Text(), etc.) already return CanvasElements,
-     * but if someone returns an actual class instance, we convert it via initialProps.
-     */
-    static nodeToDescriptor(node) {
-        if (!node)
-            return node;
-        // Already a CanvasElement (has __type)
-        if (typeof node === 'object' && '__type' in node)
-            return node;
-        // Class instance (e.g. BoxNode, TextNode, ImageNode) — convert via duck-typing
-        if (typeof node === 'object' && node.constructor !== Object) {
-            if ('initialProps' in node && 'name' in node) {
-                const { children, ...rest } = node.initialProps || {};
-                const childArray = Array.isArray(children) ? children : children ? [children] : [];
-                const convertedChildren = childArray
-                    .filter((c) => c)
-                    .map((c) => this.nodeToDescriptor(c))
-                    .filter((c) => !!c);
-                const name = node.name;
-                const type = name === 'TextNode'
-                    ? 'Text'
-                    : name === 'Row'
-                        ? 'Row'
-                        : name === 'Image'
-                            ? 'Image'
-                            : rest.flexDirection === Style.FlexDirection.Column
-                                ? 'Column'
-                                : 'Box';
-                if (type === 'Text') {
-                    // TextNode stores original text in segments — fall back to joined segment text
-                    const text = node.segments?.map((s) => s.text).join('') ?? '';
-                    return { __type: 'Text', text, props: rest };
-                }
-                if (type === 'Image') {
-                    return { __type: 'Image', props: rest };
-                }
-                return {
-                    __type: type,
-                    props: rest,
-                    ...(convertedChildren.length > 0 ? { children: convertedChildren } : {}),
-                };
-            }
-            console.warn('[WorkerPreProcessor] Render function returned an unrecognized class instance. Use descriptor functions (Box(), Text(), etc.) instead.');
-            return null;
-        }
-        return node;
-    }
-    static generateColor(index) {
-        return this.CHART_COLORS[index % this.CHART_COLORS.length];
-    }
-    static stripNonSerializable(obj) {
-        if (obj === null || obj === undefined)
-            return obj;
-        if (typeof obj === 'function')
-            return undefined;
-        if (typeof obj === 'symbol')
-            return undefined;
-        if (typeof obj !== 'object')
-            return obj;
-        // Preserve binary data types
-        if (Buffer.isBuffer(obj))
-            return obj;
-        if (obj instanceof ArrayBuffer)
-            return obj;
-        if (ArrayBuffer.isView(obj))
-            return obj;
-        if (Array.isArray(obj)) {
-            return obj.map(item => this.stripNonSerializable(item));
-        }
-        const result = {};
-        for (const key of Object.keys(obj)) {
-            const value = obj[key];
-            if (typeof value === 'function' || typeof value === 'symbol')
-                continue;
-            result[key] = this.stripNonSerializable(value);
-        }
-        return result;
-    }
-}
 
-export { WorkerPreProcessor, drawBorders, drawRoundedRectPath, parseBorderRadius, parsePercentage };
+export { drawBorders, drawRoundedRectPath, parseBorderRadius, parsePercentage };