More cleanup

package-lock.json

@@ -4,11 +4,6 @@
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
-    "@types/long": {
-      "version": "3.0.32",
-      "resolved": "https://registry.npmjs.org/@types/long/-/long-3.0.32.tgz",
-      "integrity": "sha512-ZXyOOm83p7X8p3s0IYM3VeueNmHpkk/yMlP8CLeOnEcu6hIwPH7YjZBvhQkR0ZFS2DqZAxKtJ/M5fcuv3OU5BA=="
-    },
     "@types/strip-bom": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/@types/strip-bom/-/strip-bom-3.0.0.tgz",
@@ -4809,9 +4804,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "2.7.1",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.7.1.tgz",
-      "integrity": "sha512-bqB1yS6o9TNA9ZC/MJxM0FZzPnZdtHj0xWK/IZ5khzVqdpGul/R/EIiHRgFXlwTD7PSIaYVnGKq1QgMCu2mnqw==",
+      "version": "2.7.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.7.2.tgz",
+      "integrity": "sha512-p5TCYZDAO0m4G344hD+wx/LATebLWZNkkh2asWUFqSsD2OrDNhbAHuSjobrmsUmdzjJjEeZVU9g1h3O6vpstnw==",
       "dev": true
     },
     "uglify-js": {

package.json

@@ -11,7 +11,6 @@
     "url": "https://github.com/AssemblyScript/assemblyscript/issues"
   },
   "dependencies": {
-    "@types/long": "^3.0.32",
     "binaryen": "42.0.0-nightly.20180213",
     "glob": "^7.1.2",
     "long": "^4.0.0",
@@ -26,7 +25,7 @@
     "source-map-support": "^0.5.3",
     "ts-loader": "^3.5.0",
     "tslint": "^5.9.1",
-    "typescript": "^2.7.1",
+    "typescript": "^2.7.2",
     "webpack": "^3.11.0"
   },
   "main": "index.js",

src/ast.ts

