@as-pect/transform 8.0.1 → 9.0.0

package/lib/src/createAddReflectedValueKeyValuePairsMember.js

@@ -0,0 +1,176 @@
+// import { } from "@as-pect/;
+import { TypeNode, } from "assemblyscript/dist/assemblyscript.js";
+import { createGenericTypeParameter } from "./createGenericTypeParameter.js";
+import { djb2Hash } from "./hash.js";
+// const TypeNode = TypeNode;
+// const {
+//   BlockStatement,
+//   ClassDeclaration,
+//   FieldDeclaration,
+//   MethodDeclaration,
+//   Range,
+//   Statement
+// } =
+// type BlockStatement = InstanceType<typeof BlockStatement>;
+// type ClassDeclaration = InstanceType<typeof ClassDeclaration>;
+// type FieldDeclaration = InstanceType<typeof FieldDeclaration>;
+// type MethodDeclaration = InstanceType<typeof MethodDeclaration>;
+// type Range = InstanceType<typeof Range>;
+// type Statement = InstanceType<typeof Statement>;
+/**
+ * Create a prototype method called __aspectAddReflectedValueKeyValuePairs on a given
+ * ClassDeclaration dynamically.
+ *
+ * @param {ClassDeclaration} classDeclaration - The target classDeclaration
+ */
+export function createAddReflectedValueKeyValuePairsMember(classDeclaration) {
+    const range = classDeclaration.name.range;
+    // __aspectAddReflectedValueKeyValuePairs(reflectedValue: i32, seen: Map<usize, i32>, ignore: StaticArray<i64>): void
+    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression("__aspectAddReflectedValueKeyValuePairs", range), null, 256 /* CommonFlags.Public */ | 262144 /* CommonFlags.Instance */ | (classDeclaration.isGeneric ? 131072 /* CommonFlags.GenericContext */ : 0), null, TypeNode.createFunctionType([
+        // reflectedValue: i32
+        TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression("reflectedValue", range), createGenericTypeParameter("i32", range), null, range),
+        // seen: Map<usize, i32>
+        TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression("seen", range), TypeNode.createNamedType(TypeNode.createSimpleTypeName("Map", range), [createGenericTypeParameter("usize", range), createGenericTypeParameter("i32", range)], false, range), null, range),
+        // ignore: i64[]
+        TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression("ignore", range), 
+        // Array<i64> -> i64[]
+        TypeNode.createNamedType(TypeNode.createSimpleTypeName("StaticArray", range), [createGenericTypeParameter("i64", range)], false, range), null, range),
+    ], 
+    // : void
+    TypeNode.createNamedType(TypeNode.createSimpleTypeName("void", range), [], false, range), null, false, range), createAddReflectedValueKeyValuePairsFunctionBody(classDeclaration), range);
+}
+/**
+ * Iterate over a given ClassDeclaration and return a block statement that contains the
+ * body of a supposed function that reports the key value pairs of a given class.
+ *
+ * @param {ClassDeclaration} classDeclaration - The class declaration to be reported
+ */
+function createAddReflectedValueKeyValuePairsFunctionBody(classDeclaration) {
+    const body = new Array();
+    const range = classDeclaration.name.range;
+    const nameHashes = new Array();
+    // for each field declaration, generate a check
+    for (const member of classDeclaration.members) {
+        // if it's an instance member, regardless of access modifier
+        if (member.is(262144 /* CommonFlags.Instance */)) {
+            switch (member.kind) {
+                // field declarations automatically get added
+                case 55 /* NodeKind.FieldDeclaration */: {
+                    const fieldDeclaration = member;
+                    const hashValue = djb2Hash(member.name.text);
+                    pushKeyValueIfStatement(body, member.name.text, hashValue, fieldDeclaration.range);
+                    nameHashes.push(hashValue);
+                    break;
+                }
+                // function declarations can be getters, check the get flag
+                case 59 /* NodeKind.MethodDeclaration */: {
+                    if (member.is(2048 /* CommonFlags.Get */)) {
+                        const methodDeclaration = member;
+                        const hashValue = djb2Hash(member.name.text);
+                        pushKeyValueIfStatement(body, member.name.text, hashValue, methodDeclaration.range);
+                        nameHashes.push(hashValue);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    // call into super first after all the property checks have been added
+    body.unshift(createIsDefinedIfStatement(nameHashes, range));
+    return TypeNode.createBlockStatement(body, range);
+}
+/**
+ * Create an isDefined() function call with an if statement to prevent calls to
+ * super where they should not be made.
+ *
+ * @param {number[]} nameHashes - The array of property names to ignore in the children
+ * @param {Range} range - The reporting range of this statement
+ */
+function createIsDefinedIfStatement(nameHashes, range) {
+    // if (isDefined(super.__aspectAddReflectedValueKeyValuePairs))
+    //   super.__aspectAddReflectedValueKeyValuePairs(reflectedValue, seen, StaticArray.concat(ignore, [...] as StaticArray<i64>))
+    return TypeNode.createIfStatement(
+    // isDefined(super.__aspectAddReflectedValueKeyValuePairs)
+    TypeNode.createCallExpression(TypeNode.createIdentifierExpression("isDefined", range), null, [
+        // super.__aspectAddReflectedValueKeyValuePairs
+        TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectAddReflectedValueKeyValuePairs", range), range),
+    ], range), TypeNode.createBlockStatement([
+        TypeNode.createExpressionStatement(
+        // super.__aspectAddReflectedValueKeyValuePairs(reflectedValue, seen, StaticArray.concat(ignore, [...] as StaticArray<i64>))
+        TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectAddReflectedValueKeyValuePairs", range), range), null, [
+            // reflectedValue,
+            TypeNode.createIdentifierExpression("reflectedValue", range),
+            // seen,
+            TypeNode.createIdentifierExpression("seen", range),
+            // StaticArray.concat(ignore, [...])
+            TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("StaticArray", range), TypeNode.createIdentifierExpression("concat", range), range), null, [
+                TypeNode.createIdentifierExpression("ignore", range),
+                // [...propNames]
+                TypeNode.createAssertionExpression(1 /* AssertionKind.As */, TypeNode.createArrayLiteralExpression(nameHashes.map((e) => TypeNode.createIntegerLiteralExpression(f64_as_i64(e), range)), range), TypeNode.createNamedType(TypeNode.createSimpleTypeName("StaticArray", range), [TypeNode.createNamedType(TypeNode.createSimpleTypeName("i64", range), null, false, range)], false, range), range),
+            ], range),
+        ], range)),
+    ], range), null, range);
+}
+/**
+ * For each key-value pair, we need to perform a runtime check to make sure that this property
+ * was not overridden in the parent of a given class.
+ *
+ * @param {Statement[]} body - The collection of statements for the function body
+ * @param {string} name - The name of the property
+ * @param {Range} range - The range for these statements
+ */
+function pushKeyValueIfStatement(body, name, hashValue, range) {
+    body.push(
+    // if (!ignore.includes("propName")) { ... }
+    TypeNode.createIfStatement(TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, 
+    // ignore.includes("propName")
+    TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("ignore", range), TypeNode.createIdentifierExpression("includes", range), range), null, [
+        // hashValue
+        TypeNode.createIntegerLiteralExpression(f64_as_i64(hashValue), range),
+    ], range), range), TypeNode.createBlockStatement([createPushReflectedObjectKeyStatement(name, range), createPushReflectedObjectValueStatement(name, range)], range), null, range));
+}
+/**
+ * Create a function call to __aspectPushReflectedObjectKey to add a key to a given
+ * reflected value.
+ *
+ * @param {string} name - The name of the property
+ * @param {Range} range - The reange for this function call
+ */
+function createPushReflectedObjectKeyStatement(name, range) {
+    // __aspectPushReflectedObjectKey(reflectedValue, Reflect.toReflectedValue("propertyName", seen));
+    return TypeNode.createExpressionStatement(TypeNode.createCallExpression(TypeNode.createIdentifierExpression("__aspectPushReflectedObjectKey", range), null, [
+        // reflectedValue
+        TypeNode.createIdentifierExpression("reflectedValue", range),
+        // Reflect.toReflectedValue("propertyName", seen)
+        TypeNode.createCallExpression(
+        // Reflect.toReflectedValue
+        TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("Reflect", range), TypeNode.createIdentifierExpression("toReflectedValue", range), range), null, [TypeNode.createStringLiteralExpression(name, range), TypeNode.createIdentifierExpression("seen", range)], range),
+    ], range));
+}
+/**
+ * Create a function call to __aspectPushReflectedObjectValue to add a key to a given
+ * reflected value.
+ *
+ * @param {string} name - The name of the property
+ * @param {Range} range - The reange for this function call
+ */
+function createPushReflectedObjectValueStatement(name, range) {
+    // __aspectPushReflectedObjectValue(reflectedValue, Reflect.toReflectedValue(this.propertyName, seen, ignore.concat([...])));
+    return TypeNode.createExpressionStatement(
+    // __aspectPushReflectedObjectValue(reflectedValue, Reflect.toReflectedValue(this.propertyName, seen, ignore.concat([...])))
+    TypeNode.createCallExpression(
+    // __aspectPushReflectedObjectValue
+    TypeNode.createIdentifierExpression("__aspectPushReflectedObjectValue", range), null, [
+        // reflectedValue
+        TypeNode.createIdentifierExpression("reflectedValue", range),
+        // Reflect.toReflectedValue(this.propertyName, seen))
+        TypeNode.createCallExpression(
+        // Reflect.toReflectedValue
+        TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("Reflect", range), TypeNode.createIdentifierExpression("toReflectedValue", range), range), null, [
+            //this.propertyName
+            TypeNode.createPropertyAccessExpression(TypeNode.createThisExpression(range), TypeNode.createIdentifierExpression(name, range), range),
+            // seen
+            TypeNode.createIdentifierExpression("seen", range),
+        ], range),
+    ], range));
+}

