json-as 1.0.0-beta.1 → 1.0.0-beta.11

package/transform/src/index.ts

@@ -1,4 +1,4 @@
-import { ClassDeclaration, FieldDeclaration, IdentifierExpression, Parser, Source, NodeKind, Expression, CommonFlags, StringLiteralExpression, IntegerLiteralExpression, FloatLiteralExpression, NullExpression, TrueExpression, FalseExpression, CallExpression, ImportStatement, NamespaceDeclaration, Node, Statement, Tokenizer, SourceKind, PropertyAccessExpression, Token, CommentHandler, ExpressionStatement, BinaryExpression, NamedTypeNode, Range, FEATURE_SIMD, FunctionExpression } from "assemblyscript/dist/assemblyscript.js";
+import { ClassDeclaration, FieldDeclaration, IdentifierExpression, Parser, Source, NodeKind, CommonFlags, ImportStatement, Node, Tokenizer, SourceKind, NamedTypeNode, Range, FEATURE_SIMD, FunctionExpression, MethodDeclaration } from "assemblyscript/dist/assemblyscript.js";
 import { Transform } from "assemblyscript/dist/transform.js";
 import { Visitor } from "./visitor.js";
 import { SimpleParser, toString } from "./util.js";
@@ -41,6 +41,79 @@ class JSONTransform extends Visitor {
     if (process.env["JSON_DEBUG"]) console.log("Created schema: " + this.schema.name);
 
     const members: FieldDeclaration[] = [...(node.members.filter((v) => v.kind === NodeKind.FieldDeclaration && v.flags !== CommonFlags.Static && v.flags !== CommonFlags.Private && v.flags !== CommonFlags.Protected && !v.decorators?.some((decorator) => (<IdentifierExpression>decorator.name).text === "omit")) as FieldDeclaration[])];
+    const serializers: MethodDeclaration[] = [...(node.members.filter((v) => v.kind === NodeKind.MethodDeclaration && v.decorators && v.decorators.some((e) => (<IdentifierExpression>e.name).text.toLowerCase() === "serializer")))] as MethodDeclaration[];
+    const deserializers: MethodDeclaration[] = [...(node.members.filter((v) => v.kind === NodeKind.MethodDeclaration && v.decorators && v.decorators.some((e) => (<IdentifierExpression>e.name).text.toLowerCase() === "deserializer")))] as MethodDeclaration[];
+
+    if (serializers.length > 1) throwError("Multiple serializers detected for class " + node.name.text + " but schemas can only have one serializer!", serializers[1].range);
+    if (deserializers.length > 1) throwError("Multiple deserializers detected for class " + node.name.text + " but schemas can only have one deserializer!", deserializers[1].range);
+
+    if (serializers.length) {
+      const serializer = serializers[0];
+      if (!serializer.signature.parameters.length) throwError("Could not find any parameters in custom serializer for " + this.schema.name + ". Serializers must have one parameter like 'serializer(self: " + this.schema.name + "): string {}'", serializer.range);
+      if (serializer.signature.parameters.length > 1) throwError("Found too many parameters in custom serializer for " + this.schema.name + ", but serializers can only accept one parameter of type '" + this.schema.name + "'!", serializer.signature.parameters[1].range);
+      if ((<NamedTypeNode>serializer.signature.parameters[0].type).name.identifier.text != node.name.text && (<NamedTypeNode>serializer.signature.parameters[0].type).name.identifier.text != "this") throwError("Type of parameter for custom serializer does not match! It should be 'string'either be 'this' or '" + this.schema.name + "'", serializer.signature.parameters[0].type.range);
+      if (!serializer.signature.returnType || !(<NamedTypeNode>serializer.signature.returnType).name.identifier.text.includes("string")) throwError("Could not find valid return type for serializer in " + this.schema.name + "!. Set the return type to type 'string' and try again", serializer.signature.returnType.range);
+
+      if (!serializer.decorators.some((v) => (<IdentifierExpression>v.name).text == "inline")) {
+        serializer.decorators.push(
+          Node.createDecorator(
+            Node.createIdentifierExpression(
+              "inline",
+              serializer.range
+            ),
+            null,
+            serializer.range
+          )
+        );
+      }
+      let SERIALIZER = "";
+      SERIALIZER += "  @inline __SERIALIZE_CUSTOM(ptr: usize): void {\n";
+      SERIALIZER += "    const data = this." + serializer.name.text + "(changetype<" + this.schema.name + ">(ptr));\n";
+      SERIALIZER += "    if (isNullable(data) && changetype<usize>(data) == <usize>0) throw new Error(\"Could not serialize data using custom serializer!\");\n";
+      SERIALIZER += "    const dataSize = data.length << 1;\n";
+      SERIALIZER += "    memory.copy(bs.offset, changetype<usize>(data), dataSize);\n";
+      SERIALIZER += "    bs.offset += dataSize;\n";
+      SERIALIZER += "  }\n";
+
+      if (process.env["JSON_DEBUG"]) console.log(SERIALIZER);
+
+      const SERIALIZER_METHOD = SimpleParser.parseClassMember(SERIALIZER, node);
+
+      if (!node.members.find((v) => v.name.text == "__SERIALIZE_CUSTOM")) node.members.push(SERIALIZER_METHOD);
+    }
+
+    if (deserializers.length) {
+      const deserializer = deserializers[0];
+      if (!deserializer.signature.parameters.length) throwError("Could not find any parameters in custom deserializer for " + this.schema.name + ". Deserializers must have one parameter like 'deserializer(data: string): " + this.schema.name + " {}'", deserializer.range);
+      if (deserializer.signature.parameters.length > 1) throwError("Found too many parameters in custom deserializer for " + this.schema.name + ", but deserializers can only accept one parameter of type 'string'!", deserializer.signature.parameters[1].range);
+      if ((<NamedTypeNode>deserializer.signature.parameters[0].type).name.identifier.text != "string") throwError("Type of parameter for custom deserializer does not match! It must be 'string'", deserializer.signature.parameters[0].type.range);
+      if (!deserializer.signature.returnType || !((<NamedTypeNode>deserializer.signature.returnType).name.identifier.text.includes(this.schema.name) || (<NamedTypeNode>deserializer.signature.returnType).name.identifier.text.includes("this"))) throwError("Could not find valid return type for deserializer in " + this.schema.name + "!. Set the return type to type '" + this.schema.name + "' or 'this' and try again", deserializer.signature.returnType.range);
+
+      if (!deserializer.decorators.some((v) => (<IdentifierExpression>v.name).text == "inline")) {
+        deserializer.decorators.push(
+          Node.createDecorator(
+            Node.createIdentifierExpression(
+              "inline",
+              deserializer.range
+            ),
+            null,
+            deserializer.range
+          )
+        );
+      }
+      let DESERIALIZER = "";
+      DESERIALIZER += "  @inline __DESERIALIZE_CUSTOM(data: string): " + this.schema.name + " {\n";
+      DESERIALIZER += "    const d = this." + deserializer.name.text + "(data)";
+      DESERIALIZER += "    if (isNullable(d) && changetype<usize>(d) == <usize>0) throw new Error(\"Could not deserialize data using custom deserializer!\");\n";
+      DESERIALIZER += "    return d;\n";
+      DESERIALIZER += "  }\n";
+
+      if (process.env["JSON_DEBUG"]) console.log(DESERIALIZER);
+
+      const DESERIALIZER_METHOD = SimpleParser.parseClassMember(DESERIALIZER, node);
+
+      if (!node.members.find((v) => v.name.text == "__DESERIALIZE_CUSTOM")) node.members.push(DESERIALIZER_METHOD);
+    }
 
     if (node.extendsType) {
       const extendsName = node.extendsType?.name.identifier.text;
@@ -77,15 +150,16 @@ class JSONTransform extends Visitor {
       return;
     }
 
-    this.addRequiredImports(node);
+    this.addRequiredImports(node.range.source);
 
     for (const member of members) {
       if (!member.type) throwError("Fields must be strongly typed", node.range);
-
       const type = toString(member.type!);
       const name = member.name;
       const value = member.initializer ? toString(member.initializer!) : null;
 
+      // if (!this.isValidType(type, node)) throwError("Invalid Type. " + type + " is not a JSON-compatible type. Either decorate it with @omit, set it to private, or remove it.", member.type.range);
+
       if (type.startsWith("(") && type.includes("=>")) continue;
 
       const mem = new Property();
@@ -97,16 +171,15 @@ class JSONTransform extends Visitor {
 
       this.schema.byteSize += mem.byteSize;
 
-      if (type.includes("JSON.Raw")) mem.flags.set(PropertyFlags.Raw, null);
-
       if (member.decorators) {
         for (const decorator of member.decorators) {
           const decoratorName = (decorator.name as IdentifierExpression).text.toLowerCase().trim();
           switch (decoratorName) {
             case "alias": {
-              const args = getArgs(decorator.args);
-              if (!args.length) throwError("@alias must have an argument of type string or number", member.range);
-              mem.alias = args[0]!;
+              const arg = decorator.args[0];
+              if (!arg || arg.kind != NodeKind.Literal) throwError("@alias must have an argument of type string or number", member.range);
+              // @ts-ignore: exists
+              mem.alias = arg.value.toString();
               break;
             }
             case "omitif": {
@@ -178,7 +251,7 @@ class JSONTransform extends Visitor {
         INITIALIZE += `  this.${member.name} = changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())).__INITIALIZE();\n`;
       } else if (member.type.startsWith("Array<") || member.type.startsWith("Map<")) {
         INITIALIZE += `  this.${member.name} = [];\n`;
-      } else if (member.type == "string" || member.type == "String" || member.type == "JSON.Raw") {
+      } else if (member.type == "string" || member.type == "String") {
         INITIALIZE += `  this.${member.name} = "";\n`;
       }
 
@@ -279,7 +352,7 @@ class JSONTransform extends Visitor {
       if (memberLen == 2) DESERIALIZE += `${indent}switch (load<u16>(keyStart)) {\n`;
       else if (memberLen == 4) DESERIALIZE += `${indent}switch (load<u32>(keyStart)) {\n`;
       else if (memberLen == 6) DESERIALIZE += `${indent}let code = load<u64>(keyStart) & 0x0000FFFFFFFFFFFF;\n`;
-      else if (memberLen == 6) DESERIALIZE += `${indent}let code = load<u64>(keyStart);\n`;
+      else if (memberLen == 8) DESERIALIZE += `${indent}let code = load<u64>(keyStart);\n`;
       else DESERIALIZE += toMemCDecl(memberLen, indent);
       for (let i = 0; i < memberGroup.length; i++) {
         const member = memberGroup[i];
@@ -403,32 +476,22 @@ class JSONTransform extends Visitor {
     super.visitImportStatement(node);
     const source = this.parser.sources.find((src) => src.internalPath == node.internalPath);
     if (!source) return;
-
-    if (source.statements.some((stmt) => stmt.kind === NodeKind.NamespaceDeclaration && (stmt as NamespaceDeclaration).name.text === "JSON")) this.imports.push(node);
+    this.imports.push(node);
   }
   visitSource(node: Source): void {
     this.imports = [];
     super.visitSource(node);
   }
-  addRequiredImports(node: ClassDeclaration): void {
-    // if (!this.imports.find((i) => i.declarations.find((d) => d.foreignName.text == "bs"))) {
-    //   if (!this.bsImport) {
-    //     this.bsImport = "import { bs } from \"as-bs\"";
-    //     if (process.env["JSON_DEBUG"]) console.log("Added as-bs import: " + this.bsImport + "\n");
-    //   }
-    // }
-    if (!this.imports.find((i) => i.declarations.find((d) => d.foreignName.text == "bs"))) {
-      const __filename = fileURLToPath(import.meta.url);
-      const __dirname = path.dirname(__filename);
-
-      let relativePath = path.relative(path.dirname(node.range.source.normalizedPath), path.resolve(__dirname, "../../modules/as-bs/"));
-
-      if (!relativePath.startsWith(".") && !relativePath.startsWith("/")) relativePath = "./" + relativePath;
-      // if (!existsSync(relativePath)) {
-      //   throw new Error("Could not find a valid json-as library to import from! Please add import { JSON } from \"path-to-json-as\"; in " + node.range.source.normalizedPath + "!");
-      // }
-
-      const txt = `import { bs } from "${relativePath}";`;
+  addRequiredImports(node: Source): void {
+    const bsImport = this.imports.find((i) => i.declarations.find((d) => d.foreignName.text == "bs"));
+    if (bsImport) {
+      const txt = `import { bs } from "as-bs";`;
+      if (!this.bsImport) {
+        this.bsImport = txt;
+        if (process.env["JSON_DEBUG"]) console.log("Added as-bs import: " + txt + "\n");
+      }
+    } else {
+      const txt = `import { bs } from "as-bs";`;
       if (!this.bsImport) {
         this.bsImport = txt;
         if (process.env["JSON_DEBUG"]) console.log("Added as-bs import: " + txt + "\n");
@@ -481,6 +544,48 @@ class JSONTransform extends Visitor {
     out.push("bs.offset += " + offset + ";");
     return out;
   }
+  isValidType(type: string, node: ClassDeclaration): boolean {
+    const validTypes = [
+      "string",
+      "u8",
+      "i8",
+      "u16",
+      "i16",
+      "u32",
+      "i32",
+      "u64",
+      "i64",
+      "f32",
+      "f64",
+      "bool",
+      "boolean",
+      "Date",
+      "JSON.Value",
+      "JSON.Obj",
+      "JSON.Raw",
+      "Value",
+      "Obj",
+      "Raw",
+      ...this.schemas.map((v) => v.name)
+    ];
+
+    const baseTypes = [
+      "Array",
+      "Map",
+      "Set",
+      "JSON.Box",
+      "Box"
+    ]
+
+    if (node && node.isGeneric && node.typeParameters) validTypes.push(...node.typeParameters.map((v) => v.name.text));
+    if (type.endsWith("| null")) {
+      if (isPrimitive(type.slice(0, type.indexOf("| null")))) return false;
+      return this.isValidType(type.slice(0, type.length - 7), node);
+    }
+    if (type.includes("<")) return baseTypes.includes(type.slice(0, type.indexOf("<"))) && this.isValidType(type.slice(type.indexOf("<") + 1, type.lastIndexOf(">")), node);
+    if (validTypes.includes(type)) return true;
+    return false;
+  }
 }
 
 export default class Transformer extends Transform {
@@ -505,6 +610,7 @@ export default class Transformer extends Transform {
     transformer.parser = parser;
     // Loop over every source
     for (const source of sources) {
+      // console.log("Source: " + source.normalizedPath);
       transformer.imports = [];
       transformer.currentSource = source;
       // Ignore all lib and std. Visit everything else.
@@ -560,29 +666,6 @@ function sortMembers(members: Property[]): Property[] {
   });
 }
 
-function getArgs(args: Expression[] | null): string[] {
-  if (!args) return [];
-  let out: string[] = [];
-  for (const arg of args) {
-    if (arg instanceof StringLiteralExpression) {
-      out.push(arg.value);
-    } else if (arg instanceof IntegerLiteralExpression) {
-      out.push(i64_to_string(arg.value));
-    } else if (arg instanceof FloatLiteralExpression) {
-      out.push(arg.value.toString());
-    } else if (arg instanceof NullExpression) {
-      out.push(arg.text);
-    } else if (arg instanceof TrueExpression) {
-      out.push(arg.text);
-    } else if (arg instanceof FalseExpression) {
-      out.push(arg.text);
-    } else if (arg instanceof IdentifierExpression) {
-      out.push(arg.text);
-    }
-  }
-  return out;
-}
-
 function toU16(data: string, offset: number = 0): string {
   return data.charCodeAt(offset + 0).toString();
 }

package/as-test.config.json

@@ -1,18 +0,0 @@
-{
-  "input": ["./assembly/__tests__/string.spec.ts"],
-  "outDir": "./build",
-  "config": "none",
-  "plugins": {
-    "coverage": false
-  },
-  "buildOptions": {
-    "args": ["--enable simd", "--runtime stub"],
-    "target": "wasi"
-  },
-  "runOptions": {
-    "runtime": {
-      "name": "wasmtime",
-      "run": "wasmtime <file>"
-    }
-  }
-}

package/modules/as-bs/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Jairus Tanaka <me@jairus.dev>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/modules/as-bs/README.md

@@ -1,95 +0,0 @@
-<h5 align="center">
-  <pre>
-<span style="font-size: 0.5em;">██████  ██    ██ ███████ ███████ ███████ ██████  ███████ ██ ███    ██ ██   ██ 
-██   ██ ██    ██ ██      ██      ██      ██   ██ ██      ██ ████   ██ ██  ██  
-██████  ██    ██ █████   █████   █████   ██████  ███████ ██ ██ ██  ██ █████   
-██   ██ ██    ██ ██      ██      ██      ██   ██      ██ ██ ██  ██ ██ ██  ██  
-██████   ██████  ██      ██      ███████ ██   ██ ███████ ██ ██   ████ ██   ██ 
-</span>
-    AssemblyScript - v1.0.1
-  </pre>
-</h5>
-
-## About
-
-This library provides a centralized buffer for managing memory in AssemblyScript. It keeps track of a single buffer, the current offset, and handles allocations. Using a singular buffer essentially eliminates the need for any calls to `memory.copy()` as well as any `malloc()` or `realloc()`-type calls. Highly unsafe, but extremely useful for extraordinarily high-performance scenarios.
-
-[This library](https://github.com/JairusSW/as-bs) is what makes [as-json](https://github.com/JairusSW/as-json) operate in the multi-gigabyte-per-second ranges
-
-To take a look at some practical uses of as-bs, check out the functions [here](https://github.com/JairusSW/as-json/tree/master/assembly/serialize/simple)
-
-## Installation
-
-```bash
-npm install as-bs
-```
-
-**🚨 IMPORTANT 🚨**
-
-To make sure we all depend on the same version of as-bs, please modify your package.json to meet the following
-
-Forgoing this will result in fragmentation and just a lot of problems.
-
-```json
-"dependencies": {
-  "as-bs": "latest"
-}
-```
-
-## Usage
-
-Here's an example taken out of [as-json](https://github.com/JairusSW/as-json/tree/master/assembly/serialize/simple/string.ts)
-
-This is an example of as-bs used right
-
-```js
-import { bs } from "as-bs";
-
-function serializeString(src: string): string {
-  const srcSize = bytes(src);
-  bs.ensureSize(srcSize + 4);
-
-  let srcPtr = changetype<usize>(src);
-
-  const srcEnd = srcPtr + srcSize;
-
-  store<u16>(bs.offset, QUOTE);
-
-  bs.offset += 2;
-
-  let lastPtr: i32 = srcPtr;
-  while (srcPtr < srcEnd) {
-    const code = load<u16>(srcPtr);
-    if (code == 34 || code == 92 || code < 32) {
-      const remBytes = srcPtr - lastPtr;
-      memory.copy(bs.offset, lastPtr, remBytes);
-      bs.offset += remBytes;
-      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
-      if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.ensureCapacity(12);
-        store<u64>(bs.offset, 13511005048209500, 0);
-        store<u32>(bs.offset, escaped, 8);
-        bs.offset += 12;
-      } else {
-        bs.ensureCapacity(4);
-        store<u32>(bs.offset, escaped, 0);
-        bs.offset += 4;
-      }
-      lastPtr = srcPtr + 2;
-    }
-    srcPtr += 2;
-  }
-  const remBytes = srcEnd - lastPtr;
-  memory.copy(bs.offset, lastPtr, remBytes);
-  bs.offset += remBytes;
-  store<u16>(bs.offset, QUOTE);
-  bs.offset += 2;
-  return bs.out<string>();
-}
-```
-
-If you use this project in your codebase, consider dropping a [star](https://github.com/JairusSW/as-bs). I would really appreciate it!
-
-## Issues
-
-Please submit an issue to https://github.com/JairusSW/as-bs/issues if you find anything wrong with this library

package/modules/as-bs/assembly/state.ts

@@ -1,8 +0,0 @@
-export class SinkState {
-  public offset: usize;
-  public bufferSize: usize;
-  public stackSize: usize;
-  constructor() {
-    
-  }
-}

package/modules/as-bs/assembly/tsconfig.json

@@ -1,97 +0,0 @@
-{
-  "extends": "assemblyscript/std/assembly.json",
-  "include": ["./**/*.ts"],
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-    /* Projects */
-    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-    /* Language and Environment */
-    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-    "experimentalDecorators": true /* Enable experimental support for TC39 stage 2 draft decorators. */,
-    "emitDecoratorMetadata": true /* Emit design-type metadata for decorated declarations in source files. */,
-    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-    /* Modules */
-    "module": "commonjs" /* Specify what module code is generated. */,
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
-    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-    /* JavaScript Support */
-    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-    /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
-    // "removeComments": true,                           /* Disable emitting comments. */
-    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
-    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
-    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
-    /* Interop Constraints */
-    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
-    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
-    /* Type Checking */
-    "strict": false /* Enable all strict type-checking options. */,
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-    "strictNullChecks": true /* When type checking, take into account 'null' and 'undefined'. */,
-    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-    // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */
-    "noUnusedLocals": true /* Enable error reporting when local variables aren't read. */,
-    "noUnusedParameters": true /* Raise an error when a function parameter isn't read. */,
-    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-    /* Completeness */
-    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true /* Skip type checking all .d.ts files. */
-  }
-}

package/modules/as-bs/index.ts

@@ -1 +0,0 @@
-export { bs } from "./assembly/index";

package/modules/as-bs/package.json

@@ -1,32 +0,0 @@
-{
-  "name": "as-bs",
-  "version": "1.0.1",
-  "description": "Near zero-alloc centralized buffer for high performance applications",
-  "types": "assembly/index.ts",
-  "author": "Jairus Tanaka",
-  "contributors": [],
-  "license": "MIT",
-  "scripts": {},
-  "devDependencies": {
-    "assemblyscript": "^0.27.31"
-  },
-  "dependencies": {},
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/JairusSW/as-bs.git"
-  },
-  "keywords": [
-    "assemblyscript",
-    "fast",
-    "memory",
-    "buffer"
-  ],
-  "bugs": {
-    "url": "https://github.com/JairusSW/as-bs/issues"
-  },
-  "homepage": "https://github.com/JairusSW/as-bs#readme",
-  "type": "module",
-  "publishConfig": {
-    "@JairusSW:registry": "https://npm.pkg.github.com"
-  }
-}