@api-client/core 0.3.0

package/build/src/runtime/http-engine/PayloadSupport.js

@@ -0,0 +1,78 @@
+import formDataConverter from './FormData.js';
+import { PayloadSerializer } from '../../lib/transformers/PayloadSerializer.js';
+/**
+ * A class containing static helper methods to deal with Payload
+ * transformations
+ */
+export class PayloadSupport {
+    /**
+     * NormalizeLineEndingsToCRLF
+     * https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit/Source/
+     * platform/text/LineEnding.cpp&rcl=1458041387&l=101
+     *
+     * @param string A string to be normalized.
+     * @return normalized string
+     */
+    static normalizeString(string) {
+        let result = '';
+        for (let i = 0; i < string.length; i++) {
+            const c = string[i];
+            const p = string[i + 1];
+            if (c === '\r') {
+                // Safe to look ahead because of trailing '\0'.
+                if (p && p !== '\n') {
+                    // Turn CR into CRLF.
+                    result += '\r';
+                    result += '\n';
+                }
+            }
+            else if (c === '\n') {
+                result += '\r';
+                result += '\n';
+            }
+            else {
+                // Leave other characters alone.
+                result += c;
+            }
+        }
+        return result;
+    }
+    /**
+     * Transforms the request payload into a `Buffer`
+     *
+     * @param payload A payload message
+     * @param headers A headers object where to append headers when needed
+     * @returns A promise resolved to a `Buffer`.
+     */
+    static async payloadToBuffer(payload, headers) {
+        if (!payload) {
+            return;
+        }
+        if (typeof payload === 'string') {
+            payload = PayloadSupport.normalizeString(payload);
+            return Buffer.from(payload, 'utf8');
+        }
+        if (payload.type === 'string') {
+            return PayloadSupport.payloadToBuffer(payload.data, headers);
+        }
+        if (['blob', 'file'].includes(payload.type)) {
+            if (!headers.has('content-type') && payload.mime) {
+                headers.set('content-type', payload.mime);
+            }
+            return PayloadSerializer.deserializeBlobBuffer(payload.data);
+        }
+        if (payload.type === 'buffer') {
+            return PayloadSerializer.deserializeBuffer(payload.data);
+        }
+        if (payload.type === 'arraybuffer') {
+            return PayloadSerializer.deserializeArrayBufferBuffer(payload.data);
+        }
+        if (payload.type === 'formdata') {
+            const result = await formDataConverter(payload.data);
+            headers.set('Content-Type', result.type);
+            return result.buffer;
+        }
+        throw new Error('Unsupported payload message');
+    }
+}
+//# sourceMappingURL=PayloadSupport.js.map

package/build/src/runtime/http-engine/PayloadSupport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PayloadSupport.js","sourceRoot":"","sources":["../../../../src/runtime/http-engine/PayloadSupport.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAW,iBAAiB,EAAkB,MAAM,6CAA6C,CAAC;AAEzG;;;GAGG;AACH,MAAM,OAAO,cAAc;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,eAAe,CAAC,MAAc;QACnC,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACtC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACpB,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,KAAK,IAAI,EAAE;gBACd,+CAA+C;gBAC/C,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;oBACnB,qBAAqB;oBACrB,MAAM,IAAI,IAAI,CAAC;oBACf,MAAM,IAAI,IAAI,CAAC;iBAChB;aACF;iBAAM,IAAI,CAAC,KAAK,IAAI,EAAE;gBACrB,MAAM,IAAI,IAAI,CAAC;gBACf,MAAM,IAAI,IAAI,CAAC;aAChB;iBAAM;gBACL,gCAAgC;gBAChC,MAAM,IAAI,CAAC,CAAC;aACb;SACF;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,OAAgB,EAAE,OAAgB;QAC7D,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO;SACR;QACD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;YAC/B,OAAO,GAAG,cAAc,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YAClD,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;SACrC;QAED,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE;YAC7B,OAAO,cAAc,CAAC,eAAe,CAAC,OAAO,CAAC,IAAc,EAAE,OAAO,CAAC,CAAC;SACxE;QAED,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YAC3C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,OAAO,CAAC,IAAI,EAAE;gBAChD,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;aAC3C;YACD,OAAO,iBAAiB,CAAC,qBAAqB,CAAC,OAAO,CAAC,IAAc,CAAC,CAAC;SACxE;QAED,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE;YAC7B,OAAO,iBAAiB,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAgB,CAAC,CAAC;SACtE;QAED,IAAI,OAAO,CAAC,IAAI,KAAK,aAAa,EAAE;YAClC,OAAO,iBAAiB,CAAC,4BAA4B,CAAC,OAAO,CAAC,IAAgB,CAAC,CAAC;SACjF;QAED,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE;YAC/B,MAAM,MAAM,GAAG,MAAM,iBAAiB,CAAC,OAAO,CAAC,IAAwB,CAAC,CAAC;YACzE,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;YACzC,OAAO,MAAM,CAAC,MAAM,CAAC;SACtB;QAED,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;IACjD,CAAC;CACF"}

