toiljs 0.0.4 → 0.0.5

package/examples/basic/node_modules/toilscript/std/assembly/symbol.ts

@@ -0,0 +1,114 @@
+import { Map } from "./map";
+
+// @ts-ignore: decorator
+@lazy let stringToId: Map<string, usize> = new Map();
+
+// @ts-ignore: decorator
+@lazy let idToString: Map<usize, string> = new Map();
+
+// @ts-ignore: decorator
+@lazy let nextId: usize = 12; // Symbol.unscopables + 1
+
+@unmanaged @final abstract class _Symbol {
+
+  // TODO: all of the following default symbols are unused currently yet add to
+  // binary size if #toString becomes compiled. Ultimately we'll most likely want
+  // to remove the unsupported ones and only keep what's actually supported.
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly hasInstance: symbol = changetype<symbol>(1);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly isConcatSpreadable: symbol = changetype<symbol>(2);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly isRegExp: symbol = changetype<symbol>(3);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly iterator: symbol = changetype<symbol>(3);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly match: symbol = changetype<symbol>(4);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly replace: symbol = changetype<symbol>(5);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly search: symbol = changetype<symbol>(6);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly species: symbol = changetype<symbol>(7);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly split: symbol = changetype<symbol>(8);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly toPrimitive: symbol = changetype<symbol>(9);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly toStringTag: symbol = changetype<symbol>(10);
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly unscopables: symbol = changetype<symbol>(11);
+
+  static for(key: string): symbol {
+    if (stringToId.has(key)) return changetype<symbol>(stringToId.get(key));
+    let id = nextId++;
+    if (!id) unreachable(); // out of ids
+    stringToId.set(key, id);
+    idToString.set(id, key);
+    return changetype<symbol>(id);
+  }
+
+  static keyFor(sym: symbol): string | null {
+    return idToString.has(changetype<usize>(sym))
+      ? idToString.get(changetype<usize>(sym))
+      : null;
+  }
+
+  toString(): string {
+    let id = changetype<usize>(this);
+    let str = "";
+    switch (<u32>id) {
+      case 1:  { str = "hasInstance"; break; }
+      case 2:  { str = "isConcatSpreadable"; break; }
+      case 3:  { str = "isRegExp"; break; }
+      case 4:  { str = "match"; break; }
+      case 5:  { str = "replace"; break; }
+      case 6:  { str = "search"; break; }
+      case 7:  { str = "species"; break; }
+      case 8:  { str = "split"; break; }
+      case 9:  { str = "toPrimitive"; break; }
+      case 10: { str = "toStringTag"; break; }
+      case 11: { str = "unscopables"; break; }
+      default: {
+        if (idToString != null && idToString.has(id)) str = idToString.get(id);
+        break;
+      }
+    }
+    return "Symbol(" + str + ")";
+  }
+}
+
+export function Symbol(description: string | null = null): symbol {
+  let id = nextId++;
+  if (!id) unreachable(); // out of ids
+  return changetype<symbol>(id);
+}
+
+export type Symbol = _Symbol;
+
+// @ts-ignore: nolib
+export type symbol = _Symbol;

package/examples/basic/node_modules/toilscript/std/assembly/table.ts

@@ -0,0 +1,16 @@
+import { E_NOTIMPLEMENTED } from "./util/error";
+
+export namespace table {
+
+  export function copy(dst: u32, src: u32, n: u32): void {
+    throw new Error(E_NOTIMPLEMENTED);
+  }
+
+  export function init(elementIndex: u32, srcOffset: u32, dstOffset: u32, n: u32): void {
+    throw new Error(E_NOTIMPLEMENTED);
+  }
+
+  export function drop(elementIndex: u32): void {
+    throw new Error(E_NOTIMPLEMENTED);
+  }
+}

package/examples/basic/node_modules/toilscript/std/assembly/toilscript.ts

@@ -0,0 +1,16 @@
+/**
+ * ToilScript-native declarations.
+ *
+ * Compiler-level natives available everywhere with no import. `@main` is handled
+ * directly by the ToilScript compiler — it exports the decorated top-level
+ * function as the module's `main` entry — so this declaration exists only so
+ * editors and type-checking recognize the decorator. Future zero-import toil
+ * natives (globals/decorators) belong here too.
+ */
+
+/**
+ * Marks a single top-level function as the module entry point. The compiler
+ * exports it as the WebAssembly export `main` — no `export` keyword needed.
+ * Exactly one `@main` is allowed per module.
+ */
+declare function main(...args: any[]): any;

package/examples/basic/node_modules/toilscript/std/assembly/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../assembly.json",
+  "include": [
+    "./**/*.ts"
+  ]
+}