@markw65/monkeyc-optimizer 1.0.13 → 1.0.14

package/README.md

@@ -141,3 +141,17 @@ More fixes found via open source projects.
 
 - Tests
   - Add date/time to test logging
+
+### 1.0.14
+
+- Bug fixes
+
+  - When reading a barrel project with no products, add all products by default
+  - Only set language specific paths for languages that are supported by the device
+  - Remove comments that are completely contained within removed nodes
+
+- Code cleanup
+  - Upgrade to @markw65/prettier-plugin-monkeyc@1.0.21 for some typescript fixes
+  - npm upgrade to pickup ts 4.7.2
+  - Add types to package exports for ts 4.7.2
+  - Better handling of program-logic errors

package/build/api.cjs

@@ -346,7 +346,7 @@ async function analyze(fnMap) {
                     return drop;
                 }, false);
             }
-            return null;
+            return false;
         },
         post(node, state) {
             switch (node.type) {
@@ -973,71 +973,77 @@ async function optimizeMonkeyC(fnMap) {
     Object.values(fnMap).forEach((f) => {
         collectNamespaces(f.ast, state);
     });
-    Object.values(fnMap).forEach((f) => {
-        traverseAst(f.ast, undefined, (node) => {
-            switch (node.type) {
-                case "EnumStringBody":
-                    if (node.members.every((m) => {
-                        const name = "name" in m ? m.name : m.id.name;
-                        return (hasProperty(state.index, name) &&
-                            !hasProperty(state.exposed, name));
-                    })) {
-                        node.enumType = [
-                            ...new Set(node.members.map((m) => {
-                                if (!("init" in m))
-                                    return "Number";
-                                const [node, type] = getNodeValue(m.init);
-                                if (!node) {
-                                    throw new Error("Failed to get type for eliminated enum");
-                                }
-                                return type;
-                            })),
-                        ].join(" or ");
-                        node.members.splice(0);
-                    }
-                    break;
-                case "EnumDeclaration":
-                    if (!node.body.members.length) {
-                        if (!node.id)
-                            return false;
-                        if (!node.body["enumType"]) {
-                            throw new Error("Missing enumType on optimized enum");
-                        }
-                        replace(node, {
-                            type: "TypedefDeclaration",
-                            id: node.id,
-                            ts: {
-                                type: "UnaryExpression",
-                                argument: { type: "TypeSpecList", ts: [node.body.enumType] },
-                                prefix: true,
-                                operator: " as",
-                            },
-                        });
-                    }
-                    break;
-                case "VariableDeclaration": {
-                    node.declarations = node.declarations.filter((d) => {
-                        const name = variableDeclarationName(d.id);
-                        return (!hasProperty(state.index, name) ||
-                            hasProperty(state.exposed, name));
-                    });
-                    if (!node.declarations.length) {
-                        return false;
-                    }
-                    break;
+    const cleanup = (node) => {
+        switch (node.type) {
+            case "EnumStringBody":
+                if (node.members.every((m) => {
+                    const name = "name" in m ? m.name : m.id.name;
+                    return (hasProperty(state.index, name) &&
+                        !hasProperty(state.exposed, name));
+                })) {
+                    node.enumType = [
+                        ...new Set(node.members.map((m) => {
+                            if (!("init" in m))
+                                return "Number";
+                            const [node, type] = getNodeValue(m.init);
+                            if (!node) {
+                                throw new Error("Failed to get type for eliminated enum");
+                            }
+                            return type;
+                        })),
+                    ].join(" or ");
+                    node.members.splice(0);
                 }
-                case "ClassElement":
-                    if (!node.item) {
-                        return false;
-                    }
-                    break;
-                case "FunctionDeclaration":
-                    if (!maybeCalled(node)) {
+                break;
+            case "EnumDeclaration":
+                if (!node.body.members.length) {
+                    if (!node.id)
                         return false;
+                    if (!node.body["enumType"]) {
+                        throw new Error("Missing enumType on optimized enum");
                     }
-                    break;
+                    replace(node, {
+                        type: "TypedefDeclaration",
+                        id: node.id,
+                        ts: {
+                            type: "UnaryExpression",
+                            argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                            prefix: true,
+                            operator: " as",
+                        },
+                    });
+                }
+                break;
+            case "VariableDeclaration": {
+                node.declarations = node.declarations.filter((d) => {
+                    const name = variableDeclarationName(d.id);
+                    return (!hasProperty(state.index, name) || hasProperty(state.exposed, name));
+                });
+                if (!node.declarations.length) {
+                    return false;
+                }
+                break;
             }
-            return null;
+            case "ClassElement":
+                if (!node.item) {
+                    return false;
+                }
+                break;
+            case "FunctionDeclaration":
+                if (!maybeCalled(node)) {
+                    return false;
+                }
+                break;
+        }
+        return null;
+    };
+    Object.values(fnMap).forEach((f) => {
+        traverseAst(f.ast, undefined, (node) => {
+            const ret = cleanup(node);
+            if (ret === false) {
+                state.removeNodeComments(node, f.ast);
+            }
+            return ret;
         });
     });
 }
@@ -1190,6 +1196,30 @@ function api_collectNamespaces(ast, stateIn) {
         }
         return null;
     };
+    state.removeNodeComments = (node, ast) => {
+        if (node.start && node.end && ast.comments && ast.comments.length) {
+            let low = 0, high = ast.comments.length;
+            while (true) {
+                const mid = (low + high) >> 1;
+                if (mid == low) {
+                    if (ast.comments[mid].start < node.start) {
+                        return;
+                    }
+                    break;
+                }
+                if (ast.comments[mid].start < node.start) {
+                    low = mid;
+                }
+                else {
+                    high = mid;
+                }
+            }
+            for (high = low; high < ast.comments.length && ast.comments[high].end < node.end; high++) { }
+            if (high > low) {
+                ast.comments.splice(low, high - low);
+            }
+        }
+    };
     state.lookup = (node, name, stack) => {
         stack || (stack = state.stack);
         switch (node.type) {
@@ -1400,12 +1430,17 @@ function api_collectNamespaces(ast, stateIn) {
             let ret;
             if (state.shouldExclude && state.shouldExclude(node)) {
                 // delete the node.
-                return false;
+                ret = false;
+            }
+            else {
+                if (state.post)
+                    ret = state.post(node, state);
+                if (state.stack.slice(-1).pop()?.node === node) {
+                    state.stack.pop();
+                }
             }
-            if (state.post)
-                ret = state.post(node, state);
-            if (state.stack.slice(-1).pop()?.node === node) {
-                state.stack.pop();
+            if (ret === false) {
+                state.removeNodeComments(node, ast);
             }
             return ret;
         }
@@ -1500,7 +1535,6 @@ function formatAst(node, monkeyCSource = null) {
     });
 }
 function handleException(state, node, exception) {
-    let message;
     try {
         const fullName = state.stack
             .map((e) => e.name)
@@ -1510,12 +1544,19 @@ function handleException(state, node, exception) {
         const location = node.loc && node.loc.source
             ? `${node.loc.source}:${node.start || 0}:${node.end || 0}`
             : "<unknown>";
-        message = `Got exception \`${Object.prototype.toString.call(exception)}' while processing node ${fullName}:${node.type} from ${location}`;
+        const message = `Got exception \`${exception instanceof Error
+            ? exception.message
+            : Object.prototype.toString.call(exception)}' while processing node ${fullName}:${node.type} from ${location}`;
+        if (exception instanceof Error) {
+            exception.message = message;
+        }
+        else {
+            exception = new Error(message);
+        }
     }
-    catch {
+    finally {
         throw exception;
     }
-    throw new Error(message);
 }
 
 })();

package/build/optimizer.cjs

@@ -1289,7 +1289,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 const debug = __webpack_require__(1227)('extract-zip')
 // eslint-disable-next-line node/no-unsupported-features/node-builtins
 const { createWriteStream, promises: fs } = __webpack_require__(6231)
-const getStream = __webpack_require__(7491)
+const getStream = __webpack_require__(31)
 const path = __webpack_require__(1423)
 const { promisify } = __webpack_require__(6464)
 const stream = __webpack_require__(8311)
@@ -1461,134 +1461,6 @@ module.exports = async function (zipPath, opts) {
 }
 
 
-/***/ }),
-
-/***/ 2297:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-const {PassThrough: PassThroughStream} = __webpack_require__(8311);
-
-module.exports = options => {
-	options = {...options};
-
-	const {array} = options;
-	let {encoding} = options;
-	const isBuffer = encoding === 'buffer';
-	let objectMode = false;
-
-	if (array) {
-		objectMode = !(encoding || isBuffer);
-	} else {
-		encoding = encoding || 'utf8';
-	}
-
-	if (isBuffer) {
-		encoding = null;
-	}
-
-	const stream = new PassThroughStream({objectMode});
-
-	if (encoding) {
-		stream.setEncoding(encoding);
-	}
-
-	let length = 0;
-	const chunks = [];
-
-	stream.on('data', chunk => {
-		chunks.push(chunk);
-
-		if (objectMode) {
-			length = chunks.length;
-		} else {
-			length += chunk.length;
-		}
-	});
-
-	stream.getBufferedValue = () => {
-		if (array) {
-			return chunks;
-		}
-
-		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
-	};
-
-	stream.getBufferedLength = () => length;
-
-	return stream;
-};
-
-
-/***/ }),
-
-/***/ 7491:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-const {constants: BufferConstants} = __webpack_require__(871);
-const pump = __webpack_require__(4286);
-const bufferStream = __webpack_require__(2297);
-
-class MaxBufferError extends Error {
-	constructor() {
-		super('maxBuffer exceeded');
-		this.name = 'MaxBufferError';
-	}
-}
-
-async function getStream(inputStream, options) {
-	if (!inputStream) {
-		return Promise.reject(new Error('Expected a stream'));
-	}
-
-	options = {
-		maxBuffer: Infinity,
-		...options
-	};
-
-	const {maxBuffer} = options;
-
-	let stream;
-	await new Promise((resolve, reject) => {
-		const rejectPromise = error => {
-			// Don't retrieve an oversized buffer.
-			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-				error.bufferedData = stream.getBufferedValue();
-			}
-
-			reject(error);
-		};
-
-		stream = pump(inputStream, bufferStream(options), error => {
-			if (error) {
-				rejectPromise(error);
-				return;
-			}
-
-			resolve();
-		});
-
-		stream.on('data', () => {
-			if (stream.getBufferedLength() > maxBuffer) {
-				rejectPromise(new MaxBufferError());
-			}
-		});
-	});
-
-	return stream.getBufferedValue();
-}
-
-module.exports = getStream;
-// TODO: Remove this for the next major release
-module.exports["default"] = getStream;
-module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
-module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
-module.exports.MaxBufferError = MaxBufferError;
-
-
 /***/ }),
 
 /***/ 8913:
@@ -1892,6 +1764,134 @@ function createFromFd(fd, options) {
 }
 
 
+/***/ }),
+
+/***/ 5105:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const {PassThrough: PassThroughStream} = __webpack_require__(8311);
+
+module.exports = options => {
+	options = {...options};
+
+	const {array} = options;
+	let {encoding} = options;
+	const isBuffer = encoding === 'buffer';
+	let objectMode = false;
+
+	if (array) {
+		objectMode = !(encoding || isBuffer);
+	} else {
+		encoding = encoding || 'utf8';
+	}
+
+	if (isBuffer) {
+		encoding = null;
+	}
+
+	const stream = new PassThroughStream({objectMode});
+
+	if (encoding) {
+		stream.setEncoding(encoding);
+	}
+
+	let length = 0;
+	const chunks = [];
+
+	stream.on('data', chunk => {
+		chunks.push(chunk);
+
+		if (objectMode) {
+			length = chunks.length;
+		} else {
+			length += chunk.length;
+		}
+	});
+
+	stream.getBufferedValue = () => {
+		if (array) {
+			return chunks;
+		}
+
+		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
+	};
+
+	stream.getBufferedLength = () => length;
+
+	return stream;
+};
+
+
+/***/ }),
+
+/***/ 31:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const {constants: BufferConstants} = __webpack_require__(871);
+const pump = __webpack_require__(4286);
+const bufferStream = __webpack_require__(5105);
+
+class MaxBufferError extends Error {
+	constructor() {
+		super('maxBuffer exceeded');
+		this.name = 'MaxBufferError';
+	}
+}
+
+async function getStream(inputStream, options) {
+	if (!inputStream) {
+		return Promise.reject(new Error('Expected a stream'));
+	}
+
+	options = {
+		maxBuffer: Infinity,
+		...options
+	};
+
+	const {maxBuffer} = options;
+
+	let stream;
+	await new Promise((resolve, reject) => {
+		const rejectPromise = error => {
+			// Don't retrieve an oversized buffer.
+			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+				error.bufferedData = stream.getBufferedValue();
+			}
+
+			reject(error);
+		};
+
+		stream = pump(inputStream, bufferStream(options), error => {
+			if (error) {
+				rejectPromise(error);
+				return;
+			}
+
+			resolve();
+		});
+
+		stream.on('data', () => {
+			if (stream.getBufferedLength() > maxBuffer) {
+				rejectPromise(new MaxBufferError());
+			}
+		});
+	});
+
+	return stream.getBufferedValue();
+}
+
+module.exports = getStream;
+// TODO: Remove this for the next major release
+module.exports["default"] = getStream;
+module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
+module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
+module.exports.MaxBufferError = MaxBufferError;
+
+
 /***/ }),
 
 /***/ 7824:
