Internalize base64-js, convert to TypeScript

cli/BUILD.gn

@@ -62,6 +62,7 @@ if (is_posix) {
 
 ts_sources = [
  "../js/assets.ts",
+ "../js/base64.ts",
  "../js/blob.ts",
  "../js/body.ts",
  "../js/buffer.ts",
@@ -265,11 +266,3 @@ snapshot("snapshot_compiler") {
  ":compiler_bundle",
  ]
 }
-
-action("write_gn_args") {
- script = "//tools/write_gn_args.py"
- outputs = [
- "$target_gen_dir/gn_args.txt",
- ]
- args = [ rebase_path(outputs[0], root_build_dir) ]
-}

js/base64.ts

@@ -0,0 +1,149 @@
+// Forked from https://github.com/beatgammit/base64-js
+// Copyright (c) 2014 Jameson Little. MIT License.
+
+const lookup: string[] = [];
+const revLookup: number[] = [];
+
+const code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var i = 0, len = code.length; i < len; ++i) {
+ lookup[i] = code[i];
+ revLookup[code.charCodeAt(i)] = i;
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+
+function getLens(b64: string): [number, number] {
+ var len = b64.length;
+
+ if (len % 4 > 0) {
+ throw new Error("Invalid string. Length must be a multiple of 4");
+ }
+
+ // Trim off extra bytes after placeholder bytes are found
+ // See: https://github.com/beatgammit/base64-js/issues/42
+ var validLen = b64.indexOf("=");
+ if (validLen === -1) validLen = len;
+
+ var placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
+
+ return [validLen, placeHoldersLen];
+}
+
+// base64 is 4/3 + up to two characters of the original data
+export function byteLength(b64: string): number {
+ var lens = getLens(b64);
+ var validLen = lens[0];
+ var placeHoldersLen = lens[1];
+ return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+}
+
+function _byteLength(
+ b64: string,
+ validLen: number,
+ placeHoldersLen: number
+): number {
+ return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+}
+
+export function toByteArray(b64: string): Uint8Array {
+ var tmp;
+ var lens = getLens(b64);
+ var validLen = lens[0];
+ var placeHoldersLen = lens[1];
+
+ var arr = new Uint8Array(_byteLength(b64, validLen, placeHoldersLen));
+
+ var curByte = 0;
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+
+ for (var i = 0; i < len; i += 4) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 18) |
+ (revLookup[b64.charCodeAt(i + 1)] << 12) |
+ (revLookup[b64.charCodeAt(i + 2)] << 6) |
+ revLookup[b64.charCodeAt(i + 3)];
+ arr[curByte++] = (tmp >> 16) & 0xff;
+ arr[curByte++] = (tmp >> 8) & 0xff;
+ arr[curByte++] = tmp & 0xff;
+ }
+
+ if (placeHoldersLen === 2) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 2) |
+ (revLookup[b64.charCodeAt(i + 1)] >> 4);
+ arr[curByte++] = tmp & 0xff;
+ }
+
+ if (placeHoldersLen === 1) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 10) |
+ (revLookup[b64.charCodeAt(i + 1)] << 4) |
+ (revLookup[b64.charCodeAt(i + 2)] >> 2);
+ arr[curByte++] = (tmp >> 8) & 0xff;
+ arr[curByte++] = tmp & 0xff;
+ }
+
+ return arr;
+}
+
+function tripletToBase64(num: number): string {
+ return (
+ lookup[(num >> 18) & 0x3f] +
+ lookup[(num >> 12) & 0x3f] +
+ lookup[(num >> 6) & 0x3f] +
+ lookup[num & 0x3f]
+ );
+}
+
+function encodeChunk(uint8: Uint8Array, start: number, end: number): string {
+ var tmp;
+ var output = [];
+ for (var i = start; i < end; i += 3) {
+ tmp =
+ ((uint8[i] << 16) & 0xff0000) +
+ ((uint8[i + 1] << 8) & 0xff00) +
+ (uint8[i + 2] & 0xff);
+ output.push(tripletToBase64(tmp));
+ }
+ return output.join("");
+}
+
+export function fromByteArray(uint8: Uint8Array): string {
+ var tmp;
+ var len = uint8.length;
+ var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+ var parts = [];
+ var maxChunkLength = 16383; // must be multiple of 3
+
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+ parts.push(
+ encodeChunk(
+ uint8,
+ i,
+ i + maxChunkLength > len2 ? len2 : i + maxChunkLength
+ )
+ );
+ }
+
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ if (extraBytes === 1) {
+ tmp = uint8[len - 1];
+ parts.push(lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f] + "==");
+ } else if (extraBytes === 2) {
+ tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+ parts.push(
+ lookup[tmp >> 10] +
+ lookup[(tmp >> 4) & 0x3f] +
+ lookup[(tmp << 2) & 0x3f] +
+ "="
+ );
+ }
+
+ return parts.join("");
+}