package/lib/src/createGenericTypeParameter.js

@@ -0,0 +1,10 @@
+import { TypeNode } from "assemblyscript/dist/assemblyscript.js";
+/**
+ * This method makes a generic named parameter.
+ *
+ * @param {string} name - The name of the type.
+ * @param {Range} range - The range given for the type parameter.
+ */
+export function createGenericTypeParameter(name, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range);
+}

package/lib/src/createStrictEqualsMember.js

@@ -0,0 +1,187 @@
+import { djb2Hash } from "./hash.js";
+import { TypeNode, } from "assemblyscript/dist/assemblyscript.js";
+/**
+ * This method creates a single FunctionDeclaration that allows Reflect.equals
+ * to validate normal class member values.
+ *
+ * @param {ClassDeclaration} classDeclaration - The class that requires a new function.
+ */
+export function createStrictEqualsMember(classDeclaration) {
+    const range = classDeclaration.name.range;
+    // __aspectStrictEquals(rawRef: Object, stackA: usize[], stackB: usize[], ignore: StaticArray<i64>): bool
+    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression("__aspectStrictEquals", range), null, 256 /* CommonFlags.Public */ | 262144 /* CommonFlags.Instance */ | (classDeclaration.isGeneric ? 131072 /* CommonFlags.GenericContext */ : 0), null, TypeNode.createFunctionType([
+        // rawRef: Object,
+        createDefaultParameter("rawRef", TypeNode.createNamedType(TypeNode.createSimpleTypeName("Object", range), null, false, range), range),
+        // stack: usize[]
+        createDefaultParameter("stack", createArrayType("usize", range), range),
+        // cache: usize[]
+        createDefaultParameter("cache", createArrayType("usize", range), range),
+        // ignore: StaticArray<i64>
+        createDefaultParameter("ignore", TypeNode.createNamedType(TypeNode.createSimpleTypeName("StaticArray", range), [TypeNode.createNamedType(TypeNode.createSimpleTypeName("i64", range), null, false, range)], false, range), range),
+    ], 
+    // : bool
+    createSimpleNamedType("bool", range), null, false, range), createStrictEqualsFunctionBody(classDeclaration), range);
+}
+/**
+ * This method creates a simple name type with the given name and source range.
+ *
+ * @param {string} name - The name of the type.
+ * @param {Range} range - The given source range.
+ */
+function createSimpleNamedType(name, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range);
+}
+/**
+ * This method creates an Array<name> type with the given range.
+ *
+ * @param {Range} range - The source range.
+ */
+function createArrayType(name, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName("Array", range), [TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range)], false, range);
+}
+/**
+ * This method creates the entire function body for __aspectStrictEquals.
+ *
+ * @param {ClassDeclaration} classDeclaration - The class declaration.
+ */
+function createStrictEqualsFunctionBody(classDeclaration) {
+    const body = new Array();
+    const range = classDeclaration.name.range;
+    const nameHashes = new Array();
+    const rawRef = TypeNode.createIdentifierExpression("rawRef", range);
+    const classType = TypeNode.createNamedType(TypeNode.createSimpleTypeName(classDeclaration.name.text, range), classDeclaration.isGeneric
+        ? classDeclaration.typeParameters.map((node) => TypeNode.createNamedType(TypeNode.createSimpleTypeName(node.name.text, range), null, false, range))
+        : null, false, range);
+    // Check if the parameter is an instance of the class; return otherwise
+    body.push(TypeNode.createIfStatement(TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, TypeNode.createInstanceOfExpression(rawRef, classType, range), range), TypeNode.createReturnStatement(TypeNode.createFalseExpression(range), range), null, range));
+    // Cast rawRef into an instance of the class
+    body.push(TypeNode.createVariableStatement(null, [
+        TypeNode.createVariableDeclaration(TypeNode.createIdentifierExpression("ref", range), null, 8 /* CommonFlags.Const */, classType, TypeNode.createAssertionExpression(1 /* AssertionKind.As */, rawRef, classType, range), range)
+    ], range));
+    // for each field declaration, generate a check
+    for (const member of classDeclaration.members) {
+        // if it's an instance member, regardless of access modifier
+        if (member.is(262144 /* CommonFlags.Instance */)) {
+            switch (member.kind) {
+                // field declarations automatically get added
+                case 55 /* NodeKind.FieldDeclaration */: {
+                    const fieldDeclaration = member;
+                    const hashValue = djb2Hash(member.name.text);
+                    body.push(createStrictEqualsIfCheck(member.name.text, hashValue, fieldDeclaration.range));
+                    nameHashes.push(hashValue);
+                    break;
+                }
+                // function declarations can be getters, check the get flag
+                case 59 /* NodeKind.MethodDeclaration */: {
+                    if (member.is(2048 /* CommonFlags.Get */)) {
+                        const methodDeclaration = member;
+                        const hashValue = djb2Hash(member.name.text);
+                        body.push(createStrictEqualsIfCheck(methodDeclaration.name.text, hashValue, methodDeclaration.name.range));
+                        nameHashes.push(hashValue);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    // if (isDefined(...)) super.__aspectStrictEquals(ref, stack, cache, ignore.concat([...props]));
+    body.push(createSuperCallStatement(classDeclaration, nameHashes));
+    // return true;
+    body.push(TypeNode.createReturnStatement(TypeNode.createTrueExpression(range), range));
+    return TypeNode.createBlockStatement(body, range);
+}
+/**
+ * This function generates a single IfStatement with a nested ReturnStatement
+ * to validate a nested property on a given class.
+ *
+ * @param {string} name - The name of the property.
+ * @param {Range} range - The source range for the given property.
+ */
+function createStrictEqualsIfCheck(name, hashValue, range) {
+    const equalsCheck = TypeNode.createBinaryExpression(76 /* Token.Equals_Equals */, 
+    // Reflect.equals(this.prop, ref.prop, stack, cache)
+    TypeNode.createCallExpression(
+    // Reflect.equals
+    createPropertyAccess("Reflect", "equals", range), null, // types can be inferred by the compiler!
+    // arguments
+    [
+        // this.prop
+        TypeNode.createPropertyAccessExpression(TypeNode.createThisExpression(range), TypeNode.createIdentifierExpression(name, range), range),
+        // ref.prop
+        createPropertyAccess("ref", name, range),
+        // stack
+        TypeNode.createIdentifierExpression("stack", range),
+        // cache
+        TypeNode.createIdentifierExpression("cache", range),
+    ], range), createPropertyAccess("Reflect", "FAILED_MATCH", range), range);
+    // !ignore.includes("prop")
+    const includesCheck = TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, 
+    // ignore.includes("prop")
+    TypeNode.createCallExpression(
+    // ignore.includes
+    TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("ignore", range), TypeNode.createIdentifierExpression("includes", range), range), null, 
+    // (nameHash)
+    [TypeNode.createIntegerLiteralExpression(f64_as_i64(hashValue), range)], range), range);
+    // if (Reflect.equals(this.prop, ref.prop, stack, cache) === Reflect.FAILED_MATCH) return false;
+    return TypeNode.createIfStatement(
+    // Reflect.equals(this.prop, ref.prop, stack, cache) === Reflect.FAILED_MATCH
+    TypeNode.createBinaryExpression(97 /* Token.Ampersand_Ampersand */, includesCheck, equalsCheck, range), 
+    // return false;
+    TypeNode.createReturnStatement(TypeNode.createFalseExpression(range), range), null, range);
+}
+/**
+ * Create a simple default parameter with a name and a type.
+ *
+ * @param {string} name - The name of the parameter.
+ * @param {TypeNode} typeNode - The type of the parameter.
+ * @param {Range} range - The source range of the parameter.
+ */
+function createDefaultParameter(name, typeNode, range) {
+    return TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression(name, range), typeNode, null, range);
+}
+/**
+ * This method creates a single property access and passes the given range to the AST.
+ *
+ * @param {string} root - The name of the identifier representing the root.
+ * @param {string} property - The name of the identifier representing the property.
+ * @param {Range} range - The range of the property access.
+ */
+function createPropertyAccess(root, property, range) {
+    // root.property
+    return TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression(root, range), TypeNode.createIdentifierExpression(property, range), range);
+}
+/**
+ * This method creates the function call into super.__aspectStrictEquals,
+ * wrapping it in a check to make sure the super function is defined first.
+ *
+ * @param {ClassDeclaration} classDeclaration - The given class declaration.
+ * @param {number[]} nameHashes - A collection of hash values of the comparing class properties.
+ */
+function createSuperCallStatement(classDeclaration, nameHashes) {
+    const range = classDeclaration.name.range;
+    const ifStatement = TypeNode.createIfStatement(TypeNode.createCallExpression(TypeNode.createIdentifierExpression("isDefined", range), null, [
+        TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectStrictEquals", range), range),
+    ], range), TypeNode.createBlockStatement([
+        TypeNode.createIfStatement(TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, createSuperCallExpression(nameHashes, range), range), TypeNode.createReturnStatement(TypeNode.createFalseExpression(range), range), null, range),
+    ], range), null, range);
+    return ifStatement;
+}
+/**
+ * This method actually creates the super.__aspectStrictEquals function call.
+ *
+ * @param {number[]} hashValues - The collection of hashed property name values
+ * @param {Range} range - The super call expression range
+ */
+function createSuperCallExpression(hashValues, range) {
+    return TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectStrictEquals", range), range), null, [
+        TypeNode.createIdentifierExpression("ref", range),
+        TypeNode.createIdentifierExpression("stack", range),
+        TypeNode.createIdentifierExpression("cache", range),
+        // StaticArray.concat(ignore, [... props] as StaticArray<i64>)
+        TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("StaticArray", range), TypeNode.createIdentifierExpression("concat", range), range), null, [
+            TypeNode.createIdentifierExpression("ignore", range),
+            // [...] as StaticArray<i64>
+            TypeNode.createAssertionExpression(1 /* AssertionKind.As */, TypeNode.createArrayLiteralExpression(hashValues.map((e) => TypeNode.createIntegerLiteralExpression(f64_as_i64(e), range)), range), TypeNode.createNamedType(TypeNode.createSimpleTypeName("StaticArray", range), [TypeNode.createNamedType(TypeNode.createSimpleTypeName("i64", range), null, false, range)], false, range), range),
+        ], range),
+    ], range);
+}