package/build/src/runtime/http-engine/RequestUtils.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="node" />
+import { Headers } from '../../lib/headers/Headers.js';
+import { ResponseRedirect } from '../../models/ResponseRedirect.js';
+/**
+ * Reads a port number for a connection.
+ *
+ * @param port Existing information about the port.
+ * @param protocol Request protocol. Only used if `port` is not set.
+ * @return A port number. Default to 80.
+ */
+export declare function getPort(port: number | string, protocol?: string): number;
+/**
+ * Creates a value for host header.
+ *
+ * @param value An url to get the information from.
+ * @return Value of the host header
+ */
+export declare function getHostHeader(value: string): string | undefined;
+/**
+ * Adds the `content-length` header to current request headers list if
+ * it's required.
+ * This function will do nothing if the request do not carry a payload or
+ * when the content length header is already set.
+ *
+ * @param method HTTP request method
+ * @param buffer Generated message buffer.
+ * @param headers A headers object where to append headers when needed
+ */
+export declare function addContentLength(method: string, buffer: Buffer, headers: Headers): void;
+export declare interface RedirectOptions {
+    /**
+     * true if redirect is required
+     */
+    redirect?: boolean;
+    /**
+     * If true the redirected request has to be a GET request.
+     */
+    forceGet?: boolean;
+    /**
+     * location of the resource (redirect uri)
+     */
+    location?: string;
+}
+/**
+   * Checks if redirect is required.
+   * @param status Response status code
+   * @param method Request HTTP method
+   * @param location Location header value, if any
+   * @returns The redirect options
+   */
+export declare function redirectOptions(status: number, method: string, location?: string): RedirectOptions;
+/**
+ * Checks if request is an infinite loop.
+ * @param location Redirect location
+ * @param redirects List of response objects
+ * @return True if redirect is into the same place as already visited.
+ */
+export declare function isRedirectLoop(location: string, redirects: ResponseRedirect[]): boolean;
+/**
+ * Processes redirection location
+ *
+ * @param location Redirect location
+ * @param requestUrl Request url
+ * @return Redirect location
+ */
+export declare function getRedirectLocation(location: string, requestUrl: string): string | undefined;

package/build/src/runtime/http-engine/RequestUtils.js