@@ -1,5 +1,3 @@
-///////////////////////////// Abstract Syntax Tree /////////////////////////////
-
 import {
   PATH_DELIMITER,
   STATIC_DELIMITER,

src/builtins.ts

@@ -41,7 +41,11 @@ import {
 } from "./program";
 
 /** Compiles a get of a built-in global. */
-export function compileGetConstant(compiler: Compiler, global: Global, reportNode: Node): ExpressionRef {
+export function compileGetConstant(
+  compiler: Compiler,
+  global: Global,
+  reportNode: Node
+): ExpressionRef {
   switch (global.internalName) {
 
     case "NaN": // context-sensitive
@@ -58,14 +62,23 @@ export function compileGetConstant(compiler: Compiler, global: Global, reportNod
 
     case "HEAP_BASE": // never inlined for linking purposes
       compiler.currentType = compiler.options.usizeType;
-      return compiler.module.createGetGlobal("HEAP_BASE", compiler.options.nativeSizeType);
+      return compiler.module.createGetGlobal(
+        "HEAP_BASE", compiler.currentType.toNativeType()
+      );
   }
   compiler.error(DiagnosticCode.Operation_not_supported, reportNode.range);
   return compiler.module.createUnreachable();
 }
 
 /** Compiles a call to a built-in function. */
-export function compileCall(compiler: Compiler, prototype: FunctionPrototype, typeArguments: Type[] | null, operands: Expression[], contextualType: Type, reportNode: Node): ExpressionRef {
+export function compileCall(
+  compiler: Compiler,
+  prototype: FunctionPrototype,
+  typeArguments: Type[] | null,
+  operands: Expression[],
+  contextualType: Type,
+  reportNode: Node
+): ExpressionRef {
   var module = compiler.module;
 
   var arg0: ExpressionRef,

src/extra/ast.ts

@@ -1,4 +1,5 @@
-///////////////////////// Abstract Syntax Tree Extras //////////////////////////
+// Abstract Syntax Tree extras that are not needed in a standalone compiler but
+// quite useful for testing the parser.
 
 import {
   Token,

src/glue/js/binaryen.d.ts

@@ -0,0 +1,2 @@
+declare function allocate_memory(size: usize): usize;
+declare function free_memory(ptr: usize): void;

src/glue/js/binaryen.js

@@ -0,0 +1,52 @@
+// Copy Binaryen exports to global scope
+
+const binaryen = global.Binaryen || require("binaryen");
+
+for (var key in binaryen)
+  if (key.startsWith("_Binaryen") || key.startsWith("_Relooper"))
+    global[key] = binaryen[key];
+
+// Utilize Binaryen's heap
+
+global.allocate_memory = function(size) {
+  if (!size) return 0; // should be safe in our case
+  return binaryen._malloc(size);
+};
+
+global.free_memory = function(ptr) {
+  if (ptr) binaryen._free(ptr);
+};
+
+global.move_memory = function(dest, src, n) {
+  return binaryen._memmove(dest, src, n);
+};
+
+global.store = function(ptr, val) {
+  binaryen.HEAPU8[ptr] = val;
+};
+
+global.load = function(ptr) {
+  return binaryen.HEAPU8[ptr];
+};
+
+// Implement module stubs
+
+const Module = require("../../module").Module;
+
+Module.prototype.toText = function toText() {
+  var previousPrint = binaryen.print;
+  var ret = "";
+  binaryen.print = function(x) { ret += x + "\n" };
+  _BinaryenModulePrint(this.ref);
+  binaryen.print = previousPrint;
+  return ret;
+};
+
+Module.prototype.toAsmjs = function toAsmjs() {
+  var previousPrint = binaryen.print;
+  var ret = "";
+  binaryen.print = function(x) { ret += x + "\n" };
+  _BinaryenModulePrintAsmjs(this.ref);
+  binaryen.print = previousPrint;
+  return ret;
+};

src/glue/js/i64.d.ts

@@ -1,4 +1,4 @@
-declare type I64 = Long;
+declare type I64 = { __Long__: true }; // opaque
 
 declare function i64_new(lo: i32, hi?: i32): I64;
 declare function i64_low(value: I64): i32;

src/glue/js/i64.js

@@ -0,0 +1,132 @@
+const Long = global.Long || require("long");
+
+global.i64_new = function(lo, hi) {
+  return Long.fromBits(lo, hi);
+};
+
+global.i64_low = function(value) {
+  return value.low;
+};
+
+global.i64_high = function(value) {
+  return value.high;
+};
+
+global.i64_add = function(left, right) {
+  return left.add(right);
+};
+
+global.i64_sub = function(left, right) {
+  return left.sub(right);
+};
+
+global.i64_mul = function(left, right) {
+  return left.mul(right);
+};
+
+global.i64_div = function(left, right) {
+  return left.div(right);
+};
+
+global.i64_div_u = function(left, right) {
+  return left.toUnsigned().div(right.toUnsigned()).toSigned();
+};
+
+global.i64_rem = function(left, right) {
+  return left.mod(right);
+};
+
+global.i64_rem_u = function(left, right) {
+  return left.toUnsigned().mod(right.toUnsigned()).toSigned();
+};
+
+global.i64_and = function(left, right) {
+  return left.and(right);
+};
+
+global.i64_or = function(left, right) {
+  return left.or(right);
+};
+
+global.i64_xor = function(left, right) {
+  return left.xor(right);
+};
+
+global.i64_shl = function(left, right) {
+  return left.shl(right);
+};
+
+global.i64_shr = function(left, right) {
+  return left.shr(right);
+};
+
+global.i64_shr_u = function(left, right) {
+  return left.shru(right);
+};
+
+global.i64_not = function(value) {
+  return value.not();
+};
+
+global.i64_align = function(value, alignment) {
+  assert(alignment && (alignment & (alignment - 1)) == 0);
+  var mask = Long.fromInt(alignment - 1);
+  return value.add(mask).and(mask.not());
+};
+
+global.i64_is_i8 = function(value) {
+  return value.high === 0 && (value.low >= 0 && value.low <= i8.MAX_VALUE)
+      || value.high === -1 && (value.low >= i8.MIN_VALUE && value.low < 0);
+};
+
+global.i64_is_i16 = function(value) {
+  return value.high === 0 && (value.low >= 0 && value.low <= i16.MAX_VALUE)
+      || value.high === -1 && (value.low >= i16.MIN_VALUE && value.low < 0);
+};
+
+global.i64_is_i32 = function(value) {
+  return (value.high === 0 && value.low >= 0)
+      || (value.high === -1 && value.low < 0);
+};
+
+global.i64_is_u8 = function(value) {
+  return value.high === 0 && value.low >= 0 && value.low <= u8.MAX_VALUE;
+};
+
+global.i64_is_u16 = function(value) {
+  return value.high === 0 && value.low >= 0 && value.low <= u16.MAX_VALUE;
+};
+
+global.i64_is_u32 = function(value) {
+  return value.high === 0;
+};
+
+global.i64_is_bool = function(value) {
+  return value.high === 0 && (value.low === 0 || value.low === 1);
+};
+
+const minSafeF32 = Long.fromNumber(f32.MIN_SAFE_INTEGER);
+const maxSafeF32 = Long.fromNumber(f32.MAX_SAFE_INTEGER);
+
+global.i64_is_f32 = function(value) {
+  return value.gte(minSafeF32) && value.lte(maxSafeF32);
+};
+
+const minSafeF64 = Long.fromNumber(f64.MIN_SAFE_INTEGER);
+const maxSafeF64 = Long.fromNumber(f64.MAX_SAFE_INTEGER);
+
+global.i64_is_f64 = function(value) {
+  return value.gte(minSafeF64) && value.lte(maxSafeF64);
+};
+
+global.i64_to_f32 = function(value) {
+  return global.Math.fround(value.toNumber());
+};
+
+global.i64_to_f64 = function(value) {
+  return value.toNumber();
+};
+
+global.i64_to_string = function(value, unsigned) {
+  return (unsigned ? value.toUnsigned() : value).toString(10);
+};

src/glue/js/index.ts

@@ -1,193 +1,3 @@
 import "../../../std/portable";
-
-// Copy Binaryen exports to global scope
-
-declare const global: any;
-declare function require(name: string): any;
-
-const binaryen: any = global.Binaryen || require("binaryen");
-
-for (let key in binaryen)
-  if (key.startsWith("_Binaryen") || key.startsWith("_Relooper"))
-    global[key] = (<any>binaryen)[key];
-
-// Use Binaryen's heap instead of std heap
-
-global.allocate_memory = function(size: number): number {
-  if (!size) return 0; // should be safe in our case
-  return (<any>binaryen)._malloc(size);
-};
-
-global.free_memory = function(ptr: number): void {
-  if (ptr) (<any>binaryen)._free(ptr);
-};
-
-global.move_memory = function(dest: number, src: number, n: number): number {
-  return (<any>binaryen)._memmove(dest, src, n);
-};
-
-global.store = function(ptr: number, val: number): void {
-  (<any>binaryen).HEAPU8[ptr] = val;
-};
-
-global.load = function(ptr: number): number {
-  return (<any>binaryen).HEAPU8[ptr];
-};
-
-// Implement module stubs
-
-import { Module } from "../../module";
-
-Module.prototype.toText = function toText() {
-  var previousPrint = binaryen.print;
-  var ret = "";
-  binaryen.print = (x: string) => { ret += x + "\n" };
-  this.print();
-  binaryen.print = previousPrint;
-  return ret;
-};
-
-Module.prototype.toAsmjs = function toAsmjs() {
-  var previousPrint = binaryen.print;
-  var ret = "";
-  binaryen.print = (x: string) => { ret += x + "\n" };
-  this.printAsmjs();
-  binaryen.print = previousPrint;
-  return ret;
-};
-
-// Implement I64 using long.js
-
-import * as Long from "long";
-
-/// <reference path="./i64.d.ts" />
-
-global.i64_new = function(lo: number, hi: number = 0): I64 {
-  return Long.fromBits(lo, hi);
-};
-
-global.i64_low = function(value: I64): i32 {
-  return value.low;
-};
-
-global.i64_high = function(value: I64): i32 {
-  return value.high;
-};
-
-global.i64_add = function(left: I64, right: I64): I64 {
-  return left.add(right);
-};
-
-global.i64_sub = function(left: I64, right: I64): I64 {
-  return left.sub(right);
-};
-
-global.i64_mul = function(left: I64, right: I64): I64 {
-  return left.mul(right);
-};
-
-global.i64_div = function(left: I64, right: I64): I64 {
-  return left.div(right);
-};
-
-global.i64_div_u = function(left: I64, right: I64): I64 {
-  return left.toUnsigned().div(right.toUnsigned()).toSigned();
-};
-
-global.i64_rem = function(left: I64, right: I64): I64 {
-  return left.mod(right);
-};
-
-global.i64_rem_u = function(left: I64, right: I64): I64 {
-  return left.toUnsigned().mod(right.toUnsigned()).toSigned();
-};
-
-global.i64_and = function(left: I64, right: I64): I64 {
-  return left.and(right);
-};
-
-global.i64_or = function(left: I64, right: I64): I64 {
-  return left.or(right);
-};
-
-global.i64_xor = function(left: I64, right: I64): I64 {
-  return left.xor(right);
-};
-
-global.i64_shl = function(left: I64, right: I64): I64 {
-  return left.shl(right);
-};
-
-global.i64_shr = function(left: I64, right: I64): I64 {
-  return left.shr(right);
-};
-
-global.i64_shr_u = function(left: I64, right: I64): I64 {
-  return left.shru(right);
-};
-
-global.i64_not = function(value: I64): I64 {
-  return value.not();
-};
-
-global.i64_align = function(value: I64, alignment: i32): I64 {
-  assert(alignment && (alignment & (alignment - 1)) == 0);
-  var mask = Long.fromInt(alignment - 1);
-  return value.add(mask).and(mask.not());
-};
-
-global.i64_is_i8 = function(value: I64): bool {
-  return value.high === 0 && (value.low >= 0 && value.low <= i8.MAX_VALUE)
-      || value.high === -1 && (value.low >= i8.MIN_VALUE && value.low < 0);
-};
-
-global.i64_is_i16 = function(value: I64): bool {
-  return value.high === 0 && (value.low >= 0 && value.low <= i16.MAX_VALUE)
-      || value.high === -1 && (value.low >= i16.MIN_VALUE && value.low < 0);
-};
-
-global.i64_is_i32 = function(value: I64): bool {
-  return (value.high === 0 && value.low >= 0) || (value.high === -1 && value.low < 0);
-};
-
-global.i64_is_u8 = function(value: I64): bool {
-  return value.high === 0 && value.low >= 0 && value.low <= u8.MAX_VALUE;
-};
-
-global.i64_is_u16 = function(value: I64): bool {
-  return value.high === 0 && value.low >= 0 && value.low <= u16.MAX_VALUE;
-};
-
-global.i64_is_u32 = function(value: I64): bool {
-  return value.high === 0;
-};
-
-global.i64_is_bool = function(value: I64): bool {
-  return value.high === 0 && (value.low === 0 || value.low === 1);
-};
-
-const minSafeF32 = Long.fromNumber(f32.MIN_SAFE_INTEGER);
-const maxSafeF32 = Long.fromNumber(f32.MAX_SAFE_INTEGER);
-
-global.i64_is_f32 = function(value: I64): bool {
-  return value.gte(minSafeF32) && value.lte(maxSafeF32);
-};
-
-const minSafeF64 = Long.fromNumber(f64.MIN_SAFE_INTEGER);
-const maxSafeF64 = Long.fromNumber(f64.MAX_SAFE_INTEGER);
-
-global.i64_is_f64 = function(value: I64): bool {
-  return value.gte(minSafeF64) && value.lte(maxSafeF64);
-};
-
-global.i64_to_f32 = function(value: I64): f64 {
-  return global.Math.fround(value.toNumber());
-};
-
-global.i64_to_f64 = function(value: I64): f64 {
-  return value.toNumber();
-};
-
-global.i64_to_string = function(value: I64, unsigned: bool = false): string {
-  return (unsigned ? value.toUnsigned() : value).toString(10);
-};
+import "./binaryen";
+import "./i64";

src/glue/js/node.d.ts

@@ -0,0 +1,2 @@
+declare const global: any;
+declare function require(name: string): any;

src/glue/wasm/i64.ts

@@ -0,0 +1,164 @@
+type I64 = i64;
+
+@global
+function i64_new(lo: i32, hi: i32 = 0): I64 {
+  return lo | (hi << 32);
+}
+
+@global
+function i64_low(value: I64): i32 {
+  return <i32>value;
+}
+
+@global
+function i64_high(value: I64): i32 {
+  return <i32>(value >>> 32);
+}
+
+@global
+function i64_add(left: I64, right: I64): I64 {
+  return left + right;
+}
+
+@global
+function i64_sub(left: I64, right: I64): I64 {
+  return left - right;
+}
+
+@global
+function i64_mul(left: I64, right: I64): I64 {
+  return left * right;
+}
+
+@global
+function i64_div(left: I64, right: I64): I64 {
+  return left / right;
+}
+
+@global
+function i64_div_u(left: I64, right: I64): I64 {
+  return <u64>left / <u64>right;
+}
+
+@global
+function i64_rem(left: I64, right: I64): I64 {
+  return left % right;
+}
+
+@global
+function i64_rem_u(left: I64, right: I64): I64 {
+  return <u64>left % <u64>right;
+}
+
+@global
+function i64_and(left: I64, right: I64): I64 {
+  return left & right;
+}
+
+@global
+function i64_or(left: I64, right: I64): I64 {
+  return left | right;
+}
+
+@global
+function i64_xor(left: I64, right: I64): I64 {
+  return left ^ right;
+}
+
+@global
+function i64_shl(left: I64, right: I64): I64 {
+  return left << right;
+}
+
+@global
+function i64_shr(left: I64, right: I64): I64 {
+  return left >> right;
+}
+
+@global
+function i64_shr_u(left: I64, right: I64): I64 {
+  return left >>> right;
+}
+
+@global
+function i64_not(value: I64): I64 {
+  return ~value;
+}
+
+@global
+function i64_align(value: I64, alignment: i64): I64 {
+  var mask: i64 = alignment - 1;
+  assert(alignment && (alignment & mask) == 0);
+  return (value + mask) & ~mask;
+}
+
+@global
+function i64_is_i8(value: I64): bool {
+  return value >= i8.MIN_VALUE && value <= i8.MAX_VALUE;
+}
+
+@global
+function i64_is_i16(value: I64): bool {
+  return value >= i16.MIN_VALUE && value <= i16.MAX_VALUE;
+}
+
+@global
+function i64_is_i32(value: I64): bool {
+  return value >= i32.MIN_VALUE && value <= i32.MAX_VALUE;
+}
+
+@global
+function i64_is_u8(value: I64): bool {
+  return value >= 0 && value <= u8.MAX_VALUE;
+}
+
+@global
+function i64_is_u16(value: I64): bool {
+  return value >= 0 && value <= u16.MAX_VALUE;
+}
+
+@global
+function i64_is_u32(value: I64): bool {
+  return value >= 0 && value <= u32.MAX_VALUE;
+}
+
+@global
+function i64_is_bool(value: I64): bool {
+  return value === 0 || value === 1;
+}
+
+@global
+function i64_is_f32(value: I64): bool {
+  return value >= f32.MIN_SAFE_INTEGER && value <= f32.MAX_SAFE_INTEGER;
+}
+
+@global
+function i64_is_f64(value: I64): bool {
+  return value >= f64.MIN_SAFE_INTEGER && value <= f64.MAX_SAFE_INTEGER;
+}
+
+@global
+function i64_to_f32(value: I64): f32 {
+  return <f32>value;
+}
+
+@global
+function i64_to_f64(value: I64): f64 {
+  return <f64>value;
+}
+
+import { CharCode } from "../../util/charcode";
+
+@global
+function i64_to_string(value: I64): string {
+  var chars = new Array<u16>();
+  if (value < 0) {
+    chars.push(CharCode.MINUS);
+    value = -value;
+  }
+  do {
+    chars.push(CharCode._0 + (value % 10));
+    value /= 10;
+  } while (value);
+  return String.fromCharCodes(chars);
+}

src/glue/wasm/index.ts

@@ -1,164 +1 @@
-type I64 = i64;
-
-@global
-function i64_new(lo: i32, hi: i32 = 0): I64 {
-  return lo | (hi << 32);
-}
-
-@global
-function i64_low(value: I64): i32 {
-  return <i32>value;
-}
-
-@global
-function i64_high(value: I64): i32 {
-  return <i32>(value >>> 32);
-}
-
-@global
-function i64_add(left: I64, right: I64): I64 {
-  return left + right;
-}
-
-@global
-function i64_sub(left: I64, right: I64): I64 {
-  return left - right;
-}
-
-@global
-function i64_mul(left: I64, right: I64): I64 {
-  return left * right;
-}
-
-@global
-function i64_div(left: I64, right: I64): I64 {
-  return left / right;
-}
-
-@global
-function i64_div_u(left: I64, right: I64): I64 {
-  return <u64>left / <u64>right;
-}
-
-@global
-function i64_rem(left: I64, right: I64): I64 {
-  return left % right;
-}
-
-@global
-function i64_rem_u(left: I64, right: I64): I64 {
-  return <u64>left % <u64>right;
-}
-
-@global
-function i64_and(left: I64, right: I64): I64 {
-  return left & right;
-}
-
-@global
-function i64_or(left: I64, right: I64): I64 {
-  return left | right;
-}
-
-@global
-function i64_xor(left: I64, right: I64): I64 {
-  return left ^ right;
-}
-
-@global
-function i64_shl(left: I64, right: I64): I64 {
-  return left << right;
-}
-
-@global
-function i64_shr(left: I64, right: I64): I64 {
-  return left >> right;
-}
-
-@global
-function i64_shr_u(left: I64, right: I64): I64 {
-  return left >>> right;
-}
-
-@global
-function i64_not(value: I64): I64 {
-  return ~value;
-}
-
-@global
-function i64_align(value: I64, alignment: i64): I64 {
-  var mask: i64 = alignment - 1;
-  assert(alignment && (alignment & mask) == 0);
-  return (value + mask) & ~mask;
-}
-
-@global
-function i64_is_i8(value: I64): bool {
-  return value >= i8.MIN_VALUE && value <= i8.MAX_VALUE;
-}
-
-@global
-function i64_is_i16(value: I64): bool {
-  return value >= i16.MIN_VALUE && value <= i16.MAX_VALUE;
-}
-
-@global
-function i64_is_i32(value: I64): bool {
-  return value >= i32.MIN_VALUE && value <= i32.MAX_VALUE;
-}
-
-@global
-function i64_is_u8(value: I64): bool {
-  return value >= 0 && value <= u8.MAX_VALUE;
-}
-
-@global
-function i64_is_u16(value: I64): bool {
-  return value >= 0 && value <= u16.MAX_VALUE;
-}
-
-@global
-function i64_is_u32(value: I64): bool {
-  return value >= 0 && value <= u32.MAX_VALUE;
-}
-
-@global
-function i64_is_bool(value: I64): bool {
-  return value === 0 || value === 1;
-}
-
-@global
-function i64_is_f32(value: I64): bool {
-  return value >= f32.MIN_SAFE_INTEGER && value <= f32.MAX_SAFE_INTEGER;
-}
-
-@global
-function i64_is_f64(value: I64): bool {
-  return value >= f64.MIN_SAFE_INTEGER && value <= f64.MAX_SAFE_INTEGER;
-}
-
-@global
-function i64_to_f32(value: I64): f32 {
-  return <f32>value;
-}
-
-@global
-function i64_to_f64(value: I64): f64 {
-  return <f64>value;
-}
-
-import { CharCode } from "../../util/charcode";
-
-@global
-function i64_to_string(value: I64): string {
-  var chars = new Array<u16>();
-  if (value < 0) {
-    chars.push(CharCode.MINUS);
-    value = -value;
-  }
-  do {
-    chars.push(CharCode._0 + (value % 10));
-    value /= 10;
-  } while (value);
-  return String.fromCharCodes(chars);
-}
+import "./i64";

src/module.ts

@@ -713,14 +713,6 @@ export class Module {
     _BinaryenModuleInterpret(this.ref);
   }
 
-  print(): void {
-    _BinaryenModulePrint(this.ref);
-  }
-
-  printAsmjs(): void {
-    _BinaryenModulePrintAsmjs(this.ref);
-  }
-
   toBinary(sourceMapUrl: string | null): Binary {
     var out = this.out;
     var cStr = allocString(sourceMapUrl);

src/util/charcode.ts

@@ -1,5 +1,3 @@
-//////////////////////////// Character codes utility ////////////////////////////
-
 /** An enum of named character codes. */
 export const enum CharCode {
 

src/util/path.ts

@@ -1,5 +1,3 @@
-//////////////////////////// Internal path utility /////////////////////////////
-
 import {
   CharCode
 } from "./charcode";