package/lib/src/emptyTransformer.js

@@ -0,0 +1,8 @@
+import { Transform } from "assemblyscript/dist/transform.js";
+/**
+ * Just an empty transformer.
+ */
+export default class AspectTransform extends Transform {
+    // @ts-ignore
+    afterParse(_parser) { }
+}

package/lib/src/hash.js

@@ -0,0 +1,15 @@
+/**
+ * A simple djb2hash that returns a hash of a given string. See http://www.cse.yorku.ca/~oz/hash.html
+ * for implementation details.
+ *
+ * @param {string} str - The string to be hashed
+ * @returns {number} The hash of the string
+ */
+export function djb2Hash(str) {
+    const points = Array.from(str);
+    let h = 5381;
+    for (let p = 0; p < points.length; p++)
+        // h = h * 33 + c;
+        h = (h << 5) + h + points[p].codePointAt(0);
+    return h;
+}

package/lib/src/index.js

@@ -0,0 +1,37 @@
+import { Transform } from "assemblyscript/dist/transform.js";
+import { createStrictEqualsMember } from "./createStrictEqualsMember.js";
+import { createAddReflectedValueKeyValuePairsMember } from "./createAddReflectedValueKeyValuePairsMember.js";
+// @ts-ignore
+export default class AspectTransform extends Transform {
+    /**
+     * This method results in a pure AST transform that inserts a strictEquals member
+     * into each ClassDeclaration.
+     *
+     * @param {Parser} parser - The AssemblyScript parser.
+     */
+    // @ts-ignore
+    afterParse(parser) {
+        // For backwards compatibility
+        let sources = parser.program ? parser.program.sources : parser.sources;
+        // for each program source
+        for (const source of sources) {
+            traverseStatements(source.statements);
+        }
+    }
+}
+function traverseStatements(statements) {
+    // for each statement in the source
+    for (const statement of statements) {
+        // find each class declaration
+        if (statement.kind === 52 /* NodeKind.ClassDeclaration */) {
+            // cast and create a strictEquals function
+            const classDeclaration = statement;
+            classDeclaration.members.push(createStrictEqualsMember(classDeclaration));
+            classDeclaration.members.push(createAddReflectedValueKeyValuePairsMember(classDeclaration));
+        }
+        else if (statement.kind === 60 /* NodeKind.NamespaceDeclaration */) {
+            const namespaceDeclaration = statement;
+            traverseStatements(namespaceDeclaration.members);
+        }
+    }
+}

package/package.json

@@ -1,22 +1,26 @@
 {
   "name": "@as-pect/transform",
-  "version": "8.0.1",
+  "version": "9.0.0",
   "description": "The transform used by the as-pect core and assembly packages to enable strict equality.",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
-    "tsc:all": "tsc"
+    "tsc:all": "tsc",
+    "test": "npm run tsc:all && node --test __tests__/*.test.js"
   },
   "author": "Joshua Tenner <tenner.joshua@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "assemblyscript": "^0.25.0"
+    "assemblyscript": "^0.28.19"
   },
   "devDependencies": {
-    "typescript": "^4.9.4"
+    "typescript": "^6.0.3"
   },
   "files": [
     "lib/",
     "init/"
-  ]
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
 }