groove-dev 0.26.14 → 0.26.16

package/pitch-deck-groove/node_modules/image-size/dist/types/svg.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SVG = void 0;
+const utils_1 = require("./utils");
+const svgReg = /<svg\s([^>"']|"[^"]*"|'[^']*')*>/;
+const extractorRegExps = {
+    height: /\sheight=(['"])([^%]+?)\1/,
+    root: svgReg,
+    viewbox: /\sviewBox=(['"])(.+?)\1/i,
+    width: /\swidth=(['"])([^%]+?)\1/,
+};
+const INCH_CM = 2.54;
+const units = {
+    in: 96,
+    cm: 96 / INCH_CM,
+    em: 16,
+    ex: 8,
+    m: (96 / INCH_CM) * 100,
+    mm: 96 / INCH_CM / 10,
+    pc: 96 / 72 / 12,
+    pt: 96 / 72,
+    px: 1,
+};
+const unitsReg = new RegExp(`^([0-9.]+(?:e\\d+)?)(${Object.keys(units).join('|')})?$`);
+function parseLength(len) {
+    const m = unitsReg.exec(len);
+    if (!m) {
+        return undefined;
+    }
+    return Math.round(Number(m[1]) * (units[m[2]] || 1));
+}
+function parseViewbox(viewbox) {
+    const bounds = viewbox.split(' ');
+    return {
+        height: parseLength(bounds[3]),
+        width: parseLength(bounds[2]),
+    };
+}
+function parseAttributes(root) {
+    const width = root.match(extractorRegExps.width);
+    const height = root.match(extractorRegExps.height);
+    const viewbox = root.match(extractorRegExps.viewbox);
+    return {
+        height: height && parseLength(height[2]),
+        viewbox: viewbox && parseViewbox(viewbox[2]),
+        width: width && parseLength(width[2]),
+    };
+}
+function calculateByDimensions(attrs) {
+    return {
+        height: attrs.height,
+        width: attrs.width,
+    };
+}
+function calculateByViewbox(attrs, viewbox) {
+    const ratio = viewbox.width / viewbox.height;
+    if (attrs.width) {
+        return {
+            height: Math.floor(attrs.width / ratio),
+            width: attrs.width,
+        };
+    }
+    if (attrs.height) {
+        return {
+            height: attrs.height,
+            width: Math.floor(attrs.height * ratio),
+        };
+    }
+    return {
+        height: viewbox.height,
+        width: viewbox.width,
+    };
+}
+exports.SVG = {
+    // Scan only the first kilo-byte to speed up the check on larger files
+    validate: (input) => svgReg.test((0, utils_1.toUTF8String)(input, 0, 1000)),
+    calculate(input) {
+        const root = (0, utils_1.toUTF8String)(input).match(extractorRegExps.root);
+        if (root) {
+            const attrs = parseAttributes(root[0]);
+            if (attrs.width && attrs.height) {
+                return calculateByDimensions(attrs);
+            }
+            if (attrs.viewbox) {
+                return calculateByViewbox(attrs, attrs.viewbox);
+            }
+        }
+        throw new TypeError('Invalid SVG');
+    },
+};

package/pitch-deck-groove/node_modules/image-size/dist/types/tga.d.ts

@@ -0,0 +1,2 @@
+import type { IImage } from './interface';
+export declare const TGA: IImage;

package/pitch-deck-groove/node_modules/image-size/dist/types/tga.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TGA = void 0;
+const utils_1 = require("./utils");
+exports.TGA = {
+    validate(input) {
+        return (0, utils_1.readUInt16LE)(input, 0) === 0 && (0, utils_1.readUInt16LE)(input, 4) === 0;
+    },
+    calculate(input) {
+        return {
+            height: (0, utils_1.readUInt16LE)(input, 14),
+            width: (0, utils_1.readUInt16LE)(input, 12),
+        };
+    },
+};

package/pitch-deck-groove/node_modules/image-size/dist/types/tiff.d.ts

@@ -0,0 +1,2 @@
+import type { IImage } from './interface';
+export declare const TIFF: IImage;

package/pitch-deck-groove/node_modules/image-size/dist/types/tiff.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIFF = void 0;
+// based on http://www.compix.com/fileformattif.htm
+// TO-DO: support big-endian as well
+const fs = require("fs");
+const utils_1 = require("./utils");
+// Read IFD (image-file-directory) into a buffer
+function readIFD(input, filepath, isBigEndian) {
+    const ifdOffset = (0, utils_1.readUInt)(input, 32, 4, isBigEndian);
+    // read only till the end of the file
+    let bufferSize = 1024;
+    const fileSize = fs.statSync(filepath).size;
+    if (ifdOffset + bufferSize > fileSize) {
+        bufferSize = fileSize - ifdOffset - 10;
+    }
+    // populate the buffer
+    const endBuffer = new Uint8Array(bufferSize);
+    const descriptor = fs.openSync(filepath, 'r');
+    fs.readSync(descriptor, endBuffer, 0, bufferSize, ifdOffset);
+    fs.closeSync(descriptor);
+    return endBuffer.slice(2);
+}
+// TIFF values seem to be messed up on Big-Endian, this helps
+function readValue(input, isBigEndian) {
+    const low = (0, utils_1.readUInt)(input, 16, 8, isBigEndian);
+    const high = (0, utils_1.readUInt)(input, 16, 10, isBigEndian);
+    return (high << 16) + low;
+}
+// move to the next tag
+function nextTag(input) {
+    if (input.length > 24) {
+        return input.slice(12);
+    }
+}
+// Extract IFD tags from TIFF metadata
+function extractTags(input, isBigEndian) {
+    const tags = {};
+    let temp = input;
+    while (temp && temp.length) {
+        const code = (0, utils_1.readUInt)(temp, 16, 0, isBigEndian);
+        const type = (0, utils_1.readUInt)(temp, 16, 2, isBigEndian);
+        const length = (0, utils_1.readUInt)(temp, 32, 4, isBigEndian);
+        // 0 means end of IFD
+        if (code === 0) {
+            break;
+        }
+        else {
+            // 256 is width, 257 is height
+            // if (code === 256 || code === 257) {
+            if (length === 1 && (type === 3 || type === 4)) {
+                tags[code] = readValue(temp, isBigEndian);
+            }
+            // move to the next tag
+            temp = nextTag(temp);
+        }
+    }
+    return tags;
+}
+// Test if the TIFF is Big Endian or Little Endian
+function determineEndianness(input) {
+    const signature = (0, utils_1.toUTF8String)(input, 0, 2);
+    if ('II' === signature) {
+        return 'LE';
+    }
+    else if ('MM' === signature) {
+        return 'BE';
+    }
+}
+const signatures = [
+    // '492049', // currently not supported
+    '49492a00', // Little endian
+    '4d4d002a', // Big Endian
+    // '4d4d002a', // BigTIFF > 4GB. currently not supported
+];
+exports.TIFF = {
+    validate: (input) => signatures.includes((0, utils_1.toHexString)(input, 0, 4)),
+    calculate(input, filepath) {
+        if (!filepath) {
+            throw new TypeError("Tiff doesn't support buffer");
+        }
+        // Determine BE/LE
+        const isBigEndian = determineEndianness(input) === 'BE';
+        // read the IFD
+        const ifdBuffer = readIFD(input, filepath, isBigEndian);
+        // extract the tags from the IFD
+        const tags = extractTags(ifdBuffer, isBigEndian);
+        const width = tags[256];
+        const height = tags[257];
+        if (!width || !height) {
+            throw new TypeError('Invalid Tiff. Missing tags');
+        }
+        return { height, width };
+    },
+};

package/pitch-deck-groove/node_modules/image-size/dist/types/utils.d.ts

@@ -0,0 +1,15 @@
+export declare const toUTF8String: (input: Uint8Array, start?: number, end?: number) => string;
+export declare const toHexString: (input: Uint8Array, start?: number, end?: number) => string;
+export declare const readInt16LE: (input: Uint8Array, offset?: number) => number;
+export declare const readUInt16BE: (input: Uint8Array, offset?: number) => number;
+export declare const readUInt16LE: (input: Uint8Array, offset?: number) => number;
+export declare const readUInt24LE: (input: Uint8Array, offset?: number) => number;
+export declare const readInt32LE: (input: Uint8Array, offset?: number) => number;
+export declare const readUInt32BE: (input: Uint8Array, offset?: number) => number;
+export declare const readUInt32LE: (input: Uint8Array, offset?: number) => number;
+export declare function readUInt(input: Uint8Array, bits: 16 | 32, offset: number, isBigEndian: boolean): number;
+export declare function findBox(input: Uint8Array, boxName: string, offset: number): {
+    name: string;
+    offset: number;
+    size: number;
+} | undefined;

package/pitch-deck-groove/node_modules/image-size/dist/types/utils.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findBox = exports.readUInt = exports.readUInt32LE = exports.readUInt32BE = exports.readInt32LE = exports.readUInt24LE = exports.readUInt16LE = exports.readUInt16BE = exports.readInt16LE = exports.toHexString = exports.toUTF8String = void 0;
+const decoder = new TextDecoder();
+const toUTF8String = (input, start = 0, end = input.length) => decoder.decode(input.slice(start, end));
+exports.toUTF8String = toUTF8String;
+const toHexString = (input, start = 0, end = input.length) => input
+    .slice(start, end)
+    .reduce((memo, i) => memo + ('0' + i.toString(16)).slice(-2), '');
+exports.toHexString = toHexString;
+const readInt16LE = (input, offset = 0) => {
+    const val = input[offset] + input[offset + 1] * 2 ** 8;
+    return val | ((val & (2 ** 15)) * 0x1fffe);
+};
+exports.readInt16LE = readInt16LE;
+const readUInt16BE = (input, offset = 0) => input[offset] * 2 ** 8 + input[offset + 1];
+exports.readUInt16BE = readUInt16BE;
+const readUInt16LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8;
+exports.readUInt16LE = readUInt16LE;
+const readUInt24LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8 + input[offset + 2] * 2 ** 16;
+exports.readUInt24LE = readUInt24LE;
+const readInt32LE = (input, offset = 0) => input[offset] +
+    input[offset + 1] * 2 ** 8 +
+    input[offset + 2] * 2 ** 16 +
+    (input[offset + 3] << 24);
+exports.readInt32LE = readInt32LE;
+const readUInt32BE = (input, offset = 0) => input[offset] * 2 ** 24 +
+    input[offset + 1] * 2 ** 16 +
+    input[offset + 2] * 2 ** 8 +
+    input[offset + 3];
+exports.readUInt32BE = readUInt32BE;
+const readUInt32LE = (input, offset = 0) => input[offset] +
+    input[offset + 1] * 2 ** 8 +
+    input[offset + 2] * 2 ** 16 +
+    input[offset + 3] * 2 ** 24;
+exports.readUInt32LE = readUInt32LE;
+// Abstract reading multi-byte unsigned integers
+const methods = {
+    readUInt16BE: exports.readUInt16BE,
+    readUInt16LE: exports.readUInt16LE,
+    readUInt32BE: exports.readUInt32BE,
+    readUInt32LE: exports.readUInt32LE,
+};
+function readUInt(input, bits, offset, isBigEndian) {
+    offset = offset || 0;
+    const endian = isBigEndian ? 'BE' : 'LE';
+    const methodName = ('readUInt' + bits + endian);
+    return methods[methodName](input, offset);
+}
+exports.readUInt = readUInt;
+function readBox(input, offset) {
+    if (input.length - offset < 4)
+        return;
+    const boxSize = (0, exports.readUInt32BE)(input, offset);
+    if (input.length - offset < boxSize)
+        return;
+    return {
+        name: (0, exports.toUTF8String)(input, 4 + offset, 8 + offset),
+        offset,
+        size: boxSize,
+    };
+}
+function findBox(input, boxName, offset) {
+    while (offset < input.length) {
+        const box = readBox(input, offset);
+        if (!box)
+            break;
+        if (box.name === boxName)
+            return box;
+        // Fix the infinite loop by ensuring offset always increases
+        // If box.size is 0, advance by at least 8 bytes (the size of the box header)
+        offset += box.size > 0 ? box.size : 8;
+    }
+}
+exports.findBox = findBox;

package/pitch-deck-groove/node_modules/image-size/dist/types/webp.d.ts

@@ -0,0 +1,2 @@
+import type { IImage } from './interface';
+export declare const WEBP: IImage;

package/pitch-deck-groove/node_modules/image-size/dist/types/webp.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBP = void 0;
+const utils_1 = require("./utils");
+function calculateExtended(input) {
+    return {
+        height: 1 + (0, utils_1.readUInt24LE)(input, 7),
+        width: 1 + (0, utils_1.readUInt24LE)(input, 4),
+    };
+}
+function calculateLossless(input) {
+    return {
+        height: 1 +
+            (((input[4] & 0xf) << 10) | (input[3] << 2) | ((input[2] & 0xc0) >> 6)),
+        width: 1 + (((input[2] & 0x3f) << 8) | input[1]),
+    };
+}
+function calculateLossy(input) {
+    // `& 0x3fff` returns the last 14 bits
+    // TO-DO: include webp scaling in the calculations
+    return {
+        height: (0, utils_1.readInt16LE)(input, 8) & 0x3fff,
+        width: (0, utils_1.readInt16LE)(input, 6) & 0x3fff,
+    };
+}
+exports.WEBP = {
+    validate(input) {
+        const riffHeader = 'RIFF' === (0, utils_1.toUTF8String)(input, 0, 4);
+        const webpHeader = 'WEBP' === (0, utils_1.toUTF8String)(input, 8, 12);
+        const vp8Header = 'VP8' === (0, utils_1.toUTF8String)(input, 12, 15);
+        return riffHeader && webpHeader && vp8Header;
+    },
+    calculate(input) {
+        const chunkHeader = (0, utils_1.toUTF8String)(input, 12, 16);
+        input = input.slice(20, 30);
+        // Extended webp stream signature
+        if (chunkHeader === 'VP8X') {
+            const extendedHeader = input[0];
+            const validStart = (extendedHeader & 0xc0) === 0;
+            const validEnd = (extendedHeader & 0x01) === 0;
+            if (validStart && validEnd) {
+                return calculateExtended(input);
+            }
+            else {
+                // TODO: breaking change
+                throw new TypeError('Invalid WebP');
+            }
+        }
+        // Lossless webp stream signature
+        if (chunkHeader === 'VP8 ' && input[0] !== 0x2f) {
+            return calculateLossy(input);
+        }
+        // Lossy webp stream signature
+        const signature = (0, utils_1.toHexString)(input, 3, 6);
+        if (chunkHeader === 'VP8L' && signature !== '9d012a') {
+            return calculateLossless(input);
+        }
+        throw new TypeError('Invalid WebP');
+    },
+};

package/pitch-deck-groove/node_modules/image-size/dist/utils/bit-reader.d.ts

@@ -0,0 +1,10 @@
+/** This class helps read Uint8Array bit-by-bit */
+export declare class BitReader {
+    private readonly input;
+    private readonly endianness;
+    private byteOffset;
+    private bitOffset;
+    constructor(input: Uint8Array, endianness: 'big-endian' | 'little-endian');
+    /** Reads a specified number of bits, and move the offset */
+    getBits(length?: number): number;
+}

package/pitch-deck-groove/node_modules/image-size/dist/utils/bit-reader.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitReader = void 0;
+/** This class helps read Uint8Array bit-by-bit */
+class BitReader {
+    constructor(input, endianness) {
+        this.input = input;
+        this.endianness = endianness;
+        // Skip the first 16 bits (2 bytes) of signature
+        this.byteOffset = 2;
+        this.bitOffset = 0;
+    }
+    /** Reads a specified number of bits, and move the offset */
+    getBits(length = 1) {
+        let result = 0;
+        let bitsRead = 0;
+        while (bitsRead < length) {
+            if (this.byteOffset >= this.input.length) {
+                throw new Error('Reached end of input');
+            }
+            const currentByte = this.input[this.byteOffset];
+            const bitsLeft = 8 - this.bitOffset;
+            const bitsToRead = Math.min(length - bitsRead, bitsLeft);
+            if (this.endianness === 'little-endian') {
+                const mask = (1 << bitsToRead) - 1;
+                const bits = (currentByte >> this.bitOffset) & mask;
+                result |= bits << bitsRead;
+            }
+            else {
+                const mask = ((1 << bitsToRead) - 1) << (8 - this.bitOffset - bitsToRead);
+                const bits = (currentByte & mask) >> (8 - this.bitOffset - bitsToRead);
+                result = (result << bitsToRead) | bits;
+            }
+            bitsRead += bitsToRead;
+            this.bitOffset += bitsToRead;
+            if (this.bitOffset === 8) {
+                this.byteOffset++;
+                this.bitOffset = 0;
+            }
+        }
+        return result;
+    }
+}
+exports.BitReader = BitReader;

package/pitch-deck-groove/node_modules/image-size/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "image-size",
+  "version": "1.2.1",
+  "description": "get dimensions of any image file",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "bin/image-size.js"
+  ],
+  "engines": {
+    "node": ">=16.x"
+  },
+  "packageManager": "yarn@4.0.2",
+  "bin": "bin/image-size.js",
+  "scripts": {
+    "lint": "eslint bin lib specs",
+    "format": "prettier --write lib specs eslint.config.mjs",
+    "test": "nyc mocha",
+    "clean": "rm -rf dist docs",
+    "generate-docs": "typedoc",
+    "build": "tsc",
+    "prepack": "yarn clean && yarn build"
+  },
+  "keywords": [
+    "image",
+    "size",
+    "dimensions",
+    "resolution",
+    "width",
+    "height",
+    "avif",
+    "bmp",
+    "cur",
+    "gif",
+    "heic",
+    "heif",
+    "icns",
+    "ico",
+    "jpeg",
+    "jxl",
+    "png",
+    "psd",
+    "svg",
+    "tga",
+    "tiff",
+    "webp"
+  ],
+  "repository": "git://github.com/image-size/image-size.git",
+  "author": "netroy <aditya@netroy.in> (http://netroy.in/)",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "9.5.0",
+    "@types/chai": "4.3.16",
+    "@types/eslint__js": "8.42.3",
+    "@types/glob": "8.1.0",
+    "@types/mocha": "10.0.7",
+    "@types/node": "18.19.39",
+    "@types/sinon": "17.0.3",
+    "chai": "4.4.1",
+    "eslint": "8.57.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-prettier": "5.1.3",
+    "glob": "10.4.2",
+    "mocha": "10.2.0",
+    "nyc": "15.1.0",
+    "prettier": "3.3.2",
+    "sinon": "17.0.1",
+    "ts-node": "10.9.2",
+    "typedoc": "0.25.13",
+    "typescript": "5.4.5",
+    "typescript-eslint": "7.13.1"
+  },
+  "nyc": {
+    "include": "lib",
+    "exclude": "specs/*.spec.ts"
+  },
+  "dependencies": {
+    "queue": "6.0.2"
+  }
+}

package/pitch-deck-groove/node_modules/immediate/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Barnesandnoble.com, llc, Donavon West, Domenic Denicola, Brian Cavalier
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/pitch-deck-groove/node_modules/immediate/README.md

@@ -0,0 +1,93 @@
+# immediate [![Build Status](https://travis-ci.org/calvinmetcalf/immediate.svg?branch=master)](https://travis-ci.org/calvinmetcalf/immediate)
+
+```
+npm install immediate --save
+```
+
+then
+
+```js
+var immediate = require("immediate");
+
+immediate(function () {
+  // this will run soon
+});
+
+immediate(function (arg1, arg2) {
+  // get your args like in iojs
+}, thing1, thing2);
+```
+
+## Introduction
+
+**immediate** is a microtask library, decended from [NobleJS's setImmediate](https://github.com/NobleJS/setImmediate), but including ideas from [Cujo's When](https://github.com/cujojs/when) and [RSVP][RSVP].
+
+immediate takes the tricks from setImmedate and RSVP and combines them with the schedualer inspired (vaugly) by whens.
+
+Note versions 2.6.5 and earlier were strictly speaking a 'macrotask' library not a microtask one, [see this for the difference](https://github.com/YuzuJS/setImmediate#macrotasks-and-microtasks), if you need a macrotask library, [I got you covered](https://github.com/calvinmetcalf/macrotask).
+
+Several new features were added in versions 3.1.0 and 3.2.0 to maintain parity with
+process.nextTick, but the 3.0.x series is still being kept up to date if you just need
+the small barebones version.
+
+
+## The Tricks
+
+### `process.nextTick`
+
+Note that we check for *actual* Node.js environments, not emulated ones like those produced by browserify or similar.
+
+### `MutationObserver`
+
+This is what [RSVP][RSVP] uses, it's very fast, details on [MDN](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver).
+
+
+### `MessageChannel`
+
+Unfortunately, `postMessage` has completely different semantics inside web workers, and so cannot be used there. So we
+turn to [`MessageChannel`][MessageChannel], which has worse browser support, but does work inside a web worker.
+
+### `<script> onreadystatechange`
+
+For our last trick, we pull something out to make things fast in Internet Explorer versions 6 through 8: namely,
+creating a `<script>` element and firing our calls in its `onreadystatechange` event. This does execute in a future
+turn of the event loop, and is also faster than `setTimeout(…, 0)`, so hey, why not?
+
+## Tricks we don't use
+
+### `setImmediate`
+We avoid this process.nextTick in node is better suited to our needs and in Internet Explorer 10 there is a broken version of setImmediate we avoid using this.
+
+
+In Node.js, do
+
+```
+npm install immediate
+```
+
+then
+
+```js
+var immediate = require("immediate");
+```
+
+
+## Reference and Reading
+
+ * [Efficient Script Yielding W3C Editor's Draft][spec]
+ * [W3C mailing list post introducing the specification][list-post]
+ * [IE Test Drive demo][ie-demo]
+ * [Introductory blog post by Nicholas C. Zakas][ncz]
+ * I wrote a couple blog pots on this, [part 1][my-blog-1] and [part 2][my-blog-2]
+
+[RSVP]: https://github.com/tildeio/rsvp.js
+[spec]: https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/setImmediate/Overview.html
+[list-post]: http://lists.w3.org/Archives/Public/public-web-perf/2011Jun/0100.html
+[ie-demo]: http://ie.microsoft.com/testdrive/Performance/setImmediateSorting/Default.html
+[ncz]: http://www.nczonline.net/blog/2011/09/19/script-yielding-with-setimmediate/
+[nextTick]: http://nodejs.org/docs/v0.8.16/api/process.html#process_process_nexttick_callback
+[postMessage]: http://www.whatwg.org/specs/web-apps/current-work/multipage/web-messaging.html#posting-messages
+[MessageChannel]: http://www.whatwg.org/specs/web-apps/current-work/multipage/web-messaging.html#channel-messaging
+[cross-browser-demo]: http://calvinmetcalf.github.io/setImmediate-shim-demo
+[my-blog-1]:http://calvinmetcalf.com/post/61672207151/setimmediate-etc
+[my-blog-2]:http://calvinmetcalf.com/post/61761231881/javascript-schedulers