complete es5

Author: uhyo

build/index.ts

@@ -36,6 +36,11 @@ async function main() {
       }
     }
     result += file.text.slice(file.endOfFileToken.pos);
+    // Replace <reference lib="" /> to <reference path="" />
+    result = result.replace(
+      /^\/\/\/\s*<reference\s+lib="(.+?)"\s*\/>/gm,
+      (_, lib) => `/// <reference path="./lib.${lib}.d.ts" />`
+    );
 
     await writeFile(path.join(distDir, libFile), result);
     console.log(libFile);

build/replacement.ts

@@ -2,6 +2,10 @@ export const replacement = new Set<string>([
   // lib.es5.d.ts
   "eval",
   "ObjectConstructor",
+  "CallableFunction",
+  "IArguments",
+  "JSON",
+  "ArrayConstructor",
 ]);
 
 export const betterLibs = new Set<string>(["lib.es5.d.ts"]);

lib/lib.es5.d.ts

@@ -154,3 +154,105 @@ interface ObjectConstructor {
    */
   keys(o: object): string[];
 }
+
+interface CallableFunction extends Function {
+  /**
+   * Calls the function with the specified object as the this value and the elements of specified array as the arguments.
+   * @param thisArg The object to be used as the this object.
+   * @param args An array of argument values to be passed to the function.
+   */
+  apply<T, R>(this: (this: T) => R, thisArg: T): R;
+  apply<T, A extends any[], R>(
+    this: (this: T, ...args: A) => R,
+    thisArg: T,
+    args: A
+  ): R;
+
+  /**
+   * Calls the function with the specified object as the this value and the specified rest arguments as the arguments.
+   * @param thisArg The object to be used as the this object.
+   * @param args Argument values to be passed to the function.
+   */
+  call<T, A extends any[], R>(
+    this: (this: T, ...args: A) => R,
+    thisArg: T,
+    ...args: A
+  ): R;
+
+  /**
+   * For a given function, creates a bound function that has the same body as the original function.
+   * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
+   * @param thisArg The object to be used as the this object.
+   * @param args Arguments to bind to the parameters of the function.
+   */
+  bind<T, A extends readonly any[], B extends readonly any[], R>(
+    this: (this: T, ...args: [...A, ...B]) => R,
+    thisArg: T,
+    ...args: A
+  ): (...args: B) => R;
+}
+
+interface IArguments {
+  [index: number]: unknown;
+  length: number;
+  callee: Function;
+}
+
+type JSONValue =
+  | null
+  | string
+  | number
+  | boolean
+  | {
+      [K in string]?: JSONValue;
+    }
+  | JSONValue[];
+
+interface JSON {
+  /**
+   * Converts a JavaScript Object Notation (JSON) string into an object.
+   * @param text A valid JSON string.
+   * @param reviver A function that transforms the results. This function is called for each member of the object.
+   * If a member contains nested objects, the nested objects are transformed before the parent object is.
+   */
+  parse(
+    text: string,
+    reviver?: (this: JSONValue, key: string, value: JSONValue) => any
+  ): JSONValue;
+  /**
+   * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+   * @param value A JavaScript value, usually an object or array, to be converted.
+   * @param replacer A function that transforms the results.
+   * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+   */
+  stringify(
+    value: JSONValue,
+    replacer?: (this: JSONValue, key: string, value: JSONValue) => any,
+    space?: string | number
+  ): string;
+  /**
+   * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
+   * @param value A JavaScript value, usually an object or array, to be converted.
+   * @param replacer An array of strings and numbers that acts as a approved list for selecting the object properties that will be stringified.
+   * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+   */
+  stringify(
+    value: JSONValue,
+    replacer?: (number | string)[] | null,
+    space?: string | number
+  ): string;
+}
+
+/**
+ * An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
+ */
+declare var JSON: JSON;
+
+interface ArrayConstructor {
+  new <T>(arrayLength: number): T[];
+  new <T>(...items: T[]): T[];
+  <T>(arrayLength: number): T[];
+  <T>(...items: T[]): T[];
+  isArray(arg: any): arg is unknown[];
+  readonly prototype: unknown[];
+}

tests/es5.ts

@@ -1,6 +1,6 @@
 /// <reference path="../dist/lib/lib.es5.d.ts" />
 
-import { expectType } from "tsd";
+import { expectError, expectType } from "tsd";
 
 // eval
 expectType<unknown>(eval("foo"));
@@ -54,4 +54,59 @@ expectType<{ foo: number; bar: string; baz: boolean }>(
   )
 );
 
+// CallableFunction
+{
+  const add = (a: number, b: number): number => a + b;
+  expectType<(a: number, b: number) => number>(add.bind(null));
+  expectType<(b: number) => number>(add.bind(null, 123));
+  expectType<() => number>(add.bind(null, 123, 456));
+  expectError(add.bind(null, 123, 456, 789));
+
+  const add2 = function (this: { num: number }, a: number): number {
+    return this.num + a;
+  };
+  expectError(add2.bind(null));
+  expectError(add2.bind(null, 123));
+  expectType<(a: number) => number>(add2.bind({ num: 0 }));
+  expectType<() => number>(add2.bind({ num: 100 }, 123));
+  expectError(add2.bind({ num: 100 }, 123, 456));
+}
+
+// IArguments
+(function () {
+  expectType<unknown>(arguments[0]);
+})();
+
+// JSON
+expectType<JSONValue>(JSON.parse("{}"));
+
+// ArrayConstructor
+{
+  const a1 = new Array();
+  expectType<unknown[]>(a1);
+  const a2 = new Array<number>();
+  expectType<number[]>(a2);
+  const a3: number[] = new Array();
+  expectType<number[]>(a3);
+  const a4 = new Array("foo", "bar");
+  expectType<string[]>(a4);
+
+  const a5 = new Array(1);
+  expectType<unknown[]>(a5);
+
+  const a6 = new Array<boolean>(1);
+  expectType<boolean[]>(a6);
+
+  const a7: boolean[] = new Array(1);
+  expectType<boolean[]>(a7);
+
+  const a8: {} = {};
+  if (Array.isArray(a7)) {
+    expectType<boolean>(a7[0]);
+  }
+  if (Array.isArray(a8)) {
+    expectType<unknown>(a8[0]);
+  }
+}
+
 export {};