@markw65/monkeyc-optimizer 1.1.0 → 1.1.2

package/README.md

@@ -574,3 +574,16 @@ Bug Fixes
 - Bug fixes
   - Fixes a bug that could ignore side effects from Method.invoke
   - Fixes a crash in the inliner, when trying to inline a function with multiple returns
+
+### 1.1.1
+
+- Fix the package spec to include the new .d.ts files
+
+### 1.1.2
+
+- Fix a couple of edge cases when constant folding == and !=
+- Optimize `<boolean> && false`, and `<boolean> || true`, when `<boolean>` has no side effects
+- Better optimization of inlined function bodies
+- Analyze constants with casts to help with constant propagation
+- Ignore widening casts (eg a cast that is given a `Number` and converts it to `Number or String`)
+- More accurate deletion of unused constants. Sometimes a constant that was unused after the optimization phase ended, was still considered used because of references that were eventually deleted.

package/build/optimizer.cjs

@@ -8104,6 +8104,13 @@ function hasValue(v) {
     return (isExact(v) &&
         ((v.type & SingleTonTypeTagsConst) !== 0 || v.value !== undefined));
 }
+function hasNoData(v, t) {
+    if (v.value == null)
+        return true;
+    return ((hasUnionData(v.type)
+        ? v.value.mask & t
+        : v.type & t & ~SingleTonTypeTagsConst) == 0);
+}
 function lookupByFullName(state, fullName) {
     return fullName.split(".").reduce((results, part) => {
         return results
@@ -8218,11 +8225,15 @@ function typeFromTypeStateNode(state, sn, classVsObj) {
         }
         case "VariableDeclarator":
             if (sn.node.kind === "const" && sn.node.init) {
-                if (sn.node.init.type === "Literal") {
-                    return typeFromLiteral(sn.node.init);
+                let node = sn.node.init;
+                if (node.type === "Literal") {
+                    return typeFromLiteral(node);
                 }
-                const [value] = getNodeValue(sn.node.init);
-                if (value) {
+                while (node.type === "BinaryExpression" && node.operator === "as") {
+                    node = node.left;
+                }
+                if (node.type === "Literal" ||
+                    (node.type === "UnaryExpression" && node.operator === ":")) {
                     return evaluateExpr(state, sn.node.init).value;
                 }
             }
@@ -8763,9 +8774,10 @@ function equalsCheck(left, right) {
     // otherwise if its a Char or Symbol, compare for equality
     // otherwise its unknown (we don't track object identity).
     // Note that each type can only have a single bit set. This is important!
+    const lrBits = left.type | right.type;
     return left.type & TypeTag.Numeric && right.type & TypeTag.Numeric
         ? left.value == right.value
-        : (left.type | right.type) == (TypeTag.Number | TypeTag.Char)
+        : lrBits == (TypeTag.Number | TypeTag.Char)
             ? // Char vs Number is true iff the number is the char-code of the char
                 left.type === TypeTag.Char
                     ? left.value.charCodeAt(0) === right.value
@@ -8775,14 +8787,13 @@ function equalsCheck(left, right) {
                 : right.type == TypeTag.Number && left.type & TypeTag.Boolean
                     ? right.value == (left.value ? 1 : 0)
                     : left.type !== right.type
-                        ? ((left.type | right.type) &
-                            (TypeTag.Object |
-                                TypeTag.Module |
-                                TypeTag.Function |
-                                TypeTag.Class)) ===
-                            TypeTag.Object
-                            ? undefined
-                            : false
+                        ? lrBits & TypeTag.Null
+                            ? lrBits & (TypeTag.Object | TypeTag.Array | TypeTag.Dictionary)
+                                ? undefined
+                                : false
+                            : lrBits & (TypeTag.Module | TypeTag.Function | TypeTag.Class)
+                                ? false
+                                : undefined
                         : left.type === TypeTag.Char || left.type === TypeTag.Symbol
                             ? left.value === right.value
                             : isSingleton(left)
@@ -9259,6 +9270,17 @@ function evaluateNode(istate, node) {
             const right = popIstate(istate, node.right);
             const left = popIstate(istate, node.left);
             if (node.operator === "as") {
+                if ((left.value.type & (ValueTypeTagsConst | SingleTonTypeTagsConst)) ==
+                    left.value.type &&
+                    (right.value.type & left.value.type) === left.value.type &&
+                    hasNoData(right.value, left.value.type)) {
+                    push({
+                        value: left.value,
+                        embeddedEffects: left.embeddedEffects,
+                        node,
+                    });
+                    return;
+                }
                 if (hasValue(right.value) && right.value.type === TypeTag.Enum) {
                     if ((left.value.type & (TypeTag.Numeric | TypeTag.String)) ==
                         left.value.type) {
@@ -10143,8 +10165,10 @@ function beforeEvaluate(istate, node) {
                     break;
                 if (node.operator === "==" || node.operator === "!=") {
                     const [{ value: left }, { value: right }] = istate.stack.slice(-2);
-                    if ((left.type === TypeTag.Null && !(right.type & TypeTag.Null)) ||
-                        (right.type === TypeTag.Null && !(left.type & TypeTag.Null))) {
+                    if (((left.type === TypeTag.Null && !(right.type & TypeTag.Null)) ||
+                        (right.type === TypeTag.Null && !(left.type & TypeTag.Null))) &&
+                        (left.type | right.type) &
+                            (TypeTag.Object | TypeTag.Array | TypeTag.Dictionary)) {
                         (0,external_api_cjs_namespaceObject.diagnostic)(istate.state, node.loc, `This comparison seems redundant because ${(0,external_api_cjs_namespaceObject.formatAst)(left.type === TypeTag.Null ? node.right : node.left)} should never be null`, level);
                     }
                 }
@@ -10186,6 +10210,14 @@ function beforeEvaluate(istate, node) {
                 popIstate(istate, node.right);
                 return node.left;
             }
+            if (right.value.type === (isAnd ? TypeTag.False : TypeTag.True) &&
+                !left.embeddedEffects &&
+                (left.value.type & TypeTag.Boolean) === left.value.type) {
+                popIstate(istate, node.right);
+                popIstate(istate, node.left);
+                istate.stack.push(right);
+                return node.right;
+            }
             if (isAnd ? !mustBeTrue(left.value) : !mustBeFalse(left.value)) {
                 break;
             }
@@ -11102,6 +11134,17 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
         }
         return result;
     };
+    let again = false;
+    const optimizeCallHelper = (istate, call, node) => {
+        const result = optimizeCall(istate, call, node);
+        if (result) {
+            if (isExpression(result)) {
+                istate.stack[istate.stack.length - 1].node = result;
+            }
+            again = true;
+        }
+        return result;
+    };
     const topLocals = () => state.localsStack[state.localsStack.length - 1];
     /*
      * Might this function be called from somewhere, including
@@ -11384,6 +11427,12 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                     throw new Error("Stack was not empty");
                 }
                 istate = gistate;
+                if (again) {
+                    again = false;
+                    const top = state.stack.pop();
+                    state.traverse(node);
+                    state.stack.push(top);
+                }
                 break;
             case "BlockStatement":
                 if (node.body.length === 1 && node.body[0].type === "BlockStatement") {
@@ -11398,13 +11447,13 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
             case "IfStatement": {
                 const call = inlinableSubExpression(node.test);
                 if (call) {
-                    return replace(optimizeCall(istate, call, node), node.test);
+                    return optimizeCallHelper(istate, call, node);
                 }
                 break;
             }
             case "ReturnStatement":
                 if (node.argument && node.argument.type === "CallExpression") {
-                    return replace(optimizeCall(istate, node.argument, node), node.argument);
+                    return optimizeCallHelper(istate, node.argument, node);
                 }
                 break;
             case "Identifier":
@@ -11433,7 +11482,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 }
                 break;
             case "CallExpression": {
-                return replace(optimizeCall(istate, node, null), node);
+                return optimizeCallHelper(istate, node, null);
             }
             case "VariableDeclaration": {
                 const locals = topLocals();
@@ -11450,7 +11499,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                             continue;
                         const call = inlinableSubExpression(decl.init);
                         if (call) {
-                            const inlined = replace(optimizeCall(istate, call, decl), decl.init);
+                            const inlined = optimizeCallHelper(istate, call, decl);
                             if (!inlined)
                                 continue;
                             if (Array.isArray(inlined) || inlined.type != "BlockStatement") {
@@ -11482,7 +11531,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
             }
             case "ExpressionStatement":
                 if (node.expression.type === "CallExpression") {
-                    return replace(optimizeCall(istate, node.expression, node), node.expression);
+                    return optimizeCallHelper(istate, node.expression, node);
                 }
                 else if (node.expression.type === "AssignmentExpression") {
                     const call = inlinableSubExpression(node.expression.right);
@@ -11498,7 +11547,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                             ok = !!result;
                         }
                         if (ok) {
-                            return replace(optimizeCall(istate, call, node.expression), node.expression.right);
+                            return optimizeCallHelper(istate, call, node.expression);
                         }
                     }
                 }
@@ -11544,6 +11593,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
     Object.values(fnMap).forEach((f) => {
         (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
     });
+    state.usedByName = {};
     state.calledFunctions = {};
     state.exposed = state.nextExposed;
     state.nextExposed = {};
@@ -11703,7 +11753,7 @@ function optimizeCall(istate, node, context) {
             node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
             const ret = evaluateFunction(istate, callee, node.arguments);
             if (ret) {
-                return ret;
+                return withLoc(ret, node, node);
             }
         }
         if (shouldInline(state, callees[0], node, context)) {
@@ -12233,7 +12283,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
         // 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 && 1673220499844 < opt_time) {
+        if (source_time < opt_time && 1673307671092 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -12260,7 +12310,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
                 hasTests,
                 diagnostics,
-                optimizerVersion: "1.1.0",
+                optimizerVersion: "1.1.2",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));

package/build/src/type-flow/could-be.d.ts

@@ -0,0 +1,2 @@
+import { ExactOrUnion } from "./types";
+export declare function couldBe(a: ExactOrUnion, b: ExactOrUnion): boolean;

package/build/src/type-flow/interp-binary.d.ts

@@ -0,0 +1,4 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ExactOrUnion } from "./types";
+export declare function evaluateBinaryTypes(op: mctree.BinaryOperator | "instanceof", left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;
+export declare function evaluateLogicalTypes(op: mctree.LogicalOperator, left: ExactOrUnion, right: ExactOrUnion): ExactOrUnion;

package/build/src/type-flow/interp-call.d.ts

@@ -0,0 +1,4 @@
+import { ProgramStateAnalysis } from "../optimizer-types";
+import { ExactOrUnion } from "./types";
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function evaluateCall(state: ProgramStateAnalysis, node: mctree.CallExpression, callee: ExactOrUnion, _args: ExactOrUnion[]): ExactOrUnion;

package/build/src/type-flow/interp.d.ts

@@ -0,0 +1,23 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { ExactOrUnion } from "./types";
+export declare type TypeMap = Map<mctree.Node, ExactOrUnion>;
+export declare type InterpStackElem = {
+    value: ExactOrUnion;
+    embeddedEffects: boolean;
+    node: mctree.Expression | mctree.TypeSpecList | mctree.InstanceOfCase;
+};
+export declare type InterpState = {
+    state: ProgramStateAnalysis;
+    stack: InterpStackElem[];
+    typeMap?: TypeMap;
+    func?: FunctionStateNode;
+    pre?: (node: mctree.Node) => mctree.Node | false | null | void;
+    post?: (node: mctree.Node) => mctree.Node | false | null | void;
+};
+export declare function popIstate(istate: InterpState, node: mctree.Node): InterpStackElem;
+export declare function evaluateExpr(state: ProgramStateAnalysis, expr: mctree.Expression, typeMap?: TypeMap): InterpStackElem;
+export declare function evaluate(istate: InterpState, node: mctree.Expression): InterpStackElem;
+export declare function evaluate(istate: InterpState, node: mctree.Node): InterpStackElem | undefined;
+export declare function evaluateNode(istate: InterpState, node: mctree.Node): void;
+export declare function roundToFloat(value: number): number;

package/build/src/type-flow/intersection-type.d.ts

@@ -0,0 +1,4 @@
+import { ExactOrUnion } from "./types";
+export declare function expandTypedef(t: ExactOrUnion): ExactOrUnion;
+export declare function intersection(a: ExactOrUnion, b: ExactOrUnion): ExactOrUnion;
+export declare function restrictByEquality(a: ExactOrUnion, b: ExactOrUnion): ExactOrUnion;

package/build/src/type-flow/optimize.d.ts

@@ -0,0 +1,6 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { FunctionStateNode, ProgramStateAnalysis } from "../optimizer-types";
+import { InterpState } from "./interp";
+export declare function optimizeFunction(state: ProgramStateAnalysis, func: FunctionStateNode): void;
+export declare function beforeEvaluate(istate: InterpState, node: mctree.Node): mctree.Node | null | false;
+export declare function afterEvaluate(istate: InterpState, node: mctree.Node): mctree.Node | null | false;

package/build/src/type-flow/sub-type.d.ts

@@ -0,0 +1,2 @@
+import { ExactOrUnion } from "./types";
+export declare function subtypeOf(a: ExactOrUnion, b: ExactOrUnion): boolean;

package/build/src/type-flow/types.d.ts

@@ -0,0 +1,202 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { ClassStateNode, EnumStateNode, FunctionStateNode, ModuleStateNode, ProgramStateAnalysis, ProgramStateStack, StateNodeDecl, TypedefStateNode } from "../optimizer-types";
+/**
+ * TypeBit gives the position of the 1 bit in TypeTag
+ */
+export declare enum TypeBit {
+    Null = 0,
+    False = 1,
+    True = 2,
+    Number = 3,
+    Long = 4,
+    Float = 5,
+    Double = 6,
+    Char = 7,
+    String = 8,
+    Array = 9,
+    Dictionary = 10,
+    Module = 11,
+    Function = 12,
+    Class = 13,
+    Object = 14,
+    Enum = 15,
+    Symbol = 16,
+    Typedef = 17
+}
+export declare enum TypeTag {
+    Never = 0,
+    Null = 1,
+    False = 2,
+    True = 4,
+    Boolean = 6,
+    Number = 8,
+    Long = 16,
+    Float = 32,
+    Double = 64,
+    Numeric = 120,
+    Char = 128,
+    String = 256,
+    Array = 512,
+    Dictionary = 1024,
+    Module = 2048,
+    Function = 4096,
+    Class = 8192,
+    Object = 16384,
+    Enum = 32768,
+    Symbol = 65536,
+    Typedef = 131072,
+    Any = 262143
+}
+export declare const SingleTonTypeTagsConst: number;
+export declare const UnionDataTypeTagsConst: number;
+export declare const ValueTypeTagsConst: number;
+export declare const ObjectLikeTagsConst: number;
+declare type ExactTypeTags = TypeTag.Null | TypeTag.False | TypeTag.True | TypeTag.Number | TypeTag.Long | TypeTag.Float | TypeTag.Double | TypeTag.Char | TypeTag.String | TypeTag.Array | TypeTag.Dictionary | TypeTag.Module | TypeTag.Function | TypeTag.Class | TypeTag.Object | TypeTag.Enum | TypeTag.Symbol | TypeTag.Typedef;
+export declare type EnumeratedTypeTags = ExactTypeTags | TypeTag.Never | TypeTag.Any;
+export declare type UnionTypeTags = number;
+interface AbstractValue {
+    type: UnionTypeTags;
+    value?: unknown;
+}
+export declare type ExactTypes = NullType | FalseType | TrueType | NumberType | LongType | FloatType | DoubleType | CharType | StringType | ArrayType | DictionaryType | ModuleType | FunctionType | ClassType | ObjectType | EnumType | SymbolType | TypedefType;
+declare type WithValue<T> = T extends ExactTypes ? T extends SingletonType ? T : T & {
+    value: NonNullable<T["value"]>;
+} : never;
+export declare type ValueTypes = WithValue<ExactTypes>;
+export declare type ExtendedTypes = ExactTypes | NeverType | AnyType;
+export interface NeverType extends AbstractValue {
+    type: 0;
+    value?: undefined;
+}
+export interface NullType extends AbstractValue {
+    type: TypeTag.Null;
+    value?: undefined;
+}
+export interface FalseType extends AbstractValue {
+    type: TypeTag.False;
+    value?: undefined;
+}
+export interface TrueType extends AbstractValue {
+    type: TypeTag.True;
+    value?: undefined;
+}
+export interface NumberType extends AbstractValue {
+    type: TypeTag.Number;
+    value?: number | undefined;
+}
+export interface LongType extends AbstractValue {
+    type: TypeTag.Long;
+    value?: bigint | undefined;
+}
+export interface FloatType extends AbstractValue {
+    type: TypeTag.Float;
+    value?: number | undefined;
+}
+export interface DoubleType extends AbstractValue {
+    type: TypeTag.Double;
+    value?: number | undefined;
+}
+export interface CharType extends AbstractValue {
+    type: TypeTag.Char;
+    value?: string | undefined;
+}
+export interface StringType extends AbstractValue {
+    type: TypeTag.String;
+    value?: string | undefined;
+}
+export interface ArrayType extends AbstractValue {
+    type: TypeTag.Array;
+    value?: ExactOrUnion | undefined;
+}
+export interface DictionaryType extends AbstractValue {
+    type: TypeTag.Dictionary;
+    value?: {
+        key: ExactOrUnion;
+        value: ExactOrUnion;
+    } | undefined;
+}
+export interface ModuleType extends AbstractValue {
+    type: TypeTag.Module;
+    value?: ModuleStateNode | ModuleStateNode[] | undefined;
+}
+export interface FunctionType extends AbstractValue {
+    type: TypeTag.Function;
+    value?: FunctionStateNode | FunctionStateNode[] | undefined;
+}
+export interface ClassType extends AbstractValue {
+    type: TypeTag.Class;
+    value?: ClassStateNode | ClassStateNode[] | undefined;
+}
+export interface TypedefType extends AbstractValue {
+    type: TypeTag.Typedef;
+    value?: TypedefStateNode | TypedefStateNode[] | undefined;
+}
+export interface ObjectType extends AbstractValue {
+    type: TypeTag.Object;
+    value?: {
+        klass: ClassType;
+        obj?: Record<string, ExactOrUnion>;
+    } | undefined;
+}
+export interface EnumType extends AbstractValue {
+    type: TypeTag.Enum;
+    value?: {
+        enum: EnumStateNode;
+        value?: ExactOrUnion | undefined;
+    } | undefined;
+}
+export interface SymbolType extends AbstractValue {
+    type: TypeTag.Symbol;
+    value?: string | undefined;
+}
+export interface AnyType extends AbstractValue {
+    type: -1;
+    value?: undefined;
+}
+export declare type SingletonType = NullType | FalseType | TrueType;
+export declare type UnionData = {
+    mask: TypeTag;
+    [TypeTag.Array]?: NonNullable<ArrayType["value"]>;
+    [TypeTag.Dictionary]?: NonNullable<DictionaryType["value"]>;
+    [TypeTag.Module]?: NonNullable<ModuleType["value"]>;
+    [TypeTag.Function]?: NonNullable<FunctionType["value"]>;
+    [TypeTag.Class]?: NonNullable<ClassType["value"]>;
+    [TypeTag.Object]?: NonNullable<ObjectType["value"]>;
+    [TypeTag.Enum]?: NonNullable<EnumType["value"]>;
+};
+export declare type UnionDataKey = Exclude<keyof UnionData, "mask">;
+export interface UnionType extends AbstractValue {
+    value?: UnionData | undefined;
+}
+export declare type ExactOrUnion = UnionType | ExactTypes;
+export declare type SingleValue = NonNullable<ValueTypes["value"]>;
+declare type TagValue<TAG> = Extract<ValueTypes, {
+    type: TAG;
+}>["value"];
+export declare type ArrayValueType = TagValue<TypeTag.Array>;
+export declare type DictionaryValueType = TagValue<TypeTag.Dictionary>;
+export declare type ObjectValueType = TagValue<TypeTag.Object>;
+export declare type EnumValueType = TagValue<TypeTag.Enum>;
+export declare type TypedefValueType = TagValue<TypeTag.Typedef>;
+export declare type StateDeclValueType = TagValue<TypeTag.Module> | TagValue<TypeTag.Function> | TagValue<TypeTag.Class>;
+export declare function isExact(v: AbstractValue): v is ExactTypes;
+export declare function isUnion(v: AbstractValue): v is UnionType;
+export declare function isSingleton(v: AbstractValue): v is SingletonType;
+export declare function hasValue(v: AbstractValue): v is WithValue<ExactTypes>;
+export declare function hasNoData(v: AbstractValue, t: TypeTag): boolean;
+export declare function cloneType<T extends ExactOrUnion>(t: T): T;
+export declare function typeFromTypeStateNode(state: ProgramStateAnalysis, sn: StateNodeDecl, classVsObj?: boolean): ExactOrUnion;
+export declare function typeFromTypeStateNodes(state: ProgramStateAnalysis, sns: StateNodeDecl[], classVsObj?: boolean): ExactOrUnion;
+export declare function typeFromTypespec(state: ProgramStateAnalysis, ts: mctree.TypeSpecList, stack?: ProgramStateStack | undefined): ExactOrUnion;
+export declare function typeFromLiteral(literal: mctree.Literal): ExactTypes;
+export declare function mcExprFromType(type: ValueTypes): mctree.Expression | null;
+export declare function castType(type: ExactOrUnion, target: UnionTypeTags): ExactOrUnion;
+export declare const TruthyTypes: number;
+export declare function mustBeTrue(arg: ExactOrUnion): boolean;
+export declare function mustBeFalse(arg: ExactOrUnion): boolean;
+export declare function display(type: ExactOrUnion): string;
+export declare function hasUnionData(tag: TypeTag): boolean;
+export declare function getObjectValue(t: ExactOrUnion): ObjectType["value"] | null;
+export declare function forEachUnionComponent(v: ExactOrUnion, bits: TypeTag, fn: (tag: UnionDataKey, value: SingleValue | null | undefined) => boolean | void): void;
+export declare function getUnionComponent(v: ExactOrUnion, tag: TypeTag): SingleValue | null;
+export {};

package/build/src/type-flow/union-type.d.ts

@@ -0,0 +1,3 @@
+import { ExactOrUnion, TypeTag } from "./types";
+export declare function unionInto(to: ExactOrUnion, from: ExactOrUnion): boolean;
+export declare function clearValuesUnder(v: ExactOrUnion, tag: TypeTag, clearTag?: boolean): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -35,7 +35,7 @@
     "build/util.cjs",
     "build/sdk-util.cjs",
     "build/api.cjs",
-    "build/src/*.d.ts"
+    "build/src/**/*.d.ts"
   ],
   "author": "markw65",
   "license": "MIT",