@@ -10077,7 +10077,8 @@ async function default_jungle() {
         }
         rezAndLang(deviceId, `resources-${deviceId}`, deviceFamily);
     });
-    return process_assignments(assignments, {});
+    const state = await process_assignments(assignments, {});
+    return { state, devices };
 }
 function process_assignments(assignments, current) {
     return assignments.reduce((state, a) => {
@@ -10179,9 +10180,9 @@ async function process_jungles(sources) {
         sources = [sources];
     }
     const results = await Promise.all(sources.map(parse_one));
-    const state = await default_jungle();
+    const { state, devices } = await default_jungle();
     results.forEach((r) => process_assignments(r, state));
-    return state;
+    return { state, devices };
 }
 function resolve_node_list(state, list) {
     if (!Array.isArray(list)) {
@@ -10303,7 +10304,7 @@ function resolve_filename(literal, default_source = null) {
     const root = external_path_.dirname(literal.source || default_source);
     return external_path_.resolve(root, literal.value);
 }
-async function resolve_literals(qualifier, default_source) {
+async function resolve_literals(qualifier, default_source, deviceInfo) {
     const resolve_file_list = async (literals) => literals &&
         (await Promise.all(literals.map(async (v) => {
             if (!isJNode(v)) {
@@ -10346,7 +10347,13 @@ async function resolve_literals(qualifier, default_source) {
     await resolve_one_file_list(qualifier, "barrelPath");
     const lang = qualifier["lang"];
     if (lang) {
-        await Promise.all(Object.keys(lang).map((key) => resolve_one_file_list(lang, key)));
+        await Promise.all(Object.keys(lang).map((key) => {
+            if (!(0,external_api_cjs_namespaceObject.hasProperty)(deviceInfo.languages, key)) {
+                delete lang[key];
+                return null;
+            }
+            return resolve_one_file_list(lang, key);
+        }));
         if (Object.keys(lang).length === 0)
             delete qualifier["lang"];
     }
@@ -10704,7 +10711,7 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
             jungles.push(barrels_jungle);
         }
     }
-    const state = await process_jungles(jungles);
+    const { state, devices } = await process_jungles(jungles);
     // apparently square_watch is an alias for rectangle_watch
     state["square_watch"] = state["rectangle_watch"];
     const manifest_node = resolve_node(state, resolve_node_by_path(state, ["project", "manifest"]));
@@ -10719,15 +10726,21 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
     const barrels = manifestBarrels(xml);
     const annotations = manifestAnnotations(xml);
     const products = manifestProducts(xml);
-    if (products.length === 0)
-        products.push(...defaultProducts);
+    if (products.length === 0) {
+        if (defaultProducts) {
+            products.push(...defaultProducts);
+        }
+        else if (xml["iq:manifest"]["iq:barrel"]) {
+            products.push(...Object.keys(devices).sort());
+        }
+    }
     let promise = Promise.resolve();
     const add_one = (product, shape = undefined) => {
         const rawQualifier = resolve_node(state, state[product]);
         if (!rawQualifier || Array.isArray(rawQualifier))
             return;
         promise = promise
-            .then(() => resolve_literals(rawQualifier, manifest))
+            .then(() => resolve_literals(rawQualifier, manifest, devices[product]))
             .then((qualifier) => {
             targets.push({ product, qualifier, shape });
             return resolve_barrels(product, qualifier, barrels, products, options);
@@ -10753,7 +10766,7 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
 }
 async function get_jungle(jungles, options) {
     options = options || {};
-    const result = await get_jungle_and_barrels(jungles, [], options);
+    const result = await get_jungle_and_barrels(jungles, null, options);
     identify_optimizer_groups(result.targets, options);
     return result;
 }
@@ -10888,7 +10901,7 @@ async function analyze(fnMap) {
                     return drop;
                 }, false);
             }
-            return null;
+            return false;
         },
         post(node, state) {
             switch (node.type) {
@@ -11515,71 +11528,77 @@ async function optimizeMonkeyC(fnMap) {
     Object.values(fnMap).forEach((f) => {
         (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
     });
-    Object.values(fnMap).forEach((f) => {
-        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, undefined, (node) => {
-            switch (node.type) {
-                case "EnumStringBody":
-                    if (node.members.every((m) => {
-                        const name = "name" in m ? m.name : m.id.name;
-                        return ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) &&
-                            !(0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
-                    })) {
-                        node.enumType = [
-                            ...new Set(node.members.map((m) => {
-                                if (!("init" in m))
-                                    return "Number";
-                                const [node, type] = getNodeValue(m.init);
-                                if (!node) {
-                                    throw new Error("Failed to get type for eliminated enum");
-                                }
-                                return type;
-                            })),
-                        ].join(" or ");
-                        node.members.splice(0);
-                    }
-                    break;
-                case "EnumDeclaration":
-                    if (!node.body.members.length) {
-                        if (!node.id)
-                            return false;
-                        if (!node.body["enumType"]) {
-                            throw new Error("Missing enumType on optimized enum");
-                        }
-                        replace(node, {
-                            type: "TypedefDeclaration",
-                            id: node.id,
-                            ts: {
-                                type: "UnaryExpression",
-                                argument: { type: "TypeSpecList", ts: [node.body.enumType] },
-                                prefix: true,
-                                operator: " as",
-                            },
-                        });
-                    }
-                    break;
-                case "VariableDeclaration": {
-                    node.declarations = node.declarations.filter((d) => {
-                        const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(d.id);
-                        return (!(0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) ||
-                            (0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
-                    });
-                    if (!node.declarations.length) {
-                        return false;
-                    }
-                    break;
+    const cleanup = (node) => {
+        switch (node.type) {
+            case "EnumStringBody":
+                if (node.members.every((m) => {
+                    const name = "name" in m ? m.name : m.id.name;
+                    return ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) &&
+                        !(0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
+                })) {
+                    node.enumType = [
+                        ...new Set(node.members.map((m) => {
+                            if (!("init" in m))
+                                return "Number";
+                            const [node, type] = getNodeValue(m.init);
+                            if (!node) {
+                                throw new Error("Failed to get type for eliminated enum");
+                            }
+                            return type;
+                        })),
+                    ].join(" or ");
+                    node.members.splice(0);
                 }
-                case "ClassElement":
-                    if (!node.item) {
-                        return false;
-                    }
-                    break;
-                case "FunctionDeclaration":
-                    if (!maybeCalled(node)) {
+                break;
+            case "EnumDeclaration":
+                if (!node.body.members.length) {
+                    if (!node.id)
                         return false;
+                    if (!node.body["enumType"]) {
+                        throw new Error("Missing enumType on optimized enum");
                     }
-                    break;
+                    replace(node, {
+                        type: "TypedefDeclaration",
+                        id: node.id,
+                        ts: {
+                            type: "UnaryExpression",
+                            argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                            prefix: true,
+                            operator: " as",
+                        },
+                    });
+                }
+                break;
+            case "VariableDeclaration": {
+                node.declarations = node.declarations.filter((d) => {
+                    const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(d.id);
+                    return (!(0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) || (0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
+                });
+                if (!node.declarations.length) {
+                    return false;
+                }
+                break;
             }
-            return null;
+            case "ClassElement":
+                if (!node.item) {
+                    return false;
+                }
+                break;
+            case "FunctionDeclaration":
+                if (!maybeCalled(node)) {
+                    return false;
+                }
+                break;
+        }
+        return null;
+    };
+    Object.values(fnMap).forEach((f) => {
+        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, undefined, (node) => {
+            const ret = cleanup(node);
+            if (ret === false) {
+                state.removeNodeComments(node, f.ast);
+            }
+            return ret;
         });
     });
 }
@@ -12006,7 +12025,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1653671578547 < opt_time) {
+        if (source_time < opt_time && 1653864408816 < opt_time) {
             return hasTests;
         }
     }

package/build/sdk-util.cjs

@@ -7215,8 +7215,14 @@ async function getDeviceInfo() {
     }
     return Promise.all(files.map((file) => {
         return promises_namespaceObject.readFile(file).then((data) => {
-            const { deviceId, appTypes, deviceFamily, displayName } = JSON.parse(data.toString());
-            return [deviceId, { appTypes, deviceFamily, displayName }];
+            const { deviceId, appTypes, deviceFamily, displayName, partNumbers } = JSON.parse(data.toString());
+            const languages = Object.fromEntries(partNumbers
+                .map((part) => part.languages.map((lang) => [lang.code, true]))
+                .flat(1));
+            return [
+                deviceId,
+                { appTypes, deviceFamily, displayName, languages },
+            ];
         });
     })).then((info) => {
         return Object.fromEntries(info);

package/build/src/optimizer.d.ts

@@ -90,7 +90,8 @@ declare global {
         allFunctions?: FunctionStateNode[];
         allClasses?: ClassStateNode[];
         stack?: ProgramStateStack;
-        shouldExclude?: (node: any) => any;
+        removeNodeComments?: (node: mctree.Node, ast: mctree.Program) => void;
+        shouldExclude?: (node: mctree.Node) => boolean;
         pre?: (node: mctree.Node, state: ProgramStateLive) => null | false | (keyof mctree.NodeAll)[];
         post?: (node: mctree.Node, state: ProgramStateLive) => null | false | mctree.Node;
         lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
@@ -120,7 +121,7 @@ declare global {
     type Finalized<T, Keys extends keyof T> = T & {
         [key in Keys]-?: NonNullable<T[key]>;
     };
-    export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "traverse" | "index" | "constants">;
+    export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "traverse" | "index" | "constants" | "removeNodeComments">;
     export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions">;
     export type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions">;
     type ExcludeAnnotationsMap = {

package/build/src/sdk-util.d.ts

@@ -2,7 +2,7 @@ export declare const isWin: boolean;
 export declare const appSupport: string;
 export declare const connectiq: string;
 export declare function getSdkPath(): Promise<string>;
-export declare function getDeviceInfo(): Promise<{
+export declare type DeviceInfo = {
     [key: string]: {
         appTypes: {
             memoryLimit: number;
@@ -10,6 +10,8 @@ export declare function getDeviceInfo(): Promise<{
         }[];
         deviceFamily: string;
         displayName: string;
+        languages: Record<string, true>;
     };
-}>;
+};
+export declare function getDeviceInfo(): Promise<DeviceInfo>;
 export declare function getLanguages(): Promise<any>;

package/build/util.cjs

@@ -1303,6 +1303,8 @@ function setopts (self, pattern, options) {
   // Note that they are not supported in Glob itself anyway.
   options.nonegate = true
   options.nocomment = true
+  // always treat \ in patterns as escapes, not path separators
+  options.allowWindowsEscape = false
 
   self.minimatch = new Minimatch(pattern, options)
   self.options = self.minimatch.options
@@ -1778,7 +1780,10 @@ Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
   var read
   if (prefix === null)
     read = '.'
-  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+  else if (isAbsolute(prefix) ||
+      isAbsolute(pattern.map(function (p) {
+        return typeof p === 'string' ? p : '[*]'
+      }).join('/'))) {
     if (!prefix || !isAbsolute(prefix))
       prefix = '/' + prefix
     read = prefix
@@ -2278,7 +2283,7 @@ function GlobSync (pattern, options) {
 }
 
 GlobSync.prototype._finish = function () {
-  assert(this instanceof GlobSync)
+  assert.ok(this instanceof GlobSync)
   if (this.realpath) {
     var self = this
     this.matches.forEach(function (matchset, index) {
@@ -2302,7 +2307,7 @@ GlobSync.prototype._finish = function () {
 
 
 GlobSync.prototype._process = function (pattern, index, inGlobStar) {
-  assert(this instanceof GlobSync)
+  assert.ok(this instanceof GlobSync)
 
   // Get the first [n] parts of pattern that are all strings.
   var n = 0
@@ -2339,7 +2344,10 @@ GlobSync.prototype._process = function (pattern, index, inGlobStar) {
   var read
   if (prefix === null)
     read = '.'
-  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+  else if (isAbsolute(prefix) ||
+      isAbsolute(pattern.map(function (p) {
+        return typeof p === 'string' ? p : '[*]'
+      }).join('/'))) {
     if (!prefix || !isAbsolute(prefix))
       prefix = '/' + prefix
     read = prefix

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
   "exports": {
-    ".": "./build/optimizer.cjs",
-    "./*.js": "./build/*.cjs"
+    ".": {
+      "types": "./build/src/optimizer.d.ts",
+      "default": "./build/optimizer.cjs"
+    },
+    "./*.js": {
+      "types": "./build/src/*.d.ts",
+      "default": "./build/*.cjs"
+    }
   },
   "scripts": {
     "watch": "webpack --mode development --watch",
@@ -27,7 +33,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.20"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.21"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",