js/body.ts

@@ -1,27 +1,17 @@
-import * as streams from "@stardazed/streams";
 import * as formData from "./form_data";
 import * as blob from "./blob";
 import * as encoding from "./text_encoding";
 import * as headers from "./headers";
-
 import * as domTypes from "./dom_types";
 
 const { Headers } = headers;
 
 // only namespace imports work for now, plucking out what we need
-const { ReadableStream } = streams;
 const { FormData } = formData;
 const { TextEncoder, TextDecoder } = encoding;
 const Blob = blob.DenoBlob;
 const DenoBlob = blob.DenoBlob;
 
-type ReadableStreamReader = domTypes.ReadableStreamReader;
-
-interface ReadableStreamController {
- enqueue(chunk: string | ArrayBuffer): void;
- close(): void;
-}
-
 export type BodySource =
  | domTypes.Blob
  | domTypes.BufferSource
@@ -47,8 +37,6 @@ function validateBodyType(owner: Body, bodySource: BodySource): boolean {
  return true;
  } else if (typeof bodySource === "string") {
  return true;
- } else if (bodySource instanceof ReadableStream) {
- return true;
  } else if (bodySource instanceof FormData) {
  return true;
  } else if (!bodySource) {
@@ -59,58 +47,6 @@ function validateBodyType(owner: Body, bodySource: BodySource): boolean {
  );
 }
 