@@ -0,0 +1,144 @@
+/**
+ * Reads a port number for a connection.
+ *
+ * @param port Existing information about the port.
+ * @param protocol Request protocol. Only used if `port` is not set.
+ * @return A port number. Default to 80.
+ */
+export function getPort(port, protocol) {
+    if (port) {
+        const typedPort = Number(port);
+        if (!Number.isNaN(typedPort)) {
+            return typedPort;
+        }
+    }
+    if (protocol === 'https:') {
+        return 443;
+    }
+    return 80;
+}
+/**
+ * Creates a value for host header.
+ *
+ * @param value An url to get the information from.
+ * @return Value of the host header
+ */
+export function getHostHeader(value) {
+    let uri;
+    try {
+        uri = new URL(value);
+    }
+    catch (e) {
+        return;
+    }
+    let hostValue = uri.hostname;
+    const defaultPorts = [80, 443];
+    const port = getPort(uri.port, uri.protocol);
+    if (!defaultPorts.includes(port)) {
+        hostValue += `:${port}`;
+    }
+    return hostValue;
+}
+/**
+ * Adds the `content-length` header to current request headers list if
+ * it's required.
+ * This function will do nothing if the request do not carry a payload or
+ * when the content length header is already set.
+ *
+ * @param method HTTP request method
+ * @param buffer Generated message buffer.
+ * @param headers A headers object where to append headers when needed
+ */
+export function addContentLength(method, buffer, headers) {
+    if (method.toLowerCase() === 'get') {
+        return;
+    }
+    const size = buffer ? buffer.length : 0;
+    headers.set('content-length', String(size));
+}
+/**
+   * Checks if redirect is required.
+   * @param status Response status code
+   * @param method Request HTTP method
+   * @param location Location header value, if any
+   * @returns The redirect options
+   */
+export function redirectOptions(status, method, location) {
+    const result = {
+        redirect: false,
+        forceGet: false,
+    };
+    switch (status) {
+        case 300:
+        case 304:
+        case 305:
+            // do nothing;
+            break;
+        case 301:
+        case 302:
+        case 307:
+            if (['GET', 'HEAD'].indexOf(method) !== -1) {
+                result.redirect = true;
+            }
+            break;
+        case 303:
+            result.redirect = true;
+            result.forceGet = true;
+            break;
+        default:
+    }
+    if (!result.redirect) {
+        return result;
+    }
+    if (location) {
+        result.location = location;
+    }
+    return result;
+}
+/**
+ * Checks if request is an infinite loop.
+ * @param location Redirect location
+ * @param redirects List of response objects
+ * @return True if redirect is into the same place as already visited.
+ */
+export function isRedirectLoop(location, redirects) {
+    if (redirects) {
+        let index = -1;
+        let i = 0;
+        for (const item of redirects) {
+            if (item.url === location) {
+                index = i;
+                break;
+            }
+            i++;
+        }
+        if (index !== -1) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Processes redirection location
+ *
+ * @param location Redirect location
+ * @param requestUrl Request url
+ * @return Redirect location
+ */
+export function getRedirectLocation(location, requestUrl) {
+    // https://github.com/jarrodek/socket-fetch/issues/5
+    try {
+        // eslint-disable-next-line no-new
+        new URL(location);
+    }
+    catch (e) {
+        try {
+            location = new URL(location, requestUrl).toString();
+        }
+        catch (_) {
+            return;
+        }
+    }
+    return location;
+}
+//# sourceMappingURL=RequestUtils.js.map

package/build/src/runtime/http-engine/RequestUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestUtils.js","sourceRoot":"","sources":["../../../../src/runtime/http-engine/RequestUtils.ts"],"names":[],"mappings":"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"}

package/build/src/runtime/http-engine/ntlm/Des.d.ts

@@ -0,0 +1,4 @@
+export declare class Des {
+    static des(key: string, message: string, encrypt: number, mode: number, iv?: string, padding?: number): string;
+    static createKeys(key: string): number[];
+}

package/build/src/runtime/http-engine/ntlm/Des.js

@@ -0,0 +1,343 @@
+// Paul Tero, July 2001
+// http://www.tero.co.uk/des/
+//
+// Optimised for performance with large blocks by Michael Hayworth, November 2001
+// http://www.netdealing.com
+//
+// THIS SOFTWARE IS PROVIDED "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+// SUCH DAMAGE.
+export class Des {
+    static des(key, message, encrypt, mode, iv, padding) {
+        const spfunction1 = [0x1010400, 0, 0x10000, 0x1010404, 0x1010004, 0x10404,
+            0x4, 0x10000, 0x400, 0x1010400, 0x1010404, 0x400, 0x1000404, 0x1010004,
+            0x1000000, 0x4, 0x404, 0x1000400, 0x1000400, 0x10400, 0x10400, 0x1010000,
+            0x1010000, 0x1000404, 0x10004, 0x1000004, 0x1000004, 0x10004, 0, 0x404,
+            0x10404, 0x1000000, 0x10000, 0x1010404, 0x4, 0x1010000, 0x1010400, 0x1000000,
+            0x1000000, 0x400, 0x1010004, 0x10000, 0x10400, 0x1000004, 0x400, 0x4, 0x1000404,
+            0x10404, 0x1010404, 0x10004, 0x1010000, 0x1000404, 0x1000004, 0x404, 0x10404,
+            0x1010400, 0x404, 0x1000400, 0x1000400, 0, 0x10004, 0x10400, 0, 0x1010004,
+        ];
+        const spfunction2 = [-0x7fef7fe0, -0x7fff8000, 0x8000, 0x108020, 0x100000, 0x20,
+            -0x7fefffe0, -0x7fff7fe0, -0x7fffffe0, -0x7fef7fe0, -0x7fef8000, -0x80000000,
+            -0x7fff8000, 0x100000, 0x20, -0x7fefffe0, 0x108000, 0x100020, -0x7fff7fe0, 0,
+            -0x80000000, 0x8000, 0x108020, -0x7ff00000, 0x100020, -0x7fffffe0, 0, 0x108000,
+            0x8020, -0x7fef8000, -0x7ff00000, 0x8020, 0, 0x108020, -0x7fefffe0, 0x100000,
+            -0x7fff7fe0, -0x7ff00000, -0x7fef8000, 0x8000, -0x7ff00000, -0x7fff8000, 0x20,
+            -0x7fef7fe0, 0x108020, 0x20, 0x8000, -0x80000000, 0x8020, -0x7fef8000, 0x100000,
+            -0x7fffffe0, 0x100020, -0x7fff7fe0, -0x7fffffe0, 0x100020, 0x108000, 0, -0x7fff8000,
+            0x8020, -0x80000000, -0x7fefffe0, -0x7fef7fe0, 0x108000,
+        ];
+        const spfunction3 = [0x208, 0x8020200, 0, 0x8020008, 0x8000200, 0, 0x20208, 0x8000200,
+            0x20008, 0x8000008, 0x8000008, 0x20000, 0x8020208, 0x20008, 0x8020000, 0x208,
+            0x8000000, 0x8, 0x8020200, 0x200, 0x20200, 0x8020000, 0x8020008, 0x20208,
+            0x8000208, 0x20200, 0x20000, 0x8000208, 0x8, 0x8020208, 0x200, 0x8000000,
+            0x8020200, 0x8000000, 0x20008, 0x208, 0x20000, 0x8020200, 0x8000200, 0, 0x200,
+            0x20008, 0x8020208, 0x8000200, 0x8000008, 0x200, 0, 0x8020008, 0x8000208, 0x20000,
+            0x8000000, 0x8020208, 0x8, 0x20208, 0x20200, 0x8000008, 0x8020000, 0x8000208,
+            0x208, 0x8020000, 0x20208, 0x8, 0x8020008, 0x20200,
+        ];
+        const spfunction4 = [0x802001, 0x2081, 0x2081, 0x80, 0x802080, 0x800081, 0x800001,
+            0x2001, 0, 0x802000, 0x802000, 0x802081, 0x81, 0, 0x800080, 0x800001, 0x1,
+            0x2000, 0x800000, 0x802001, 0x80, 0x800000, 0x2001, 0x2080, 0x800081, 0x1, 0x2080,
+            0x800080, 0x2000, 0x802080, 0x802081, 0x81, 0x800080, 0x800001, 0x802000, 0x802081,
+            0x81, 0, 0, 0x802000, 0x2080, 0x800080, 0x800081, 0x1, 0x802001, 0x2081, 0x2081,
+            0x80, 0x802081, 0x81, 0x1, 0x2000, 0x800001, 0x2001, 0x802080, 0x800081, 0x2001,
+            0x2080, 0x800000, 0x802001, 0x80, 0x800000, 0x2000, 0x802080,
+        ];
+        const spfunction5 = [0x100, 0x2080100, 0x2080000, 0x42000100, 0x80000, 0x100, 0x40000000,
+            0x2080000, 0x40080100, 0x80000, 0x2000100, 0x40080100, 0x42000100, 0x42080000, 0x80100,
+            0x40000000, 0x2000000, 0x40080000, 0x40080000, 0, 0x40000100, 0x42080100, 0x42080100,
+            0x2000100, 0x42080000, 0x40000100, 0, 0x42000000, 0x2080100, 0x2000000, 0x42000000,
+            0x80100, 0x80000, 0x42000100, 0x100, 0x2000000, 0x40000000, 0x2080000, 0x42000100,
+            0x40080100, 0x2000100, 0x40000000, 0x42080000, 0x2080100, 0x40080100, 0x100, 0x2000000,
+            0x42080000, 0x42080100, 0x80100, 0x42000000, 0x42080100, 0x2080000, 0, 0x40080000,
+            0x42000000, 0x80100, 0x2000100, 0x40000100, 0x80000, 0, 0x40080000, 0x2080100,
+            0x40000100,
+        ];
+        const spfunction6 = [0x20000010, 0x20400000, 0x4000, 0x20404010, 0x20400000, 0x10,
+            0x20404010, 0x400000, 0x20004000, 0x404010, 0x400000, 0x20000010, 0x400010, 0x20004000,
+            0x20000000, 0x4010, 0, 0x400010, 0x20004010, 0x4000, 0x404000, 0x20004010, 0x10,
+            0x20400010, 0x20400010, 0, 0x404010, 0x20404000, 0x4010, 0x404000, 0x20404000,
+            0x20000000, 0x20004000, 0x10, 0x20400010, 0x404000, 0x20404010, 0x400000, 0x4010,
+            0x20000010, 0x400000, 0x20004000, 0x20000000, 0x4010, 0x20000010, 0x20404010, 0x404000,
+            0x20400000, 0x404010, 0x20404000, 0, 0x20400010, 0x10, 0x4000, 0x20400000, 0x404010,
+            0x4000, 0x400010, 0x20004010, 0, 0x20404000, 0x20000000, 0x400010, 0x20004010,
+        ];
+        const spfunction7 = [0x200000, 0x4200002, 0x4000802, 0, 0x800, 0x4000802, 0x200802,
+            0x4200800, 0x4200802, 0x200000, 0, 0x4000002, 0x2, 0x4000000, 0x4200002, 0x802,
+            0x4000800, 0x200802, 0x200002, 0x4000800, 0x4000002, 0x4200000, 0x4200800, 0x200002,
+            0x4200000, 0x800, 0x802, 0x4200802, 0x200800, 0x2, 0x4000000, 0x200800, 0x4000000,
+            0x200800, 0x200000, 0x4000802, 0x4000802, 0x4200002, 0x4200002, 0x2, 0x200002,
+            0x4000000, 0x4000800, 0x200000, 0x4200800, 0x802, 0x200802, 0x4200800, 0x802,
+            0x4000002, 0x4200802, 0x4200000, 0x200800, 0, 0x2, 0x4200802, 0, 0x200802, 0x4200000,
+            0x800, 0x4000002, 0x4000800, 0x800, 0x200002,
+        ];
+        const spfunction8 = [0x10001040, 0x1000, 0x40000, 0x10041040, 0x10000000, 0x10001040,
+            0x40, 0x10000000, 0x40040, 0x10040000, 0x10041040, 0x41000, 0x10041000, 0x41040,
+            0x1000, 0x40, 0x10040000, 0x10000040, 0x10001000, 0x1040, 0x41000, 0x40040, 0x10040040,
+            0x10041000, 0x1040, 0, 0, 0x10040040, 0x10000040, 0x10001000, 0x41040, 0x40000, 0x41040,
+            0x40000, 0x10041000, 0x1000, 0x40, 0x10040040, 0x1000, 0x41040, 0x10001000, 0x40,
+            0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x40000, 0x10001040, 0, 0x10041040,
+            0x40040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0, 0x10041040, 0x41000,
+            0x41000, 0x1040, 0x1040, 0x40040, 0x10000000, 0x10041000,
+        ];
+        // create the 16 or 48 subkeys we will need
+        const keys = Des.createKeys(key);
+        let m = 0;
+        let i;
+        let j;
+        let temp;
+        let right1;
+        let right2;
+        let left;
+        let right;
+        let looping;
+        let cbcleft;
+        let cbcleft2;
+        let cbcright;
+        let cbcright2;
+        let endloop;
+        let loopinc;
+        let len = message.length;
+        let chunk = 0;
+        const iterations = keys.length === 32 ? 3 : 9;
+        if (iterations === 3) {
+            looping = encrypt ? [0, 32, 2] : [30, -2, -2];
+        }
+        else {
+            looping = encrypt ? [0, 32, 2, 62, 30, -2, 64, 96, 2] : [94, 62, -2, 32, 64, 2, 30, -2, -2];
+        }
+        if (padding === 2) {
+            message += '        ';
+        }
+        else if (padding === 1) {
+            temp = 8 - (len % 8);
+            message += String.fromCharCode(temp, temp, temp, temp, temp, temp, temp, temp);
+            if (temp === 8) {
+                len += 8;
+            }
+        }
+        else if (!padding) {
+            message += '\0\0\0\0\0\0\0\0';
+        }
+        let result = '';
+        let tempresult = '';
+        if (mode === 1) {
+            cbcleft = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) |
+                (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
+            cbcright = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) |
+                (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
+            m = 0;
+        }
+        while (m < len) {
+            left = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) |
+                (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
+            right = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) |
+                (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
+            if (mode === 1) {
+                if (encrypt) {
+                    left ^= cbcleft;
+                    right ^= cbcright;
+                }
+                else {
+                    cbcleft2 = cbcleft;
+                    cbcright2 = cbcright;
+                    cbcleft = left;
+                    cbcright = right;
+                }
+            }
+            temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+            right ^= temp;
+            left ^= (temp << 4);
+            temp = ((left >>> 16) ^ right) & 0x0000ffff;
+            right ^= temp;
+            left ^= (temp << 16);
+            temp = ((right >>> 2) ^ left) & 0x33333333;
+            left ^= temp;
+            right ^= (temp << 2);
+            temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+            left ^= temp;
+            right ^= (temp << 8);
+            temp = ((left >>> 1) ^ right) & 0x55555555;
+            right ^= temp;
+            left ^= (temp << 1);
+            left = ((left << 1) | (left >>> 31));
+            right = ((right << 1) | (right >>> 31));
+            for (j = 0; j < iterations; j += 3) {
+                endloop = looping[j + 1];
+                loopinc = looping[j + 2];
+                for (i = looping[j]; i !== endloop; i += loopinc) {
+                    right1 = right ^ keys[i];
+                    right2 = ((right >>> 4) | (right << 28)) ^ keys[i + 1];
+                    temp = left;
+                    left = right;
+                    right = temp ^ (spfunction2[(right1 >>> 24) & 0x3f] |
+                        spfunction4[(right1 >>> 16) & 0x3f] | spfunction6[(right1 >>> 8) & 0x3f] |
+                        spfunction8[right1 & 0x3f] | spfunction1[(right2 >>> 24) & 0x3f] |
+                        spfunction3[(right2 >>> 16) & 0x3f] | spfunction5[(right2 >>> 8) & 0x3f] |
+                        spfunction7[right2 & 0x3f]);
+                }
+                temp = left;
+                left = right;
+                right = temp;
+            }
+            left = ((left >>> 1) | (left << 31));
+            right = ((right >>> 1) | (right << 31));
+            temp = ((left >>> 1) ^ right) & 0x55555555;
+            right ^= temp;
+            left ^= (temp << 1);
+            temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+            left ^= temp;
+            right ^= (temp << 8);
+            temp = ((right >>> 2) ^ left) & 0x33333333;
+            left ^= temp;
+            right ^= (temp << 2);
+            temp = ((left >>> 16) ^ right) & 0x0000ffff;
+            right ^= temp;
+            left ^= (temp << 16);
+            temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+            right ^= temp;
+            left ^= (temp << 4);
+            if (mode === 1) {
+                if (encrypt) {
+                    cbcleft = left;
+                    cbcright = right;
+                }
+                else {
+                    left ^= cbcleft2;
+                    right ^= cbcright2;
+                }
+            }
+            tempresult += String.fromCharCode((left >>> 24), ((left >>> 16) & 0xff), ((left >>> 8) & 0xff), (left & 0xff), (right >>> 24), ((right >>> 16) & 0xff), ((right >>> 8) & 0xff), (right & 0xff));
+            chunk += 8;
+            if (chunk === 512) {
+                result += tempresult;
+                tempresult = '';
+                chunk = 0;
+            }
+        }
+        return result + tempresult;
+    }
+    static createKeys(key) {
+        const pc2bytes0 = [0, 0x4, 0x20000000, 0x20000004, 0x10000, 0x10004, 0x20010000,
+            0x20010004, 0x200, 0x204, 0x20000200, 0x20000204, 0x10200, 0x10204, 0x20010200,
+            0x20010204,
+        ];
+        const pc2bytes1 = [0, 0x1, 0x100000, 0x100001, 0x4000000, 0x4000001, 0x4100000,
+            0x4100001, 0x100, 0x101, 0x100100, 0x100101, 0x4000100, 0x4000101, 0x4100100,
+            0x4100101,
+        ];
+        const pc2bytes2 = [0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808,
+            0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808,
+        ];
+        const pc2bytes3 = [0, 0x200000, 0x8000000, 0x8200000, 0x2000, 0x202000, 0x8002000,
+            0x8202000, 0x20000, 0x220000, 0x8020000, 0x8220000, 0x22000, 0x222000, 0x8022000,
+            0x8222000,
+        ];
+        const pc2bytes4 = [0, 0x40000, 0x10, 0x40010, 0, 0x40000, 0x10, 0x40010, 0x1000,
+            0x41000, 0x1010, 0x41010, 0x1000, 0x41000, 0x1010, 0x41010,
+        ];
+        const pc2bytes5 = [0, 0x400, 0x20, 0x420, 0, 0x400, 0x20, 0x420, 0x2000000, 0x2000400,
+            0x2000020, 0x2000420, 0x2000000, 0x2000400, 0x2000020, 0x2000420,
+        ];
+        const pc2bytes6 = [0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002,
+            0x10080002, 0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002,
+        ];
+        const pc2bytes7 = [0, 0x10000, 0x800, 0x10800, 0x20000000, 0x20010000, 0x20000800,
+            0x20010800, 0x20000, 0x30000, 0x20800, 0x30800, 0x20020000, 0x20030000, 0x20020800,
+            0x20030800,
+        ];
+        const pc2bytes8 = [0, 0x40000, 0, 0x40000, 0x2, 0x40002, 0x2, 0x40002, 0x2000000,
+            0x2040000, 0x2000000, 0x2040000, 0x2000002, 0x2040002, 0x2000002, 0x2040002,
+        ];
+        const pc2bytes9 = [0, 0x10000000, 0x8, 0x10000008, 0, 0x10000000, 0x8, 0x10000008,
+            0x400, 0x10000400, 0x408, 0x10000408, 0x400, 0x10000400, 0x408, 0x10000408,
+        ];
+        const pc2bytes10 = [0, 0x20, 0, 0x20, 0x100000, 0x100020, 0x100000, 0x100020, 0x2000,
+            0x2020, 0x2000, 0x2020, 0x102000, 0x102020, 0x102000, 0x102020,
+        ];
+        const pc2bytes11 = [0, 0x1000000, 0x200, 0x1000200, 0x200000, 0x1200000, 0x200200,
+            0x1200200, 0x4000000, 0x5000000, 0x4000200, 0x5000200, 0x4200000, 0x5200000,
+            0x4200200, 0x5200200,
+        ];
+        const pc2bytes12 = [0, 0x1000, 0x8000000, 0x8001000, 0x80000, 0x81000, 0x8080000,
+            0x8081000, 0x10, 0x1010, 0x8000010, 0x8001010, 0x80010, 0x81010, 0x8080010, 0x8081010,
+        ];
+        const pc2bytes13 = [0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101,
+            0x105, 0x1, 0x5, 0x101, 0x105,
+        ];
+        const iterations = key.length > 8 ? 3 : 1;
+        const keys = new Array(32 * iterations);
+        const shifts = [0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0];
+        let lefttemp;
+        let righttemp;
+        let m = 0;
+        let n = 0;
+        let temp;
+        for (let j = 0; j < iterations; j++) {
+            let left = (key.charCodeAt(m++) << 24) |
+                (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
+            let right = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) |
+                (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
+            temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
+            right ^= temp;
+            left ^= (temp << 4);
+            temp = ((right >>> -16) ^ left) & 0x0000ffff;
+            left ^= temp;
+            right ^= (temp << -16);
+            temp = ((left >>> 2) ^ right) & 0x33333333;
+            right ^= temp;
+            left ^= (temp << 2);
+            temp = ((right >>> -16) ^ left) & 0x0000ffff;
+            left ^= temp;
+            right ^= (temp << -16);
+            temp = ((left >>> 1) ^ right) & 0x55555555;
+            right ^= temp;
+            left ^= (temp << 1);
+            temp = ((right >>> 8) ^ left) & 0x00ff00ff;
+            left ^= temp;
+            right ^= (temp << 8);
+            temp = ((left >>> 1) ^ right) & 0x55555555;
+            right ^= temp;
+            left ^= (temp << 1);
+            temp = (left << 8) | ((right >>> 20) & 0x000000f0);
+            left = (right << 24) | ((right << 8) & 0xff0000) |
+                ((right >>> 8) & 0xff00) | ((right >>> 24) & 0xf0);
+            right = temp;
+            for (let i = 0; i < shifts.length; i++) {
+                if (shifts[i]) {
+                    left = (left << 2) | (left >>> 26);
+                    right = (right << 2) | (right >>> 26);
+                }
+                else {
+                    left = (left << 1) | (left >>> 27);
+                    right = (right << 1) | (right >>> 27);
+                }
+                left &= -0xf;
+                right &= -0xf;
+                lefttemp = pc2bytes0[left >>> 28] | pc2bytes1[(left >>> 24) & 0xf] |
+                    pc2bytes2[(left >>> 20) & 0xf] | pc2bytes3[(left >>> 16) & 0xf] |
+                    pc2bytes4[(left >>> 12) & 0xf] | pc2bytes5[(left >>> 8) & 0xf] |
+                    pc2bytes6[(left >>> 4) & 0xf];
+                righttemp = pc2bytes7[right >>> 28] | pc2bytes8[(right >>> 24) & 0xf] |
+                    pc2bytes9[(right >>> 20) & 0xf] | pc2bytes10[(right >>> 16) & 0xf] |
+                    pc2bytes11[(right >>> 12) & 0xf] | pc2bytes12[(right >>> 8) & 0xf] |
+                    pc2bytes13[(right >>> 4) & 0xf];
+                temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff;
+                keys[n++] = lefttemp ^ temp;
+                keys[n++] = righttemp ^ (temp << 16);
+            }
+        }
+        return keys;
+    }
+}
+//# sourceMappingURL=Des.js.map