-function concatenate(...arrays: Uint8Array[]): ArrayBuffer {
- let totalLength = 0;
- for (const arr of arrays) {
- totalLength += arr.length;
- }
- const result = new Uint8Array(totalLength);
- let offset = 0;
- for (const arr of arrays) {
- result.set(arr, offset);
- offset += arr.length;
- }
- return result.buffer as ArrayBuffer;
-}
-
-function bufferFromStream(stream: ReadableStreamReader): Promise<ArrayBuffer> {
- return new Promise(
- (resolve, reject): void => {
- const parts: Uint8Array[] = [];
- const encoder = new TextEncoder();
- // recurse
- (function pump(): void {
- stream
- .read()
- .then(
- ({ done, value }): void => {
- if (done) {
- return resolve(concatenate(...parts));
- }
-
- if (typeof value === "string") {
- parts.push(encoder.encode(value));
- } else if (value instanceof ArrayBuffer) {
- parts.push(new Uint8Array(value));
- } else if (!value) {
- // noop for undefined
- } else {
- reject("unhandled type on stream read");
- }
-
- return pump();
- }
- )
- .catch(
- (err): void => {
- reject(err);
- }
- );
- })();
- }
- );
-}
-
 function getHeaderValueParams(value: string): Map<string, string> {
  const params = new Map();
  // Forced to do so for some Map constructor param mismatch
@@ -145,17 +81,8 @@ export class Body implements domTypes.Body {
  if (this._stream) {
  return this._stream;
  }
- if (this._bodySource instanceof ReadableStream) {
- // @ts-ignore
- this._stream = this._bodySource;
- }
  if (typeof this._bodySource === "string") {
- this._stream = new ReadableStream({
- start(controller: ReadableStreamController): void {
- controller.enqueue(this._bodySource);
- controller.close();
- }
- });
+ throw Error("not implemented");
  }
  return this._stream;
  }
@@ -332,9 +259,6 @@ export class Body implements domTypes.Body {
  } else if (typeof this._bodySource === "string") {
  const enc = new TextEncoder();
  return enc.encode(this._bodySource).buffer as ArrayBuffer;
- } else if (this._bodySource instanceof ReadableStream) {
- // @ts-ignore
- return bufferFromStream(this._bodySource.getReader());
  } else if (this._bodySource instanceof FormData) {
  const enc = new TextEncoder();
  return enc.encode(this._bodySource.toString()).buffer as ArrayBuffer;

js/request.ts

@@ -1,13 +1,9 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
 import * as headers from "./headers";
 import * as body from "./body";
-
-import * as streams from "@stardazed/streams";
-
 import * as domTypes from "./dom_types";
 
 const { Headers } = headers;
-const { ReadableStream } = streams;
 
 function byteUpperCase(s: string): string {
  return String(s).replace(/[a-z]/g, function byteUpperCaseReplace(c): string {
@@ -144,11 +140,6 @@ export class Request extends body.Body implements domTypes.Request {
 
  let body2 = this._bodySource;
 
- if (this._bodySource instanceof ReadableStream) {
- const tees = (this._bodySource as domTypes.ReadableStream).tee();
- this._stream = this._bodySource = tees[0];
- body2 = tees[1];
- }
  const cloned = new Request(this.url, {
  body: body2,
  method: this.method,

js/request_test.ts

@@ -1,5 +1,5 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { test, assertEquals, assert } from "./test_util.ts";
+import { test, assertEquals } from "./test_util.ts";
 
 test(function fromInit(): void {
  const req = new Request("https://example.com", {
@@ -15,35 +15,3 @@ test(function fromInit(): void {
  assertEquals(req.url, "https://example.com");
  assertEquals(req.headers.get("test-header"), "value");
 });
-
-test(function fromRequest(): void {
- const r = new Request("https://example.com");
- // @ts-ignore
- r._bodySource = "ahoyhoy";
- r.headers.set("test-header", "value");
-
- const req = new Request(r);
-
- // @ts-ignore
- assertEquals(req._bodySource, r._bodySource);
- assertEquals(req.url, r.url);
- assertEquals(req.headers.get("test-header"), r.headers.get("test-header"));
-});
-
-test(async function cloneRequestBodyStream(): Promise<void> {
- // hack to get a stream
- const stream = new Request("", { body: "a test body" }).body;
- const r1 = new Request("https://example.com", {
- body: stream
- });
-
- const r2 = r1.clone();
-
- const b1 = await r1.text();
- const b2 = await r2.text();
-
- assertEquals(b1, b2);
-
- // @ts-ignore
- assert(r1._bodySource !== r2._bodySource);
-});

js/text_encoding.ts

@@ -23,7 +23,7 @@
 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 
-import * as base64 from "base64-js";
+import * as base64 from "./base64";
 import * as domTypes from "./dom_types";
 import { DenoError, ErrorKind } from "./errors";
 

package.json

@@ -1,12 +1,9 @@
 {
  "name": "deno",
  "devDependencies": {
- "@stardazed/streams": "3.0.0",
- "@types/base64-js": "1.2.5",
  "@types/prettier": "1.16.1",
  "@typescript-eslint/eslint-plugin": "1.6.0",
  "@typescript-eslint/parser": "1.6.0",
- "base64-js": "1.3.0",
  "eslint": "5.15.1",
  "eslint-config-prettier": "4.1.0",
  "magic-string": "0.25.2",